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