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