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