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