diff --git a/Cargo.lock b/Cargo.lock
index 574c80f..2ce4bbf 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -340,6 +340,26 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "thiserror"
+version = "1.0.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "978c9a314bd8dc99be594bc3c175faaa9794be04a5a5e153caba6915336cebac"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f9456a42c5b0d803c8cd86e73dd7cc9edd429499f37a3550d286d5e86720569f"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "umskt"
 version = "0.1.0"
@@ -347,8 +367,10 @@ dependencies = [
  "anyhow",
  "bitreader",
  "clap",
+ "libc",
  "openssl",
  "serde_json",
+ "thiserror",
 ]
 
 [[package]]
diff --git a/Cargo.toml b/Cargo.toml
index 541817d..0a9af1d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -9,5 +9,7 @@ edition = "2021"
 anyhow = "1.0.71"
 bitreader = "0.3.7"
 clap = { version = "4.3.4", features = ["derive"] }
+libc = "0.2.146"
 openssl = { git = "https://github.com/anpage/rust-openssl.git" }
 serde_json = "1.0"
+thiserror = "1.0.40"
diff --git a/src/cli.rs b/src/cli.rs
index ab0c8f6..b69bd44 100644
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -9,7 +9,7 @@ use openssl::{
 };
 use serde_json::{from_reader, from_str};
 
-use crate::{bink1998, bink2002, crypto::initialize_elliptic_curve};
+use crate::{bink1998, bink2002, confid, crypto::initialize_elliptic_curve};
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum Mode {
@@ -268,7 +268,11 @@ impl Cli {
     }
 
     fn confirmation_id(&mut self) -> Result<()> {
-        todo!()
+        if let Some(instid) = &self.options.instid {
+            let confirmation_id = confid::generate(instid)?;
+            println!("Confirmation ID: {confirmation_id}");
+        };
+        Ok(())
     }
 
     fn print_key(pk: &str) {
diff --git a/src/confid.rs b/src/confid.rs
new file mode 100644
index 0000000..7013151
--- /dev/null
+++ b/src/confid.rs
@@ -0,0 +1,1588 @@
+#![allow(
+    dead_code,
+    mutable_transmutes,
+    non_camel_case_types,
+    non_snake_case,
+    non_upper_case_globals,
+    unused_assignments,
+    unused_mut
+)]
+
+use std::ffi::{CStr, CString};
+
+use thiserror::Error;
+extern "C" {
+    fn printf(_: *const libc::c_char, _: ...) -> libc::c_int;
+    fn memcpy(_: *mut libc::c_void, _: *const libc::c_void, _: libc::c_ulong) -> *mut libc::c_void;
+    fn memset(_: *mut libc::c_void, _: libc::c_int, _: libc::c_ulong) -> *mut libc::c_void;
+}
+type size_t = libc::c_ulong;
+type int64_t = libc::c_long;
+type uint16_t = libc::c_ushort;
+type uint32_t = libc::c_uint;
+type uint64_t = libc::c_ulong;
+#[derive(Copy, Clone)]
+#[repr(C)]
+struct TDivisor {
+    u: [uint16_t; 2],
+    v: [uint16_t; 2],
+}
+#[derive(Copy, Clone)]
+#[repr(C)]
+struct C2RustUnnamed {
+    encoded: [uint32_t; 4],
+}
+#[derive(Copy, Clone)]
+#[repr(C)]
+union C2RustUnnamed_0 {
+    c2rust_unnamed: C2RustUnnamed_1,
+    c2rust_unnamed_0: C2RustUnnamed,
+}
+#[derive(Copy, Clone)]
+#[repr(C)]
+struct C2RustUnnamed_1 {
+    encoded_lo: uint64_t,
+    encoded_hi: uint64_t,
+}
+#[derive(Copy, Clone)]
+#[repr(C)]
+struct C2RustUnnamed_2 {
+    lo: uint64_t,
+    hi: uint64_t,
+}
+#[derive(Copy, Clone)]
+#[repr(C)]
+union C2RustUnnamed_3 {
+    buffer: [libc::c_uchar; 14],
+    c2rust_unnamed: C2RustUnnamed_2,
+}
+#[derive(Copy, Clone)]
+#[repr(C, packed)]
+struct C2RustUnnamed_4 {
+    HardwareID: uint64_t,
+    ProductIDLow: uint64_t,
+    ProductIDHigh: libc::c_uchar,
+    KeySHA1: libc::c_ushort,
+}
+static mut f: [uint64_t; 6] = [
+    0 as libc::c_int as uint64_t,
+    0x21840136c85381 as libc::c_ulonglong as uint64_t,
+    0x44197b83892ad0 as libc::c_ulonglong as uint64_t,
+    0x1400606322b3b04 as libc::c_ulonglong as uint64_t,
+    0x1400606322b3b04 as libc::c_ulonglong as uint64_t,
+    1 as libc::c_int 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 libc::c_ulonglong >= 0x16a6b036d7f2a79 as libc::c_ulonglong {
+        z = (z as libc::c_ulonglong).wrapping_sub(0x16a6b036d7f2a79 as libc::c_ulonglong)
+            as uint64_t as uint64_t;
+    }
+    return 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 libc::c_ulonglong).wrapping_add(0x16a6b036d7f2a79 as libc::c_ulonglong)
+            as uint64_t as uint64_t;
+    }
+    return z;
+}
+#[no_mangle]
+unsafe extern "C" fn __umul128(
+    mut multiplier: uint64_t,
+    mut multiplicand: uint64_t,
+    mut product_hi: *mut uint64_t,
+) -> uint64_t {
+    let mut a: uint64_t = multiplier >> 32 as libc::c_int;
+    let mut b: uint64_t = multiplier & 0xffffffff as libc::c_uint as libc::c_ulong;
+    let mut c: uint64_t = multiplicand >> 32 as libc::c_int;
+    let mut d: uint64_t = multiplicand & 0xffffffff as libc::c_uint as libc::c_ulong;
+    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 libc::c_int
+    } else {
+        0 as libc::c_int
+    }) as uint64_t;
+    let mut product_lo: uint64_t = bd.wrapping_add(adbc << 32 as libc::c_int);
+    let mut product_lo_carry: uint64_t = (if product_lo < bd {
+        1 as libc::c_int
+    } else {
+        0 as libc::c_int
+    }) as uint64_t;
+    *product_hi = a
+        .wrapping_mul(c)
+        .wrapping_add(adbc >> 32 as libc::c_int)
+        .wrapping_add(adbc_carry << 32 as libc::c_int)
+        .wrapping_add(product_lo_carry);
+    return product_lo;
+}
+#[no_mangle]
+unsafe extern "C" fn ui128_quotient_mod(mut lo: uint64_t, mut hi: uint64_t) -> uint64_t {
+    let mut prod1: uint64_t = 0;
+    __umul128(lo, 0x604fa6a1c6346a87_i64 as uint64_t, &mut prod1);
+    let mut part1hi: uint64_t = 0;
+    let mut part1lo: uint64_t = __umul128(lo, 0x2d351c6d04f8b_i64 as uint64_t, &mut part1hi);
+    let mut part2hi: uint64_t = 0;
+    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: libc::c_uint = (sum1 < part1lo) as libc::c_int as libc::c_uint;
+    sum1 = (sum1 as libc::c_ulong).wrapping_add(prod1) as uint64_t as uint64_t;
+    sum1carry = sum1carry.wrapping_add((sum1 < prod1) as libc::c_int as libc::c_uint);
+    let mut prod2: uint64_t = part1hi
+        .wrapping_add(part2hi)
+        .wrapping_add(sum1carry as libc::c_ulong);
+    let mut prod3hi: uint64_t = 0;
+    let mut prod3lo: uint64_t = __umul128(hi, 0x2d351c6d04f8b_i64 as uint64_t, &mut prod3hi);
+    prod3lo = (prod3lo as libc::c_ulong).wrapping_add(prod2) as uint64_t as uint64_t;
+    prod3hi = (prod3hi as libc::c_ulong)
+        .wrapping_add((prod3lo < prod2) as libc::c_int as libc::c_ulong) as uint64_t
+        as uint64_t;
+    return prod3lo >> 42 as libc::c_int | prod3hi << 22 as libc::c_int;
+}
+#[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 libc::c_ulonglong).wrapping_sub(
+        (quotient as libc::c_ulonglong).wrapping_mul(0x16a6b036d7f2a79 as libc::c_ulonglong),
+    ) 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 libc::c_int as libc::c_ulong {
+        return 1 as libc::c_int as uint64_t;
+    }
+    let mut cur: uint64_t = x;
+    while y & 1 as libc::c_int as libc::c_ulong == 0 {
+        cur = residue_mul(cur, cur);
+        y >>= 1 as libc::c_int;
+    }
+    let mut res: uint64_t = cur;
+    loop {
+        y >>= 1 as libc::c_int;
+        if !(y != 0 as libc::c_int as libc::c_ulong) {
+            break;
+        }
+        cur = residue_mul(cur, cur);
+        if y & 1 as libc::c_int as libc::c_ulong != 0 {
+            res = residue_mul(res, cur);
+        }
+    }
+    return 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 libc::c_int as int64_t;
+    let mut xv: int64_t = 0 as libc::c_int as int64_t;
+    let mut v0: uint64_t = v;
+    while u > 1 as libc::c_int as libc::c_ulong {
+        let mut d: uint64_t = v.wrapping_div(u);
+        let mut remainder: uint64_t = v.wrapping_rem(u);
+        tmp = u as int64_t;
+        u = remainder;
+        v = tmp as uint64_t;
+        tmp = xu;
+        xu = (xv as libc::c_ulong).wrapping_sub(d.wrapping_mul(xu as libc::c_ulong)) as int64_t;
+        xv = tmp;
+    }
+    xu = (xu as libc::c_ulong).wrapping_add(if xu < 0 as libc::c_int as libc::c_long {
+        v0
+    } else {
+        0 as libc::c_int as libc::c_ulong
+    }) as int64_t as int64_t;
+    return xu as uint64_t;
+}
+#[no_mangle]
+unsafe extern "C" fn residue_inv(mut x: uint64_t) -> uint64_t {
+    return inverse(x, 0x16a6b036d7f2a79 as libc::c_ulonglong as uint64_t);
+}
+#[no_mangle]
+unsafe extern "C" fn residue_sqrt(mut what: uint64_t) -> uint64_t {
+    if what == 0 {
+        return 0 as libc::c_int as uint64_t;
+    }
+    let mut g: uint64_t = 43 as libc::c_int 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 libc::c_int as uint64_t;
+    let mut q: uint64_t = (0x16a6b036d7f2a79 as libc::c_ulonglong)
+        .wrapping_sub(1 as libc::c_int as libc::c_ulonglong) as uint64_t;
+    while q & 1 as libc::c_int as libc::c_ulong == 0 {
+        e = e.wrapping_add(1);
+        q >>= 1 as libc::c_int;
+    }
+    z = residue_pow(g, q);
+    y = z;
+    r = e;
+    x = residue_pow(
+        what,
+        q.wrapping_sub(1 as libc::c_int as libc::c_ulong)
+            .wrapping_div(2 as libc::c_int as libc::c_ulong),
+    );
+    b = residue_mul(residue_mul(what, x), x);
+    x = residue_mul(what, x);
+    while b != 1 as libc::c_int as libc::c_ulong {
+        let mut m: uint64_t = 0 as libc::c_int as uint64_t;
+        let mut b2: uint64_t = b;
+        loop {
+            m = m.wrapping_add(1);
+            b2 = residue_mul(b2, b2);
+            if !(b2 != 1 as libc::c_int as libc::c_ulong) {
+                break;
+            }
+        }
+        if m == r {
+            return 0xffffffffffffffff as libc::c_ulonglong as uint64_t;
+        }
+        t = residue_pow(
+            y,
+            ((1 as libc::c_int)
+                << r.wrapping_sub(m)
+                    .wrapping_sub(1 as libc::c_int as libc::c_ulong)) as uint64_t,
+        );
+        y = residue_mul(t, t);
+        r = m;
+        x = residue_mul(x, t);
+        b = residue_mul(b, y);
+    }
+    if residue_mul(x, x) != what {
+        return 0xffffffffffffffff as libc::c_ulonglong as uint64_t;
+    }
+    return x;
+}
+#[no_mangle]
+unsafe extern "C" fn find_divisor_v(mut d: *mut TDivisor) -> libc::c_int {
+    let mut v1: uint64_t = 0;
+    let mut f2: [uint64_t; 6] = [0; 6];
+    let mut i: libc::c_int = 0 as libc::c_int;
+    while i < 6 as libc::c_int {
+        f2[i as usize] = f[i as usize];
+        i += 1;
+    }
+    let u0: uint64_t = (*d).u[0 as libc::c_int as usize] as uint64_t;
+    let u1: uint64_t = (*d).u[1 as libc::c_int as usize] as uint64_t;
+    let mut j: libc::c_int = 4 as libc::c_int;
+    loop {
+        let fresh0 = j;
+        j = j - 1;
+        if !(fresh0 != 0) {
+            break;
+        }
+        f2[j as usize] = residue_sub(
+            f2[j as usize],
+            residue_mul(u0, f2[(j + 2 as libc::c_int) as usize]),
+        );
+        f2[(j + 1 as libc::c_int) as usize] = residue_sub(
+            f2[(j + 1 as libc::c_int) as usize],
+            residue_mul(u1, f2[(j + 2 as libc::c_int) as usize]),
+        );
+        f2[(j + 2 as libc::c_int) as usize] = 0 as libc::c_int as uint64_t;
+    }
+    let f0: uint64_t = f2[0 as libc::c_int as usize];
+    let f1: uint64_t = f2[1 as libc::c_int 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 libc::c_int as libc::c_ulong {
+        if coeff1 == 0 as libc::c_int as libc::c_ulong {
+            f1 == 0 as libc::c_int as libc::c_ulong;
+            return 0 as libc::c_int;
+        }
+        let mut sqr: uint64_t = residue_mul(
+            residue_mul(f1, f1),
+            residue_inv(residue_add(coeff1, coeff1)),
+        );
+        v1 = residue_sqrt(sqr);
+        if v1 as libc::c_ulonglong == 0xffffffffffffffff as libc::c_ulonglong {
+            return 0 as libc::c_int;
+        }
+    } else {
+        let mut d_0: uint64_t = residue_add(
+            residue_mul(f0, f0),
+            residue_mul(f1, residue_sub(residue_mul(f1, u0), residue_mul(f0, u1))),
+        );
+        d_0 = residue_sqrt(d_0);
+        if d_0 as libc::c_ulonglong == 0xffffffffffffffff as libc::c_ulonglong {
+            return 0 as libc::c_int;
+        }
+        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 libc::c_ulonglong == 0xffffffffffffffff as libc::c_ulonglong {
+            root = residue_mul(residue_sub(coeff1, d_0), inv);
+            v1 = residue_sqrt(root);
+            if v1 as libc::c_ulonglong == 0xffffffffffffffff as libc::c_ulonglong {
+                return 0 as libc::c_int;
+            }
+        }
+    }
+    let mut v0: uint64_t = residue_mul(
+        residue_add(f1, residue_mul(u1, residue_mul(v1, v1))),
+        residue_inv(residue_add(v1, v1)),
+    );
+    (*d).v[0 as libc::c_int as usize] = v0 as uint16_t;
+    (*d).v[1 as libc::c_int as usize] = v1 as uint16_t;
+    return 1 as libc::c_int;
+}
+#[no_mangle]
+unsafe extern "C" fn polynomial_mul(
+    mut adeg: libc::c_int,
+    mut a: *const uint64_t,
+    mut bdeg: libc::c_int,
+    mut b: *const uint64_t,
+    mut resultprevdeg: libc::c_int,
+    mut result: *mut uint64_t,
+) -> libc::c_int {
+    if adeg < 0 as libc::c_int || bdeg < 0 as libc::c_int {
+        return resultprevdeg;
+    }
+    let mut i: libc::c_int = 0;
+    let mut j: libc::c_int = 0;
+    i = resultprevdeg + 1 as libc::c_int;
+    while i <= adeg + bdeg {
+        *result.offset(i as isize) = 0 as libc::c_int as uint64_t;
+        i += 1;
+    }
+    resultprevdeg = i - 1 as libc::c_int;
+    i = 0 as libc::c_int;
+    while i <= adeg {
+        j = 0 as libc::c_int;
+        while j <= bdeg {
+            *result.offset((i + j) as isize) = residue_add(
+                *result.offset((i + j) as isize),
+                residue_mul(*a.offset(i as isize), *b.offset(j as isize)),
+            );
+            j += 1;
+        }
+        i += 1;
+    }
+    while resultprevdeg >= 0 as libc::c_int
+        && *result.offset(resultprevdeg as isize) == 0 as libc::c_int as libc::c_ulong
+    {
+        resultprevdeg -= 1;
+    }
+    return resultprevdeg;
+}
+#[no_mangle]
+unsafe extern "C" fn polynomial_div_monic(
+    mut adeg: libc::c_int,
+    mut a: *mut uint64_t,
+    mut bdeg: libc::c_int,
+    mut b: *const uint64_t,
+    mut quotient: *mut uint64_t,
+) -> libc::c_int {
+    let mut i: libc::c_int = 0;
+    let mut j: libc::c_int = 0;
+    i = adeg - bdeg;
+    while i >= 0 as libc::c_int {
+        let mut q: uint64_t = *a.offset((i + bdeg) as isize);
+        if !quotient.is_null() {
+            *quotient.offset(i as isize) = q;
+        }
+        j = 0 as libc::c_int;
+        while j < bdeg {
+            *a.offset((i + j) as isize) = residue_sub(
+                *a.offset((i + j) as isize),
+                residue_mul(q, *b.offset(j as isize)),
+            );
+            j += 1;
+        }
+        *a.offset((i + j) as isize) = 0 as libc::c_int as uint64_t;
+        i -= 1;
+    }
+    i += bdeg;
+    while i >= 0 as libc::c_int && *a.offset(i as isize) == 0 as libc::c_int as libc::c_ulong {
+        i -= 1;
+    }
+    return i;
+}
+#[no_mangle]
+unsafe extern "C" fn polynomial_xgcd(
+    mut adeg: libc::c_int,
+    mut a: *const uint64_t,
+    mut bdeg: libc::c_int,
+    mut b: *const uint64_t,
+    mut pgcddeg: *mut libc::c_int,
+    mut gcd: *mut uint64_t,
+    mut pmult1deg: *mut libc::c_int,
+    mut mult1: *mut uint64_t,
+    mut pmult2deg: *mut libc::c_int,
+    mut mult2: *mut uint64_t,
+) {
+    let mut sdeg: libc::c_int = -(1 as libc::c_int);
+    let mut s: [uint64_t; 3] = [
+        0 as libc::c_int as uint64_t,
+        0 as libc::c_int as uint64_t,
+        0 as libc::c_int as uint64_t,
+    ];
+    let mut mult1deg: libc::c_int = 0 as libc::c_int;
+    *mult1.offset(0 as libc::c_int as isize) = 1 as libc::c_int as uint64_t;
+    *mult1.offset(1 as libc::c_int as isize) = 0 as libc::c_int as uint64_t;
+    *mult1.offset(2 as libc::c_int as isize) = 0 as libc::c_int as uint64_t;
+    let mut tdeg: libc::c_int = 0 as libc::c_int;
+    let mut t: [uint64_t; 3] = [
+        1 as libc::c_int as uint64_t,
+        0 as libc::c_int as uint64_t,
+        0 as libc::c_int as uint64_t,
+    ];
+    let mut mult2deg: libc::c_int = -(1 as libc::c_int);
+    *mult2.offset(0 as libc::c_int as isize) = 0 as libc::c_int as uint64_t;
+    *mult2.offset(1 as libc::c_int as isize) = 0 as libc::c_int as uint64_t;
+    *mult2.offset(2 as libc::c_int as isize) = 0 as libc::c_int as uint64_t;
+    let mut rdeg: libc::c_int = bdeg;
+    let mut r: [uint64_t; 3] = [
+        *b.offset(0 as libc::c_int as isize),
+        *b.offset(1 as libc::c_int as isize),
+        *b.offset(2 as libc::c_int as isize),
+    ];
+    let mut gcddeg: libc::c_int = adeg;
+    *gcd.offset(0 as libc::c_int as isize) = *a.offset(0 as libc::c_int as isize);
+    *gcd.offset(1 as libc::c_int as isize) = *a.offset(1 as libc::c_int as isize);
+    *gcd.offset(2 as libc::c_int as isize) = *a.offset(2 as libc::c_int as isize);
+    while rdeg >= 0 as libc::c_int {
+        if rdeg > gcddeg {
+            let mut tmp: libc::c_uint = 0;
+            let mut tmpi: libc::c_int = 0;
+            tmp = rdeg as libc::c_uint;
+            rdeg = gcddeg;
+            gcddeg = tmp as libc::c_int;
+            tmpi = sdeg;
+            sdeg = mult1deg;
+            mult1deg = tmpi;
+            tmpi = tdeg;
+            tdeg = mult2deg;
+            mult2deg = tmpi;
+            let mut tmp2: uint64_t = 0;
+            tmp2 = r[0 as libc::c_int as usize];
+            r[0 as libc::c_int as usize] = *gcd.offset(0 as libc::c_int as isize);
+            *gcd.offset(0 as libc::c_int as isize) = tmp2;
+            tmp2 = r[1 as libc::c_int as usize];
+            r[1 as libc::c_int as usize] = *gcd.offset(1 as libc::c_int as isize);
+            *gcd.offset(1 as libc::c_int as isize) = tmp2;
+            tmp2 = r[2 as libc::c_int as usize];
+            r[2 as libc::c_int as usize] = *gcd.offset(2 as libc::c_int as isize);
+            *gcd.offset(2 as libc::c_int as isize) = tmp2;
+            tmp2 = s[0 as libc::c_int as usize];
+            s[0 as libc::c_int as usize] = *mult1.offset(0 as libc::c_int as isize);
+            *mult1.offset(0 as libc::c_int as isize) = tmp2;
+            tmp2 = s[1 as libc::c_int as usize];
+            s[1 as libc::c_int as usize] = *mult1.offset(1 as libc::c_int as isize);
+            *mult1.offset(1 as libc::c_int as isize) = tmp2;
+            tmp2 = s[2 as libc::c_int as usize];
+            s[2 as libc::c_int as usize] = *mult1.offset(2 as libc::c_int as isize);
+            *mult1.offset(2 as libc::c_int as isize) = tmp2;
+            tmp2 = t[0 as libc::c_int as usize];
+            t[0 as libc::c_int as usize] = *mult2.offset(0 as libc::c_int as isize);
+            *mult2.offset(0 as libc::c_int as isize) = tmp2;
+            tmp2 = t[1 as libc::c_int as usize];
+            t[1 as libc::c_int as usize] = *mult2.offset(1 as libc::c_int as isize);
+            *mult2.offset(1 as libc::c_int as isize) = tmp2;
+            tmp2 = t[2 as libc::c_int as usize];
+            t[2 as libc::c_int as usize] = *mult2.offset(2 as libc::c_int as isize);
+            *mult2.offset(2 as libc::c_int as isize) = tmp2;
+        } else {
+            let mut delta: libc::c_int = gcddeg - rdeg;
+            let mut mult: uint64_t =
+                residue_mul(*gcd.offset(gcddeg as isize), residue_inv(r[rdeg as usize]));
+            let mut i: libc::c_int = 0 as libc::c_int;
+            while i <= rdeg {
+                *gcd.offset((i + delta) as isize) = residue_sub(
+                    *gcd.offset((i + delta) as isize),
+                    residue_mul(mult, r[i as usize]),
+                );
+                i += 1;
+            }
+            while gcddeg >= 0 as libc::c_int
+                && *gcd.offset(gcddeg as isize) == 0 as libc::c_int as libc::c_ulong
+            {
+                gcddeg -= 1;
+            }
+            let mut i_0: libc::c_int = 0 as libc::c_int;
+            while i_0 <= sdeg {
+                *mult1.offset((i_0 + delta) as isize) = residue_sub(
+                    *mult1.offset((i_0 + delta) as isize),
+                    residue_mul(mult, s[i_0 as usize]),
+                );
+                i_0 += 1;
+            }
+            if mult1deg < sdeg + delta {
+                mult1deg = sdeg + delta;
+            }
+            while mult1deg >= 0 as libc::c_int
+                && *mult1.offset(mult1deg as isize) == 0 as libc::c_int as libc::c_ulong
+            {
+                mult1deg -= 1;
+            }
+            let mut i_1: libc::c_int = 0 as libc::c_int;
+            while i_1 <= tdeg {
+                *mult2.offset((i_1 + delta) as isize) = residue_sub(
+                    *mult2.offset((i_1 + delta) as isize),
+                    residue_mul(mult, t[i_1 as usize]),
+                );
+                i_1 += 1;
+            }
+            if mult2deg < tdeg + delta {
+                mult2deg = tdeg + delta;
+            }
+            while mult2deg >= 0 as libc::c_int
+                && *mult2.offset(mult2deg as isize) == 0 as libc::c_int as libc::c_ulong
+            {
+                mult2deg -= 1;
+            }
+        }
+    }
+    *pgcddeg = gcddeg;
+    *pmult1deg = mult1deg;
+    *pmult2deg = mult2deg;
+}
+#[no_mangle]
+unsafe extern "C" fn u2poly(
+    mut src: *const TDivisor,
+    mut polyu: *mut uint64_t,
+    mut polyv: *mut uint64_t,
+) -> libc::c_int {
+    if (*src).u[1 as libc::c_int as usize] as libc::c_ulonglong
+        != 0xffffffffffffffff as libc::c_ulonglong
+    {
+        *polyu.offset(0 as libc::c_int as isize) = (*src).u[0 as libc::c_int as usize] as uint64_t;
+        *polyu.offset(1 as libc::c_int as isize) = (*src).u[1 as libc::c_int as usize] as uint64_t;
+        *polyu.offset(2 as libc::c_int as isize) = 1 as libc::c_int as uint64_t;
+        *polyv.offset(0 as libc::c_int as isize) = (*src).v[0 as libc::c_int as usize] as uint64_t;
+        *polyv.offset(1 as libc::c_int as isize) = (*src).v[1 as libc::c_int as usize] as uint64_t;
+        return 2 as libc::c_int;
+    }
+    if (*src).u[0 as libc::c_int as usize] as libc::c_ulonglong
+        != 0xffffffffffffffff as libc::c_ulonglong
+    {
+        *polyu.offset(0 as libc::c_int as isize) = (*src).u[0 as libc::c_int as usize] as uint64_t;
+        *polyu.offset(1 as libc::c_int as isize) = 1 as libc::c_int as uint64_t;
+        *polyv.offset(0 as libc::c_int as isize) = (*src).v[0 as libc::c_int as usize] as uint64_t;
+        *polyv.offset(1 as libc::c_int as isize) = 0 as libc::c_int as uint64_t;
+        return 1 as libc::c_int;
+    }
+    *polyu.offset(0 as libc::c_int as isize) = 1 as libc::c_int as uint64_t;
+    *polyv.offset(0 as libc::c_int as isize) = 0 as libc::c_int as uint64_t;
+    *polyv.offset(1 as libc::c_int as isize) = 0 as libc::c_int as uint64_t;
+    return 0 as libc::c_int;
+}
+#[no_mangle]
+unsafe extern "C" fn divisor_add(
+    mut src1: *const TDivisor,
+    mut src2: *const TDivisor,
+    mut dst: *mut TDivisor,
+) {
+    let mut u1: [uint64_t; 3] = [0; 3];
+    let mut u2: [uint64_t; 3] = [0; 3];
+    let mut v1: [uint64_t; 2] = [0; 2];
+    let mut v2: [uint64_t; 2] = [0; 2];
+    let mut u1deg: libc::c_int = u2poly(src1, u1.as_mut_ptr(), v1.as_mut_ptr());
+    let mut u2deg: libc::c_int = u2poly(src2, u2.as_mut_ptr(), v2.as_mut_ptr());
+    let mut d1deg: libc::c_int = 0;
+    let mut e1deg: libc::c_int = 0;
+    let mut e2deg: libc::c_int = 0;
+    let mut d1: [uint64_t; 3] = [0; 3];
+    let mut e1: [uint64_t; 3] = [0; 3];
+    let mut e2: [uint64_t; 3] = [0; 3];
+    polynomial_xgcd(
+        u1deg,
+        u1.as_mut_ptr() as *const uint64_t,
+        u2deg,
+        u2.as_mut_ptr() as *const uint64_t,
+        &mut d1deg,
+        d1.as_mut_ptr(),
+        &mut e1deg,
+        e1.as_mut_ptr(),
+        &mut e2deg,
+        e2.as_mut_ptr(),
+    );
+    let mut b: [uint64_t; 3] = [
+        residue_add(v1[0 as libc::c_int as usize], v2[0 as libc::c_int as usize]),
+        residue_add(v1[1 as libc::c_int as usize], v2[1 as libc::c_int as usize]),
+        0 as libc::c_int as uint64_t,
+    ];
+    let mut bdeg: libc::c_int = if b[1 as libc::c_int as usize] == 0 as libc::c_int as libc::c_ulong
+    {
+        if b[0 as libc::c_int as usize] == 0 as libc::c_int as libc::c_ulong {
+            -(1 as libc::c_int)
+        } else {
+            0 as libc::c_int
+        }
+    } else {
+        1 as libc::c_int
+    };
+    let mut ddeg: libc::c_int = 0;
+    let mut c1deg: libc::c_int = 0;
+    let mut c2deg: libc::c_int = 0;
+    let mut d: [uint64_t; 3] = [0; 3];
+    let mut c1: [uint64_t; 3] = [0; 3];
+    let mut c2: [uint64_t; 3] = [0; 3];
+    polynomial_xgcd(
+        d1deg,
+        d1.as_mut_ptr() as *const uint64_t,
+        bdeg,
+        b.as_mut_ptr() as *const uint64_t,
+        &mut ddeg,
+        d.as_mut_ptr(),
+        &mut c1deg,
+        c1.as_mut_ptr(),
+        &mut c2deg,
+        c2.as_mut_ptr(),
+    );
+    let mut dmult: uint64_t = residue_inv(d[ddeg as usize]);
+    let mut i: libc::c_int = 0;
+    i = 0 as libc::c_int;
+    while i < ddeg {
+        d[i as usize] = residue_mul(d[i as usize], dmult);
+        i += 1;
+    }
+    d[i as usize] = 1 as libc::c_int as uint64_t;
+    i = 0 as libc::c_int;
+    while i <= c1deg {
+        c1[i as usize] = residue_mul(c1[i as usize], dmult);
+        i += 1;
+    }
+    i = 0 as libc::c_int;
+    while i <= c2deg {
+        c2[i as usize] = residue_mul(c2[i as usize], dmult);
+        i += 1;
+    }
+    let mut u: [uint64_t; 5] = [0; 5];
+    let mut udeg: libc::c_int = polynomial_mul(
+        u1deg,
+        u1.as_mut_ptr() as *const uint64_t,
+        u2deg,
+        u2.as_mut_ptr() as *const uint64_t,
+        -(1 as libc::c_int),
+        u.as_mut_ptr(),
+    );
+    let mut v: [uint64_t; 7] = [0; 7];
+    let mut tmp: [uint64_t; 7] = [0; 7];
+    let mut vdeg: libc::c_int = 0;
+    let mut tmpdeg: libc::c_int = 0;
+    v[0 as libc::c_int as usize] =
+        residue_sub(v2[0 as libc::c_int as usize], v1[0 as libc::c_int as usize]);
+    v[1 as libc::c_int as usize] =
+        residue_sub(v2[1 as libc::c_int as usize], v1[1 as libc::c_int as usize]);
+    tmpdeg = polynomial_mul(
+        e1deg,
+        e1.as_mut_ptr() as *const uint64_t,
+        1 as libc::c_int,
+        v.as_mut_ptr() as *const uint64_t,
+        -(1 as libc::c_int),
+        tmp.as_mut_ptr(),
+    );
+    vdeg = polynomial_mul(
+        u1deg,
+        u1.as_mut_ptr() as *const uint64_t,
+        tmpdeg,
+        tmp.as_mut_ptr() as *const uint64_t,
+        -(1 as libc::c_int),
+        v.as_mut_ptr(),
+    );
+    vdeg = polynomial_mul(
+        d1deg,
+        d1.as_mut_ptr() as *const uint64_t,
+        1 as libc::c_int,
+        v1.as_mut_ptr() as *const uint64_t,
+        vdeg,
+        v.as_mut_ptr(),
+    );
+    i = 0 as libc::c_int;
+    while i <= vdeg {
+        v[i as usize] = residue_mul(v[i as usize], c1[0 as libc::c_int as usize]);
+        i += 1;
+    }
+    memcpy(
+        tmp.as_mut_ptr() as *mut libc::c_void,
+        f.as_ptr() as *const libc::c_void,
+        (6 as libc::c_int as libc::c_ulong)
+            .wrapping_mul(::std::mem::size_of::<uint64_t>() as libc::c_ulong),
+    );
+    tmpdeg = 5 as libc::c_int;
+    tmpdeg = polynomial_mul(
+        1 as libc::c_int,
+        v1.as_mut_ptr() as *const uint64_t,
+        1 as libc::c_int,
+        v2.as_mut_ptr() as *const uint64_t,
+        tmpdeg,
+        tmp.as_mut_ptr(),
+    );
+    vdeg = polynomial_mul(
+        c2deg,
+        c2.as_mut_ptr() as *const uint64_t,
+        tmpdeg,
+        tmp.as_mut_ptr() as *const uint64_t,
+        vdeg,
+        v.as_mut_ptr(),
+    );
+    if ddeg > 0 as libc::c_int {
+        let mut udiv: [uint64_t; 5] = [0; 5];
+        polynomial_div_monic(
+            udeg,
+            u.as_mut_ptr(),
+            ddeg,
+            d.as_mut_ptr() as *const uint64_t,
+            udiv.as_mut_ptr(),
+        );
+        udeg -= ddeg;
+        polynomial_div_monic(
+            udeg,
+            udiv.as_mut_ptr(),
+            ddeg,
+            d.as_mut_ptr() as *const uint64_t,
+            u.as_mut_ptr(),
+        );
+        udeg -= ddeg;
+        if vdeg >= 0 as libc::c_int {
+            polynomial_div_monic(
+                vdeg,
+                v.as_mut_ptr(),
+                ddeg,
+                d.as_mut_ptr() as *const uint64_t,
+                udiv.as_mut_ptr(),
+            );
+            vdeg -= ddeg;
+            memcpy(
+                v.as_mut_ptr() as *mut libc::c_void,
+                udiv.as_mut_ptr() as *const libc::c_void,
+                ((vdeg + 1 as libc::c_int) as libc::c_ulong)
+                    .wrapping_mul(::std::mem::size_of::<uint64_t>() as libc::c_ulong),
+            );
+        }
+    }
+    vdeg = polynomial_div_monic(
+        vdeg,
+        v.as_mut_ptr(),
+        udeg,
+        u.as_mut_ptr() as *const uint64_t,
+        0 as *mut uint64_t,
+    );
+    while udeg > 2 as libc::c_int {
+        tmpdeg = polynomial_mul(
+            vdeg,
+            v.as_mut_ptr() as *const uint64_t,
+            vdeg,
+            v.as_mut_ptr() as *const uint64_t,
+            -(1 as libc::c_int),
+            tmp.as_mut_ptr(),
+        );
+        i = 0 as libc::c_int;
+        while i <= tmpdeg && i <= 5 as libc::c_int {
+            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 libc::c_int as uint64_t, tmp[i as usize]);
+            i += 1;
+        }
+        while i <= 5 as libc::c_int {
+            tmp[i as usize] = f[i as usize];
+            i += 1;
+        }
+        tmpdeg = i - 1 as libc::c_int;
+        let mut udiv_0: [uint64_t; 5] = [0; 5];
+        polynomial_div_monic(
+            tmpdeg,
+            tmp.as_mut_ptr(),
+            udeg,
+            u.as_mut_ptr() as *const uint64_t,
+            udiv_0.as_mut_ptr(),
+        );
+        udeg = tmpdeg - udeg;
+        let mut mult: uint64_t = residue_inv(udiv_0[udeg as usize]);
+        i = 0 as libc::c_int;
+        while i < udeg {
+            u[i as usize] = residue_mul(udiv_0[i as usize], mult);
+            i += 1;
+        }
+        u[i as usize] = 1 as libc::c_int as uint64_t;
+        i = 0 as libc::c_int;
+        while i <= vdeg {
+            v[i as usize] = residue_sub(0 as libc::c_int as uint64_t, v[i as usize]);
+            i += 1;
+        }
+        vdeg = polynomial_div_monic(
+            vdeg,
+            v.as_mut_ptr(),
+            udeg,
+            u.as_mut_ptr() as *const uint64_t,
+            0 as *mut uint64_t,
+        );
+    }
+    if udeg == 2 as libc::c_int {
+        (*dst).u[0 as libc::c_int as usize] = u[0 as libc::c_int as usize] as uint16_t;
+        (*dst).u[1 as libc::c_int as usize] = u[1 as libc::c_int as usize] as uint16_t;
+        (*dst).v[0 as libc::c_int as usize] = (if vdeg >= 0 as libc::c_int {
+            v[0 as libc::c_int as usize]
+        } else {
+            0 as libc::c_int as libc::c_ulong
+        }) as uint16_t;
+        (*dst).v[1 as libc::c_int as usize] = (if vdeg >= 1 as libc::c_int {
+            v[1 as libc::c_int as usize]
+        } else {
+            0 as libc::c_int as libc::c_ulong
+        }) as uint16_t;
+    } else if udeg == 1 as libc::c_int {
+        (*dst).u[0 as libc::c_int as usize] = u[0 as libc::c_int as usize] as uint16_t;
+        (*dst).u[1 as libc::c_int as usize] = 0xffffffffffffffff as libc::c_ulonglong as uint16_t;
+        (*dst).v[0 as libc::c_int as usize] = (if vdeg >= 0 as libc::c_int {
+            v[0 as libc::c_int as usize]
+        } else {
+            0 as libc::c_int as libc::c_ulong
+        }) as uint16_t;
+        (*dst).v[1 as libc::c_int as usize] = 0xffffffffffffffff as libc::c_ulonglong as uint16_t;
+    } else {
+        (*dst).u[0 as libc::c_int as usize] = 0xffffffffffffffff as libc::c_ulonglong as uint16_t;
+        (*dst).u[1 as libc::c_int as usize] = 0xffffffffffffffff as libc::c_ulonglong as uint16_t;
+        (*dst).v[0 as libc::c_int as usize] = 0xffffffffffffffff as libc::c_ulonglong as uint16_t;
+        (*dst).v[1 as libc::c_int as usize] = 0xffffffffffffffff as libc::c_ulonglong as uint16_t;
+    };
+}
+#[no_mangle]
+unsafe extern "C" fn divisor_mul(
+    mut src: *const TDivisor,
+    mut mult: uint64_t,
+    mut dst: *mut TDivisor,
+) {
+    if mult == 0 as libc::c_int as libc::c_ulong {
+        (*dst).u[0 as libc::c_int as usize] = 0xffffffffffffffff as libc::c_ulonglong as uint16_t;
+        (*dst).u[1 as libc::c_int as usize] = 0xffffffffffffffff as libc::c_ulonglong as uint16_t;
+        (*dst).v[0 as libc::c_int as usize] = 0xffffffffffffffff as libc::c_ulonglong as uint16_t;
+        (*dst).v[1 as libc::c_int as usize] = 0xffffffffffffffff as libc::c_ulonglong as uint16_t;
+        return;
+    }
+    let mut cur: TDivisor = *src;
+    while mult & 1 as libc::c_int as libc::c_ulong == 0 {
+        divisor_add(&mut cur, &mut cur, &mut cur);
+        mult >>= 1 as libc::c_int;
+    }
+    *dst = cur;
+    loop {
+        mult >>= 1 as libc::c_int;
+        if !(mult != 0 as libc::c_int as libc::c_ulong) {
+            break;
+        }
+        divisor_add(&mut cur, &mut cur, &mut cur);
+        if mult & 1 as libc::c_int as libc::c_ulong != 0 {
+            divisor_add(dst, &mut cur, dst);
+        }
+    }
+}
+#[no_mangle]
+unsafe extern "C" fn divisor_mul128(
+    mut src: *const TDivisor,
+    mut mult_lo: uint64_t,
+    mut mult_hi: uint64_t,
+    mut dst: *mut TDivisor,
+) {
+    if mult_lo == 0 as libc::c_int as libc::c_ulong && mult_hi == 0 as libc::c_int as libc::c_ulong
+    {
+        (*dst).u[0 as libc::c_int as usize] = 0xffffffffffffffff as libc::c_ulonglong as uint16_t;
+        (*dst).u[1 as libc::c_int as usize] = 0xffffffffffffffff as libc::c_ulonglong as uint16_t;
+        (*dst).v[0 as libc::c_int as usize] = 0xffffffffffffffff as libc::c_ulonglong as uint16_t;
+        (*dst).v[1 as libc::c_int as usize] = 0xffffffffffffffff as libc::c_ulonglong as uint16_t;
+        return;
+    }
+    let mut cur: TDivisor = *src;
+    while mult_lo & 1 as libc::c_int as libc::c_ulong == 0 {
+        divisor_add(&mut cur, &mut cur, &mut cur);
+        mult_lo >>= 1 as libc::c_int;
+        if mult_hi & 1 as libc::c_int as libc::c_ulong != 0 {
+            mult_lo = (mult_lo as libc::c_ulonglong | (1 as libc::c_ulonglong) << 63 as libc::c_int)
+                as uint64_t;
+        }
+        mult_hi >>= 1 as libc::c_int;
+    }
+    *dst = cur;
+    loop {
+        mult_lo >>= 1 as libc::c_int;
+        if mult_hi & 1 as libc::c_int as libc::c_ulong != 0 {
+            mult_lo = (mult_lo as libc::c_ulonglong | (1 as libc::c_ulonglong) << 63 as libc::c_int)
+                as uint64_t;
+        }
+        mult_hi >>= 1 as libc::c_int;
+        if mult_lo == 0 as libc::c_int as libc::c_ulong
+            && mult_hi == 0 as libc::c_int as libc::c_ulong
+        {
+            break;
+        }
+        divisor_add(&mut cur, &mut cur, &mut cur);
+        if mult_lo & 1 as libc::c_int as libc::c_ulong != 0 {
+            divisor_add(dst, &mut cur, dst);
+        }
+    }
+}
+#[no_mangle]
+unsafe extern "C" fn rol(mut x: libc::c_uint, mut shift: libc::c_int) -> libc::c_uint {
+    return x << shift | x >> 32 as libc::c_int - shift;
+}
+#[no_mangle]
+unsafe extern "C" fn sha1_single_block(
+    mut input: *mut libc::c_uchar,
+    mut output: *mut libc::c_uchar,
+) {
+    let mut a: libc::c_uint = 0;
+    let mut b: libc::c_uint = 0;
+    let mut c: libc::c_uint = 0;
+    let mut d: libc::c_uint = 0;
+    let mut e: libc::c_uint = 0;
+    a = 0x67452301 as libc::c_int as libc::c_uint;
+    b = 0xefcdab89 as libc::c_uint;
+    c = 0x98badcfe as libc::c_uint;
+    d = 0x10325476 as libc::c_int as libc::c_uint;
+    e = 0xc3d2e1f0 as libc::c_uint;
+    let mut w: [libc::c_uint; 80] = [0; 80];
+    let mut i: size_t = 0;
+    i = 0 as libc::c_int as size_t;
+    while i < 16 as libc::c_int as libc::c_ulong {
+        w[i as usize] = ((*input
+            .offset((4 as libc::c_int as libc::c_ulong).wrapping_mul(i) as isize)
+            as libc::c_int)
+            << 24 as libc::c_int
+            | (*input.offset(
+                (4 as libc::c_int as libc::c_ulong)
+                    .wrapping_mul(i)
+                    .wrapping_add(1 as libc::c_int as libc::c_ulong) as isize,
+            ) as libc::c_int)
+                << 16 as libc::c_int
+            | (*input.offset(
+                (4 as libc::c_int as libc::c_ulong)
+                    .wrapping_mul(i)
+                    .wrapping_add(2 as libc::c_int as libc::c_ulong) as isize,
+            ) as libc::c_int)
+                << 8 as libc::c_int
+            | *input.offset(
+                (4 as libc::c_int as libc::c_ulong)
+                    .wrapping_mul(i)
+                    .wrapping_add(3 as libc::c_int as libc::c_ulong) as isize,
+            ) as libc::c_int) as libc::c_uint;
+        i = i.wrapping_add(1);
+    }
+    i = 16 as libc::c_int as size_t;
+    while i < 80 as libc::c_int as libc::c_ulong {
+        w[i as usize] = rol(
+            w[i.wrapping_sub(3 as libc::c_int as libc::c_ulong) as usize]
+                ^ w[i.wrapping_sub(8 as libc::c_int as libc::c_ulong) as usize]
+                ^ w[i.wrapping_sub(14 as libc::c_int as libc::c_ulong) as usize]
+                ^ w[i.wrapping_sub(16 as libc::c_int as libc::c_ulong) as usize],
+            1 as libc::c_int,
+        );
+        i = i.wrapping_add(1);
+    }
+    i = 0 as libc::c_int as size_t;
+    while i < 20 as libc::c_int as libc::c_ulong {
+        let mut tmp: libc::c_uint = (rol(a, 5 as libc::c_int))
+            .wrapping_add(b & c | !b & d)
+            .wrapping_add(e)
+            .wrapping_add(w[i as usize])
+            .wrapping_add(0x5a827999 as libc::c_int as libc::c_uint);
+        e = d;
+        d = c;
+        c = rol(b, 30 as libc::c_int);
+        b = a;
+        a = tmp;
+        i = i.wrapping_add(1);
+    }
+    i = 20 as libc::c_int as size_t;
+    while i < 40 as libc::c_int as libc::c_ulong {
+        let mut tmp_0: libc::c_uint = (rol(a, 5 as libc::c_int))
+            .wrapping_add(b ^ c ^ d)
+            .wrapping_add(e)
+            .wrapping_add(w[i as usize])
+            .wrapping_add(0x6ed9eba1 as libc::c_int as libc::c_uint);
+        e = d;
+        d = c;
+        c = rol(b, 30 as libc::c_int);
+        b = a;
+        a = tmp_0;
+        i = i.wrapping_add(1);
+    }
+    i = 40 as libc::c_int as size_t;
+    while i < 60 as libc::c_int as libc::c_ulong {
+        let mut tmp_1: libc::c_uint = (rol(a, 5 as libc::c_int))
+            .wrapping_add(b & c | b & d | c & d)
+            .wrapping_add(e)
+            .wrapping_add(w[i as usize])
+            .wrapping_add(0x8f1bbcdc as libc::c_uint);
+        e = d;
+        d = c;
+        c = rol(b, 30 as libc::c_int);
+        b = a;
+        a = tmp_1;
+        i = i.wrapping_add(1);
+    }
+    i = 60 as libc::c_int as size_t;
+    while i < 80 as libc::c_int as libc::c_ulong {
+        let mut tmp_2: libc::c_uint = (rol(a, 5 as libc::c_int))
+            .wrapping_add(b ^ c ^ d)
+            .wrapping_add(e)
+            .wrapping_add(w[i as usize])
+            .wrapping_add(0xca62c1d6 as libc::c_uint);
+        e = d;
+        d = c;
+        c = rol(b, 30 as libc::c_int);
+        b = a;
+        a = tmp_2;
+        i = i.wrapping_add(1);
+    }
+    a = a.wrapping_add(0x67452301 as libc::c_int as libc::c_uint);
+    b = b.wrapping_add(0xefcdab89 as libc::c_uint);
+    c = c.wrapping_add(0x98badcfe as libc::c_uint);
+    d = d.wrapping_add(0x10325476 as libc::c_int as libc::c_uint);
+    e = e.wrapping_add(0xc3d2e1f0 as libc::c_uint);
+    *output.offset(0 as libc::c_int as isize) = (a >> 24 as libc::c_int) as libc::c_uchar;
+    *output.offset(1 as libc::c_int as isize) = (a >> 16 as libc::c_int) as libc::c_uchar;
+    *output.offset(2 as libc::c_int as isize) = (a >> 8 as libc::c_int) as libc::c_uchar;
+    *output.offset(3 as libc::c_int as isize) = a as libc::c_uchar;
+    *output.offset(4 as libc::c_int as isize) = (b >> 24 as libc::c_int) as libc::c_uchar;
+    *output.offset(5 as libc::c_int as isize) = (b >> 16 as libc::c_int) as libc::c_uchar;
+    *output.offset(6 as libc::c_int as isize) = (b >> 8 as libc::c_int) as libc::c_uchar;
+    *output.offset(7 as libc::c_int as isize) = b as libc::c_uchar;
+    *output.offset(8 as libc::c_int as isize) = (c >> 24 as libc::c_int) as libc::c_uchar;
+    *output.offset(9 as libc::c_int as isize) = (c >> 16 as libc::c_int) as libc::c_uchar;
+    *output.offset(10 as libc::c_int as isize) = (c >> 8 as libc::c_int) as libc::c_uchar;
+    *output.offset(11 as libc::c_int as isize) = c as libc::c_uchar;
+    *output.offset(12 as libc::c_int as isize) = (d >> 24 as libc::c_int) as libc::c_uchar;
+    *output.offset(13 as libc::c_int as isize) = (d >> 16 as libc::c_int) as libc::c_uchar;
+    *output.offset(14 as libc::c_int as isize) = (d >> 8 as libc::c_int) as libc::c_uchar;
+    *output.offset(15 as libc::c_int as isize) = d as libc::c_uchar;
+    *output.offset(16 as libc::c_int as isize) = (e >> 24 as libc::c_int) as libc::c_uchar;
+    *output.offset(17 as libc::c_int as isize) = (e >> 16 as libc::c_int) as libc::c_uchar;
+    *output.offset(18 as libc::c_int as isize) = (e >> 8 as libc::c_int) as libc::c_uchar;
+    *output.offset(19 as libc::c_int as isize) = e as libc::c_uchar;
+}
+#[no_mangle]
+unsafe extern "C" fn Mix(
+    mut buffer: *mut libc::c_uchar,
+    mut bufSize: size_t,
+    mut key: *const libc::c_uchar,
+    mut keySize: size_t,
+) {
+    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 libc::c_int as libc::c_ulong);
+    let mut external_counter: libc::c_int = 0;
+    external_counter = 0 as libc::c_int;
+    while external_counter < 4 as libc::c_int {
+        memset(
+            sha1_input.as_mut_ptr() as *mut libc::c_void,
+            0 as libc::c_int,
+            ::std::mem::size_of::<[libc::c_uchar; 64]>() as libc::c_ulong,
+        );
+        memcpy(
+            sha1_input.as_mut_ptr() as *mut libc::c_void,
+            buffer.offset(half as isize) as *const libc::c_void,
+            half,
+        );
+        memcpy(
+            sha1_input.as_mut_ptr().offset(half as isize) as *mut libc::c_void,
+            key as *const libc::c_void,
+            keySize,
+        );
+        sha1_input[half.wrapping_add(keySize) as usize] = 0x80 as libc::c_int as libc::c_uchar;
+        sha1_input[(::std::mem::size_of::<[libc::c_uchar; 64]>() as libc::c_ulong)
+            .wrapping_sub(1 as libc::c_int as libc::c_ulong) as usize] =
+            half.wrapping_add(keySize)
+                .wrapping_mul(8 as libc::c_int as libc::c_ulong) as libc::c_uchar;
+        sha1_input[(::std::mem::size_of::<[libc::c_uchar; 64]>() as libc::c_ulong)
+            .wrapping_sub(2 as libc::c_int as libc::c_ulong) as usize] =
+            half.wrapping_add(keySize)
+                .wrapping_mul(8 as libc::c_int as libc::c_ulong)
+                .wrapping_div(0x100 as libc::c_int as libc::c_ulong) 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 libc::c_int) as libc::c_ulong;
+        while i < half {
+            sha1_result[i as usize] = sha1_result[i
+                .wrapping_add(4 as libc::c_int as libc::c_ulong)
+                .wrapping_sub(half & 3 as libc::c_int as libc::c_ulong)
+                as usize];
+            i = i.wrapping_add(1);
+        }
+        i = 0 as libc::c_int 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 libc::c_int
+                ^ sha1_result[i as usize] as libc::c_int)
+                as libc::c_uchar;
+            *buffer.offset(i as isize) = tmp;
+            i = i.wrapping_add(1);
+        }
+        external_counter += 1;
+    }
+}
+#[no_mangle]
+unsafe extern "C" fn Unmix(
+    mut buffer: *mut libc::c_uchar,
+    mut bufSize: size_t,
+    mut key: *const libc::c_uchar,
+    mut keySize: size_t,
+) {
+    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 libc::c_int as libc::c_ulong);
+    let mut external_counter: libc::c_int = 0;
+    external_counter = 0 as libc::c_int;
+    while external_counter < 4 as libc::c_int {
+        memset(
+            sha1_input.as_mut_ptr() as *mut libc::c_void,
+            0 as libc::c_int,
+            ::std::mem::size_of::<[libc::c_uchar; 64]>() as libc::c_ulong,
+        );
+        memcpy(
+            sha1_input.as_mut_ptr() as *mut libc::c_void,
+            buffer as *const libc::c_void,
+            half,
+        );
+        memcpy(
+            sha1_input.as_mut_ptr().offset(half as isize) as *mut libc::c_void,
+            key as *const libc::c_void,
+            keySize,
+        );
+        sha1_input[half.wrapping_add(keySize) as usize] = 0x80 as libc::c_int as libc::c_uchar;
+        sha1_input[(::std::mem::size_of::<[libc::c_uchar; 64]>() as libc::c_ulong)
+            .wrapping_sub(1 as libc::c_int as libc::c_ulong) as usize] =
+            half.wrapping_add(keySize)
+                .wrapping_mul(8 as libc::c_int as libc::c_ulong) as libc::c_uchar;
+        sha1_input[(::std::mem::size_of::<[libc::c_uchar; 64]>() as libc::c_ulong)
+            .wrapping_sub(2 as libc::c_int as libc::c_ulong) as usize] =
+            half.wrapping_add(keySize)
+                .wrapping_mul(8 as libc::c_int as libc::c_ulong)
+                .wrapping_div(0x100 as libc::c_int as libc::c_ulong) 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 libc::c_int) as libc::c_ulong;
+        while i < half {
+            sha1_result[i as usize] = sha1_result[i
+                .wrapping_add(4 as libc::c_int as libc::c_ulong)
+                .wrapping_sub(half & 3 as libc::c_int as libc::c_ulong)
+                as usize];
+            i = i.wrapping_add(1);
+        }
+        i = 0 as libc::c_int 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 libc::c_int
+                    ^ sha1_result[i as usize] as libc::c_int) as libc::c_uchar;
+            *buffer.offset(i.wrapping_add(half) as isize) = tmp;
+            i = i.wrapping_add(1);
+        }
+        external_counter += 1;
+    }
+}
+#[no_mangle]
+unsafe extern "C" fn Generate(
+    mut installation_id_str: *const libc::c_char,
+    mut confirmation_id: *mut libc::c_char,
+) -> libc::c_int {
+    let mut installation_id: [libc::c_uchar; 19] = [0; 19];
+    let mut installation_id_len: size_t = 0 as libc::c_int as size_t;
+    let mut p: *const libc::c_char = installation_id_str;
+    let mut count: size_t = 0 as libc::c_int as size_t;
+    let mut totalCount: size_t = 0 as libc::c_int as size_t;
+    let mut check: libc::c_uint = 0 as libc::c_int as libc::c_uint;
+    let mut i: size_t = 0;
+    while *p != 0 {
+        if !(*p as libc::c_int == ' ' as i32 || *p as libc::c_int == '-' as i32) {
+            let mut d: libc::c_int = *p as libc::c_int - '0' as i32;
+            if d < 0 as libc::c_int || d > 9 as libc::c_int {
+                return 3 as libc::c_int;
+            }
+            if count == 5 as libc::c_int as libc::c_ulong
+                || *p.offset(1 as libc::c_int as isize) as libc::c_int == 0 as libc::c_int
+            {
+                if count == 0 {
+                    return if totalCount == 45 as libc::c_int as libc::c_ulong {
+                        2 as libc::c_int
+                    } else {
+                        1 as libc::c_int
+                    };
+                }
+                if d as libc::c_uint != check.wrapping_rem(7 as libc::c_int as libc::c_uint) {
+                    return if count < 5 as libc::c_int as libc::c_ulong {
+                        1 as libc::c_int
+                    } else {
+                        4 as libc::c_int
+                    };
+                }
+                check = 0 as libc::c_int as libc::c_uint;
+                count = 0 as libc::c_int as size_t;
+            } else {
+                check = check.wrapping_add(
+                    (if count.wrapping_rem(2 as libc::c_int as libc::c_ulong) != 0 {
+                        d * 2 as libc::c_int
+                    } else {
+                        d
+                    }) as libc::c_uint,
+                );
+                count = count.wrapping_add(1);
+                totalCount = totalCount.wrapping_add(1);
+                if totalCount > 45 as libc::c_int as libc::c_ulong {
+                    return 2 as libc::c_int;
+                }
+                let mut carry: libc::c_uchar = d as libc::c_uchar;
+                i = 0 as libc::c_int as size_t;
+                while i < installation_id_len {
+                    let mut x: libc::c_uint =
+                        (installation_id[i as usize] as libc::c_int * 10 as libc::c_int
+                            + carry as libc::c_int) as libc::c_uint;
+                    installation_id[i as usize] =
+                        (x & 0xff as libc::c_int as libc::c_uint) as libc::c_uchar;
+                    carry = (x >> 8 as libc::c_int) as libc::c_uchar;
+                    i = i.wrapping_add(1);
+                }
+                if carry != 0 {
+                    let fresh1 = installation_id_len;
+                    installation_id_len = installation_id_len.wrapping_add(1);
+                    installation_id[fresh1 as usize] = carry;
+                }
+            }
+        }
+        p = p.offset(1);
+    }
+    if totalCount != 41 as libc::c_int as libc::c_ulong
+        && totalCount < 45 as libc::c_int as libc::c_ulong
+    {
+        return 1 as libc::c_int;
+    }
+    while installation_id_len < ::std::mem::size_of::<[libc::c_uchar; 19]>() as libc::c_ulong {
+        installation_id[installation_id_len as usize] = 0 as libc::c_int as libc::c_uchar;
+        installation_id_len = installation_id_len.wrapping_add(1);
+    }
+    static mut iid_key: [libc::c_uchar; 4] = [
+        0x6a as libc::c_int as libc::c_uchar,
+        0xc8 as libc::c_int as libc::c_uchar,
+        0x5e as libc::c_int as libc::c_uchar,
+        0xd4 as libc::c_int as libc::c_uchar,
+    ];
+    Unmix(
+        installation_id.as_mut_ptr(),
+        (if totalCount == 41 as libc::c_int as libc::c_ulong {
+            17 as libc::c_int
+        } else {
+            19 as libc::c_int
+        }) as size_t,
+        iid_key.as_ptr(),
+        4 as libc::c_int as size_t,
+    );
+    if installation_id[18 as libc::c_int as usize] as libc::c_int >= 0x10 as libc::c_int {
+        return 5 as libc::c_int;
+    }
+    let mut parsed: C2RustUnnamed_4 = C2RustUnnamed_4 {
+        HardwareID: 0,
+        ProductIDLow: 0,
+        ProductIDHigh: 0,
+        KeySHA1: 0,
+    };
+    memcpy(
+        &mut parsed as *mut C2RustUnnamed_4 as *mut libc::c_void,
+        installation_id.as_mut_ptr() as *const libc::c_void,
+        ::std::mem::size_of::<C2RustUnnamed_4>() as libc::c_ulong,
+    );
+    let mut productId1: libc::c_uint = (parsed.ProductIDLow
+        & (((1 as libc::c_int) << 17 as libc::c_int) - 1 as libc::c_int) as libc::c_ulong)
+        as libc::c_uint;
+    let mut productId2: libc::c_uint = (parsed.ProductIDLow >> 17 as libc::c_int
+        & (((1 as libc::c_int) << 10 as libc::c_int) - 1 as libc::c_int) as libc::c_ulong)
+        as libc::c_uint;
+    let mut productId3: libc::c_uint = (parsed.ProductIDLow >> 27 as libc::c_int
+        & (((1 as libc::c_int) << 25 as libc::c_int) - 1 as libc::c_int) as libc::c_ulong)
+        as libc::c_uint;
+    let mut version: libc::c_uint = (parsed.ProductIDLow >> 52 as libc::c_int
+        & 7 as libc::c_int as libc::c_ulong) as libc::c_uint;
+    let mut productId4: libc::c_uint = (parsed.ProductIDLow >> 55 as libc::c_int
+        | ((parsed.ProductIDHigh as libc::c_int) << 9 as libc::c_int) as libc::c_ulong)
+        as libc::c_uint;
+    if version
+        != (if totalCount == 41 as libc::c_int as libc::c_ulong {
+            4 as libc::c_int
+        } else {
+            5 as libc::c_int
+        }) as libc::c_uint
+    {
+        return 5 as libc::c_int;
+    }
+    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 libc::c_int as libc::c_ulong,
+    );
+    let mut productIdMixed: uint64_t = (productId1 as uint64_t) << 41 as libc::c_int
+        | (productId2 as uint64_t) << 58 as libc::c_int
+        | (productId3 as uint64_t) << 17 as libc::c_int
+        | productId4 as libc::c_ulong;
+    memcpy(
+        keybuf.as_mut_ptr().offset(8 as libc::c_int as isize) as *mut libc::c_void,
+        &mut productIdMixed as *mut uint64_t as *const libc::c_void,
+        8 as libc::c_int as libc::c_ulong,
+    );
+    let mut d_0: TDivisor = TDivisor {
+        u: [0; 2],
+        v: [0; 2],
+    };
+    let mut attempt: libc::c_uchar = 0;
+    attempt = 0 as libc::c_int as libc::c_uchar;
+    while attempt as libc::c_int <= 0x80 as libc::c_int {
+        let mut u: C2RustUnnamed_3 = C2RustUnnamed_3 { buffer: [0; 14] };
+        u.c2rust_unnamed.lo = 0 as libc::c_int as uint64_t;
+        u.c2rust_unnamed.hi = 0 as libc::c_int as uint64_t;
+        u.buffer[7 as libc::c_int as usize] = attempt;
+        Mix(
+            (u.buffer).as_mut_ptr(),
+            14 as libc::c_int as size_t,
+            keybuf.as_mut_ptr(),
+            16 as libc::c_int 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 libc::c_ulonglong).wrapping_sub(
+            (x2 as libc::c_ulonglong).wrapping_mul(0x16a6b036d7f2a79 as libc::c_ulonglong),
+        ) as uint64_t;
+        x2 = x2.wrapping_add(1);
+        d_0.u[0 as libc::c_int as usize] = residue_sub(
+            residue_mul(x1, x1),
+            residue_mul(43 as libc::c_int as uint64_t, residue_mul(x2, x2)),
+        ) as uint16_t;
+        d_0.u[1 as libc::c_int 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 libc::c_int > 0x80 as libc::c_int {
+        return 6 as libc::c_int;
+    }
+    divisor_mul128(
+        &mut d_0,
+        0x4e21b9d10f127c1_i64 as uint64_t,
+        0x40da7c36d44c_i64 as uint64_t,
+        &mut d_0,
+    );
+    let mut e: C2RustUnnamed_0 = C2RustUnnamed_0 {
+        c2rust_unnamed: C2RustUnnamed_1 {
+            encoded_lo: 0,
+            encoded_hi: 0,
+        },
+    };
+    if d_0.u[0 as libc::c_int as usize] as libc::c_ulonglong
+        == 0xffffffffffffffff as libc::c_ulonglong
+    {
+        e.c2rust_unnamed.encoded_lo = __umul128(
+            (0x16a6b036d7f2a79 as libc::c_ulonglong)
+                .wrapping_add(2 as libc::c_int as libc::c_ulonglong) as uint64_t,
+            0x16a6b036d7f2a79 as libc::c_ulonglong as uint64_t,
+            &mut e.c2rust_unnamed.encoded_hi,
+        );
+    } else if d_0.u[1 as libc::c_int as usize] as libc::c_ulonglong
+        == 0xffffffffffffffff as libc::c_ulonglong
+    {
+        e.c2rust_unnamed.encoded_lo = __umul128(
+            (0x16a6b036d7f2a79 as libc::c_ulonglong)
+                .wrapping_add(1 as libc::c_int as libc::c_ulonglong) as uint64_t,
+            d_0.u[0 as libc::c_int as usize] as uint64_t,
+            &mut e.c2rust_unnamed.encoded_hi,
+        );
+        e.c2rust_unnamed.encoded_lo = (e.c2rust_unnamed.encoded_lo as libc::c_ulonglong)
+            .wrapping_add(0x16a6b036d7f2a79 as libc::c_ulonglong)
+            as uint64_t as uint64_t;
+        e.c2rust_unnamed.encoded_hi = (e.c2rust_unnamed.encoded_hi as libc::c_ulong).wrapping_add(
+            ((e.c2rust_unnamed.encoded_lo as libc::c_ulonglong)
+                < 0x16a6b036d7f2a79 as libc::c_ulonglong) as libc::c_int
+                as libc::c_ulong,
+        ) as uint64_t as uint64_t;
+    } else {
+        let mut x1_0: uint64_t =
+            (if d_0.u[1 as libc::c_int as usize] as libc::c_int % 2 as libc::c_int != 0 {
+                (d_0.u[1 as libc::c_int as usize] as libc::c_ulonglong)
+                    .wrapping_add(0x16a6b036d7f2a79 as libc::c_ulonglong)
+            } else {
+                d_0.u[1 as libc::c_int as usize] as libc::c_ulonglong
+            })
+            .wrapping_div(2 as libc::c_int as libc::c_ulonglong) as uint64_t;
+        let mut x2sqr: uint64_t = residue_sub(
+            residue_mul(x1_0, x1_0),
+            d_0.u[0 as libc::c_int as usize] as uint64_t,
+        );
+        let mut x2_0: uint64_t = residue_sqrt(x2sqr);
+        if x2_0 as libc::c_ulonglong == 0xffffffffffffffff as libc::c_ulonglong {
+            x2_0 = residue_sqrt(residue_mul(
+                x2sqr,
+                residue_inv(43 as libc::c_int as uint64_t),
+            ));
+            e.c2rust_unnamed.encoded_lo = __umul128(
+                (0x16a6b036d7f2a79 as libc::c_ulonglong)
+                    .wrapping_add(1 as libc::c_int as libc::c_ulonglong)
+                    as uint64_t,
+                (0x16a6b036d7f2a79 as libc::c_ulonglong).wrapping_add(x2_0 as libc::c_ulonglong)
+                    as uint64_t,
+                &mut e.c2rust_unnamed.encoded_hi,
+            );
+            e.c2rust_unnamed.encoded_lo = (e.c2rust_unnamed.encoded_lo as libc::c_ulong)
+                .wrapping_add(x1_0) as uint64_t
+                as uint64_t;
+            e.c2rust_unnamed.encoded_hi = (e.c2rust_unnamed.encoded_hi as libc::c_ulong)
+                .wrapping_add((e.c2rust_unnamed.encoded_lo < x1_0) as libc::c_int as libc::c_ulong)
+                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 libc::c_int as usize] as uint64_t,
+                residue_mul(d_0.v[1 as libc::c_int 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 libc::c_int as usize] as uint64_t,
+                residue_mul(d_0.v[1 as libc::c_int as usize] as uint64_t, x2a),
+            );
+            if x1a > x2a {
+                let mut tmp: uint64_t = x1a;
+                x1a = x2a;
+                x2a = tmp;
+            }
+            if (y1 ^ y2) & 1 as libc::c_int as libc::c_ulong != 0 {
+                let mut tmp_0: uint64_t = x1a;
+                x1a = x2a;
+                x2a = tmp_0;
+            }
+            e.c2rust_unnamed.encoded_lo = __umul128(
+                (0x16a6b036d7f2a79 as libc::c_ulonglong)
+                    .wrapping_add(1 as libc::c_int as libc::c_ulonglong)
+                    as uint64_t,
+                x1a,
+                &mut e.c2rust_unnamed.encoded_hi,
+            );
+            e.c2rust_unnamed.encoded_lo = (e.c2rust_unnamed.encoded_lo as libc::c_ulong)
+                .wrapping_add(x2a) as uint64_t
+                as uint64_t;
+            e.c2rust_unnamed.encoded_hi = (e.c2rust_unnamed.encoded_hi as libc::c_ulong)
+                .wrapping_add((e.c2rust_unnamed.encoded_lo < x2a) as libc::c_int as libc::c_ulong)
+                as uint64_t as uint64_t;
+        }
+    }
+    let mut decimal: [libc::c_uchar; 35] = [0; 35];
+    i = 0 as libc::c_int as size_t;
+    while i < 35 as libc::c_int as libc::c_ulong {
+        let mut c: libc::c_uint = (e.c2rust_unnamed_0.encoded[3 as libc::c_int as usize])
+            .wrapping_rem(10 as libc::c_int as libc::c_uint);
+        e.c2rust_unnamed_0.encoded[3 as libc::c_int as usize] =
+            (e.c2rust_unnamed_0.encoded[3 as libc::c_int as usize] as libc::c_uint)
+                .wrapping_div(10 as libc::c_int as libc::c_uint) as uint32_t
+                as uint32_t;
+        let mut c2: libc::c_uint = ((c as uint64_t) << 32 as libc::c_int
+            | e.c2rust_unnamed_0.encoded[2 as libc::c_int as usize] as libc::c_ulong)
+            .wrapping_rem(10 as libc::c_int as libc::c_ulong)
+            as libc::c_uint;
+        e.c2rust_unnamed_0.encoded[2 as libc::c_int as usize] =
+            ((c as uint64_t) << 32 as libc::c_int
+                | e.c2rust_unnamed_0.encoded[2 as libc::c_int as usize] as libc::c_ulong)
+                .wrapping_div(10 as libc::c_int as libc::c_ulong) as uint32_t;
+        let mut c3: libc::c_uint = ((c2 as uint64_t) << 32 as libc::c_int
+            | e.c2rust_unnamed_0.encoded[1 as libc::c_int as usize] as libc::c_ulong)
+            .wrapping_rem(10 as libc::c_int as libc::c_ulong)
+            as libc::c_uint;
+        e.c2rust_unnamed_0.encoded[1 as libc::c_int as usize] =
+            ((c2 as uint64_t) << 32 as libc::c_int
+                | e.c2rust_unnamed_0.encoded[1 as libc::c_int as usize] as libc::c_ulong)
+                .wrapping_div(10 as libc::c_int as libc::c_ulong) as uint32_t;
+        let mut c4: libc::c_uint = ((c3 as uint64_t) << 32 as libc::c_int
+            | e.c2rust_unnamed_0.encoded[0 as libc::c_int as usize] as libc::c_ulong)
+            .wrapping_rem(10 as libc::c_int as libc::c_ulong)
+            as libc::c_uint;
+        e.c2rust_unnamed_0.encoded[0 as libc::c_int as usize] =
+            ((c3 as uint64_t) << 32 as libc::c_int
+                | e.c2rust_unnamed_0.encoded[0 as libc::c_int as usize] as libc::c_ulong)
+                .wrapping_div(10 as libc::c_int as libc::c_ulong) as uint32_t;
+        decimal[(34 as libc::c_int as libc::c_ulong).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 libc::c_int as size_t;
+    while i < 7 as libc::c_int as libc::c_ulong {
+        if i != 0 {
+            let fresh2 = q;
+            q = q.offset(1);
+            *fresh2 = '-' as i32 as libc::c_char;
+        }
+        let mut p_0: *mut libc::c_uchar = decimal
+            .as_mut_ptr()
+            .offset(i.wrapping_mul(5 as libc::c_int as libc::c_ulong) as isize);
+        *q.offset(0 as libc::c_int as isize) =
+            (*p_0.offset(0 as libc::c_int as isize) as libc::c_int + '0' as i32) as libc::c_char;
+        *q.offset(1 as libc::c_int as isize) =
+            (*p_0.offset(1 as libc::c_int as isize) as libc::c_int + '0' as i32) as libc::c_char;
+        *q.offset(2 as libc::c_int as isize) =
+            (*p_0.offset(2 as libc::c_int as isize) as libc::c_int + '0' as i32) as libc::c_char;
+        *q.offset(3 as libc::c_int as isize) =
+            (*p_0.offset(3 as libc::c_int as isize) as libc::c_int + '0' as i32) as libc::c_char;
+        *q.offset(4 as libc::c_int as isize) =
+            (*p_0.offset(4 as libc::c_int as isize) as libc::c_int + '0' as i32) as libc::c_char;
+        *q.offset(5 as libc::c_int as isize) = ((*p_0.offset(0 as libc::c_int as isize)
+            as libc::c_int
+            + *p_0.offset(1 as libc::c_int as isize) as libc::c_int * 2 as libc::c_int
+            + *p_0.offset(2 as libc::c_int as isize) as libc::c_int
+            + *p_0.offset(3 as libc::c_int as isize) as libc::c_int * 2 as libc::c_int
+            + *p_0.offset(4 as libc::c_int as isize) as libc::c_int)
+            % 7 as libc::c_int
+            + '0' as i32) as libc::c_char;
+        q = q.offset(6 as libc::c_int as isize);
+        i = i.wrapping_add(1);
+    }
+    let fresh3 = q;
+    q = q.offset(1);
+    *fresh3 = 0 as libc::c_int as libc::c_char;
+    return 0 as libc::c_int;
+}
+
+#[derive(Error, Debug)]
+pub enum ConfirmationIdError {
+    #[error("Installation ID is too short.")]
+    TooShort,
+    #[error("Installation ID is too long.")]
+    TooLarge,
+    #[error("Invalid character in installation ID.")]
+    InvalidCharacter,
+    #[error("Installation ID checksum failed. Please check that it is typed correctly.")]
+    InvalidCheckDigit,
+    #[error("Unknown installation ID version.")]
+    UnknownVersion,
+    #[error("Unable to generate valid confirmation ID.")]
+    Unlucky,
+}
+
+pub fn generate(installation_id: &str) -> Result<String, ConfirmationIdError> {
+    unsafe {
+        let inst_id = CString::new(installation_id).unwrap();
+        let conf_id = [0u8; 49];
+        let result = Generate(inst_id.as_ptr(), conf_id.as_ptr() as *mut libc::c_char);
+        match result {
+            0 => {}
+            1 => return Err(ConfirmationIdError::TooShort),
+            2 => return Err(ConfirmationIdError::TooLarge),
+            3 => return Err(ConfirmationIdError::InvalidCharacter),
+            4 => return Err(ConfirmationIdError::InvalidCheckDigit),
+            5 => return Err(ConfirmationIdError::UnknownVersion),
+            6 => return Err(ConfirmationIdError::Unlucky),
+            _ => panic!("Unknown error code: {}", result),
+        }
+        Ok(CStr::from_ptr(conf_id.as_ptr() as *const libc::c_char)
+            .to_str()
+            .unwrap()
+            .to_string())
+    }
+}
diff --git a/src/main.rs b/src/main.rs
index b8b51c4..73492d7 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -3,6 +3,7 @@ use anyhow::Result;
 mod bink1998;
 mod bink2002;
 mod cli;
+mod confid;
 mod crypto;
 mod key;