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