diff --git a/src/confid/black_box.rs b/src/confid/black_box.rs
index 1839691..d05f6a6 100644
--- a/src/confid/black_box.rs
+++ b/src/confid/black_box.rs
@@ -1,13 +1,7 @@
-#![allow(
-    non_camel_case_types,
-    non_snake_case,
-    non_upper_case_globals,
-    clippy::too_many_arguments
-)]
+#![allow(clippy::too_many_arguments)]
 
 use std::{ffi::c_void, ptr};
 
-type size_t = u64;
 #[derive(Copy, Clone)]
 #[repr(C)]
 struct TDivisor {
@@ -46,12 +40,12 @@ union C2RustUnnamed_3 {
 #[derive(Copy, Clone)]
 #[repr(C, packed)]
 struct C2RustUnnamed_4 {
-    HardwareID: u64,
-    ProductIDLow: u64,
-    ProductIDHigh: u8,
-    KeySHA1: u16,
+    hardware_id: u64,
+    product_id_low: u64,
+    product_id_high: u8,
+    key_sha1: u16,
 }
-static mut f: [u64; 6] = [
+static mut F: [u64; 6] = [
     0,
     0x21840136c85381,
     0x44197b83892ad0,
@@ -220,7 +214,7 @@ unsafe fn find_divisor_v(mut d: *mut TDivisor) -> i32 {
     let mut f2: [u64; 6] = [0; 6];
     let mut i: i32 = 0_i32;
     while i < 6_i32 {
-        f2[i as usize] = f[i as usize];
+        f2[i as usize] = F[i as usize];
         i += 1;
     }
     let u0: u64 = (*d).u[0_i32 as usize];
@@ -629,12 +623,12 @@ unsafe fn divisor_add(src1: *const TDivisor, src2: *const TDivisor, mut dst: *mu
         v[i as usize] = residue_mul(v[i as usize], c1[0_i32 as usize]);
         i += 1;
     }
-    tmp[0] = f[0];
-    tmp[1] = f[1];
-    tmp[2] = f[2];
-    tmp[3] = f[3];
-    tmp[4] = f[4];
-    tmp[5] = f[5];
+    tmp[0] = F[0];
+    tmp[1] = F[1];
+    tmp[2] = F[2];
+    tmp[3] = F[3];
+    tmp[4] = F[4];
+    tmp[5] = F[5];
     tmpdeg = 5_i32;
     tmpdeg = polynomial_mul(
         1_i32,
@@ -703,7 +697,7 @@ unsafe fn divisor_add(src1: *const TDivisor, src2: *const TDivisor, mut dst: *mu
         );
         i = 0_i32;
         while i <= tmpdeg && i <= 5_i32 {
-            tmp[i as usize] = residue_sub(f[i as usize], tmp[i as usize]);
+            tmp[i as usize] = residue_sub(F[i as usize], tmp[i as usize]);
             i += 1;
         }
         while i <= tmpdeg {
@@ -711,7 +705,7 @@ unsafe fn divisor_add(src1: *const TDivisor, src2: *const TDivisor, mut dst: *mu
             i += 1;
         }
         while i <= 5_i32 {
-            tmp[i as usize] = f[i as usize];
+            tmp[i as usize] = F[i as usize];
             i += 1;
         }
         tmpdeg = i - 1_i32;
@@ -824,32 +818,30 @@ unsafe fn sha1_single_block(input: *mut u8, output: *mut u8) {
     let mut d = 0x10325476_i32 as u32;
     let mut e = 0xc3d2e1f0_u32;
     let mut w: [u32; 80] = [0; 80];
-    let mut i = 0_i32 as size_t;
-    while i < 16_i32 as u64 {
-        w[i as usize] = ((*input.offset((4_i32 as u64).wrapping_mul(i) as isize) as i32) << 24_i32
-            | (*input.offset((4_i32 as u64).wrapping_mul(i).wrapping_add(1_i32 as u64) as isize)
-                as i32)
+    let mut i = 0_i32 as usize;
+    while i < 16 {
+        w[i as usize] = ((*input.offset((4 as usize).wrapping_mul(i) as isize) as i32) << 24_i32
+            | (*input.offset((4 as usize).wrapping_mul(i).wrapping_add(1) as isize) as i32)
                 << 16_i32
-            | (*input.offset((4_i32 as u64).wrapping_mul(i).wrapping_add(2_i32 as u64) as isize)
-                as i32)
+            | (*input.offset((4 as usize).wrapping_mul(i).wrapping_add(2) as isize) as i32)
                 << 8_i32
-            | *input.offset((4_i32 as u64).wrapping_mul(i).wrapping_add(3_i32 as u64) as isize)
-                as i32) as u32;
+            | *input.offset((4 as usize).wrapping_mul(i).wrapping_add(3) as isize) as i32)
+            as u32;
         i = i.wrapping_add(1);
     }
-    i = 16_i32 as size_t;
-    while i < 80_i32 as u64 {
+    i = 16_i32 as usize;
+    while i < 80 {
         w[i as usize] = rol(
-            w[i.wrapping_sub(3_i32 as u64) as usize]
-                ^ w[i.wrapping_sub(8_i32 as u64) as usize]
-                ^ w[i.wrapping_sub(14_i32 as u64) as usize]
-                ^ w[i.wrapping_sub(16_i32 as u64) as usize],
+            w[i.wrapping_sub(3) as usize]
+                ^ w[i.wrapping_sub(8) as usize]
+                ^ w[i.wrapping_sub(14) as usize]
+                ^ w[i.wrapping_sub(16) as usize],
             1_i32,
         );
         i = i.wrapping_add(1);
     }
-    i = 0_i32 as size_t;
-    while i < 20_i32 as u64 {
+    i = 0_i32 as usize;
+    while i < 20 {
         let tmp: u32 = (rol(a, 5_i32))
             .wrapping_add(b & c | !b & d)
             .wrapping_add(e)
@@ -862,8 +854,8 @@ unsafe fn sha1_single_block(input: *mut u8, output: *mut u8) {
         a = tmp;
         i = i.wrapping_add(1);
     }
-    i = 20_i32 as size_t;
-    while i < 40_i32 as u64 {
+    i = 20_i32 as usize;
+    while i < 40 {
         let tmp_0: u32 = (rol(a, 5_i32))
             .wrapping_add(b ^ c ^ d)
             .wrapping_add(e)
@@ -876,8 +868,8 @@ unsafe fn sha1_single_block(input: *mut u8, output: *mut u8) {
         a = tmp_0;
         i = i.wrapping_add(1);
     }
-    i = 40_i32 as size_t;
-    while i < 60_i32 as u64 {
+    i = 40_i32 as usize;
+    while i < 60 {
         let tmp_1: u32 = (rol(a, 5_i32))
             .wrapping_add(b & c | b & d | c & d)
             .wrapping_add(e)
@@ -890,8 +882,8 @@ unsafe fn sha1_single_block(input: *mut u8, output: *mut u8) {
         a = tmp_1;
         i = i.wrapping_add(1);
     }
-    i = 60_i32 as size_t;
-    while i < 80_i32 as u64 {
+    i = 60_i32 as usize;
+    while i < 80 {
         let tmp_2: u32 = (rol(a, 5_i32))
             .wrapping_add(b ^ c ^ d)
             .wrapping_add(e)
@@ -931,10 +923,10 @@ unsafe fn sha1_single_block(input: *mut u8, output: *mut u8) {
     *output.offset(19_i32 as isize) = e as u8;
 }
 
-unsafe fn Mix(buffer: *mut u8, bufSize: size_t, key: *const u8, keySize: size_t) {
+unsafe fn mix(buffer: *mut u8, buf_size: usize, key: *const u8, key_size: usize) {
     let mut sha1_input: [u8; 64] = [0; 64];
     let mut sha1_result: [u8; 20] = [0; 20];
-    let half: size_t = bufSize.wrapping_div(2_i32 as u64);
+    let half: usize = buf_size.wrapping_div(2);
     let mut external_counter = 0_i32;
     while external_counter < 4_i32 {
         for n in &mut sha1_input {
@@ -948,27 +940,25 @@ unsafe fn Mix(buffer: *mut u8, bufSize: size_t, key: *const u8, keySize: size_t)
         ptr::copy_nonoverlapping(
             key as *const c_void,
             sha1_input.as_mut_ptr().offset(half as isize) as *mut c_void,
-            keySize as usize,
+            key_size as usize,
         );
-        sha1_input[half.wrapping_add(keySize) as usize] = 0x80_i32 as u8;
+        sha1_input[half.wrapping_add(key_size) as usize] = 0x80_i32 as u8;
         sha1_input
             [(::std::mem::size_of::<[u8; 64]>() as u64).wrapping_sub(1_i32 as u64) as usize] =
-            half.wrapping_add(keySize).wrapping_mul(8_i32 as u64) as u8;
+            half.wrapping_add(key_size).wrapping_mul(8) as u8;
         sha1_input
             [(::std::mem::size_of::<[u8; 64]>() as u64).wrapping_sub(2_i32 as u64) as usize] =
-            half.wrapping_add(keySize)
-                .wrapping_mul(8_i32 as u64)
-                .wrapping_div(0x100_i32 as u64) as u8;
+            half.wrapping_add(key_size)
+                .wrapping_mul(8)
+                .wrapping_div(0x100) as u8;
         sha1_single_block(sha1_input.as_mut_ptr(), sha1_result.as_mut_ptr());
-        let mut i = half & !3_i32 as u64;
+        let mut i = half & !3;
         while i < half {
-            sha1_result[i as usize] = sha1_result[i
-                .wrapping_add(4_i32 as u64)
-                .wrapping_sub(half & 3_i32 as u64)
-                as usize];
+            sha1_result[i as usize] =
+                sha1_result[i.wrapping_add(4).wrapping_sub(half & 3) as usize];
             i = i.wrapping_add(1);
         }
-        i = 0_i32 as size_t;
+        i = 0_i32 as usize;
         while i < half {
             let tmp: u8 = *buffer.offset(i.wrapping_add(half) as isize);
             *buffer.offset(i.wrapping_add(half) as isize) =
@@ -980,10 +970,10 @@ unsafe fn Mix(buffer: *mut u8, bufSize: size_t, key: *const u8, keySize: size_t)
     }
 }
 
-unsafe fn Unmix(buffer: *mut u8, bufSize: size_t, key: *const u8, keySize: size_t) {
+unsafe fn unmix(buffer: *mut u8, buf_size: usize, key: *const u8, key_size: usize) {
     let mut sha1_input: [u8; 64] = [0; 64];
     let mut sha1_result: [u8; 20] = [0; 20];
-    let half: size_t = bufSize.wrapping_div(2_i32 as u64);
+    let half: usize = buf_size.wrapping_div(2);
     let mut external_counter = 0_i32;
     while external_counter < 4_i32 {
         for n in &mut sha1_input {
@@ -993,27 +983,25 @@ unsafe fn Unmix(buffer: *mut u8, bufSize: size_t, key: *const u8, keySize: size_
         ptr::copy_nonoverlapping(
             key,
             sha1_input.as_mut_ptr().offset(half as isize),
-            keySize as usize,
+            key_size as usize,
         );
-        sha1_input[half.wrapping_add(keySize) as usize] = 0x80_i32 as u8;
+        sha1_input[half.wrapping_add(key_size) as usize] = 0x80_i32 as u8;
         sha1_input
             [(::std::mem::size_of::<[u8; 64]>() as u64).wrapping_sub(1_i32 as u64) as usize] =
-            half.wrapping_add(keySize).wrapping_mul(8_i32 as u64) as u8;
+            half.wrapping_add(key_size).wrapping_mul(8) as u8;
         sha1_input
             [(::std::mem::size_of::<[u8; 64]>() as u64).wrapping_sub(2_i32 as u64) as usize] =
-            half.wrapping_add(keySize)
-                .wrapping_mul(8_i32 as u64)
-                .wrapping_div(0x100_i32 as u64) as u8;
+            half.wrapping_add(key_size)
+                .wrapping_mul(8)
+                .wrapping_div(0x100) as u8;
         sha1_single_block(sha1_input.as_mut_ptr(), sha1_result.as_mut_ptr());
-        let mut i = half & !3_i32 as u64;
+        let mut i = half & !3;
         while i < half {
-            sha1_result[i as usize] = sha1_result[i
-                .wrapping_add(4_i32 as u64)
-                .wrapping_sub(half & 3_i32 as u64)
-                as usize];
+            sha1_result[i as usize] =
+                sha1_result[i.wrapping_add(4).wrapping_sub(half & 3) as usize];
             i = i.wrapping_add(1);
         }
-        i = 0_i32 as size_t;
+        i = 0_i32 as usize;
         while i < half {
             let tmp: u8 = *buffer.offset(i as isize);
             *buffer.offset(i as isize) = (*buffer.offset(i.wrapping_add(half) as isize) as i32
@@ -1025,12 +1013,12 @@ unsafe fn Unmix(buffer: *mut u8, bufSize: size_t, key: *const u8, keySize: size_
     }
 }
 
-pub unsafe fn Generate(installation_id_str: *const i8, confirmation_id: *mut i8) -> i32 {
+pub unsafe fn generate(installation_id_str: *const i8, confirmation_id: *mut i8) -> i32 {
     let mut installation_id: [u8; 19] = [0; 19]; // 10**45 < 256**19
-    let mut installation_id_len: size_t = 0_i32 as size_t;
+    let mut installation_id_len: usize = 0_i32 as usize;
     let mut p: *const i8 = installation_id_str;
-    let mut count: size_t = 0_i32 as size_t;
-    let mut totalCount: size_t = 0_i32 as size_t;
+    let mut count: usize = 0_i32 as usize;
+    let mut total_count: usize = 0_i32 as usize;
     let mut check: u32 = 0_i32 as u32;
     while *p != 0 {
         if !(*p as i32 == ' ' as i32 || *p as i32 == '-' as i32) {
@@ -1038,34 +1026,30 @@ pub unsafe fn Generate(installation_id_str: *const i8, confirmation_id: *mut i8)
             if !(0_i32..=9_i32).contains(&d) {
                 return 3_i32;
             }
-            if count == 5_i32 as u64 || *p.offset(1_i32 as isize) as i32 == 0_i32 {
+            if count == 5 || *p.offset(1_i32 as isize) as i32 == 0_i32 {
                 if count == 0 {
-                    return if totalCount == 45_i32 as u64 {
-                        2_i32
-                    } else {
-                        1_i32
-                    };
+                    return if total_count == 45 { 2_i32 } else { 1_i32 };
                 }
                 if d as u32 != check.wrapping_rem(7_i32 as u32) {
-                    return if count < 5_i32 as u64 { 1_i32 } else { 4_i32 };
+                    return if count < 5 { 1_i32 } else { 4_i32 };
                 }
                 check = 0_i32 as u32;
-                count = 0_i32 as size_t;
+                count = 0_i32 as usize;
             } else {
                 check = check.wrapping_add(
-                    (if count.wrapping_rem(2_i32 as u64) != 0 {
+                    (if count.wrapping_rem(2) != 0 {
                         d * 2_i32
                     } else {
                         d
                     }) as u32,
                 );
                 count = count.wrapping_add(1);
-                totalCount = totalCount.wrapping_add(1);
-                if totalCount > 45_i32 as u64 {
+                total_count = total_count.wrapping_add(1);
+                if total_count > 45 {
                     return 2_i32;
                 }
                 let mut carry: u8 = d as u8;
-                let mut i = 0_i32 as size_t;
+                let mut i = 0_i32 as usize;
                 while i < installation_id_len {
                     let x: u32 =
                         (installation_id[i as usize] as i32 * 10_i32 + carry as i32) as u32;
@@ -1082,73 +1066,63 @@ pub unsafe fn Generate(installation_id_str: *const i8, confirmation_id: *mut i8)
         }
         p = p.offset(1);
     }
-    if totalCount != 41_i32 as u64 && totalCount < 45_i32 as u64 {
+    if total_count != 41 && total_count < 45 {
         return 1_i32;
     }
-    while installation_id_len < ::std::mem::size_of::<[u8; 19]>() as u64 {
+    while installation_id_len < ::std::mem::size_of::<[u8; 19]>() {
         installation_id[installation_id_len as usize] = 0_i32 as u8;
         installation_id_len = installation_id_len.wrapping_add(1);
     }
-    static mut iid_key: [u8; 4] = [
+    const IID_KEY: [u8; 4] = [
         0x6a_i32 as u8,
         0xc8_i32 as u8,
         0x5e_i32 as u8,
         0xd4_i32 as u8,
     ];
-    Unmix(
+    unmix(
         installation_id.as_mut_ptr(),
-        (if totalCount == 41_i32 as u64 {
-            17_i32
-        } else {
-            19_i32
-        }) as size_t,
-        iid_key.as_ptr(),
-        4_i32 as size_t,
+        (if total_count == 41 { 17_i32 } else { 19_i32 }) as usize,
+        IID_KEY.as_ptr(),
+        4_i32 as usize,
     );
     if installation_id[18_i32 as usize] as i32 >= 0x10_i32 {
         return 5_i32;
     }
     let mut parsed: C2RustUnnamed_4 = C2RustUnnamed_4 {
-        HardwareID: 0,
-        ProductIDLow: 0,
-        ProductIDHigh: 0,
-        KeySHA1: 0,
+        hardware_id: 0,
+        product_id_low: 0,
+        product_id_high: 0,
+        key_sha1: 0,
     };
     ptr::copy_nonoverlapping(
         installation_id.as_mut_ptr() as *const c_void,
         &mut parsed as *mut C2RustUnnamed_4 as *mut c_void,
         std::mem::size_of::<C2RustUnnamed_4>(),
     );
-    let productId1: u32 = (parsed.ProductIDLow & ((1_i32 << 17_i32) - 1_i32) as u64) as u32;
-    let productId2: u32 =
-        (parsed.ProductIDLow >> 17_i32 & ((1_i32 << 10_i32) - 1_i32) as u64) as u32;
-    let productId3: u32 =
-        (parsed.ProductIDLow >> 27_i32 & ((1_i32 << 25_i32) - 1_i32) as u64) as u32;
-    let version: u32 = (parsed.ProductIDLow >> 52_i32 & 7_i32 as u64) as u32;
-    let productId4: u32 =
-        (parsed.ProductIDLow >> 55_i32 | ((parsed.ProductIDHigh as i32) << 9_i32) as u64) as u32;
-    if version
-        != (if totalCount == 41_i32 as u64 {
-            4_i32
-        } else {
-            5_i32
-        }) as u32
-    {
+    let product_id_1: u32 = (parsed.product_id_low & ((1_i32 << 17_i32) - 1_i32) as u64) as u32;
+    let product_id_2: u32 =
+        (parsed.product_id_low >> 17_i32 & ((1_i32 << 10_i32) - 1_i32) as u64) as u32;
+    let product_id_3: u32 =
+        (parsed.product_id_low >> 27_i32 & ((1_i32 << 25_i32) - 1_i32) as u64) as u32;
+    let version: u32 = (parsed.product_id_low >> 52_i32 & 7_i32 as u64) as u32;
+    let product_id_4: u32 = (parsed.product_id_low >> 55_i32
+        | ((parsed.product_id_high as i32) << 9_i32) as u64) as u32;
+    if version != (if total_count == 41 { 4_i32 } else { 5_i32 }) as u32 {
         return 5_i32;
     }
     let mut keybuf: [u8; 16] = [0; 16];
-    let mut hardware_id = parsed.HardwareID;
+    let mut hardware_id = parsed.hardware_id;
     ptr::copy_nonoverlapping(
         &mut hardware_id as *mut u64 as *const c_void,
         keybuf.as_mut_ptr() as *mut c_void,
         8,
     );
-    let mut productIdMixed: u64 = (productId1 as u64) << 41_i32
-        | (productId2 as u64) << 58_i32
-        | (productId3 as u64) << 17_i32
-        | productId4 as u64;
+    let mut product_id_mixed: u64 = (product_id_1 as u64) << 41_i32
+        | (product_id_2 as u64) << 58_i32
+        | (product_id_3 as u64) << 17_i32
+        | product_id_4 as u64;
     ptr::copy_nonoverlapping(
-        &mut productIdMixed as *mut u64 as *const c_void,
+        &mut product_id_mixed as *mut u64 as *const c_void,
         keybuf.as_mut_ptr().offset(8) as *mut c_void,
         8,
     );
@@ -1162,11 +1136,11 @@ pub unsafe fn Generate(installation_id_str: *const i8, confirmation_id: *mut i8)
         u.c2rust_unnamed.lo = 0_i32 as u64;
         u.c2rust_unnamed.hi = 0_i32 as u64;
         u.buffer[7_i32 as usize] = attempt;
-        Mix(
+        mix(
             (u.buffer).as_mut_ptr(),
-            14_i32 as size_t,
+            14_i32 as usize,
             keybuf.as_mut_ptr(),
-            16_i32 as size_t,
+            16_i32 as usize,
         );
         let mut x2: u64 = ui128_quotient_mod(u.c2rust_unnamed.lo, u.c2rust_unnamed.hi);
         let x1: u64 = u.c2rust_unnamed.lo.wrapping_sub(x2.wrapping_mul(MOD));
@@ -1266,8 +1240,8 @@ pub unsafe fn Generate(installation_id_str: *const i8, confirmation_id: *mut i8)
         }
     }
     let mut decimal: [u8; 35] = [0; 35];
-    let mut i = 0_i32 as size_t;
-    while i < 35_i32 as u64 {
+    let mut i = 0_i32 as usize;
+    while i < 35 {
         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].wrapping_div(10_i32 as u32);
@@ -1286,20 +1260,18 @@ pub unsafe fn Generate(installation_id_str: *const i8, confirmation_id: *mut i8)
         e.c2rust_unnamed_0.encoded[0_i32 as usize] =
             ((c3 as u64) << 32_i32 | e.c2rust_unnamed_0.encoded[0_i32 as usize] as u64)
                 .wrapping_div(10_i32 as u64) as u32;
-        decimal[(34_i32 as u64).wrapping_sub(i) as usize] = c4 as u8;
+        decimal[(34 as usize).wrapping_sub(i) as usize] = c4 as u8;
         i = i.wrapping_add(1);
     }
     let mut q: *mut i8 = confirmation_id;
-    i = 0_i32 as size_t;
-    while i < 7_i32 as u64 {
+    i = 0_i32 as usize;
+    while i < 7 {
         if i != 0 {
             let fresh2 = q;
             q = q.offset(1);
             *fresh2 = '-' as i32 as i8;
         }
-        let p_0: *mut u8 = decimal
-            .as_mut_ptr()
-            .offset(i.wrapping_mul(5_i32 as u64) as isize);
+        let p_0: *mut u8 = decimal.as_mut_ptr().offset(i.wrapping_mul(5) as isize);
         *q.offset(0_i32 as isize) = (*p_0.offset(0_i32 as isize) as i32 + '0' as i32) as i8;
         *q.offset(1_i32 as isize) = (*p_0.offset(1_i32 as isize) as i32 + '0' as i32) as i8;
         *q.offset(2_i32 as isize) = (*p_0.offset(2_i32 as isize) as i32 + '0' as i32) as i8;
diff --git a/src/confid/mod.rs b/src/confid/mod.rs
index 0bc1e3c..397a938 100644
--- a/src/confid/mod.rs
+++ b/src/confid/mod.rs
@@ -23,7 +23,7 @@ pub enum ConfirmationIdError {
 pub fn generate(installation_id: &str) -> Result<String, ConfirmationIdError> {
     let inst_id = CString::new(installation_id).unwrap();
     let conf_id = [0u8; 49];
-    let result = unsafe { black_box::Generate(inst_id.as_ptr(), conf_id.as_ptr() as *mut i8) };
+    let result = unsafe { black_box::generate(inst_id.as_ptr(), conf_id.as_ptr() as *mut i8) };
     match result {
         0 => {}
         1 => return Err(ConfirmationIdError::TooShort),