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