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