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