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