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