diff --git a/src/confid.rs b/src/confid.rs
index 57ac9cf..cb3a1b9 100644
--- a/src/confid.rs
+++ b/src/confid.rs
@@ -1,4 +1,9 @@
-#![allow(non_camel_case_types, non_snake_case, non_upper_case_globals)]
+#![allow(
+    non_camel_case_types,
+    non_snake_case,
+    non_upper_case_globals,
+    clippy::too_many_arguments
+)]
 
 use std::ffi::{CStr, CString};
 
@@ -63,24 +68,24 @@ static mut f: [uint64_t; 6] = [
     0x1400606322b3b04_u64 as uint64_t,
     1_i32 as uint64_t,
 ];
-#[no_mangle]
-unsafe extern "C" fn residue_add(x: uint64_t, y: uint64_t) -> uint64_t {
+
+unsafe fn residue_add(x: uint64_t, y: uint64_t) -> uint64_t {
     let mut z: uint64_t = x.wrapping_add(y);
     if z >= 0x16a6b036d7f2a79_u64 {
         z = z.wrapping_sub(0x16a6b036d7f2a79_u64) as uint64_t as uint64_t;
     }
     z
 }
-#[no_mangle]
-unsafe extern "C" fn residue_sub(x: uint64_t, y: uint64_t) -> uint64_t {
+
+unsafe fn residue_sub(x: uint64_t, y: uint64_t) -> uint64_t {
     let mut z: uint64_t = x.wrapping_sub(y);
     if x < y {
         z = z.wrapping_add(0x16a6b036d7f2a79_u64) as uint64_t as uint64_t;
     }
     z
 }
-#[no_mangle]
-unsafe extern "C" fn __umul128(
+
+unsafe fn __umul128(
     multiplier: uint64_t,
     multiplicand: uint64_t,
     product_hi: *mut uint64_t,
@@ -102,8 +107,8 @@ unsafe extern "C" fn __umul128(
         .wrapping_add(product_lo_carry);
     product_lo
 }
-#[no_mangle]
-unsafe extern "C" fn ui128_quotient_mod(lo: uint64_t, hi: uint64_t) -> uint64_t {
+
+unsafe fn ui128_quotient_mod(lo: uint64_t, 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;
@@ -121,15 +126,15 @@ unsafe extern "C" fn ui128_quotient_mod(lo: uint64_t, hi: uint64_t) -> uint64_t
     prod3hi = prod3hi.wrapping_add((prod3lo < prod2) as i32 as u64) as uint64_t as uint64_t;
     prod3lo >> 42_i32 | prod3hi << 22_i32
 }
-#[no_mangle]
-unsafe extern "C" fn residue_mul(x: uint64_t, y: uint64_t) -> uint64_t {
+
+unsafe fn residue_mul(x: uint64_t, y: uint64_t) -> uint64_t {
     let mut hi: uint64_t = 0;
     let lo: uint64_t = __umul128(x, y, &mut hi);
     let quotient: uint64_t = ui128_quotient_mod(lo, hi);
     lo.wrapping_sub(quotient.wrapping_mul(0x16a6b036d7f2a79_u64)) as uint64_t
 }
-#[no_mangle]
-unsafe extern "C" fn residue_pow(x: uint64_t, mut y: uint64_t) -> uint64_t {
+
+unsafe fn residue_pow(x: uint64_t, mut y: uint64_t) -> uint64_t {
     if y == 0_i32 as u64 {
         return 1_i32 as uint64_t;
     }
@@ -151,8 +156,8 @@ unsafe extern "C" fn residue_pow(x: uint64_t, mut y: uint64_t) -> uint64_t {
     }
     res
 }
-#[no_mangle]
-unsafe extern "C" fn inverse(mut u: uint64_t, mut v: uint64_t) -> uint64_t {
+
+unsafe fn inverse(mut u: uint64_t, mut v: uint64_t) -> uint64_t {
     let mut tmp;
     let mut xu: int64_t = 1_i32 as int64_t;
     let mut xv: int64_t = 0_i32 as int64_t;
@@ -171,12 +176,12 @@ unsafe extern "C" fn inverse(mut u: uint64_t, mut v: uint64_t) -> uint64_t {
         as int64_t;
     xu as uint64_t
 }
-#[no_mangle]
-unsafe extern "C" fn residue_inv(x: uint64_t) -> uint64_t {
+
+unsafe fn residue_inv(x: uint64_t) -> uint64_t {
     inverse(x, 0x16a6b036d7f2a79_u64 as uint64_t)
 }
-#[no_mangle]
-unsafe extern "C" fn residue_sqrt(what: uint64_t) -> uint64_t {
+
+unsafe fn residue_sqrt(what: uint64_t) -> uint64_t {
     if what == 0 {
         return 0_i32 as uint64_t;
     }
@@ -223,8 +228,8 @@ unsafe extern "C" fn residue_sqrt(what: uint64_t) -> uint64_t {
     }
     x
 }
-#[no_mangle]
-unsafe extern "C" fn find_divisor_v(mut d: *mut TDivisor) -> i32 {
+
+unsafe fn find_divisor_v(mut d: *mut TDivisor) -> i32 {
     let mut v1;
     let mut f2: [uint64_t; 6] = [0; 6];
     let mut i: i32 = 0_i32;
@@ -298,8 +303,8 @@ unsafe extern "C" fn find_divisor_v(mut d: *mut TDivisor) -> i32 {
     (*d).v[1_i32 as usize] = v1 as uint16_t;
     1_i32
 }
-#[no_mangle]
-unsafe extern "C" fn polynomial_mul(
+
+unsafe fn polynomial_mul(
     adeg: i32,
     a: *const uint64_t,
     bdeg: i32,
@@ -333,8 +338,8 @@ unsafe extern "C" fn polynomial_mul(
     }
     resultprevdeg
 }
-#[no_mangle]
-unsafe extern "C" fn polynomial_div_monic(
+
+unsafe fn polynomial_div_monic(
     adeg: i32,
     a: *mut uint64_t,
     bdeg: i32,
@@ -364,8 +369,8 @@ unsafe extern "C" fn polynomial_div_monic(
     }
     i
 }
-#[no_mangle]
-unsafe extern "C" fn polynomial_xgcd(
+
+unsafe fn polynomial_xgcd(
     adeg: i32,
     a: *const uint64_t,
     bdeg: i32,
@@ -482,12 +487,8 @@ unsafe extern "C" fn polynomial_xgcd(
     *pmult1deg = mult1deg;
     *pmult2deg = mult2deg;
 }
-#[no_mangle]
-unsafe extern "C" fn u2poly(
-    src: *const TDivisor,
-    polyu: *mut uint64_t,
-    polyv: *mut uint64_t,
-) -> i32 {
+
+unsafe fn u2poly(src: *const TDivisor, polyu: *mut uint64_t, polyv: *mut uint64_t) -> i32 {
     if (*src).u[1_i32 as usize] as u64 != 0xffffffffffffffff_u64 {
         *polyu.offset(0_i32 as isize) = (*src).u[0_i32 as usize] as uint64_t;
         *polyu.offset(1_i32 as isize) = (*src).u[1_i32 as usize] as uint64_t;
@@ -508,12 +509,8 @@ unsafe extern "C" fn u2poly(
     *polyv.offset(1_i32 as isize) = 0_i32 as uint64_t;
     0_i32
 }
-#[no_mangle]
-unsafe extern "C" fn divisor_add(
-    src1: *const TDivisor,
-    src2: *const TDivisor,
-    mut dst: *mut TDivisor,
-) {
+
+unsafe fn divisor_add(src1: *const TDivisor, 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];
@@ -773,34 +770,8 @@ unsafe extern "C" fn divisor_add(
         (*dst).v[1_i32 as usize] = 0xffffffffffffffff_u64 as uint16_t;
     };
 }
-#[no_mangle]
-unsafe extern "C" fn divisor_mul(src: *const TDivisor, mut mult: uint64_t, mut dst: *mut TDivisor) {
-    if mult == 0_i32 as u64 {
-        (*dst).u[0_i32 as usize] = 0xffffffffffffffff_u64 as uint16_t;
-        (*dst).u[1_i32 as usize] = 0xffffffffffffffff_u64 as uint16_t;
-        (*dst).v[0_i32 as usize] = 0xffffffffffffffff_u64 as uint16_t;
-        (*dst).v[1_i32 as usize] = 0xffffffffffffffff_u64 as uint16_t;
-        return;
-    }
-    let mut cur: TDivisor = *src;
-    while mult & 1_i32 as u64 == 0 {
-        divisor_add(&cur, &cur, &mut cur);
-        mult >>= 1_i32;
-    }
-    *dst = cur;
-    loop {
-        mult >>= 1_i32;
-        if mult == 0_i32 as u64 {
-            break;
-        }
-        divisor_add(&cur, &cur, &mut cur);
-        if mult & 1_i32 as u64 != 0 {
-            divisor_add(dst, &cur, dst);
-        }
-    }
-}
-#[no_mangle]
-unsafe extern "C" fn divisor_mul128(
+
+unsafe fn divisor_mul128(
     src: *const TDivisor,
     mut mult_lo: uint64_t,
     mut mult_hi: uint64_t,
@@ -838,12 +809,12 @@ unsafe extern "C" fn divisor_mul128(
         }
     }
 }
-#[no_mangle]
-unsafe extern "C" fn rol(x: u32, shift: i32) -> u32 {
+
+unsafe fn rol(x: u32, shift: i32) -> u32 {
     x << shift | x >> (32_i32 - shift)
 }
-#[no_mangle]
-unsafe extern "C" fn sha1_single_block(input: *mut libc::c_uchar, output: *mut libc::c_uchar) {
+
+unsafe fn sha1_single_block(input: *mut libc::c_uchar, output: *mut libc::c_uchar) {
     let mut a = 0x67452301_i32 as u32;
     let mut b = 0xefcdab89_u32;
     let mut c = 0x98badcfe_u32;
@@ -956,8 +927,8 @@ unsafe extern "C" fn sha1_single_block(input: *mut libc::c_uchar, output: *mut l
     *output.offset(18_i32 as isize) = (e >> 8_i32) as libc::c_uchar;
     *output.offset(19_i32 as isize) = e as libc::c_uchar;
 }
-#[no_mangle]
-unsafe extern "C" fn Mix(
+
+unsafe fn Mix(
     buffer: *mut libc::c_uchar,
     bufSize: size_t,
     key: *const libc::c_uchar,
@@ -1012,8 +983,8 @@ unsafe extern "C" fn Mix(
         external_counter += 1;
     }
 }
-#[no_mangle]
-unsafe extern "C" fn Unmix(
+
+unsafe fn Unmix(
     buffer: *mut libc::c_uchar,
     bufSize: size_t,
     key: *const libc::c_uchar,
@@ -1068,8 +1039,8 @@ unsafe extern "C" fn Unmix(
         external_counter += 1;
     }
 }
-#[no_mangle]
-unsafe extern "C" fn Generate(
+
+unsafe fn Generate(
     installation_id_str: *const libc::c_char,
     confirmation_id: *mut libc::c_char,
 ) -> i32 {