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