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