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