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