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