From a678d927ca5d0002ea3ff116ab68171ba5b0a957 Mon Sep 17 00:00:00 2001
From: Alex Page <alex@anpage.me>
Date: Wed, 21 Jun 2023 20:51:26 -0400
Subject: [PATCH] Run clippy --fix

---
 src/confid.rs | 1045 ++++++++++++++++++++++++-------------------------
 1 file changed, 507 insertions(+), 538 deletions(-)

diff --git a/src/confid.rs b/src/confid.rs
index b8b6e2d..58328e6 100644
--- a/src/confid.rs
+++ b/src/confid.rs
@@ -65,28 +65,28 @@ struct C2RustUnnamed_4 {
     KeySHA1: libc::c_ushort,
 }
 static mut f: [uint64_t; 6] = [
-    0 as i32 as uint64_t,
-    0x21840136c85381 as u64 as uint64_t,
-    0x44197b83892ad0 as u64 as uint64_t,
-    0x1400606322b3b04 as u64 as uint64_t,
-    0x1400606322b3b04 as u64 as uint64_t,
-    1 as i32 as uint64_t,
+    0_i32 as uint64_t,
+    0x21840136c85381_u64 as uint64_t,
+    0x44197b83892ad0_u64 as uint64_t,
+    0x1400606322b3b04_u64 as uint64_t,
+    0x1400606322b3b04_u64 as uint64_t,
+    1_i32 as uint64_t,
 ];
 #[no_mangle]
 unsafe extern "C" fn residue_add(mut x: uint64_t, mut y: uint64_t) -> uint64_t {
     let mut z: uint64_t = x.wrapping_add(y);
-    if z as u64 >= 0x16a6b036d7f2a79 as u64 {
-        z = (z as u64).wrapping_sub(0x16a6b036d7f2a79 as u64) as uint64_t as uint64_t;
+    if z >= 0x16a6b036d7f2a79_u64 {
+        z = z.wrapping_sub(0x16a6b036d7f2a79_u64) as uint64_t as uint64_t;
     }
-    return z;
+    z
 }
 #[no_mangle]
 unsafe extern "C" fn residue_sub(mut x: uint64_t, mut y: uint64_t) -> uint64_t {
     let mut z: uint64_t = x.wrapping_sub(y);
     if x < y {
-        z = (z as u64).wrapping_add(0x16a6b036d7f2a79 as u64) as uint64_t as uint64_t;
+        z = z.wrapping_add(0x16a6b036d7f2a79_u64) as uint64_t as uint64_t;
     }
-    return z;
+    z
 }
 #[no_mangle]
 unsafe extern "C" fn __umul128(
@@ -94,23 +94,22 @@ unsafe extern "C" fn __umul128(
     mut multiplicand: uint64_t,
     mut product_hi: *mut uint64_t,
 ) -> uint64_t {
-    let mut a: uint64_t = multiplier >> 32 as i32;
-    let mut b: uint64_t = multiplier & 0xffffffff as u32 as u64;
-    let mut c: uint64_t = multiplicand >> 32 as i32;
-    let mut d: uint64_t = multiplicand & 0xffffffff as u32 as u64;
+    let mut a: uint64_t = multiplier >> 32_i32;
+    let mut b: uint64_t = multiplier & 0xffffffff_u32 as u64;
+    let mut c: uint64_t = multiplicand >> 32_i32;
+    let mut d: uint64_t = multiplicand & 0xffffffff_u32 as u64;
     let mut ad: uint64_t = a.wrapping_mul(d);
     let mut bd: uint64_t = b.wrapping_mul(d);
     let mut adbc: uint64_t = ad.wrapping_add(b.wrapping_mul(c));
-    let mut adbc_carry: uint64_t = (if adbc < ad { 1 as i32 } else { 0 as i32 }) as uint64_t;
-    let mut product_lo: uint64_t = bd.wrapping_add(adbc << 32 as i32);
-    let mut product_lo_carry: uint64_t =
-        (if product_lo < bd { 1 as i32 } else { 0 as i32 }) as uint64_t;
+    let mut adbc_carry: uint64_t = (if adbc < ad { 1_i32 } else { 0_i32 }) as uint64_t;
+    let mut product_lo: uint64_t = bd.wrapping_add(adbc << 32_i32);
+    let mut product_lo_carry: uint64_t = (if product_lo < bd { 1_i32 } else { 0_i32 }) as uint64_t;
     *product_hi = a
         .wrapping_mul(c)
-        .wrapping_add(adbc >> 32 as i32)
-        .wrapping_add(adbc_carry << 32 as i32)
+        .wrapping_add(adbc >> 32_i32)
+        .wrapping_add(adbc_carry << 32_i32)
         .wrapping_add(product_lo_carry);
-    return product_lo;
+    product_lo
 }
 #[no_mangle]
 unsafe extern "C" fn ui128_quotient_mod(mut lo: uint64_t, mut hi: uint64_t) -> uint64_t {
@@ -122,54 +121,52 @@ unsafe extern "C" fn ui128_quotient_mod(mut lo: uint64_t, mut hi: uint64_t) -> u
     let mut part2lo: uint64_t = __umul128(hi, 0x604fa6a1c6346a87_i64 as uint64_t, &mut part2hi);
     let mut sum1: uint64_t = part1lo.wrapping_add(part2lo);
     let mut sum1carry: u32 = (sum1 < part1lo) as i32 as u32;
-    sum1 = (sum1 as u64).wrapping_add(prod1) as uint64_t as uint64_t;
+    sum1 = sum1.wrapping_add(prod1) as uint64_t as uint64_t;
     sum1carry = sum1carry.wrapping_add((sum1 < prod1) as i32 as u32);
     let mut prod2: uint64_t = part1hi.wrapping_add(part2hi).wrapping_add(sum1carry as u64);
     let mut prod3hi: uint64_t = 0;
     let mut prod3lo: uint64_t = __umul128(hi, 0x2d351c6d04f8b_i64 as uint64_t, &mut prod3hi);
-    prod3lo = (prod3lo as u64).wrapping_add(prod2) as uint64_t as uint64_t;
-    prod3hi =
-        (prod3hi as u64).wrapping_add((prod3lo < prod2) as i32 as u64) as uint64_t as uint64_t;
-    return prod3lo >> 42 as i32 | prod3hi << 22 as i32;
+    prod3lo = prod3lo.wrapping_add(prod2) as uint64_t as uint64_t;
+    prod3hi = prod3hi.wrapping_add((prod3lo < prod2) as i32 as u64) as uint64_t as uint64_t;
+    prod3lo >> 42_i32 | prod3hi << 22_i32
 }
 #[no_mangle]
 unsafe extern "C" fn residue_mul(mut x: uint64_t, mut y: uint64_t) -> uint64_t {
     let mut hi: uint64_t = 0;
     let mut lo: uint64_t = __umul128(x, y, &mut hi);
     let mut quotient: uint64_t = ui128_quotient_mod(lo, hi);
-    return (lo as u64).wrapping_sub((quotient as u64).wrapping_mul(0x16a6b036d7f2a79 as u64))
-        as uint64_t;
+    lo.wrapping_sub(quotient.wrapping_mul(0x16a6b036d7f2a79_u64)) as uint64_t
 }
 #[no_mangle]
 unsafe extern "C" fn residue_pow(mut x: uint64_t, mut y: uint64_t) -> uint64_t {
-    if y == 0 as i32 as u64 {
-        return 1 as i32 as uint64_t;
+    if y == 0_i32 as u64 {
+        return 1_i32 as uint64_t;
     }
     let mut cur: uint64_t = x;
-    while y & 1 as i32 as u64 == 0 {
+    while y & 1_i32 as u64 == 0 {
         cur = residue_mul(cur, cur);
-        y >>= 1 as i32;
+        y >>= 1_i32;
     }
     let mut res: uint64_t = cur;
     loop {
-        y >>= 1 as i32;
-        if !(y != 0 as i32 as u64) {
+        y >>= 1_i32;
+        if y == 0_i32 as u64 {
             break;
         }
         cur = residue_mul(cur, cur);
-        if y & 1 as i32 as u64 != 0 {
+        if y & 1_i32 as u64 != 0 {
             res = residue_mul(res, cur);
         }
     }
-    return res;
+    res
 }
 #[no_mangle]
 unsafe extern "C" fn inverse(mut u: uint64_t, mut v: uint64_t) -> uint64_t {
     let mut tmp: int64_t = 0;
-    let mut xu: int64_t = 1 as i32 as int64_t;
-    let mut xv: int64_t = 0 as i32 as int64_t;
+    let mut xu: int64_t = 1_i32 as int64_t;
+    let mut xv: int64_t = 0_i32 as int64_t;
     let mut v0: uint64_t = v;
-    while u > 1 as i32 as u64 {
+    while u > 1_i32 as u64 {
         let mut d: uint64_t = v.wrapping_div(u);
         let mut remainder: uint64_t = v.wrapping_rem(u);
         tmp = u as int64_t;
@@ -179,61 +176,57 @@ unsafe extern "C" fn inverse(mut u: uint64_t, mut v: uint64_t) -> uint64_t {
         xu = (xv as u64).wrapping_sub(d.wrapping_mul(xu as u64)) as int64_t;
         xv = tmp;
     }
-    xu = (xu as u64).wrapping_add(if xu < 0 as i32 as i64 {
-        v0
-    } else {
-        0 as i32 as u64
-    }) as int64_t as int64_t;
-    return xu as uint64_t;
+    xu = (xu as u64).wrapping_add(if xu < 0_i32 as i64 { v0 } else { 0_i32 as u64 }) as int64_t
+        as int64_t;
+    xu as uint64_t
 }
 #[no_mangle]
 unsafe extern "C" fn residue_inv(mut x: uint64_t) -> uint64_t {
-    return inverse(x, 0x16a6b036d7f2a79 as u64 as uint64_t);
+    inverse(x, 0x16a6b036d7f2a79_u64 as uint64_t)
 }
 #[no_mangle]
 unsafe extern "C" fn residue_sqrt(mut what: uint64_t) -> uint64_t {
     if what == 0 {
-        return 0 as i32 as uint64_t;
+        return 0_i32 as uint64_t;
     }
-    let mut g: uint64_t = 43 as i32 as uint64_t;
+    let mut g: uint64_t = 43_i32 as uint64_t;
     let mut z: uint64_t = 0;
     let mut y: uint64_t = 0;
     let mut r: uint64_t = 0;
     let mut x: uint64_t = 0;
     let mut b: uint64_t = 0;
     let mut t: uint64_t = 0;
-    let mut e: uint64_t = 0 as i32 as uint64_t;
-    let mut q: uint64_t = (0x16a6b036d7f2a79 as u64).wrapping_sub(1 as i32 as u64) as uint64_t;
-    while q & 1 as i32 as u64 == 0 {
+    let mut e: uint64_t = 0_i32 as uint64_t;
+    let mut q: uint64_t = 0x16a6b036d7f2a79_u64.wrapping_sub(1_i32 as u64) as uint64_t;
+    while q & 1_i32 as u64 == 0 {
         e = e.wrapping_add(1);
-        q >>= 1 as i32;
+        q >>= 1_i32;
     }
     z = residue_pow(g, q);
     y = z;
     r = e;
     x = residue_pow(
         what,
-        q.wrapping_sub(1 as i32 as u64)
-            .wrapping_div(2 as i32 as u64),
+        q.wrapping_sub(1_i32 as u64).wrapping_div(2_i32 as u64),
     );
     b = residue_mul(residue_mul(what, x), x);
     x = residue_mul(what, x);
-    while b != 1 as i32 as u64 {
-        let mut m: uint64_t = 0 as i32 as uint64_t;
+    while b != 1_i32 as u64 {
+        let mut m: uint64_t = 0_i32 as uint64_t;
         let mut b2: uint64_t = b;
         loop {
             m = m.wrapping_add(1);
             b2 = residue_mul(b2, b2);
-            if !(b2 != 1 as i32 as u64) {
+            if b2 == 1_i32 as u64 {
                 break;
             }
         }
         if m == r {
-            return 0xffffffffffffffff as u64 as uint64_t;
+            return 0xffffffffffffffff_u64 as uint64_t;
         }
         t = residue_pow(
             y,
-            ((1 as i32) << r.wrapping_sub(m).wrapping_sub(1 as i32 as u64)) as uint64_t,
+            (1_i32 << r.wrapping_sub(m).wrapping_sub(1_i32 as u64)) as uint64_t,
         );
         y = residue_mul(t, t);
         r = m;
@@ -241,52 +234,52 @@ unsafe extern "C" fn residue_sqrt(mut what: uint64_t) -> uint64_t {
         b = residue_mul(b, y);
     }
     if residue_mul(x, x) != what {
-        return 0xffffffffffffffff as u64 as uint64_t;
+        return 0xffffffffffffffff_u64 as uint64_t;
     }
-    return x;
+    x
 }
 #[no_mangle]
 unsafe extern "C" fn find_divisor_v(mut d: *mut TDivisor) -> i32 {
     let mut v1: uint64_t = 0;
     let mut f2: [uint64_t; 6] = [0; 6];
-    let mut i: i32 = 0 as i32;
-    while i < 6 as i32 {
+    let mut i: i32 = 0_i32;
+    while i < 6_i32 {
         f2[i as usize] = f[i as usize];
         i += 1;
     }
-    let u0: uint64_t = (*d).u[0 as i32 as usize] as uint64_t;
-    let u1: uint64_t = (*d).u[1 as i32 as usize] as uint64_t;
-    let mut j: i32 = 4 as i32;
+    let u0: uint64_t = (*d).u[0_i32 as usize] as uint64_t;
+    let u1: uint64_t = (*d).u[1_i32 as usize] as uint64_t;
+    let mut j: i32 = 4_i32;
     loop {
         let fresh0 = j;
-        j = j - 1;
-        if !(fresh0 != 0) {
+        j -= 1;
+        if fresh0 == 0 {
             break;
         }
-        f2[j as usize] = residue_sub(f2[j as usize], residue_mul(u0, f2[(j + 2 as i32) as usize]));
-        f2[(j + 1 as i32) as usize] = residue_sub(
-            f2[(j + 1 as i32) as usize],
-            residue_mul(u1, f2[(j + 2 as i32) as usize]),
+        f2[j as usize] = residue_sub(f2[j as usize], residue_mul(u0, f2[(j + 2_i32) as usize]));
+        f2[(j + 1_i32) as usize] = residue_sub(
+            f2[(j + 1_i32) as usize],
+            residue_mul(u1, f2[(j + 2_i32) as usize]),
         );
-        f2[(j + 2 as i32) as usize] = 0 as i32 as uint64_t;
+        f2[(j + 2_i32) as usize] = 0_i32 as uint64_t;
     }
-    let f0: uint64_t = f2[0 as i32 as usize];
-    let f1: uint64_t = f2[1 as i32 as usize];
+    let f0: uint64_t = f2[0_i32 as usize];
+    let f1: uint64_t = f2[1_i32 as usize];
     let u0double: uint64_t = residue_add(u0, u0);
     let coeff2: uint64_t = residue_sub(residue_mul(u1, u1), residue_add(u0double, u0double));
     let coeff1: uint64_t = residue_sub(residue_add(f0, f0), residue_mul(f1, u1));
-    if coeff2 == 0 as i32 as u64 {
-        if coeff1 == 0 as i32 as u64 {
-            f1 == 0 as i32 as u64;
-            return 0 as i32;
+    if coeff2 == 0_i32 as u64 {
+        if coeff1 == 0_i32 as u64 {
+            f1 == 0_i32 as u64;
+            return 0_i32;
         }
         let mut sqr: uint64_t = residue_mul(
             residue_mul(f1, f1),
             residue_inv(residue_add(coeff1, coeff1)),
         );
         v1 = residue_sqrt(sqr);
-        if v1 as u64 == 0xffffffffffffffff as u64 {
-            return 0 as i32;
+        if v1 == 0xffffffffffffffff_u64 {
+            return 0_i32;
         }
     } else {
         let mut d_0: uint64_t = residue_add(
@@ -294,18 +287,18 @@ unsafe extern "C" fn find_divisor_v(mut d: *mut TDivisor) -> i32 {
             residue_mul(f1, residue_sub(residue_mul(f1, u0), residue_mul(f0, u1))),
         );
         d_0 = residue_sqrt(d_0);
-        if d_0 as u64 == 0xffffffffffffffff as u64 {
-            return 0 as i32;
+        if d_0 == 0xffffffffffffffff_u64 {
+            return 0_i32;
         }
         d_0 = residue_add(d_0, d_0);
         let mut inv: uint64_t = residue_inv(coeff2);
         let mut root: uint64_t = residue_mul(residue_add(coeff1, d_0), inv);
         v1 = residue_sqrt(root);
-        if v1 as u64 == 0xffffffffffffffff as u64 {
+        if v1 == 0xffffffffffffffff_u64 {
             root = residue_mul(residue_sub(coeff1, d_0), inv);
             v1 = residue_sqrt(root);
-            if v1 as u64 == 0xffffffffffffffff as u64 {
-                return 0 as i32;
+            if v1 == 0xffffffffffffffff_u64 {
+                return 0_i32;
             }
         }
     }
@@ -313,9 +306,9 @@ unsafe extern "C" fn find_divisor_v(mut d: *mut TDivisor) -> i32 {
         residue_add(f1, residue_mul(u1, residue_mul(v1, v1))),
         residue_inv(residue_add(v1, v1)),
     );
-    (*d).v[0 as i32 as usize] = v0 as uint16_t;
-    (*d).v[1 as i32 as usize] = v1 as uint16_t;
-    return 1 as i32;
+    (*d).v[0_i32 as usize] = v0 as uint16_t;
+    (*d).v[1_i32 as usize] = v1 as uint16_t;
+    1_i32
 }
 #[no_mangle]
 unsafe extern "C" fn polynomial_mul(
@@ -326,20 +319,20 @@ unsafe extern "C" fn polynomial_mul(
     mut resultprevdeg: i32,
     mut result: *mut uint64_t,
 ) -> i32 {
-    if adeg < 0 as i32 || bdeg < 0 as i32 {
+    if adeg < 0_i32 || bdeg < 0_i32 {
         return resultprevdeg;
     }
     let mut i: i32 = 0;
     let mut j: i32 = 0;
-    i = resultprevdeg + 1 as i32;
+    i = resultprevdeg + 1_i32;
     while i <= adeg + bdeg {
-        *result.offset(i as isize) = 0 as i32 as uint64_t;
+        *result.offset(i as isize) = 0_i32 as uint64_t;
         i += 1;
     }
-    resultprevdeg = i - 1 as i32;
-    i = 0 as i32;
+    resultprevdeg = i - 1_i32;
+    i = 0_i32;
     while i <= adeg {
-        j = 0 as i32;
+        j = 0_i32;
         while j <= bdeg {
             *result.offset((i + j) as isize) = residue_add(
                 *result.offset((i + j) as isize),
@@ -349,10 +342,10 @@ unsafe extern "C" fn polynomial_mul(
         }
         i += 1;
     }
-    while resultprevdeg >= 0 as i32 && *result.offset(resultprevdeg as isize) == 0 as i32 as u64 {
+    while resultprevdeg >= 0_i32 && *result.offset(resultprevdeg as isize) == 0_i32 as u64 {
         resultprevdeg -= 1;
     }
-    return resultprevdeg;
+    resultprevdeg
 }
 #[no_mangle]
 unsafe extern "C" fn polynomial_div_monic(
@@ -365,12 +358,12 @@ unsafe extern "C" fn polynomial_div_monic(
     let mut i: i32 = 0;
     let mut j: i32 = 0;
     i = adeg - bdeg;
-    while i >= 0 as i32 {
+    while i >= 0_i32 {
         let mut q: uint64_t = *a.offset((i + bdeg) as isize);
         if !quotient.is_null() {
             *quotient.offset(i as isize) = q;
         }
-        j = 0 as i32;
+        j = 0_i32;
         while j < bdeg {
             *a.offset((i + j) as isize) = residue_sub(
                 *a.offset((i + j) as isize),
@@ -378,14 +371,14 @@ unsafe extern "C" fn polynomial_div_monic(
             );
             j += 1;
         }
-        *a.offset((i + j) as isize) = 0 as i32 as uint64_t;
+        *a.offset((i + j) as isize) = 0_i32 as uint64_t;
         i -= 1;
     }
     i += bdeg;
-    while i >= 0 as i32 && *a.offset(i as isize) == 0 as i32 as u64 {
+    while i >= 0_i32 && *a.offset(i as isize) == 0_i32 as u64 {
         i -= 1;
     }
-    return i;
+    i
 }
 #[no_mangle]
 unsafe extern "C" fn polynomial_xgcd(
@@ -400,37 +393,29 @@ unsafe extern "C" fn polynomial_xgcd(
     mut pmult2deg: *mut i32,
     mut mult2: *mut uint64_t,
 ) {
-    let mut sdeg: i32 = -(1 as i32);
-    let mut s: [uint64_t; 3] = [
-        0 as i32 as uint64_t,
-        0 as i32 as uint64_t,
-        0 as i32 as uint64_t,
-    ];
-    let mut mult1deg: i32 = 0 as i32;
-    *mult1.offset(0 as i32 as isize) = 1 as i32 as uint64_t;
-    *mult1.offset(1 as i32 as isize) = 0 as i32 as uint64_t;
-    *mult1.offset(2 as i32 as isize) = 0 as i32 as uint64_t;
-    let mut tdeg: i32 = 0 as i32;
-    let mut t: [uint64_t; 3] = [
-        1 as i32 as uint64_t,
-        0 as i32 as uint64_t,
-        0 as i32 as uint64_t,
-    ];
-    let mut mult2deg: i32 = -(1 as i32);
-    *mult2.offset(0 as i32 as isize) = 0 as i32 as uint64_t;
-    *mult2.offset(1 as i32 as isize) = 0 as i32 as uint64_t;
-    *mult2.offset(2 as i32 as isize) = 0 as i32 as uint64_t;
+    let mut sdeg: i32 = -1_i32;
+    let mut s: [uint64_t; 3] = [0_i32 as uint64_t, 0_i32 as uint64_t, 0_i32 as uint64_t];
+    let mut mult1deg: i32 = 0_i32;
+    *mult1.offset(0_i32 as isize) = 1_i32 as uint64_t;
+    *mult1.offset(1_i32 as isize) = 0_i32 as uint64_t;
+    *mult1.offset(2_i32 as isize) = 0_i32 as uint64_t;
+    let mut tdeg: i32 = 0_i32;
+    let mut t: [uint64_t; 3] = [1_i32 as uint64_t, 0_i32 as uint64_t, 0_i32 as uint64_t];
+    let mut mult2deg: i32 = -1_i32;
+    *mult2.offset(0_i32 as isize) = 0_i32 as uint64_t;
+    *mult2.offset(1_i32 as isize) = 0_i32 as uint64_t;
+    *mult2.offset(2_i32 as isize) = 0_i32 as uint64_t;
     let mut rdeg: i32 = bdeg;
     let mut r: [uint64_t; 3] = [
-        *b.offset(0 as i32 as isize),
-        *b.offset(1 as i32 as isize),
-        *b.offset(2 as i32 as isize),
+        *b.offset(0_i32 as isize),
+        *b.offset(1_i32 as isize),
+        *b.offset(2_i32 as isize),
     ];
     let mut gcddeg: i32 = adeg;
-    *gcd.offset(0 as i32 as isize) = *a.offset(0 as i32 as isize);
-    *gcd.offset(1 as i32 as isize) = *a.offset(1 as i32 as isize);
-    *gcd.offset(2 as i32 as isize) = *a.offset(2 as i32 as isize);
-    while rdeg >= 0 as i32 {
+    *gcd.offset(0_i32 as isize) = *a.offset(0_i32 as isize);
+    *gcd.offset(1_i32 as isize) = *a.offset(1_i32 as isize);
+    *gcd.offset(2_i32 as isize) = *a.offset(2_i32 as isize);
+    while rdeg >= 0_i32 {
         if rdeg > gcddeg {
             let mut tmp: u32 = 0;
             let mut tmpi: i32 = 0;
@@ -444,38 +429,38 @@ unsafe extern "C" fn polynomial_xgcd(
             tdeg = mult2deg;
             mult2deg = tmpi;
             let mut tmp2: uint64_t = 0;
-            tmp2 = r[0 as i32 as usize];
-            r[0 as i32 as usize] = *gcd.offset(0 as i32 as isize);
-            *gcd.offset(0 as i32 as isize) = tmp2;
-            tmp2 = r[1 as i32 as usize];
-            r[1 as i32 as usize] = *gcd.offset(1 as i32 as isize);
-            *gcd.offset(1 as i32 as isize) = tmp2;
-            tmp2 = r[2 as i32 as usize];
-            r[2 as i32 as usize] = *gcd.offset(2 as i32 as isize);
-            *gcd.offset(2 as i32 as isize) = tmp2;
-            tmp2 = s[0 as i32 as usize];
-            s[0 as i32 as usize] = *mult1.offset(0 as i32 as isize);
-            *mult1.offset(0 as i32 as isize) = tmp2;
-            tmp2 = s[1 as i32 as usize];
-            s[1 as i32 as usize] = *mult1.offset(1 as i32 as isize);
-            *mult1.offset(1 as i32 as isize) = tmp2;
-            tmp2 = s[2 as i32 as usize];
-            s[2 as i32 as usize] = *mult1.offset(2 as i32 as isize);
-            *mult1.offset(2 as i32 as isize) = tmp2;
-            tmp2 = t[0 as i32 as usize];
-            t[0 as i32 as usize] = *mult2.offset(0 as i32 as isize);
-            *mult2.offset(0 as i32 as isize) = tmp2;
-            tmp2 = t[1 as i32 as usize];
-            t[1 as i32 as usize] = *mult2.offset(1 as i32 as isize);
-            *mult2.offset(1 as i32 as isize) = tmp2;
-            tmp2 = t[2 as i32 as usize];
-            t[2 as i32 as usize] = *mult2.offset(2 as i32 as isize);
-            *mult2.offset(2 as i32 as isize) = tmp2;
+            tmp2 = r[0_i32 as usize];
+            r[0_i32 as usize] = *gcd.offset(0_i32 as isize);
+            *gcd.offset(0_i32 as isize) = tmp2;
+            tmp2 = r[1_i32 as usize];
+            r[1_i32 as usize] = *gcd.offset(1_i32 as isize);
+            *gcd.offset(1_i32 as isize) = tmp2;
+            tmp2 = r[2_i32 as usize];
+            r[2_i32 as usize] = *gcd.offset(2_i32 as isize);
+            *gcd.offset(2_i32 as isize) = tmp2;
+            tmp2 = s[0_i32 as usize];
+            s[0_i32 as usize] = *mult1.offset(0_i32 as isize);
+            *mult1.offset(0_i32 as isize) = tmp2;
+            tmp2 = s[1_i32 as usize];
+            s[1_i32 as usize] = *mult1.offset(1_i32 as isize);
+            *mult1.offset(1_i32 as isize) = tmp2;
+            tmp2 = s[2_i32 as usize];
+            s[2_i32 as usize] = *mult1.offset(2_i32 as isize);
+            *mult1.offset(2_i32 as isize) = tmp2;
+            tmp2 = t[0_i32 as usize];
+            t[0_i32 as usize] = *mult2.offset(0_i32 as isize);
+            *mult2.offset(0_i32 as isize) = tmp2;
+            tmp2 = t[1_i32 as usize];
+            t[1_i32 as usize] = *mult2.offset(1_i32 as isize);
+            *mult2.offset(1_i32 as isize) = tmp2;
+            tmp2 = t[2_i32 as usize];
+            t[2_i32 as usize] = *mult2.offset(2_i32 as isize);
+            *mult2.offset(2_i32 as isize) = tmp2;
         } else {
             let mut delta: i32 = gcddeg - rdeg;
             let mut mult: uint64_t =
                 residue_mul(*gcd.offset(gcddeg as isize), residue_inv(r[rdeg as usize]));
-            let mut i: i32 = 0 as i32;
+            let mut i: i32 = 0_i32;
             while i <= rdeg {
                 *gcd.offset((i + delta) as isize) = residue_sub(
                     *gcd.offset((i + delta) as isize),
@@ -483,10 +468,10 @@ unsafe extern "C" fn polynomial_xgcd(
                 );
                 i += 1;
             }
-            while gcddeg >= 0 as i32 && *gcd.offset(gcddeg as isize) == 0 as i32 as u64 {
+            while gcddeg >= 0_i32 && *gcd.offset(gcddeg as isize) == 0_i32 as u64 {
                 gcddeg -= 1;
             }
-            let mut i_0: i32 = 0 as i32;
+            let mut i_0: i32 = 0_i32;
             while i_0 <= sdeg {
                 *mult1.offset((i_0 + delta) as isize) = residue_sub(
                     *mult1.offset((i_0 + delta) as isize),
@@ -497,10 +482,10 @@ unsafe extern "C" fn polynomial_xgcd(
             if mult1deg < sdeg + delta {
                 mult1deg = sdeg + delta;
             }
-            while mult1deg >= 0 as i32 && *mult1.offset(mult1deg as isize) == 0 as i32 as u64 {
+            while mult1deg >= 0_i32 && *mult1.offset(mult1deg as isize) == 0_i32 as u64 {
                 mult1deg -= 1;
             }
-            let mut i_1: i32 = 0 as i32;
+            let mut i_1: i32 = 0_i32;
             while i_1 <= tdeg {
                 *mult2.offset((i_1 + delta) as isize) = residue_sub(
                     *mult2.offset((i_1 + delta) as isize),
@@ -511,7 +496,7 @@ unsafe extern "C" fn polynomial_xgcd(
             if mult2deg < tdeg + delta {
                 mult2deg = tdeg + delta;
             }
-            while mult2deg >= 0 as i32 && *mult2.offset(mult2deg as isize) == 0 as i32 as u64 {
+            while mult2deg >= 0_i32 && *mult2.offset(mult2deg as isize) == 0_i32 as u64 {
                 mult2deg -= 1;
             }
         }
@@ -526,25 +511,25 @@ unsafe extern "C" fn u2poly(
     mut polyu: *mut uint64_t,
     mut polyv: *mut uint64_t,
 ) -> i32 {
-    if (*src).u[1 as i32 as usize] as u64 != 0xffffffffffffffff as u64 {
-        *polyu.offset(0 as i32 as isize) = (*src).u[0 as i32 as usize] as uint64_t;
-        *polyu.offset(1 as i32 as isize) = (*src).u[1 as i32 as usize] as uint64_t;
-        *polyu.offset(2 as i32 as isize) = 1 as i32 as uint64_t;
-        *polyv.offset(0 as i32 as isize) = (*src).v[0 as i32 as usize] as uint64_t;
-        *polyv.offset(1 as i32 as isize) = (*src).v[1 as i32 as usize] as uint64_t;
-        return 2 as i32;
+    if (*src).u[1_i32 as usize] as u64 != 0xffffffffffffffff_u64 {
+        *polyu.offset(0_i32 as isize) = (*src).u[0_i32 as usize] as uint64_t;
+        *polyu.offset(1_i32 as isize) = (*src).u[1_i32 as usize] as uint64_t;
+        *polyu.offset(2_i32 as isize) = 1_i32 as uint64_t;
+        *polyv.offset(0_i32 as isize) = (*src).v[0_i32 as usize] as uint64_t;
+        *polyv.offset(1_i32 as isize) = (*src).v[1_i32 as usize] as uint64_t;
+        return 2_i32;
     }
-    if (*src).u[0 as i32 as usize] as u64 != 0xffffffffffffffff as u64 {
-        *polyu.offset(0 as i32 as isize) = (*src).u[0 as i32 as usize] as uint64_t;
-        *polyu.offset(1 as i32 as isize) = 1 as i32 as uint64_t;
-        *polyv.offset(0 as i32 as isize) = (*src).v[0 as i32 as usize] as uint64_t;
-        *polyv.offset(1 as i32 as isize) = 0 as i32 as uint64_t;
-        return 1 as i32;
+    if (*src).u[0_i32 as usize] as u64 != 0xffffffffffffffff_u64 {
+        *polyu.offset(0_i32 as isize) = (*src).u[0_i32 as usize] as uint64_t;
+        *polyu.offset(1_i32 as isize) = 1_i32 as uint64_t;
+        *polyv.offset(0_i32 as isize) = (*src).v[0_i32 as usize] as uint64_t;
+        *polyv.offset(1_i32 as isize) = 0_i32 as uint64_t;
+        return 1_i32;
     }
-    *polyu.offset(0 as i32 as isize) = 1 as i32 as uint64_t;
-    *polyv.offset(0 as i32 as isize) = 0 as i32 as uint64_t;
-    *polyv.offset(1 as i32 as isize) = 0 as i32 as uint64_t;
-    return 0 as i32;
+    *polyu.offset(0_i32 as isize) = 1_i32 as uint64_t;
+    *polyv.offset(0_i32 as isize) = 0_i32 as uint64_t;
+    *polyv.offset(1_i32 as isize) = 0_i32 as uint64_t;
+    0_i32
 }
 #[no_mangle]
 unsafe extern "C" fn divisor_add(
@@ -577,18 +562,18 @@ unsafe extern "C" fn divisor_add(
         e2.as_mut_ptr(),
     );
     let mut b: [uint64_t; 3] = [
-        residue_add(v1[0 as i32 as usize], v2[0 as i32 as usize]),
-        residue_add(v1[1 as i32 as usize], v2[1 as i32 as usize]),
-        0 as i32 as uint64_t,
+        residue_add(v1[0_i32 as usize], v2[0_i32 as usize]),
+        residue_add(v1[1_i32 as usize], v2[1_i32 as usize]),
+        0_i32 as uint64_t,
     ];
-    let mut bdeg: i32 = if b[1 as i32 as usize] == 0 as i32 as u64 {
-        if b[0 as i32 as usize] == 0 as i32 as u64 {
-            -(1 as i32)
+    let mut bdeg: i32 = if b[1_i32 as usize] == 0_i32 as u64 {
+        if b[0_i32 as usize] == 0_i32 as u64 {
+            -1_i32
         } else {
-            0 as i32
+            0_i32
         }
     } else {
-        1 as i32
+        1_i32
     };
     let mut ddeg: i32 = 0;
     let mut c1deg: i32 = 0;
@@ -610,18 +595,18 @@ unsafe extern "C" fn divisor_add(
     );
     let mut dmult: uint64_t = residue_inv(d[ddeg as usize]);
     let mut i: i32 = 0;
-    i = 0 as i32;
+    i = 0_i32;
     while i < ddeg {
         d[i as usize] = residue_mul(d[i as usize], dmult);
         i += 1;
     }
-    d[i as usize] = 1 as i32 as uint64_t;
-    i = 0 as i32;
+    d[i as usize] = 1_i32 as uint64_t;
+    i = 0_i32;
     while i <= c1deg {
         c1[i as usize] = residue_mul(c1[i as usize], dmult);
         i += 1;
     }
-    i = 0 as i32;
+    i = 0_i32;
     while i <= c2deg {
         c2[i as usize] = residue_mul(c2[i as usize], dmult);
         i += 1;
@@ -632,21 +617,21 @@ unsafe extern "C" fn divisor_add(
         u1.as_mut_ptr() as *const uint64_t,
         u2deg,
         u2.as_mut_ptr() as *const uint64_t,
-        -(1 as i32),
+        -1_i32,
         u.as_mut_ptr(),
     );
     let mut v: [uint64_t; 7] = [0; 7];
     let mut tmp: [uint64_t; 7] = [0; 7];
     let mut vdeg: i32 = 0;
     let mut tmpdeg: i32 = 0;
-    v[0 as i32 as usize] = residue_sub(v2[0 as i32 as usize], v1[0 as i32 as usize]);
-    v[1 as i32 as usize] = residue_sub(v2[1 as i32 as usize], v1[1 as i32 as usize]);
+    v[0_i32 as usize] = residue_sub(v2[0_i32 as usize], v1[0_i32 as usize]);
+    v[1_i32 as usize] = residue_sub(v2[1_i32 as usize], v1[1_i32 as usize]);
     tmpdeg = polynomial_mul(
         e1deg,
         e1.as_mut_ptr() as *const uint64_t,
-        1 as i32,
+        1_i32,
         v.as_mut_ptr() as *const uint64_t,
-        -(1 as i32),
+        -1_i32,
         tmp.as_mut_ptr(),
     );
     vdeg = polynomial_mul(
@@ -654,32 +639,32 @@ unsafe extern "C" fn divisor_add(
         u1.as_mut_ptr() as *const uint64_t,
         tmpdeg,
         tmp.as_mut_ptr() as *const uint64_t,
-        -(1 as i32),
+        -1_i32,
         v.as_mut_ptr(),
     );
     vdeg = polynomial_mul(
         d1deg,
         d1.as_mut_ptr() as *const uint64_t,
-        1 as i32,
+        1_i32,
         v1.as_mut_ptr() as *const uint64_t,
         vdeg,
         v.as_mut_ptr(),
     );
-    i = 0 as i32;
+    i = 0_i32;
     while i <= vdeg {
-        v[i as usize] = residue_mul(v[i as usize], c1[0 as i32 as usize]);
+        v[i as usize] = residue_mul(v[i as usize], c1[0_i32 as usize]);
         i += 1;
     }
     memcpy(
         tmp.as_mut_ptr() as *mut libc::c_void,
         f.as_ptr() as *const libc::c_void,
-        (6 as i32 as u64).wrapping_mul(::std::mem::size_of::<uint64_t>() as u64),
+        (6_i32 as u64).wrapping_mul(::std::mem::size_of::<uint64_t>() as u64),
     );
-    tmpdeg = 5 as i32;
+    tmpdeg = 5_i32;
     tmpdeg = polynomial_mul(
-        1 as i32,
+        1_i32,
         v1.as_mut_ptr() as *const uint64_t,
-        1 as i32,
+        1_i32,
         v2.as_mut_ptr() as *const uint64_t,
         tmpdeg,
         tmp.as_mut_ptr(),
@@ -692,7 +677,7 @@ unsafe extern "C" fn divisor_add(
         vdeg,
         v.as_mut_ptr(),
     );
-    if ddeg > 0 as i32 {
+    if ddeg > 0_i32 {
         let mut udiv: [uint64_t; 5] = [0; 5];
         polynomial_div_monic(
             udeg,
@@ -710,7 +695,7 @@ unsafe extern "C" fn divisor_add(
             u.as_mut_ptr(),
         );
         udeg -= ddeg;
-        if vdeg >= 0 as i32 {
+        if vdeg >= 0_i32 {
             polynomial_div_monic(
                 vdeg,
                 v.as_mut_ptr(),
@@ -722,7 +707,7 @@ unsafe extern "C" fn divisor_add(
             memcpy(
                 v.as_mut_ptr() as *mut libc::c_void,
                 udiv.as_mut_ptr() as *const libc::c_void,
-                ((vdeg + 1 as i32) as u64).wrapping_mul(::std::mem::size_of::<uint64_t>() as u64),
+                ((vdeg + 1_i32) as u64).wrapping_mul(::std::mem::size_of::<uint64_t>() as u64),
             );
         }
     }
@@ -731,31 +716,31 @@ unsafe extern "C" fn divisor_add(
         v.as_mut_ptr(),
         udeg,
         u.as_mut_ptr() as *const uint64_t,
-        0 as *mut uint64_t,
+        std::ptr::null_mut::<uint64_t>(),
     );
-    while udeg > 2 as i32 {
+    while udeg > 2_i32 {
         tmpdeg = polynomial_mul(
             vdeg,
             v.as_mut_ptr() as *const uint64_t,
             vdeg,
             v.as_mut_ptr() as *const uint64_t,
-            -(1 as i32),
+            -1_i32,
             tmp.as_mut_ptr(),
         );
-        i = 0 as i32;
-        while i <= tmpdeg && i <= 5 as i32 {
+        i = 0_i32;
+        while i <= tmpdeg && i <= 5_i32 {
             tmp[i as usize] = residue_sub(f[i as usize], tmp[i as usize]);
             i += 1;
         }
         while i <= tmpdeg {
-            tmp[i as usize] = residue_sub(0 as i32 as uint64_t, tmp[i as usize]);
+            tmp[i as usize] = residue_sub(0_i32 as uint64_t, tmp[i as usize]);
             i += 1;
         }
-        while i <= 5 as i32 {
+        while i <= 5_i32 {
             tmp[i as usize] = f[i as usize];
             i += 1;
         }
-        tmpdeg = i - 1 as i32;
+        tmpdeg = i - 1_i32;
         let mut udiv_0: [uint64_t; 5] = [0; 5];
         polynomial_div_monic(
             tmpdeg,
@@ -766,15 +751,15 @@ unsafe extern "C" fn divisor_add(
         );
         udeg = tmpdeg - udeg;
         let mut mult: uint64_t = residue_inv(udiv_0[udeg as usize]);
-        i = 0 as i32;
+        i = 0_i32;
         while i < udeg {
             u[i as usize] = residue_mul(udiv_0[i as usize], mult);
             i += 1;
         }
-        u[i as usize] = 1 as i32 as uint64_t;
-        i = 0 as i32;
+        u[i as usize] = 1_i32 as uint64_t;
+        i = 0_i32;
         while i <= vdeg {
-            v[i as usize] = residue_sub(0 as i32 as uint64_t, v[i as usize]);
+            v[i as usize] = residue_sub(0_i32 as uint64_t, v[i as usize]);
             i += 1;
         }
         vdeg = polynomial_div_monic(
@@ -782,36 +767,36 @@ unsafe extern "C" fn divisor_add(
             v.as_mut_ptr(),
             udeg,
             u.as_mut_ptr() as *const uint64_t,
-            0 as *mut uint64_t,
+            std::ptr::null_mut::<uint64_t>(),
         );
     }
-    if udeg == 2 as i32 {
-        (*dst).u[0 as i32 as usize] = u[0 as i32 as usize] as uint16_t;
-        (*dst).u[1 as i32 as usize] = u[1 as i32 as usize] as uint16_t;
-        (*dst).v[0 as i32 as usize] = (if vdeg >= 0 as i32 {
-            v[0 as i32 as usize]
+    if udeg == 2_i32 {
+        (*dst).u[0_i32 as usize] = u[0_i32 as usize] as uint16_t;
+        (*dst).u[1_i32 as usize] = u[1_i32 as usize] as uint16_t;
+        (*dst).v[0_i32 as usize] = (if vdeg >= 0_i32 {
+            v[0_i32 as usize]
         } else {
-            0 as i32 as u64
+            0_i32 as u64
         }) as uint16_t;
-        (*dst).v[1 as i32 as usize] = (if vdeg >= 1 as i32 {
-            v[1 as i32 as usize]
+        (*dst).v[1_i32 as usize] = (if vdeg >= 1_i32 {
+            v[1_i32 as usize]
         } else {
-            0 as i32 as u64
+            0_i32 as u64
         }) as uint16_t;
-    } else if udeg == 1 as i32 {
-        (*dst).u[0 as i32 as usize] = u[0 as i32 as usize] as uint16_t;
-        (*dst).u[1 as i32 as usize] = 0xffffffffffffffff as u64 as uint16_t;
-        (*dst).v[0 as i32 as usize] = (if vdeg >= 0 as i32 {
-            v[0 as i32 as usize]
+    } else if udeg == 1_i32 {
+        (*dst).u[0_i32 as usize] = u[0_i32 as usize] as uint16_t;
+        (*dst).u[1_i32 as usize] = 0xffffffffffffffff_u64 as uint16_t;
+        (*dst).v[0_i32 as usize] = (if vdeg >= 0_i32 {
+            v[0_i32 as usize]
         } else {
-            0 as i32 as u64
+            0_i32 as u64
         }) as uint16_t;
-        (*dst).v[1 as i32 as usize] = 0xffffffffffffffff as u64 as uint16_t;
+        (*dst).v[1_i32 as usize] = 0xffffffffffffffff_u64 as uint16_t;
     } else {
-        (*dst).u[0 as i32 as usize] = 0xffffffffffffffff as u64 as uint16_t;
-        (*dst).u[1 as i32 as usize] = 0xffffffffffffffff as u64 as uint16_t;
-        (*dst).v[0 as i32 as usize] = 0xffffffffffffffff as u64 as uint16_t;
-        (*dst).v[1 as i32 as usize] = 0xffffffffffffffff as u64 as uint16_t;
+        (*dst).u[0_i32 as usize] = 0xffffffffffffffff_u64 as uint16_t;
+        (*dst).u[1_i32 as usize] = 0xffffffffffffffff_u64 as uint16_t;
+        (*dst).v[0_i32 as usize] = 0xffffffffffffffff_u64 as uint16_t;
+        (*dst).v[1_i32 as usize] = 0xffffffffffffffff_u64 as uint16_t;
     };
 }
 #[no_mangle]
@@ -820,26 +805,26 @@ unsafe extern "C" fn divisor_mul(
     mut mult: uint64_t,
     mut dst: *mut TDivisor,
 ) {
-    if mult == 0 as i32 as u64 {
-        (*dst).u[0 as i32 as usize] = 0xffffffffffffffff as u64 as uint16_t;
-        (*dst).u[1 as i32 as usize] = 0xffffffffffffffff as u64 as uint16_t;
-        (*dst).v[0 as i32 as usize] = 0xffffffffffffffff as u64 as uint16_t;
-        (*dst).v[1 as i32 as usize] = 0xffffffffffffffff as u64 as uint16_t;
+    if mult == 0_i32 as u64 {
+        (*dst).u[0_i32 as usize] = 0xffffffffffffffff_u64 as uint16_t;
+        (*dst).u[1_i32 as usize] = 0xffffffffffffffff_u64 as uint16_t;
+        (*dst).v[0_i32 as usize] = 0xffffffffffffffff_u64 as uint16_t;
+        (*dst).v[1_i32 as usize] = 0xffffffffffffffff_u64 as uint16_t;
         return;
     }
     let mut cur: TDivisor = *src;
-    while mult & 1 as i32 as u64 == 0 {
+    while mult & 1_i32 as u64 == 0 {
         divisor_add(&mut cur, &mut cur, &mut cur);
-        mult >>= 1 as i32;
+        mult >>= 1_i32;
     }
     *dst = cur;
     loop {
-        mult >>= 1 as i32;
-        if !(mult != 0 as i32 as u64) {
+        mult >>= 1_i32;
+        if mult == 0_i32 as u64 {
             break;
         }
         divisor_add(&mut cur, &mut cur, &mut cur);
-        if mult & 1 as i32 as u64 != 0 {
+        if mult & 1_i32 as u64 != 0 {
             divisor_add(dst, &mut cur, dst);
         }
     }
@@ -851,41 +836,41 @@ unsafe extern "C" fn divisor_mul128(
     mut mult_hi: uint64_t,
     mut dst: *mut TDivisor,
 ) {
-    if mult_lo == 0 as i32 as u64 && mult_hi == 0 as i32 as u64 {
-        (*dst).u[0 as i32 as usize] = 0xffffffffffffffff as u64 as uint16_t;
-        (*dst).u[1 as i32 as usize] = 0xffffffffffffffff as u64 as uint16_t;
-        (*dst).v[0 as i32 as usize] = 0xffffffffffffffff as u64 as uint16_t;
-        (*dst).v[1 as i32 as usize] = 0xffffffffffffffff as u64 as uint16_t;
+    if mult_lo == 0_i32 as u64 && mult_hi == 0_i32 as u64 {
+        (*dst).u[0_i32 as usize] = 0xffffffffffffffff_u64 as uint16_t;
+        (*dst).u[1_i32 as usize] = 0xffffffffffffffff_u64 as uint16_t;
+        (*dst).v[0_i32 as usize] = 0xffffffffffffffff_u64 as uint16_t;
+        (*dst).v[1_i32 as usize] = 0xffffffffffffffff_u64 as uint16_t;
         return;
     }
     let mut cur: TDivisor = *src;
-    while mult_lo & 1 as i32 as u64 == 0 {
+    while mult_lo & 1_i32 as u64 == 0 {
         divisor_add(&mut cur, &mut cur, &mut cur);
-        mult_lo >>= 1 as i32;
-        if mult_hi & 1 as i32 as u64 != 0 {
-            mult_lo = (mult_lo as u64 | (1 as u64) << 63 as i32) as uint64_t;
+        mult_lo >>= 1_i32;
+        if mult_hi & 1_i32 as u64 != 0 {
+            mult_lo = (mult_lo | 1_u64 << 63_i32) as uint64_t;
         }
-        mult_hi >>= 1 as i32;
+        mult_hi >>= 1_i32;
     }
     *dst = cur;
     loop {
-        mult_lo >>= 1 as i32;
-        if mult_hi & 1 as i32 as u64 != 0 {
-            mult_lo = (mult_lo as u64 | (1 as u64) << 63 as i32) as uint64_t;
+        mult_lo >>= 1_i32;
+        if mult_hi & 1_i32 as u64 != 0 {
+            mult_lo = (mult_lo | 1_u64 << 63_i32) as uint64_t;
         }
-        mult_hi >>= 1 as i32;
-        if mult_lo == 0 as i32 as u64 && mult_hi == 0 as i32 as u64 {
+        mult_hi >>= 1_i32;
+        if mult_lo == 0_i32 as u64 && mult_hi == 0_i32 as u64 {
             break;
         }
         divisor_add(&mut cur, &mut cur, &mut cur);
-        if mult_lo & 1 as i32 as u64 != 0 {
+        if mult_lo & 1_i32 as u64 != 0 {
             divisor_add(dst, &mut cur, dst);
         }
     }
 }
 #[no_mangle]
 unsafe extern "C" fn rol(mut x: u32, mut shift: i32) -> u32 {
-    return x << shift | x >> 32 as i32 - shift;
+    x << shift | x >> (32_i32 - shift)
 }
 #[no_mangle]
 unsafe extern "C" fn sha1_single_block(
@@ -897,128 +882,118 @@ unsafe extern "C" fn sha1_single_block(
     let mut c: u32 = 0;
     let mut d: u32 = 0;
     let mut e: u32 = 0;
-    a = 0x67452301 as i32 as u32;
-    b = 0xefcdab89 as u32;
-    c = 0x98badcfe as u32;
-    d = 0x10325476 as i32 as u32;
-    e = 0xc3d2e1f0 as u32;
+    a = 0x67452301_i32 as u32;
+    b = 0xefcdab89_u32;
+    c = 0x98badcfe_u32;
+    d = 0x10325476_i32 as u32;
+    e = 0xc3d2e1f0_u32;
     let mut w: [u32; 80] = [0; 80];
     let mut i: size_t = 0;
-    i = 0 as i32 as size_t;
-    while i < 16 as i32 as u64 {
-        w[i as usize] = ((*input.offset((4 as i32 as u64).wrapping_mul(i) as isize) as i32)
-            << 24 as i32
-            | (*input.offset(
-                (4 as i32 as u64)
-                    .wrapping_mul(i)
-                    .wrapping_add(1 as i32 as u64) as isize,
-            ) as i32)
-                << 16 as i32
-            | (*input.offset(
-                (4 as i32 as u64)
-                    .wrapping_mul(i)
-                    .wrapping_add(2 as i32 as u64) as isize,
-            ) as i32)
-                << 8 as i32
-            | *input.offset(
-                (4 as i32 as u64)
-                    .wrapping_mul(i)
-                    .wrapping_add(3 as i32 as u64) as isize,
-            ) as i32) as u32;
+    i = 0_i32 as size_t;
+    while i < 16_i32 as u64 {
+        w[i as usize] = ((*input.offset((4_i32 as u64).wrapping_mul(i) as isize) as i32) << 24_i32
+            | (*input.offset((4_i32 as u64).wrapping_mul(i).wrapping_add(1_i32 as u64) as isize)
+                as i32)
+                << 16_i32
+            | (*input.offset((4_i32 as u64).wrapping_mul(i).wrapping_add(2_i32 as u64) as isize)
+                as i32)
+                << 8_i32
+            | *input.offset((4_i32 as u64).wrapping_mul(i).wrapping_add(3_i32 as u64) as isize)
+                as i32) as u32;
         i = i.wrapping_add(1);
     }
-    i = 16 as i32 as size_t;
-    while i < 80 as i32 as u64 {
+    i = 16_i32 as size_t;
+    while i < 80_i32 as u64 {
         w[i as usize] = rol(
-            w[i.wrapping_sub(3 as i32 as u64) as usize]
-                ^ w[i.wrapping_sub(8 as i32 as u64) as usize]
-                ^ w[i.wrapping_sub(14 as i32 as u64) as usize]
-                ^ w[i.wrapping_sub(16 as i32 as u64) as usize],
-            1 as i32,
+            w[i.wrapping_sub(3_i32 as u64) as usize]
+                ^ w[i.wrapping_sub(8_i32 as u64) as usize]
+                ^ w[i.wrapping_sub(14_i32 as u64) as usize]
+                ^ w[i.wrapping_sub(16_i32 as u64) as usize],
+            1_i32,
         );
         i = i.wrapping_add(1);
     }
-    i = 0 as i32 as size_t;
-    while i < 20 as i32 as u64 {
-        let mut tmp: u32 = (rol(a, 5 as i32))
+    i = 0_i32 as size_t;
+    while i < 20_i32 as u64 {
+        let mut tmp: u32 = (rol(a, 5_i32))
             .wrapping_add(b & c | !b & d)
             .wrapping_add(e)
             .wrapping_add(w[i as usize])
-            .wrapping_add(0x5a827999 as i32 as u32);
+            .wrapping_add(0x5a827999_i32 as u32);
         e = d;
         d = c;
-        c = rol(b, 30 as i32);
+        c = rol(b, 30_i32);
         b = a;
         a = tmp;
         i = i.wrapping_add(1);
     }
-    i = 20 as i32 as size_t;
-    while i < 40 as i32 as u64 {
-        let mut tmp_0: u32 = (rol(a, 5 as i32))
+    i = 20_i32 as size_t;
+    while i < 40_i32 as u64 {
+        let mut tmp_0: u32 = (rol(a, 5_i32))
             .wrapping_add(b ^ c ^ d)
             .wrapping_add(e)
             .wrapping_add(w[i as usize])
-            .wrapping_add(0x6ed9eba1 as i32 as u32);
+            .wrapping_add(0x6ed9eba1_i32 as u32);
         e = d;
         d = c;
-        c = rol(b, 30 as i32);
+        c = rol(b, 30_i32);
         b = a;
         a = tmp_0;
         i = i.wrapping_add(1);
     }
-    i = 40 as i32 as size_t;
-    while i < 60 as i32 as u64 {
-        let mut tmp_1: u32 = (rol(a, 5 as i32))
+    i = 40_i32 as size_t;
+    while i < 60_i32 as u64 {
+        let mut tmp_1: u32 = (rol(a, 5_i32))
             .wrapping_add(b & c | b & d | c & d)
             .wrapping_add(e)
             .wrapping_add(w[i as usize])
-            .wrapping_add(0x8f1bbcdc as u32);
+            .wrapping_add(0x8f1bbcdc_u32);
         e = d;
         d = c;
-        c = rol(b, 30 as i32);
+        c = rol(b, 30_i32);
         b = a;
         a = tmp_1;
         i = i.wrapping_add(1);
     }
-    i = 60 as i32 as size_t;
-    while i < 80 as i32 as u64 {
-        let mut tmp_2: u32 = (rol(a, 5 as i32))
+    i = 60_i32 as size_t;
+    while i < 80_i32 as u64 {
+        let mut tmp_2: u32 = (rol(a, 5_i32))
             .wrapping_add(b ^ c ^ d)
             .wrapping_add(e)
             .wrapping_add(w[i as usize])
-            .wrapping_add(0xca62c1d6 as u32);
+            .wrapping_add(0xca62c1d6_u32);
         e = d;
         d = c;
-        c = rol(b, 30 as i32);
+        c = rol(b, 30_i32);
         b = a;
         a = tmp_2;
         i = i.wrapping_add(1);
     }
-    a = a.wrapping_add(0x67452301 as i32 as u32);
-    b = b.wrapping_add(0xefcdab89 as u32);
-    c = c.wrapping_add(0x98badcfe as u32);
-    d = d.wrapping_add(0x10325476 as i32 as u32);
-    e = e.wrapping_add(0xc3d2e1f0 as u32);
-    *output.offset(0 as i32 as isize) = (a >> 24 as i32) as libc::c_uchar;
-    *output.offset(1 as i32 as isize) = (a >> 16 as i32) as libc::c_uchar;
-    *output.offset(2 as i32 as isize) = (a >> 8 as i32) as libc::c_uchar;
-    *output.offset(3 as i32 as isize) = a as libc::c_uchar;
-    *output.offset(4 as i32 as isize) = (b >> 24 as i32) as libc::c_uchar;
-    *output.offset(5 as i32 as isize) = (b >> 16 as i32) as libc::c_uchar;
-    *output.offset(6 as i32 as isize) = (b >> 8 as i32) as libc::c_uchar;
-    *output.offset(7 as i32 as isize) = b as libc::c_uchar;
-    *output.offset(8 as i32 as isize) = (c >> 24 as i32) as libc::c_uchar;
-    *output.offset(9 as i32 as isize) = (c >> 16 as i32) as libc::c_uchar;
-    *output.offset(10 as i32 as isize) = (c >> 8 as i32) as libc::c_uchar;
-    *output.offset(11 as i32 as isize) = c as libc::c_uchar;
-    *output.offset(12 as i32 as isize) = (d >> 24 as i32) as libc::c_uchar;
-    *output.offset(13 as i32 as isize) = (d >> 16 as i32) as libc::c_uchar;
-    *output.offset(14 as i32 as isize) = (d >> 8 as i32) as libc::c_uchar;
-    *output.offset(15 as i32 as isize) = d as libc::c_uchar;
-    *output.offset(16 as i32 as isize) = (e >> 24 as i32) as libc::c_uchar;
-    *output.offset(17 as i32 as isize) = (e >> 16 as i32) as libc::c_uchar;
-    *output.offset(18 as i32 as isize) = (e >> 8 as i32) as libc::c_uchar;
-    *output.offset(19 as i32 as isize) = e as libc::c_uchar;
+    a = a.wrapping_add(0x67452301_i32 as u32);
+    b = b.wrapping_add(0xefcdab89_u32);
+    c = c.wrapping_add(0x98badcfe_u32);
+    d = d.wrapping_add(0x10325476_i32 as u32);
+    e = e.wrapping_add(0xc3d2e1f0_u32);
+    *output.offset(0_i32 as isize) = (a >> 24_i32) as libc::c_uchar;
+    *output.offset(1_i32 as isize) = (a >> 16_i32) as libc::c_uchar;
+    *output.offset(2_i32 as isize) = (a >> 8_i32) as libc::c_uchar;
+    *output.offset(3_i32 as isize) = a as libc::c_uchar;
+    *output.offset(4_i32 as isize) = (b >> 24_i32) as libc::c_uchar;
+    *output.offset(5_i32 as isize) = (b >> 16_i32) as libc::c_uchar;
+    *output.offset(6_i32 as isize) = (b >> 8_i32) as libc::c_uchar;
+    *output.offset(7_i32 as isize) = b as libc::c_uchar;
+    *output.offset(8_i32 as isize) = (c >> 24_i32) as libc::c_uchar;
+    *output.offset(9_i32 as isize) = (c >> 16_i32) as libc::c_uchar;
+    *output.offset(10_i32 as isize) = (c >> 8_i32) as libc::c_uchar;
+    *output.offset(11_i32 as isize) = c as libc::c_uchar;
+    *output.offset(12_i32 as isize) = (d >> 24_i32) as libc::c_uchar;
+    *output.offset(13_i32 as isize) = (d >> 16_i32) as libc::c_uchar;
+    *output.offset(14_i32 as isize) = (d >> 8_i32) as libc::c_uchar;
+    *output.offset(15_i32 as isize) = d as libc::c_uchar;
+    *output.offset(16_i32 as isize) = (e >> 24_i32) as libc::c_uchar;
+    *output.offset(17_i32 as isize) = (e >> 16_i32) as libc::c_uchar;
+    *output.offset(18_i32 as isize) = (e >> 8_i32) as libc::c_uchar;
+    *output.offset(19_i32 as isize) = e as libc::c_uchar;
 }
 #[no_mangle]
 unsafe extern "C" fn Mix(
@@ -1029,13 +1004,13 @@ unsafe extern "C" fn Mix(
 ) {
     let mut sha1_input: [libc::c_uchar; 64] = [0; 64];
     let mut sha1_result: [libc::c_uchar; 20] = [0; 20];
-    let mut half: size_t = bufSize.wrapping_div(2 as i32 as u64);
+    let mut half: size_t = bufSize.wrapping_div(2_i32 as u64);
     let mut external_counter: i32 = 0;
-    external_counter = 0 as i32;
-    while external_counter < 4 as i32 {
+    external_counter = 0_i32;
+    while external_counter < 4_i32 {
         memset(
             sha1_input.as_mut_ptr() as *mut libc::c_void,
-            0 as i32,
+            0_i32,
             ::std::mem::size_of::<[libc::c_uchar; 64]>() as u64,
         );
         memcpy(
@@ -1048,26 +1023,25 @@ unsafe extern "C" fn Mix(
             key as *const libc::c_void,
             keySize,
         );
-        sha1_input[half.wrapping_add(keySize) as usize] = 0x80 as i32 as libc::c_uchar;
-        sha1_input[(::std::mem::size_of::<[libc::c_uchar; 64]>() as u64)
-            .wrapping_sub(1 as i32 as u64) as usize] =
-            half.wrapping_add(keySize).wrapping_mul(8 as i32 as u64) as libc::c_uchar;
-        sha1_input[(::std::mem::size_of::<[libc::c_uchar; 64]>() as u64)
-            .wrapping_sub(2 as i32 as u64) as usize] =
-            half.wrapping_add(keySize)
-                .wrapping_mul(8 as i32 as u64)
-                .wrapping_div(0x100 as i32 as u64) as libc::c_uchar;
+        sha1_input[half.wrapping_add(keySize) as usize] = 0x80_i32 as libc::c_uchar;
+        sha1_input[(::std::mem::size_of::<[libc::c_uchar; 64]>() as u64).wrapping_sub(1_i32 as u64)
+            as usize] = half.wrapping_add(keySize).wrapping_mul(8_i32 as u64) as libc::c_uchar;
+        sha1_input[(::std::mem::size_of::<[libc::c_uchar; 64]>() as u64).wrapping_sub(2_i32 as u64)
+            as usize] = half
+            .wrapping_add(keySize)
+            .wrapping_mul(8_i32 as u64)
+            .wrapping_div(0x100_i32 as u64) as libc::c_uchar;
         sha1_single_block(sha1_input.as_mut_ptr(), sha1_result.as_mut_ptr());
         let mut i: size_t = 0;
-        i = half & !(3 as i32) as u64;
+        i = half & !3_i32 as u64;
         while i < half {
             sha1_result[i as usize] = sha1_result[i
-                .wrapping_add(4 as i32 as u64)
-                .wrapping_sub(half & 3 as i32 as u64)
+                .wrapping_add(4_i32 as u64)
+                .wrapping_sub(half & 3_i32 as u64)
                 as usize];
             i = i.wrapping_add(1);
         }
-        i = 0 as i32 as size_t;
+        i = 0_i32 as size_t;
         while i < half {
             let mut tmp: libc::c_uchar = *buffer.offset(i.wrapping_add(half) as isize);
             *buffer.offset(i.wrapping_add(half) as isize) = (*buffer.offset(i as isize) as i32
@@ -1088,13 +1062,13 @@ unsafe extern "C" fn Unmix(
 ) {
     let mut sha1_input: [libc::c_uchar; 64] = [0; 64];
     let mut sha1_result: [libc::c_uchar; 20] = [0; 20];
-    let mut half: size_t = bufSize.wrapping_div(2 as i32 as u64);
+    let mut half: size_t = bufSize.wrapping_div(2_i32 as u64);
     let mut external_counter: i32 = 0;
-    external_counter = 0 as i32;
-    while external_counter < 4 as i32 {
+    external_counter = 0_i32;
+    while external_counter < 4_i32 {
         memset(
             sha1_input.as_mut_ptr() as *mut libc::c_void,
-            0 as i32,
+            0_i32,
             ::std::mem::size_of::<[libc::c_uchar; 64]>() as u64,
         );
         memcpy(
@@ -1107,26 +1081,25 @@ unsafe extern "C" fn Unmix(
             key as *const libc::c_void,
             keySize,
         );
-        sha1_input[half.wrapping_add(keySize) as usize] = 0x80 as i32 as libc::c_uchar;
-        sha1_input[(::std::mem::size_of::<[libc::c_uchar; 64]>() as u64)
-            .wrapping_sub(1 as i32 as u64) as usize] =
-            half.wrapping_add(keySize).wrapping_mul(8 as i32 as u64) as libc::c_uchar;
-        sha1_input[(::std::mem::size_of::<[libc::c_uchar; 64]>() as u64)
-            .wrapping_sub(2 as i32 as u64) as usize] =
-            half.wrapping_add(keySize)
-                .wrapping_mul(8 as i32 as u64)
-                .wrapping_div(0x100 as i32 as u64) as libc::c_uchar;
+        sha1_input[half.wrapping_add(keySize) as usize] = 0x80_i32 as libc::c_uchar;
+        sha1_input[(::std::mem::size_of::<[libc::c_uchar; 64]>() as u64).wrapping_sub(1_i32 as u64)
+            as usize] = half.wrapping_add(keySize).wrapping_mul(8_i32 as u64) as libc::c_uchar;
+        sha1_input[(::std::mem::size_of::<[libc::c_uchar; 64]>() as u64).wrapping_sub(2_i32 as u64)
+            as usize] = half
+            .wrapping_add(keySize)
+            .wrapping_mul(8_i32 as u64)
+            .wrapping_div(0x100_i32 as u64) as libc::c_uchar;
         sha1_single_block(sha1_input.as_mut_ptr(), sha1_result.as_mut_ptr());
         let mut i: size_t = 0;
-        i = half & !(3 as i32) as u64;
+        i = half & !3_i32 as u64;
         while i < half {
             sha1_result[i as usize] = sha1_result[i
-                .wrapping_add(4 as i32 as u64)
-                .wrapping_sub(half & 3 as i32 as u64)
+                .wrapping_add(4_i32 as u64)
+                .wrapping_sub(half & 3_i32 as u64)
                 as usize];
             i = i.wrapping_add(1);
         }
-        i = 0 as i32 as size_t;
+        i = 0_i32 as size_t;
         while i < half {
             let mut tmp: libc::c_uchar = *buffer.offset(i as isize);
             *buffer.offset(i as isize) = (*buffer.offset(i.wrapping_add(half) as isize) as i32
@@ -1144,55 +1117,51 @@ unsafe extern "C" fn Generate(
     mut confirmation_id: *mut libc::c_char,
 ) -> i32 {
     let mut installation_id: [libc::c_uchar; 19] = [0; 19];
-    let mut installation_id_len: size_t = 0 as i32 as size_t;
+    let mut installation_id_len: size_t = 0_i32 as size_t;
     let mut p: *const libc::c_char = installation_id_str;
-    let mut count: size_t = 0 as i32 as size_t;
-    let mut totalCount: size_t = 0 as i32 as size_t;
-    let mut check: u32 = 0 as i32 as u32;
+    let mut count: size_t = 0_i32 as size_t;
+    let mut totalCount: size_t = 0_i32 as size_t;
+    let mut check: u32 = 0_i32 as u32;
     let mut i: size_t = 0;
     while *p != 0 {
         if !(*p as i32 == ' ' as i32 || *p as i32 == '-' as i32) {
             let mut d: i32 = *p as i32 - '0' as i32;
-            if d < 0 as i32 || d > 9 as i32 {
-                return 3 as i32;
+            if !(0_i32..=9_i32).contains(&d) {
+                return 3_i32;
             }
-            if count == 5 as i32 as u64 || *p.offset(1 as i32 as isize) as i32 == 0 as i32 {
+            if count == 5_i32 as u64 || *p.offset(1_i32 as isize) as i32 == 0_i32 {
                 if count == 0 {
-                    return if totalCount == 45 as i32 as u64 {
-                        2 as i32
+                    return if totalCount == 45_i32 as u64 {
+                        2_i32
                     } else {
-                        1 as i32
+                        1_i32
                     };
                 }
-                if d as u32 != check.wrapping_rem(7 as i32 as u32) {
-                    return if count < 5 as i32 as u64 {
-                        1 as i32
-                    } else {
-                        4 as i32
-                    };
+                if d as u32 != check.wrapping_rem(7_i32 as u32) {
+                    return if count < 5_i32 as u64 { 1_i32 } else { 4_i32 };
                 }
-                check = 0 as i32 as u32;
-                count = 0 as i32 as size_t;
+                check = 0_i32 as u32;
+                count = 0_i32 as size_t;
             } else {
                 check = check.wrapping_add(
-                    (if count.wrapping_rem(2 as i32 as u64) != 0 {
-                        d * 2 as i32
+                    (if count.wrapping_rem(2_i32 as u64) != 0 {
+                        d * 2_i32
                     } else {
                         d
                     }) as u32,
                 );
                 count = count.wrapping_add(1);
                 totalCount = totalCount.wrapping_add(1);
-                if totalCount > 45 as i32 as u64 {
-                    return 2 as i32;
+                if totalCount > 45_i32 as u64 {
+                    return 2_i32;
                 }
                 let mut carry: libc::c_uchar = d as libc::c_uchar;
-                i = 0 as i32 as size_t;
+                i = 0_i32 as size_t;
                 while i < installation_id_len {
                     let mut x: u32 =
-                        (installation_id[i as usize] as i32 * 10 as i32 + carry as i32) as u32;
-                    installation_id[i as usize] = (x & 0xff as i32 as u32) as libc::c_uchar;
-                    carry = (x >> 8 as i32) as libc::c_uchar;
+                        (installation_id[i as usize] as i32 * 10_i32 + carry as i32) as u32;
+                    installation_id[i as usize] = (x & 0xff_i32 as u32) as libc::c_uchar;
+                    carry = (x >> 8_i32) as libc::c_uchar;
                     i = i.wrapping_add(1);
                 }
                 if carry != 0 {
@@ -1204,31 +1173,31 @@ unsafe extern "C" fn Generate(
         }
         p = p.offset(1);
     }
-    if totalCount != 41 as i32 as u64 && totalCount < 45 as i32 as u64 {
-        return 1 as i32;
+    if totalCount != 41_i32 as u64 && totalCount < 45_i32 as u64 {
+        return 1_i32;
     }
     while installation_id_len < ::std::mem::size_of::<[libc::c_uchar; 19]>() as u64 {
-        installation_id[installation_id_len as usize] = 0 as i32 as libc::c_uchar;
+        installation_id[installation_id_len as usize] = 0_i32 as libc::c_uchar;
         installation_id_len = installation_id_len.wrapping_add(1);
     }
     static mut iid_key: [libc::c_uchar; 4] = [
-        0x6a as i32 as libc::c_uchar,
-        0xc8 as i32 as libc::c_uchar,
-        0x5e as i32 as libc::c_uchar,
-        0xd4 as i32 as libc::c_uchar,
+        0x6a_i32 as libc::c_uchar,
+        0xc8_i32 as libc::c_uchar,
+        0x5e_i32 as libc::c_uchar,
+        0xd4_i32 as libc::c_uchar,
     ];
     Unmix(
         installation_id.as_mut_ptr(),
-        (if totalCount == 41 as i32 as u64 {
-            17 as i32
+        (if totalCount == 41_i32 as u64 {
+            17_i32
         } else {
-            19 as i32
+            19_i32
         }) as size_t,
         iid_key.as_ptr(),
-        4 as i32 as size_t,
+        4_i32 as size_t,
     );
-    if installation_id[18 as i32 as usize] as i32 >= 0x10 as i32 {
-        return 5 as i32;
+    if installation_id[18_i32 as usize] as i32 >= 0x10_i32 {
+        return 5_i32;
     }
     let mut parsed: C2RustUnnamed_4 = C2RustUnnamed_4 {
         HardwareID: 0,
@@ -1241,74 +1210,74 @@ unsafe extern "C" fn Generate(
         installation_id.as_mut_ptr() as *const libc::c_void,
         ::std::mem::size_of::<C2RustUnnamed_4>() as u64,
     );
-    let mut productId1: u32 =
-        (parsed.ProductIDLow & (((1 as i32) << 17 as i32) - 1 as i32) as u64) as u32;
+    let mut productId1: u32 = (parsed.ProductIDLow & ((1_i32 << 17_i32) - 1_i32) as u64) as u32;
     let mut productId2: u32 =
-        (parsed.ProductIDLow >> 17 as i32 & (((1 as i32) << 10 as i32) - 1 as i32) as u64) as u32;
+        (parsed.ProductIDLow >> 17_i32 & ((1_i32 << 10_i32) - 1_i32) as u64) as u32;
     let mut productId3: u32 =
-        (parsed.ProductIDLow >> 27 as i32 & (((1 as i32) << 25 as i32) - 1 as i32) as u64) as u32;
-    let mut version: u32 = (parsed.ProductIDLow >> 52 as i32 & 7 as i32 as u64) as u32;
-    let mut productId4: u32 = (parsed.ProductIDLow >> 55 as i32
-        | ((parsed.ProductIDHigh as i32) << 9 as i32) as u64) as u32;
+        (parsed.ProductIDLow >> 27_i32 & ((1_i32 << 25_i32) - 1_i32) as u64) as u32;
+    let mut version: u32 = (parsed.ProductIDLow >> 52_i32 & 7_i32 as u64) as u32;
+    let mut productId4: u32 =
+        (parsed.ProductIDLow >> 55_i32 | ((parsed.ProductIDHigh as i32) << 9_i32) as u64) as u32;
     if version
-        != (if totalCount == 41 as i32 as u64 {
-            4 as i32
+        != (if totalCount == 41_i32 as u64 {
+            4_i32
         } else {
-            5 as i32
+            5_i32
         }) as u32
     {
-        return 5 as i32;
+        return 5_i32;
     }
     let mut keybuf: [libc::c_uchar; 16] = [0; 16];
     let mut hardware_id = parsed.HardwareID;
     memcpy(
         keybuf.as_mut_ptr() as *mut libc::c_void,
         &mut hardware_id as *mut uint64_t as *const libc::c_void,
-        8 as i32 as u64,
+        8_i32 as u64,
     );
-    let mut productIdMixed: uint64_t = (productId1 as uint64_t) << 41 as i32
-        | (productId2 as uint64_t) << 58 as i32
-        | (productId3 as uint64_t) << 17 as i32
+    let mut productIdMixed: uint64_t = (productId1 as uint64_t) << 41_i32
+        | (productId2 as uint64_t) << 58_i32
+        | (productId3 as uint64_t) << 17_i32
         | productId4 as u64;
     memcpy(
-        keybuf.as_mut_ptr().offset(8 as i32 as isize) as *mut libc::c_void,
+        keybuf.as_mut_ptr().offset(8_i32 as isize) as *mut libc::c_void,
         &mut productIdMixed as *mut uint64_t as *const libc::c_void,
-        8 as i32 as u64,
+        8_i32 as u64,
     );
     let mut d_0: TDivisor = TDivisor {
         u: [0; 2],
         v: [0; 2],
     };
     let mut attempt: libc::c_uchar = 0;
-    attempt = 0 as i32 as libc::c_uchar;
-    while attempt as i32 <= 0x80 as i32 {
+    attempt = 0_i32 as libc::c_uchar;
+    while attempt as i32 <= 0x80_i32 {
         let mut u: C2RustUnnamed_3 = C2RustUnnamed_3 { buffer: [0; 14] };
-        u.c2rust_unnamed.lo = 0 as i32 as uint64_t;
-        u.c2rust_unnamed.hi = 0 as i32 as uint64_t;
-        u.buffer[7 as i32 as usize] = attempt;
+        u.c2rust_unnamed.lo = 0_i32 as uint64_t;
+        u.c2rust_unnamed.hi = 0_i32 as uint64_t;
+        u.buffer[7_i32 as usize] = attempt;
         Mix(
             (u.buffer).as_mut_ptr(),
-            14 as i32 as size_t,
+            14_i32 as size_t,
             keybuf.as_mut_ptr(),
-            16 as i32 as size_t,
+            16_i32 as size_t,
         );
         let mut x2: uint64_t = ui128_quotient_mod(u.c2rust_unnamed.lo, u.c2rust_unnamed.hi);
-        let mut x1: uint64_t = (u.c2rust_unnamed.lo as u64)
-            .wrapping_sub((x2 as u64).wrapping_mul(0x16a6b036d7f2a79 as u64))
-            as uint64_t;
+        let mut x1: uint64_t =
+            u.c2rust_unnamed
+                .lo
+                .wrapping_sub(x2.wrapping_mul(0x16a6b036d7f2a79_u64)) as uint64_t;
         x2 = x2.wrapping_add(1);
-        d_0.u[0 as i32 as usize] = residue_sub(
+        d_0.u[0_i32 as usize] = residue_sub(
             residue_mul(x1, x1),
-            residue_mul(43 as i32 as uint64_t, residue_mul(x2, x2)),
+            residue_mul(43_i32 as uint64_t, residue_mul(x2, x2)),
         ) as uint16_t;
-        d_0.u[1 as i32 as usize] = residue_add(x1, x1) as uint16_t;
+        d_0.u[1_i32 as usize] = residue_add(x1, x1) as uint16_t;
         if find_divisor_v(&mut d_0) != 0 {
             break;
         }
         attempt = attempt.wrapping_add(1);
     }
-    if attempt as i32 > 0x80 as i32 {
-        return 6 as i32;
+    if attempt as i32 > 0x80_i32 {
+        return 6_i32;
     }
     divisor_mul128(
         &mut d_0,
@@ -1322,113 +1291,113 @@ unsafe extern "C" fn Generate(
             encoded_hi: 0,
         },
     };
-    if d_0.u[0 as i32 as usize] as u64 == 0xffffffffffffffff as u64 {
+    if d_0.u[0_i32 as usize] as u64 == 0xffffffffffffffff_u64 {
         e.c2rust_unnamed.encoded_lo = __umul128(
-            (0x16a6b036d7f2a79 as u64).wrapping_add(2 as i32 as u64) as uint64_t,
-            0x16a6b036d7f2a79 as u64 as uint64_t,
+            0x16a6b036d7f2a79_u64.wrapping_add(2_i32 as u64) as uint64_t,
+            0x16a6b036d7f2a79_u64 as uint64_t,
             &mut e.c2rust_unnamed.encoded_hi,
         );
-    } else if d_0.u[1 as i32 as usize] as u64 == 0xffffffffffffffff as u64 {
+    } else if d_0.u[1_i32 as usize] as u64 == 0xffffffffffffffff_u64 {
         e.c2rust_unnamed.encoded_lo = __umul128(
-            (0x16a6b036d7f2a79 as u64).wrapping_add(1 as i32 as u64) as uint64_t,
-            d_0.u[0 as i32 as usize] as uint64_t,
+            0x16a6b036d7f2a79_u64.wrapping_add(1_i32 as u64) as uint64_t,
+            d_0.u[0_i32 as usize] as uint64_t,
             &mut e.c2rust_unnamed.encoded_hi,
         );
-        e.c2rust_unnamed.encoded_lo = (e.c2rust_unnamed.encoded_lo as u64)
-            .wrapping_add(0x16a6b036d7f2a79 as u64)
+        e.c2rust_unnamed.encoded_lo =
+            e.c2rust_unnamed
+                .encoded_lo
+                .wrapping_add(0x16a6b036d7f2a79_u64) as uint64_t as uint64_t;
+        e.c2rust_unnamed.encoded_hi = e
+            .c2rust_unnamed
+            .encoded_hi
+            .wrapping_add((e.c2rust_unnamed.encoded_lo < 0x16a6b036d7f2a79_u64) as i32 as u64)
             as uint64_t as uint64_t;
-        e.c2rust_unnamed.encoded_hi = (e.c2rust_unnamed.encoded_hi as u64).wrapping_add(
-            ((e.c2rust_unnamed.encoded_lo as u64) < 0x16a6b036d7f2a79 as u64) as i32 as u64,
-        ) as uint64_t as uint64_t;
     } else {
-        let mut x1_0: uint64_t = (if d_0.u[1 as i32 as usize] as i32 % 2 as i32 != 0 {
-            (d_0.u[1 as i32 as usize] as u64).wrapping_add(0x16a6b036d7f2a79 as u64)
+        let mut x1_0: uint64_t = (if d_0.u[1_i32 as usize] as i32 % 2_i32 != 0 {
+            (d_0.u[1_i32 as usize] as u64).wrapping_add(0x16a6b036d7f2a79_u64)
         } else {
-            d_0.u[1 as i32 as usize] as u64
+            d_0.u[1_i32 as usize] as u64
         })
-        .wrapping_div(2 as i32 as u64) as uint64_t;
-        let mut x2sqr: uint64_t = residue_sub(
-            residue_mul(x1_0, x1_0),
-            d_0.u[0 as i32 as usize] as uint64_t,
-        );
+        .wrapping_div(2_i32 as u64) as uint64_t;
+        let mut x2sqr: uint64_t =
+            residue_sub(residue_mul(x1_0, x1_0), d_0.u[0_i32 as usize] as uint64_t);
         let mut x2_0: uint64_t = residue_sqrt(x2sqr);
-        if x2_0 as u64 == 0xffffffffffffffff as u64 {
-            x2_0 = residue_sqrt(residue_mul(x2sqr, residue_inv(43 as i32 as uint64_t)));
+        if x2_0 == 0xffffffffffffffff_u64 {
+            x2_0 = residue_sqrt(residue_mul(x2sqr, residue_inv(43_i32 as uint64_t)));
             e.c2rust_unnamed.encoded_lo = __umul128(
-                (0x16a6b036d7f2a79 as u64).wrapping_add(1 as i32 as u64) as uint64_t,
-                (0x16a6b036d7f2a79 as u64).wrapping_add(x2_0 as u64) as uint64_t,
+                0x16a6b036d7f2a79_u64.wrapping_add(1_i32 as u64) as uint64_t,
+                0x16a6b036d7f2a79_u64.wrapping_add(x2_0) as uint64_t,
                 &mut e.c2rust_unnamed.encoded_hi,
             );
             e.c2rust_unnamed.encoded_lo =
-                (e.c2rust_unnamed.encoded_lo as u64).wrapping_add(x1_0) as uint64_t as uint64_t;
-            e.c2rust_unnamed.encoded_hi = (e.c2rust_unnamed.encoded_hi as u64)
+                e.c2rust_unnamed.encoded_lo.wrapping_add(x1_0) as uint64_t as uint64_t;
+            e.c2rust_unnamed.encoded_hi = e
+                .c2rust_unnamed
+                .encoded_hi
                 .wrapping_add((e.c2rust_unnamed.encoded_lo < x1_0) as i32 as u64)
                 as uint64_t as uint64_t;
         } else {
             let mut x1a: uint64_t = residue_sub(x1_0, x2_0);
             let mut y1: uint64_t = residue_sub(
-                d_0.v[0 as i32 as usize] as uint64_t,
-                residue_mul(d_0.v[1 as i32 as usize] as uint64_t, x1a),
+                d_0.v[0_i32 as usize] as uint64_t,
+                residue_mul(d_0.v[1_i32 as usize] as uint64_t, x1a),
             );
             let mut x2a: uint64_t = residue_add(x1_0, x2_0);
             let mut y2: uint64_t = residue_sub(
-                d_0.v[0 as i32 as usize] as uint64_t,
-                residue_mul(d_0.v[1 as i32 as usize] as uint64_t, x2a),
+                d_0.v[0_i32 as usize] as uint64_t,
+                residue_mul(d_0.v[1_i32 as usize] as uint64_t, x2a),
             );
             if x1a > x2a {
-                let mut tmp: uint64_t = x1a;
-                x1a = x2a;
-                x2a = tmp;
+                std::mem::swap(&mut x1a, &mut x2a);
             }
-            if (y1 ^ y2) & 1 as i32 as u64 != 0 {
-                let mut tmp_0: uint64_t = x1a;
-                x1a = x2a;
-                x2a = tmp_0;
+            if (y1 ^ y2) & 1_i32 as u64 != 0 {
+                std::mem::swap(&mut x1a, &mut x2a);
             }
             e.c2rust_unnamed.encoded_lo = __umul128(
-                (0x16a6b036d7f2a79 as u64).wrapping_add(1 as i32 as u64) as uint64_t,
+                0x16a6b036d7f2a79_u64.wrapping_add(1_i32 as u64) as uint64_t,
                 x1a,
                 &mut e.c2rust_unnamed.encoded_hi,
             );
             e.c2rust_unnamed.encoded_lo =
-                (e.c2rust_unnamed.encoded_lo as u64).wrapping_add(x2a) as uint64_t as uint64_t;
-            e.c2rust_unnamed.encoded_hi = (e.c2rust_unnamed.encoded_hi as u64)
+                e.c2rust_unnamed.encoded_lo.wrapping_add(x2a) as uint64_t as uint64_t;
+            e.c2rust_unnamed.encoded_hi = e
+                .c2rust_unnamed
+                .encoded_hi
                 .wrapping_add((e.c2rust_unnamed.encoded_lo < x2a) as i32 as u64)
                 as uint64_t as uint64_t;
         }
     }
     let mut decimal: [libc::c_uchar; 35] = [0; 35];
-    i = 0 as i32 as size_t;
-    while i < 35 as i32 as u64 {
-        let mut c: u32 =
-            (e.c2rust_unnamed_0.encoded[3 as i32 as usize]).wrapping_rem(10 as i32 as u32);
-        e.c2rust_unnamed_0.encoded[3 as i32 as usize] =
-            (e.c2rust_unnamed_0.encoded[3 as i32 as usize] as u32).wrapping_div(10 as i32 as u32)
-                as uint32_t as uint32_t;
-        let mut c2: u32 = ((c as uint64_t) << 32 as i32
-            | e.c2rust_unnamed_0.encoded[2 as i32 as usize] as u64)
-            .wrapping_rem(10 as i32 as u64) as u32;
-        e.c2rust_unnamed_0.encoded[2 as i32 as usize] =
-            ((c as uint64_t) << 32 as i32 | e.c2rust_unnamed_0.encoded[2 as i32 as usize] as u64)
-                .wrapping_div(10 as i32 as u64) as uint32_t;
-        let mut c3: u32 = ((c2 as uint64_t) << 32 as i32
-            | e.c2rust_unnamed_0.encoded[1 as i32 as usize] as u64)
-            .wrapping_rem(10 as i32 as u64) as u32;
-        e.c2rust_unnamed_0.encoded[1 as i32 as usize] =
-            ((c2 as uint64_t) << 32 as i32 | e.c2rust_unnamed_0.encoded[1 as i32 as usize] as u64)
-                .wrapping_div(10 as i32 as u64) as uint32_t;
-        let mut c4: u32 = ((c3 as uint64_t) << 32 as i32
-            | e.c2rust_unnamed_0.encoded[0 as i32 as usize] as u64)
-            .wrapping_rem(10 as i32 as u64) as u32;
-        e.c2rust_unnamed_0.encoded[0 as i32 as usize] =
-            ((c3 as uint64_t) << 32 as i32 | e.c2rust_unnamed_0.encoded[0 as i32 as usize] as u64)
-                .wrapping_div(10 as i32 as u64) as uint32_t;
-        decimal[(34 as i32 as u64).wrapping_sub(i) as usize] = c4 as libc::c_uchar;
+    i = 0_i32 as size_t;
+    while i < 35_i32 as u64 {
+        let mut c: u32 = (e.c2rust_unnamed_0.encoded[3_i32 as usize]).wrapping_rem(10_i32 as u32);
+        e.c2rust_unnamed_0.encoded[3_i32 as usize] = e.c2rust_unnamed_0.encoded[3_i32 as usize]
+            .wrapping_div(10_i32 as u32)
+            as uint32_t as uint32_t;
+        let mut c2: u32 = ((c as uint64_t) << 32_i32
+            | e.c2rust_unnamed_0.encoded[2_i32 as usize] as u64)
+            .wrapping_rem(10_i32 as u64) as u32;
+        e.c2rust_unnamed_0.encoded[2_i32 as usize] =
+            ((c as uint64_t) << 32_i32 | e.c2rust_unnamed_0.encoded[2_i32 as usize] as u64)
+                .wrapping_div(10_i32 as u64) as uint32_t;
+        let mut c3: u32 = ((c2 as uint64_t) << 32_i32
+            | e.c2rust_unnamed_0.encoded[1_i32 as usize] as u64)
+            .wrapping_rem(10_i32 as u64) as u32;
+        e.c2rust_unnamed_0.encoded[1_i32 as usize] =
+            ((c2 as uint64_t) << 32_i32 | e.c2rust_unnamed_0.encoded[1_i32 as usize] as u64)
+                .wrapping_div(10_i32 as u64) as uint32_t;
+        let mut c4: u32 = ((c3 as uint64_t) << 32_i32
+            | e.c2rust_unnamed_0.encoded[0_i32 as usize] as u64)
+            .wrapping_rem(10_i32 as u64) as u32;
+        e.c2rust_unnamed_0.encoded[0_i32 as usize] =
+            ((c3 as uint64_t) << 32_i32 | e.c2rust_unnamed_0.encoded[0_i32 as usize] as u64)
+                .wrapping_div(10_i32 as u64) as uint32_t;
+        decimal[(34_i32 as u64).wrapping_sub(i) as usize] = c4 as libc::c_uchar;
         i = i.wrapping_add(1);
     }
     let mut q: *mut libc::c_char = confirmation_id;
-    i = 0 as i32 as size_t;
-    while i < 7 as i32 as u64 {
+    i = 0_i32 as size_t;
+    while i < 7_i32 as u64 {
         if i != 0 {
             let fresh2 = q;
             q = q.offset(1);
@@ -1436,31 +1405,31 @@ unsafe extern "C" fn Generate(
         }
         let mut p_0: *mut libc::c_uchar = decimal
             .as_mut_ptr()
-            .offset(i.wrapping_mul(5 as i32 as u64) as isize);
-        *q.offset(0 as i32 as isize) =
-            (*p_0.offset(0 as i32 as isize) as i32 + '0' as i32) as libc::c_char;
-        *q.offset(1 as i32 as isize) =
-            (*p_0.offset(1 as i32 as isize) as i32 + '0' as i32) as libc::c_char;
-        *q.offset(2 as i32 as isize) =
-            (*p_0.offset(2 as i32 as isize) as i32 + '0' as i32) as libc::c_char;
-        *q.offset(3 as i32 as isize) =
-            (*p_0.offset(3 as i32 as isize) as i32 + '0' as i32) as libc::c_char;
-        *q.offset(4 as i32 as isize) =
-            (*p_0.offset(4 as i32 as isize) as i32 + '0' as i32) as libc::c_char;
-        *q.offset(5 as i32 as isize) = ((*p_0.offset(0 as i32 as isize) as i32
-            + *p_0.offset(1 as i32 as isize) as i32 * 2 as i32
-            + *p_0.offset(2 as i32 as isize) as i32
-            + *p_0.offset(3 as i32 as isize) as i32 * 2 as i32
-            + *p_0.offset(4 as i32 as isize) as i32)
-            % 7 as i32
+            .offset(i.wrapping_mul(5_i32 as u64) as isize);
+        *q.offset(0_i32 as isize) =
+            (*p_0.offset(0_i32 as isize) as i32 + '0' as i32) as libc::c_char;
+        *q.offset(1_i32 as isize) =
+            (*p_0.offset(1_i32 as isize) as i32 + '0' as i32) as libc::c_char;
+        *q.offset(2_i32 as isize) =
+            (*p_0.offset(2_i32 as isize) as i32 + '0' as i32) as libc::c_char;
+        *q.offset(3_i32 as isize) =
+            (*p_0.offset(3_i32 as isize) as i32 + '0' as i32) as libc::c_char;
+        *q.offset(4_i32 as isize) =
+            (*p_0.offset(4_i32 as isize) as i32 + '0' as i32) as libc::c_char;
+        *q.offset(5_i32 as isize) = ((*p_0.offset(0_i32 as isize) as i32
+            + *p_0.offset(1_i32 as isize) as i32 * 2_i32
+            + *p_0.offset(2_i32 as isize) as i32
+            + *p_0.offset(3_i32 as isize) as i32 * 2_i32
+            + *p_0.offset(4_i32 as isize) as i32)
+            % 7_i32
             + '0' as i32) as libc::c_char;
-        q = q.offset(6 as i32 as isize);
+        q = q.offset(6_i32 as isize);
         i = i.wrapping_add(1);
     }
     let fresh3 = q;
     q = q.offset(1);
-    *fresh3 = 0 as i32 as libc::c_char;
-    return 0 as i32;
+    *fresh3 = 0_i32 as libc::c_char;
+    0_i32
 }
 
 #[derive(Error, Debug)]