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