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