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