valter/umskt-rs
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Run clippy --fix again

Browse source
This commit is contained in:
Alex Page 2023-06-21 20:56:48 -04:00
parent 7145e14d29
commit dfbd994d19
1 changed files with 104 additions and 111 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

215
src/confid.rs
View file

@ -64,7 +64,7 @@ static mut f: [uint64_t; 6] = [
1_i32 as uint64_t, 1_i32 as uint64_t,
]; ];
#[no_mangle] #[no_mangle]
unsafe extern "C" fn residue_add(mut x: uint64_t, mut y: uint64_t) -> uint64_t { unsafe extern "C" fn residue_add(x: uint64_t, y: uint64_t) -> uint64_t {
let mut z: uint64_t = x.wrapping_add(y); let mut z: uint64_t = x.wrapping_add(y);
if z >= 0x16a6b036d7f2a79_u64 { if z >= 0x16a6b036d7f2a79_u64 {
z = z.wrapping_sub(0x16a6b036d7f2a79_u64) as uint64_t as uint64_t; z = z.wrapping_sub(0x16a6b036d7f2a79_u64) as uint64_t as uint64_t;
@ -72,7 +72,7 @@ unsafe extern "C" fn residue_add(mut x: uint64_t, mut y: uint64_t) -> uint64_t {
z z
} }
#[no_mangle] #[no_mangle]
unsafe extern "C" fn residue_sub(mut x: uint64_t, mut y: uint64_t) -> uint64_t { unsafe extern "C" fn residue_sub(x: uint64_t, y: uint64_t) -> uint64_t {
let mut z: uint64_t = x.wrapping_sub(y); let mut z: uint64_t = x.wrapping_sub(y);
if x < y { if x < y {
z = z.wrapping_add(0x16a6b036d7f2a79_u64) as uint64_t as uint64_t; z = z.wrapping_add(0x16a6b036d7f2a79_u64) as uint64_t as uint64_t;
@ -81,20 +81,20 @@ unsafe extern "C" fn residue_sub(mut x: uint64_t, mut y: uint64_t) -> uint64_t {
} }
#[no_mangle] #[no_mangle]
unsafe extern "C" fn __umul128( unsafe extern "C" fn __umul128(
mut multiplier: uint64_t, multiplier: uint64_t,
mut multiplicand: uint64_t, multiplicand: uint64_t,
mut product_hi: *mut uint64_t, product_hi: *mut uint64_t,
) -> uint64_t { ) -> uint64_t {
let mut a: uint64_t = multiplier >> 32_i32; let a: uint64_t = multiplier >> 32_i32;
let mut b: uint64_t = multiplier & 0xffffffff_u32 as u64; let b: uint64_t = multiplier & 0xffffffff_u32 as u64;
let mut c: uint64_t = multiplicand >> 32_i32; let c: uint64_t = multiplicand >> 32_i32;
let mut d: uint64_t = multiplicand & 0xffffffff_u32 as u64; let d: uint64_t = multiplicand & 0xffffffff_u32 as u64;
let mut ad: uint64_t = a.wrapping_mul(d); let ad: uint64_t = a.wrapping_mul(d);
let mut bd: uint64_t = b.wrapping_mul(d); let bd: uint64_t = b.wrapping_mul(d);
let mut adbc: uint64_t = ad.wrapping_add(b.wrapping_mul(c)); let adbc: uint64_t = ad.wrapping_add(b.wrapping_mul(c));
let mut adbc_carry: uint64_t = (if adbc < ad { 1_i32 } else { 0_i32 }) as uint64_t; let 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 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; let product_lo_carry: uint64_t = (if product_lo < bd { 1_i32 } else { 0_i32 }) as uint64_t;
*product_hi = a *product_hi = a
.wrapping_mul(c) .wrapping_mul(c)
.wrapping_add(adbc >> 32_i32) .wrapping_add(adbc >> 32_i32)
@ -103,18 +103,18 @@ unsafe extern "C" fn __umul128(
product_lo product_lo
} }
#[no_mangle] #[no_mangle]
unsafe extern "C" fn ui128_quotient_mod(mut lo: uint64_t, mut hi: uint64_t) -> uint64_t { unsafe extern "C" fn ui128_quotient_mod(lo: uint64_t, hi: uint64_t) -> uint64_t {
let mut prod1: uint64_t = 0; let mut prod1: uint64_t = 0;
__umul128(lo, 0x604fa6a1c6346a87_i64 as uint64_t, &mut prod1); __umul128(lo, 0x604fa6a1c6346a87_i64 as uint64_t, &mut prod1);
let mut part1hi: uint64_t = 0; let mut part1hi: uint64_t = 0;
let mut part1lo: uint64_t = __umul128(lo, 0x2d351c6d04f8b_i64 as uint64_t, &mut part1hi); let part1lo: uint64_t = __umul128(lo, 0x2d351c6d04f8b_i64 as uint64_t, &mut part1hi);
let mut part2hi: uint64_t = 0; let mut part2hi: uint64_t = 0;
let mut part2lo: uint64_t = __umul128(hi, 0x604fa6a1c6346a87_i64 as uint64_t, &mut part2hi); let part2lo: uint64_t = __umul128(hi, 0x604fa6a1c6346a87_i64 as uint64_t, &mut part2hi);
let mut sum1: uint64_t = part1lo.wrapping_add(part2lo); let mut sum1: uint64_t = part1lo.wrapping_add(part2lo);
let mut sum1carry: u32 = (sum1 < part1lo) as i32 as u32; let mut sum1carry: u32 = (sum1 < part1lo) as i32 as u32;
sum1 = sum1.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); 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 prod2: uint64_t = part1hi.wrapping_add(part2hi).wrapping_add(sum1carry as u64);
let mut prod3hi: uint64_t = 0; let mut prod3hi: uint64_t = 0;
let mut prod3lo: uint64_t = __umul128(hi, 0x2d351c6d04f8b_i64 as uint64_t, &mut prod3hi); let mut prod3lo: uint64_t = __umul128(hi, 0x2d351c6d04f8b_i64 as uint64_t, &mut prod3hi);
prod3lo = prod3lo.wrapping_add(prod2) as uint64_t as uint64_t; prod3lo = prod3lo.wrapping_add(prod2) as uint64_t as uint64_t;
@ -122,14 +122,14 @@ unsafe extern "C" fn ui128_quotient_mod(mut lo: uint64_t, mut hi: uint64_t) -> u
prod3lo >> 42_i32 | prod3hi << 22_i32 prod3lo >> 42_i32 | prod3hi << 22_i32
} }
#[no_mangle] #[no_mangle]
unsafe extern "C" fn residue_mul(mut x: uint64_t, mut y: uint64_t) -> uint64_t { unsafe extern "C" fn residue_mul(x: uint64_t, y: uint64_t) -> uint64_t {
let mut hi: uint64_t = 0; let mut hi: uint64_t = 0;
let mut lo: uint64_t = __umul128(x, y, &mut hi); let lo: uint64_t = __umul128(x, y, &mut hi);
let mut quotient: uint64_t = ui128_quotient_mod(lo, hi); let quotient: uint64_t = ui128_quotient_mod(lo, hi);
lo.wrapping_sub(quotient.wrapping_mul(0x16a6b036d7f2a79_u64)) as uint64_t lo.wrapping_sub(quotient.wrapping_mul(0x16a6b036d7f2a79_u64)) as uint64_t
} }
#[no_mangle] #[no_mangle]
unsafe extern "C" fn residue_pow(mut x: uint64_t, mut y: uint64_t) -> uint64_t { unsafe extern "C" fn residue_pow(x: uint64_t, mut y: uint64_t) -> uint64_t {
if y == 0_i32 as u64 { if y == 0_i32 as u64 {
return 1_i32 as uint64_t; return 1_i32 as uint64_t;
} }
@ -156,10 +156,10 @@ unsafe extern "C" fn inverse(mut u: uint64_t, mut v: uint64_t) -> uint64_t {
let mut tmp: int64_t = 0; let mut tmp: int64_t = 0;
let mut xu: int64_t = 1_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 xv: int64_t = 0_i32 as int64_t;
let mut v0: uint64_t = v; let v0: uint64_t = v;
while u > 1_i32 as u64 { while u > 1_i32 as u64 {
let mut d: uint64_t = v.wrapping_div(u); let d: uint64_t = v.wrapping_div(u);
let mut remainder: uint64_t = v.wrapping_rem(u); let remainder: uint64_t = v.wrapping_rem(u);
tmp = u as int64_t; tmp = u as int64_t;
u = remainder; u = remainder;
v = tmp as uint64_t; v = tmp as uint64_t;
@ -172,15 +172,15 @@ unsafe extern "C" fn inverse(mut u: uint64_t, mut v: uint64_t) -> uint64_t {
xu as uint64_t xu as uint64_t
} }
#[no_mangle] #[no_mangle]
unsafe extern "C" fn residue_inv(mut x: uint64_t) -> uint64_t { unsafe extern "C" fn residue_inv(x: uint64_t) -> uint64_t {
inverse(x, 0x16a6b036d7f2a79_u64 as uint64_t) inverse(x, 0x16a6b036d7f2a79_u64 as uint64_t)
} }
#[no_mangle] #[no_mangle]
unsafe extern "C" fn residue_sqrt(mut what: uint64_t) -> uint64_t { unsafe extern "C" fn residue_sqrt(what: uint64_t) -> uint64_t {
if what == 0 { if what == 0 {
return 0_i32 as uint64_t; return 0_i32 as uint64_t;
} }
let mut g: uint64_t = 43_i32 as uint64_t; let g: uint64_t = 43_i32 as uint64_t;
let mut z: uint64_t = 0; let mut z: uint64_t = 0;
let mut y: uint64_t = 0; let mut y: uint64_t = 0;
let mut r: uint64_t = 0; let mut r: uint64_t = 0;
@ -267,7 +267,7 @@ unsafe extern "C" fn find_divisor_v(mut d: *mut TDivisor) -> i32 {
} }
return 0_i32; return 0_i32;
} }
let mut sqr: uint64_t = residue_mul( let sqr: uint64_t = residue_mul(
residue_mul(f1, f1), residue_mul(f1, f1),
residue_inv(residue_add(coeff1, coeff1)), residue_inv(residue_add(coeff1, coeff1)),
); );
@ -285,7 +285,7 @@ unsafe extern "C" fn find_divisor_v(mut d: *mut TDivisor) -> i32 {
return 0_i32; return 0_i32;
} }
d_0 = residue_add(d_0, d_0); d_0 = residue_add(d_0, d_0);
let mut inv: uint64_t = residue_inv(coeff2); let inv: uint64_t = residue_inv(coeff2);
let mut root: uint64_t = residue_mul(residue_add(coeff1, d_0), inv); let mut root: uint64_t = residue_mul(residue_add(coeff1, d_0), inv);
v1 = residue_sqrt(root); v1 = residue_sqrt(root);
if v1 == 0xffffffffffffffff_u64 { if v1 == 0xffffffffffffffff_u64 {
@ -296,7 +296,7 @@ unsafe extern "C" fn find_divisor_v(mut d: *mut TDivisor) -> i32 {
} }
} }
} }
let mut v0: uint64_t = residue_mul( let v0: uint64_t = residue_mul(
residue_add(f1, residue_mul(u1, residue_mul(v1, v1))), residue_add(f1, residue_mul(u1, residue_mul(v1, v1))),
residue_inv(residue_add(v1, v1)), residue_inv(residue_add(v1, v1)),
); );
@ -306,12 +306,12 @@ unsafe extern "C" fn find_divisor_v(mut d: *mut TDivisor) -> i32 {
} }
#[no_mangle] #[no_mangle]
unsafe extern "C" fn polynomial_mul( unsafe extern "C" fn polynomial_mul(
mut adeg: i32, adeg: i32,
mut a: *const uint64_t, a: *const uint64_t,
mut bdeg: i32, bdeg: i32,
mut b: *const uint64_t, b: *const uint64_t,
mut resultprevdeg: i32, mut resultprevdeg: i32,
mut result: *mut uint64_t, result: *mut uint64_t,
) -> i32 { ) -> i32 {
if adeg < 0_i32 || bdeg < 0_i32 { if adeg < 0_i32 || bdeg < 0_i32 {
return resultprevdeg; return resultprevdeg;
@ -343,17 +343,17 @@ unsafe extern "C" fn polynomial_mul(
} }
#[no_mangle] #[no_mangle]
unsafe extern "C" fn polynomial_div_monic( unsafe extern "C" fn polynomial_div_monic(
mut adeg: i32, adeg: i32,
mut a: *mut uint64_t, a: *mut uint64_t,
mut bdeg: i32, bdeg: i32,
mut b: *const uint64_t, b: *const uint64_t,
mut quotient: *mut uint64_t, quotient: *mut uint64_t,
) -> i32 { ) -> i32 {
let mut i: i32 = 0; let mut i: i32 = 0;
let mut j: i32 = 0; let mut j: i32 = 0;
i = adeg - bdeg; i = adeg - bdeg;
while i >= 0_i32 { while i >= 0_i32 {
let mut q: uint64_t = *a.offset((i + bdeg) as isize); let q: uint64_t = *a.offset((i + bdeg) as isize);
if !quotient.is_null() { if !quotient.is_null() {
*quotient.offset(i as isize) = q; *quotient.offset(i as isize) = q;
} }
@ -376,16 +376,16 @@ unsafe extern "C" fn polynomial_div_monic(
} }
#[no_mangle] #[no_mangle]
unsafe extern "C" fn polynomial_xgcd( unsafe extern "C" fn polynomial_xgcd(
mut adeg: i32, adeg: i32,
mut a: *const uint64_t, a: *const uint64_t,
mut bdeg: i32, bdeg: i32,
mut b: *const uint64_t, b: *const uint64_t,
mut pgcddeg: *mut i32, pgcddeg: *mut i32,
mut gcd: *mut uint64_t, gcd: *mut uint64_t,
mut pmult1deg: *mut i32, pmult1deg: *mut i32,
mut mult1: *mut uint64_t, mult1: *mut uint64_t,
mut pmult2deg: *mut i32, pmult2deg: *mut i32,
mut mult2: *mut uint64_t, mult2: *mut uint64_t,
) { ) {
let mut sdeg: i32 = -1_i32; 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 s: [uint64_t; 3] = [0_i32 as uint64_t, 0_i32 as uint64_t, 0_i32 as uint64_t];
@ -451,8 +451,8 @@ unsafe extern "C" fn polynomial_xgcd(
t[2_i32 as usize] = *mult2.offset(2_i32 as isize); t[2_i32 as usize] = *mult2.offset(2_i32 as isize);
*mult2.offset(2_i32 as isize) = tmp2; *mult2.offset(2_i32 as isize) = tmp2;
} else { } else {
let mut delta: i32 = gcddeg - rdeg; let delta: i32 = gcddeg - rdeg;
let mut mult: uint64_t = let mult: uint64_t =
residue_mul(*gcd.offset(gcddeg as isize), residue_inv(r[rdeg as usize])); residue_mul(*gcd.offset(gcddeg as isize), residue_inv(r[rdeg as usize]));
let mut i: i32 = 0_i32; let mut i: i32 = 0_i32;
while i <= rdeg { while i <= rdeg {
@ -501,9 +501,9 @@ unsafe extern "C" fn polynomial_xgcd(
} }
#[no_mangle] #[no_mangle]
unsafe extern "C" fn u2poly( unsafe extern "C" fn u2poly(
mut src: *const TDivisor, src: *const TDivisor,
mut polyu: *mut uint64_t, polyu: *mut uint64_t,
mut polyv: *mut uint64_t, polyv: *mut uint64_t,
) -> i32 { ) -> i32 {
if (*src).u[1_i32 as usize] as u64 != 0xffffffffffffffff_u64 { 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(0_i32 as isize) = (*src).u[0_i32 as usize] as uint64_t;
@ -527,16 +527,16 @@ unsafe extern "C" fn u2poly(
} }
#[no_mangle] #[no_mangle]
unsafe extern "C" fn divisor_add( unsafe extern "C" fn divisor_add(
mut src1: *const TDivisor, src1: *const TDivisor,
mut src2: *const TDivisor, src2: *const TDivisor,
mut dst: *mut TDivisor, mut dst: *mut TDivisor,
) { ) {
let mut u1: [uint64_t; 3] = [0; 3]; let mut u1: [uint64_t; 3] = [0; 3];
let mut u2: [uint64_t; 3] = [0; 3]; let mut u2: [uint64_t; 3] = [0; 3];
let mut v1: [uint64_t; 2] = [0; 2]; let mut v1: [uint64_t; 2] = [0; 2];
let mut v2: [uint64_t; 2] = [0; 2]; let mut v2: [uint64_t; 2] = [0; 2];
let mut u1deg: i32 = u2poly(src1, u1.as_mut_ptr(), v1.as_mut_ptr()); let u1deg: i32 = u2poly(src1, u1.as_mut_ptr(), v1.as_mut_ptr());
let mut u2deg: i32 = u2poly(src2, u2.as_mut_ptr(), v2.as_mut_ptr()); let u2deg: i32 = u2poly(src2, u2.as_mut_ptr(), v2.as_mut_ptr());
let mut d1deg: i32 = 0; let mut d1deg: i32 = 0;
let mut e1deg: i32 = 0; let mut e1deg: i32 = 0;
let mut e2deg: i32 = 0; let mut e2deg: i32 = 0;
@ -560,7 +560,7 @@ unsafe extern "C" fn divisor_add(
residue_add(v1[1_i32 as usize], v2[1_i32 as usize]), residue_add(v1[1_i32 as usize], v2[1_i32 as usize]),
0_i32 as uint64_t, 0_i32 as uint64_t,
]; ];
let mut bdeg: i32 = if b[1_i32 as usize] == 0_i32 as u64 { let bdeg: i32 = if b[1_i32 as usize] == 0_i32 as u64 {
if b[0_i32 as usize] == 0_i32 as u64 { if b[0_i32 as usize] == 0_i32 as u64 {
-1_i32 -1_i32
} else { } else {
@ -587,7 +587,7 @@ unsafe extern "C" fn divisor_add(
&mut c2deg, &mut c2deg,
c2.as_mut_ptr(), c2.as_mut_ptr(),
); );
let mut dmult: uint64_t = residue_inv(d[ddeg as usize]); let dmult: uint64_t = residue_inv(d[ddeg as usize]);
let mut i: i32 = 0; let mut i: i32 = 0;
i = 0_i32; i = 0_i32;
while i < ddeg { while i < ddeg {
@ -744,7 +744,7 @@ unsafe extern "C" fn divisor_add(
udiv_0.as_mut_ptr(), udiv_0.as_mut_ptr(),
); );
udeg = tmpdeg - udeg; udeg = tmpdeg - udeg;
let mut mult: uint64_t = residue_inv(udiv_0[udeg as usize]); let mult: uint64_t = residue_inv(udiv_0[udeg as usize]);
i = 0_i32; i = 0_i32;
while i < udeg { while i < udeg {
u[i as usize] = residue_mul(udiv_0[i as usize], mult); u[i as usize] = residue_mul(udiv_0[i as usize], mult);
@ -794,11 +794,7 @@ unsafe extern "C" fn divisor_add(
}; };
} }
#[no_mangle] #[no_mangle]
unsafe extern "C" fn divisor_mul( unsafe extern "C" fn divisor_mul(src: *const TDivisor, mut mult: uint64_t, mut dst: *mut TDivisor) {
mut src: *const TDivisor,
mut mult: uint64_t,
mut dst: *mut TDivisor,
) {
if mult == 0_i32 as u64 { if mult == 0_i32 as u64 {
(*dst).u[0_i32 as usize] = 0xffffffffffffffff_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).u[1_i32 as usize] = 0xffffffffffffffff_u64 as uint16_t;
@ -825,7 +821,7 @@ unsafe extern "C" fn divisor_mul(
} }
#[no_mangle] #[no_mangle]
unsafe extern "C" fn divisor_mul128( unsafe extern "C" fn divisor_mul128(
mut src: *const TDivisor, src: *const TDivisor,
mut mult_lo: uint64_t, mut mult_lo: uint64_t,
mut mult_hi: uint64_t, mut mult_hi: uint64_t,
mut dst: *mut TDivisor, mut dst: *mut TDivisor,
@ -863,14 +859,11 @@ unsafe extern "C" fn divisor_mul128(
} }
} }
#[no_mangle] #[no_mangle]
unsafe extern "C" fn rol(mut x: u32, mut shift: i32) -> u32 { unsafe extern "C" fn rol(x: u32, shift: i32) -> u32 {
x << shift | x >> (32_i32 - shift) x << shift | x >> (32_i32 - shift)
} }
#[no_mangle] #[no_mangle]
unsafe extern "C" fn sha1_single_block( unsafe extern "C" fn sha1_single_block(input: *mut libc::c_uchar, output: *mut libc::c_uchar) {
mut input: *mut libc::c_uchar,
mut output: *mut libc::c_uchar,
) {
let mut a: u32 = 0; let mut a: u32 = 0;
let mut b: u32 = 0; let mut b: u32 = 0;
let mut c: u32 = 0; let mut c: u32 = 0;
@ -909,7 +902,7 @@ unsafe extern "C" fn sha1_single_block(
} }
i = 0_i32 as size_t; i = 0_i32 as size_t;
while i < 20_i32 as u64 { while i < 20_i32 as u64 {
let mut tmp: u32 = (rol(a, 5_i32)) let tmp: u32 = (rol(a, 5_i32))
.wrapping_add(b & c | !b & d) .wrapping_add(b & c | !b & d)
.wrapping_add(e) .wrapping_add(e)
.wrapping_add(w[i as usize]) .wrapping_add(w[i as usize])
@ -923,7 +916,7 @@ unsafe extern "C" fn sha1_single_block(
} }
i = 20_i32 as size_t; i = 20_i32 as size_t;
while i < 40_i32 as u64 { while i < 40_i32 as u64 {
let mut tmp_0: u32 = (rol(a, 5_i32)) let tmp_0: u32 = (rol(a, 5_i32))
.wrapping_add(b ^ c ^ d) .wrapping_add(b ^ c ^ d)
.wrapping_add(e) .wrapping_add(e)
.wrapping_add(w[i as usize]) .wrapping_add(w[i as usize])
@ -937,7 +930,7 @@ unsafe extern "C" fn sha1_single_block(
} }
i = 40_i32 as size_t; i = 40_i32 as size_t;
while i < 60_i32 as u64 { while i < 60_i32 as u64 {
let mut tmp_1: u32 = (rol(a, 5_i32)) let tmp_1: u32 = (rol(a, 5_i32))
.wrapping_add(b & c | b & d | c & d) .wrapping_add(b & c | b & d | c & d)
.wrapping_add(e) .wrapping_add(e)
.wrapping_add(w[i as usize]) .wrapping_add(w[i as usize])
@ -951,7 +944,7 @@ unsafe extern "C" fn sha1_single_block(
} }
i = 60_i32 as size_t; i = 60_i32 as size_t;
while i < 80_i32 as u64 { while i < 80_i32 as u64 {
let mut tmp_2: u32 = (rol(a, 5_i32)) let tmp_2: u32 = (rol(a, 5_i32))
.wrapping_add(b ^ c ^ d) .wrapping_add(b ^ c ^ d)
.wrapping_add(e) .wrapping_add(e)
.wrapping_add(w[i as usize]) .wrapping_add(w[i as usize])
@ -991,14 +984,14 @@ unsafe extern "C" fn sha1_single_block(
} }
#[no_mangle] #[no_mangle]
unsafe extern "C" fn Mix( unsafe extern "C" fn Mix(
mut buffer: *mut libc::c_uchar, buffer: *mut libc::c_uchar,
mut bufSize: size_t, bufSize: size_t,
mut key: *const libc::c_uchar, key: *const libc::c_uchar,
mut keySize: size_t, keySize: size_t,
) { ) {
let mut sha1_input: [libc::c_uchar; 64] = [0; 64]; let mut sha1_input: [libc::c_uchar; 64] = [0; 64];
let mut sha1_result: [libc::c_uchar; 20] = [0; 20]; let mut sha1_result: [libc::c_uchar; 20] = [0; 20];
let mut half: size_t = bufSize.wrapping_div(2_i32 as u64); let half: size_t = bufSize.wrapping_div(2_i32 as u64);
let mut external_counter: i32 = 0; let mut external_counter: i32 = 0;
external_counter = 0_i32; external_counter = 0_i32;
while external_counter < 4_i32 { while external_counter < 4_i32 {
@ -1037,7 +1030,7 @@ unsafe extern "C" fn Mix(
} }
i = 0_i32 as size_t; i = 0_i32 as size_t;
while i < half { while i < half {
let mut tmp: libc::c_uchar = *buffer.offset(i.wrapping_add(half) as isize); let 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 *buffer.offset(i.wrapping_add(half) as isize) = (*buffer.offset(i as isize) as i32
^ sha1_result[i as usize] as i32) ^ sha1_result[i as usize] as i32)
as libc::c_uchar; as libc::c_uchar;
@ -1049,14 +1042,14 @@ unsafe extern "C" fn Mix(
} }
#[no_mangle] #[no_mangle]
unsafe extern "C" fn Unmix( unsafe extern "C" fn Unmix(
mut buffer: *mut libc::c_uchar, buffer: *mut libc::c_uchar,
mut bufSize: size_t, bufSize: size_t,
mut key: *const libc::c_uchar, key: *const libc::c_uchar,
mut keySize: size_t, keySize: size_t,
) { ) {
let mut sha1_input: [libc::c_uchar; 64] = [0; 64]; let mut sha1_input: [libc::c_uchar; 64] = [0; 64];
let mut sha1_result: [libc::c_uchar; 20] = [0; 20]; let mut sha1_result: [libc::c_uchar; 20] = [0; 20];
let mut half: size_t = bufSize.wrapping_div(2_i32 as u64); let half: size_t = bufSize.wrapping_div(2_i32 as u64);
let mut external_counter: i32 = 0; let mut external_counter: i32 = 0;
external_counter = 0_i32; external_counter = 0_i32;
while external_counter < 4_i32 { while external_counter < 4_i32 {
@ -1095,7 +1088,7 @@ unsafe extern "C" fn Unmix(
} }
i = 0_i32 as size_t; i = 0_i32 as size_t;
while i < half { while i < half {
let mut tmp: libc::c_uchar = *buffer.offset(i as isize); let tmp: libc::c_uchar = *buffer.offset(i as isize);
*buffer.offset(i as isize) = (*buffer.offset(i.wrapping_add(half) as isize) as i32 *buffer.offset(i as isize) = (*buffer.offset(i.wrapping_add(half) as isize) as i32
^ sha1_result[i as usize] as i32) ^ sha1_result[i as usize] as i32)
as libc::c_uchar; as libc::c_uchar;
@ -1107,8 +1100,8 @@ unsafe extern "C" fn Unmix(
} }
#[no_mangle] #[no_mangle]
unsafe extern "C" fn Generate( unsafe extern "C" fn Generate(
mut installation_id_str: *const libc::c_char, installation_id_str: *const libc::c_char,
mut confirmation_id: *mut libc::c_char, confirmation_id: *mut libc::c_char,
) -> i32 { ) -> i32 {
let mut installation_id: [libc::c_uchar; 19] = [0; 19]; let mut installation_id: [libc::c_uchar; 19] = [0; 19];
let mut installation_id_len: size_t = 0_i32 as size_t; let mut installation_id_len: size_t = 0_i32 as size_t;
@ -1119,7 +1112,7 @@ unsafe extern "C" fn Generate(
let mut i: size_t = 0; let mut i: size_t = 0;
while *p != 0 { while *p != 0 {
if !(*p as i32 == ' ' as i32 || *p as i32 == '-' as i32) { if !(*p as i32 == ' ' as i32 || *p as i32 == '-' as i32) {
let mut d: i32 = *p as i32 - '0' as i32; let d: i32 = *p as i32 - '0' as i32;
if !(0_i32..=9_i32).contains(&d) { if !(0_i32..=9_i32).contains(&d) {
return 3_i32; return 3_i32;
} }
@ -1152,7 +1145,7 @@ unsafe extern "C" fn Generate(
let mut carry: libc::c_uchar = d as libc::c_uchar; let mut carry: libc::c_uchar = d as libc::c_uchar;
i = 0_i32 as size_t; i = 0_i32 as size_t;
while i < installation_id_len { while i < installation_id_len {
let mut x: u32 = let x: u32 =
(installation_id[i as usize] as i32 * 10_i32 + carry as i32) as u32; (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; installation_id[i as usize] = (x & 0xff_i32 as u32) as libc::c_uchar;
carry = (x >> 8_i32) as libc::c_uchar; carry = (x >> 8_i32) as libc::c_uchar;
@ -1204,13 +1197,13 @@ unsafe extern "C" fn Generate(
installation_id.as_mut_ptr() as *const libc::c_void, installation_id.as_mut_ptr() as *const libc::c_void,
::std::mem::size_of::<C2RustUnnamed_4>() as u64, ::std::mem::size_of::<C2RustUnnamed_4>() as u64,
); );
let mut productId1: u32 = (parsed.ProductIDLow & ((1_i32 << 17_i32) - 1_i32) as u64) as u32; let productId1: u32 = (parsed.ProductIDLow & ((1_i32 << 17_i32) - 1_i32) as u64) as u32;
let mut productId2: u32 = let productId2: u32 =
(parsed.ProductIDLow >> 17_i32 & ((1_i32 << 10_i32) - 1_i32) as u64) as u32; (parsed.ProductIDLow >> 17_i32 & ((1_i32 << 10_i32) - 1_i32) as u64) as u32;
let mut productId3: u32 = let productId3: u32 =
(parsed.ProductIDLow >> 27_i32 & ((1_i32 << 25_i32) - 1_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 version: u32 = (parsed.ProductIDLow >> 52_i32 & 7_i32 as u64) as u32;
let mut productId4: u32 = let productId4: u32 =
(parsed.ProductIDLow >> 55_i32 | ((parsed.ProductIDHigh as i32) << 9_i32) as u64) as u32; (parsed.ProductIDLow >> 55_i32 | ((parsed.ProductIDHigh as i32) << 9_i32) as u64) as u32;
if version if version
!= (if totalCount == 41_i32 as u64 { != (if totalCount == 41_i32 as u64 {
@ -1255,7 +1248,7 @@ unsafe extern "C" fn Generate(
16_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 x2: uint64_t = ui128_quotient_mod(u.c2rust_unnamed.lo, u.c2rust_unnamed.hi);
let mut x1: uint64_t = let x1: uint64_t =
u.c2rust_unnamed u.c2rust_unnamed
.lo .lo
.wrapping_sub(x2.wrapping_mul(0x16a6b036d7f2a79_u64)) as uint64_t; .wrapping_sub(x2.wrapping_mul(0x16a6b036d7f2a79_u64)) as uint64_t;
@ -1307,13 +1300,13 @@ unsafe extern "C" fn Generate(
.wrapping_add((e.c2rust_unnamed.encoded_lo < 0x16a6b036d7f2a79_u64) as i32 as u64) .wrapping_add((e.c2rust_unnamed.encoded_lo < 0x16a6b036d7f2a79_u64) as i32 as u64)
as uint64_t as uint64_t; as uint64_t as uint64_t;
} else { } else {
let mut x1_0: uint64_t = (if d_0.u[1_i32 as usize] as i32 % 2_i32 != 0 { let 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) (d_0.u[1_i32 as usize] as u64).wrapping_add(0x16a6b036d7f2a79_u64)
} else { } else {
d_0.u[1_i32 as usize] as u64 d_0.u[1_i32 as usize] as u64
}) })
.wrapping_div(2_i32 as u64) as uint64_t; .wrapping_div(2_i32 as u64) as uint64_t;
let mut x2sqr: uint64_t = let x2sqr: uint64_t =
residue_sub(residue_mul(x1_0, x1_0), d_0.u[0_i32 as usize] as 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); let mut x2_0: uint64_t = residue_sqrt(x2sqr);
if x2_0 == 0xffffffffffffffff_u64 { if x2_0 == 0xffffffffffffffff_u64 {
@ -1332,12 +1325,12 @@ unsafe extern "C" fn Generate(
as uint64_t as uint64_t; as uint64_t as uint64_t;
} else { } else {
let mut x1a: uint64_t = residue_sub(x1_0, x2_0); let mut x1a: uint64_t = residue_sub(x1_0, x2_0);
let mut y1: uint64_t = residue_sub( let y1: uint64_t = residue_sub(
d_0.v[0_i32 as usize] as uint64_t, d_0.v[0_i32 as usize] as uint64_t,
residue_mul(d_0.v[1_i32 as usize] as uint64_t, x1a), 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 x2a: uint64_t = residue_add(x1_0, x2_0);
let mut y2: uint64_t = residue_sub( let y2: uint64_t = residue_sub(
d_0.v[0_i32 as usize] as uint64_t, d_0.v[0_i32 as usize] as uint64_t,
residue_mul(d_0.v[1_i32 as usize] as uint64_t, x2a), residue_mul(d_0.v[1_i32 as usize] as uint64_t, x2a),
); );
@ -1364,23 +1357,23 @@ unsafe extern "C" fn Generate(
let mut decimal: [libc::c_uchar; 35] = [0; 35]; let mut decimal: [libc::c_uchar; 35] = [0; 35];
i = 0_i32 as size_t; i = 0_i32 as size_t;
while i < 35_i32 as u64 { 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); let 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] e.c2rust_unnamed_0.encoded[3_i32 as usize] = e.c2rust_unnamed_0.encoded[3_i32 as usize]
.wrapping_div(10_i32 as u32) .wrapping_div(10_i32 as u32)
as uint32_t as uint32_t; as uint32_t as uint32_t;
let mut c2: u32 = ((c as uint64_t) << 32_i32 let c2: u32 = ((c as uint64_t) << 32_i32
| e.c2rust_unnamed_0.encoded[2_i32 as usize] as u64) | e.c2rust_unnamed_0.encoded[2_i32 as usize] as u64)
.wrapping_rem(10_i32 as u64) as u32; .wrapping_rem(10_i32 as u64) as u32;
e.c2rust_unnamed_0.encoded[2_i32 as usize] = 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) ((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; .wrapping_div(10_i32 as u64) as uint32_t;
let mut c3: u32 = ((c2 as uint64_t) << 32_i32 let c3: u32 = ((c2 as uint64_t) << 32_i32
| e.c2rust_unnamed_0.encoded[1_i32 as usize] as u64) | e.c2rust_unnamed_0.encoded[1_i32 as usize] as u64)
.wrapping_rem(10_i32 as u64) as u32; .wrapping_rem(10_i32 as u64) as u32;
e.c2rust_unnamed_0.encoded[1_i32 as usize] = 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) ((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; .wrapping_div(10_i32 as u64) as uint32_t;
let mut c4: u32 = ((c3 as uint64_t) << 32_i32 let c4: u32 = ((c3 as uint64_t) << 32_i32
| e.c2rust_unnamed_0.encoded[0_i32 as usize] as u64) | e.c2rust_unnamed_0.encoded[0_i32 as usize] as u64)
.wrapping_rem(10_i32 as u64) as u32; .wrapping_rem(10_i32 as u64) as u32;
e.c2rust_unnamed_0.encoded[0_i32 as usize] = e.c2rust_unnamed_0.encoded[0_i32 as usize] =
@ -1397,7 +1390,7 @@ unsafe extern "C" fn Generate(
q = q.offset(1); q = q.offset(1);
*fresh2 = '-' as i32 as libc::c_char; *fresh2 = '-' as i32 as libc::c_char;
} }
let mut p_0: *mut libc::c_uchar = decimal let p_0: *mut libc::c_uchar = decimal
.as_mut_ptr() .as_mut_ptr()
.offset(i.wrapping_mul(5_i32 as u64) as isize); .offset(i.wrapping_mul(5_i32 as u64) as isize);
*q.offset(0_i32 as isize) = *q.offset(0_i32 as isize) =