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