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