diff --git a/yescrypt/src/lib.rs b/yescrypt/src/lib.rs
index 2f4f10e4..e0e4be96 100644
--- a/yescrypt/src/lib.rs
+++ b/yescrypt/src/lib.rs
@@ -56,10 +56,7 @@ mod salsa20;
 mod sha256;
 
 use crate::{
-    common::{
-        atoi64, blkcpy, blkxor, decode64, decode64_uint32, decode64_uint32_fixed, encode64,
-        encode64_uint32, encrypt, integerify, le32dec, le32enc, p2floor, wrap, N2log2,
-    },
+    common::{blkcpy, blkxor, integerify, le32dec, le32enc, p2floor, wrap},
     sha256::{HMAC_SHA256_Buf, SHA256_Buf, PBKDF2_SHA256},
 };
 use alloc::{vec, vec::Vec};
@@ -67,7 +64,7 @@ use core::{
     mem::{self, size_of},
     ptr,
 };
-use libc::{free, malloc, memcpy, memset, strlen, strncmp, strrchr};
+use libc::{free, malloc, memcpy};
 
 type uint8_t = libc::c_uchar;
 type uint32_t = libc::c_uint;
@@ -118,8 +115,6 @@ struct PwxformCtx {
 }
 
 const DEC: encrypt_dir_t = -1;
-#[allow(dead_code)]
-const ENC: encrypt_dir_t = 1;
 
 /// yescrypt Key Derivation Function (KDF)
 pub fn yescrypt_kdf(
@@ -166,252 +161,6 @@ pub fn yescrypt_kdf(
     dst
 }
 
-#[allow(dead_code)]
-unsafe fn yescrypt(mut passwd: *const uint8_t, mut setting: *const uint8_t) -> *mut uint8_t {
-    static mut buf: [uint8_t; 140] = [0; 140];
-    let mut local: Local = Local {
-        base: 0 as *mut libc::c_void,
-        aligned: 0 as *mut libc::c_void,
-        base_size: 0,
-        aligned_size: 0,
-    };
-    let mut retval: *mut uint8_t = 0 as *mut uint8_t;
-    if yescrypt_init_local(&mut local) != 0 {
-        return 0 as *mut uint8_t;
-    }
-    retval = yescrypt_r(
-        0 as *const Shared,
-        &mut local,
-        passwd,
-        strlen(passwd as *mut libc::c_char),
-        setting,
-        0 as *const Binary,
-        buf.as_mut_ptr(),
-        size_of::<[uint8_t; 140]>(),
-    );
-    if yescrypt_free_local(&mut local) != 0 {
-        return 0 as *mut uint8_t;
-    }
-    return retval;
-}
-
-#[allow(dead_code)]
-unsafe fn yescrypt_r(
-    mut shared: *const Shared,
-    mut local: *mut Local,
-    mut passwd: *const uint8_t,
-    mut passwdlen: size_t,
-    mut setting: *const uint8_t,
-    mut key: *const Binary,
-    mut buf: *mut uint8_t,
-    mut buflen: size_t,
-) -> *mut uint8_t {
-    let mut current_block: u64;
-    let mut saltbin: [libc::c_uchar; 64] = [0; 64];
-    let mut hashbin: [libc::c_uchar; 32] = [0; 32];
-    let mut src: *const uint8_t = 0 as *const uint8_t;
-    let mut saltstr: *const uint8_t = 0 as *const uint8_t;
-    let mut salt: *const uint8_t = 0 as *const uint8_t;
-    let mut dst: *mut uint8_t = 0 as *mut uint8_t;
-    let mut need: usize = 0;
-    let mut prefixlen: usize = 0;
-    let mut saltstrlen: usize = 0;
-    let mut saltlen: size_t = 0;
-    let mut params: Params = Params {
-        flags: 0,
-        N: 0,
-        r: 0,
-        p: 1,
-        t: 0,
-        g: 0,
-        NROM: 0,
-    };
-    if *setting.offset(0 as libc::c_int as isize) as libc::c_int != '$' as i32
-        || *setting.offset(1 as libc::c_int as isize) as libc::c_int != '7' as i32
-            && *setting.offset(1 as libc::c_int as isize) as libc::c_int != 'y' as i32
-        || *setting.offset(2 as libc::c_int as isize) as libc::c_int != '$' as i32
-    {
-        return 0 as *mut uint8_t;
-    }
-    src = setting.offset(3 as libc::c_int as isize);
-    if *setting.offset(1 as libc::c_int as isize) as libc::c_int == '7' as i32 {
-        let fresh14 = src;
-        src = src.offset(1);
-        let mut N_log2: uint32_t = atoi64(*fresh14);
-        if N_log2 < 1 as libc::c_int as libc::c_uint || N_log2 > 63 as libc::c_int as libc::c_uint {
-            return 0 as *mut uint8_t;
-        }
-        params.N = (1 as libc::c_int as uint64_t) << N_log2;
-        src = decode64_uint32_fixed(&mut params.r, 30 as libc::c_int as uint32_t, src);
-        if src.is_null() {
-            return 0 as *mut uint8_t;
-        }
-        src = decode64_uint32_fixed(&mut params.p, 30 as libc::c_int as uint32_t, src);
-        if src.is_null() {
-            return 0 as *mut uint8_t;
-        }
-        if !key.is_null() {
-            return 0 as *mut uint8_t;
-        }
-    } else {
-        let mut flavor: uint32_t = 0;
-        let mut N_log2_0: uint32_t = 0;
-        src = decode64_uint32(&mut flavor, src, 0 as libc::c_int as uint32_t);
-        if src.is_null() {
-            return 0 as *mut uint8_t;
-        }
-        if flavor < 0x2 as libc::c_int as libc::c_uint {
-            params.flags = flavor;
-        } else if flavor
-            <= (0x2 as libc::c_int + (0x3fc as libc::c_int >> 2 as libc::c_int)) as libc::c_uint
-        {
-            params.flags = (0x2 as libc::c_int as libc::c_uint).wrapping_add(
-                flavor.wrapping_sub(0x2 as libc::c_int as libc::c_uint) << 2 as libc::c_int,
-            );
-        } else {
-            return 0 as *mut uint8_t;
-        }
-        src = decode64_uint32(&mut N_log2_0, src, 1 as libc::c_int as uint32_t);
-        if src.is_null() || N_log2_0 > 63 as libc::c_int as libc::c_uint {
-            return 0 as *mut uint8_t;
-        }
-        params.N = (1 as libc::c_int as uint64_t) << N_log2_0;
-        src = decode64_uint32(&mut params.r, src, 1 as libc::c_int as uint32_t);
-        if src.is_null() {
-            return 0 as *mut uint8_t;
-        }
-        if *src as libc::c_int != '$' as i32 {
-            let mut have: uint32_t = 0;
-            src = decode64_uint32(&mut have, src, 1 as libc::c_int as uint32_t);
-            if src.is_null() {
-                return 0 as *mut uint8_t;
-            }
-            if have & 1 as libc::c_int as libc::c_uint != 0 {
-                src = decode64_uint32(&mut params.p, src, 2 as libc::c_int as uint32_t);
-                if src.is_null() {
-                    return 0 as *mut uint8_t;
-                }
-            }
-            if have & 2 as libc::c_int as libc::c_uint != 0 {
-                src = decode64_uint32(&mut params.t, src, 1 as libc::c_int as uint32_t);
-                if src.is_null() {
-                    return 0 as *mut uint8_t;
-                }
-            }
-            if have & 4 as libc::c_int as libc::c_uint != 0 {
-                src = decode64_uint32(&mut params.g, src, 1 as libc::c_int as uint32_t);
-                if src.is_null() {
-                    return 0 as *mut uint8_t;
-                }
-            }
-            if have & 8 as libc::c_int as libc::c_uint != 0 {
-                let mut NROM_log2: uint32_t = 0;
-                src = decode64_uint32(&mut NROM_log2, src, 1 as libc::c_int as uint32_t);
-                if src.is_null() || NROM_log2 > 63 as libc::c_int as libc::c_uint {
-                    return 0 as *mut uint8_t;
-                }
-                params.NROM = (1 as libc::c_int as uint64_t) << NROM_log2;
-            }
-        }
-        let fresh15 = src;
-        src = src.offset(1);
-        if *fresh15 as libc::c_int != '$' as i32 {
-            return 0 as *mut uint8_t;
-        }
-    }
-    prefixlen = src.offset_from(setting) as usize;
-    saltstr = src;
-    src = strrchr(saltstr as *mut libc::c_char, '$' as i32) as *mut uint8_t;
-    if !src.is_null() {
-        saltstrlen = src.offset_from(saltstr) as usize;
-    } else {
-        saltstrlen = strlen(saltstr as *mut libc::c_char);
-    }
-    if *setting.offset(1 as libc::c_int as isize) as libc::c_int == '7' as i32 {
-        salt = saltstr;
-        saltlen = saltstrlen as size_t;
-        current_block = 1623252117315916725;
-    } else {
-        let mut saltend: *const uint8_t = 0 as *const uint8_t;
-        saltlen = size_of::<[libc::c_uchar; 64]>() as size_t;
-        saltend = decode64(
-            saltbin.as_mut_ptr(),
-            &mut saltlen,
-            saltstr,
-            saltstrlen as size_t,
-        );
-        if saltend.is_null() || saltend.offset_from(saltstr) as usize != saltstrlen {
-            current_block = 3736434875406665187;
-        } else {
-            salt = saltbin.as_mut_ptr();
-            if !key.is_null() {
-                encrypt(saltbin.as_mut_ptr(), saltlen, key, ENC);
-            }
-            current_block = 1623252117315916725;
-        }
-    }
-    match current_block {
-        1623252117315916725 => {
-            need = prefixlen
-                .wrapping_add(saltstrlen)
-                .wrapping_add(1)
-                .wrapping_add(
-                    (size_of::<Binary>())
-                        .wrapping_mul(8)
-                        .wrapping_add(5)
-                        .wrapping_div(6),
-                )
-                .wrapping_add(1);
-            if !(need > buflen || need < saltstrlen) {
-                if !(yescrypt_kdf_inner(
-                    shared,
-                    local,
-                    passwd,
-                    passwdlen,
-                    salt,
-                    saltlen,
-                    &mut params,
-                    hashbin.as_mut_ptr(),
-                    size_of::<[libc::c_uchar; 32]>(),
-                ) != 0)
-                {
-                    if !key.is_null() {
-                        encrypt(
-                            hashbin.as_mut_ptr(),
-                            size_of::<[libc::c_uchar; 32]>(),
-                            key,
-                            ENC,
-                        );
-                    }
-                    dst = buf;
-                    memcpy(
-                        dst as *mut libc::c_void,
-                        setting as *const libc::c_void,
-                        prefixlen.wrapping_add(saltstrlen),
-                    );
-                    dst = dst.offset(prefixlen.wrapping_add(saltstrlen) as isize);
-                    let fresh16 = dst;
-                    dst = dst.offset(1);
-                    *fresh16 = '$' as i32 as uint8_t;
-                    dst = encode64(
-                        dst,
-                        buflen.wrapping_sub(dst.offset_from(buf) as usize),
-                        hashbin.as_mut_ptr(),
-                        size_of::<[libc::c_uchar; 32]>(),
-                    );
-                    if dst.is_null() || dst >= buf.offset(buflen as isize) {
-                        return 0 as *mut uint8_t;
-                    }
-                    *dst = 0 as libc::c_int as uint8_t;
-                    return buf;
-                }
-            }
-        }
-        _ => {}
-    }
-    return 0 as *mut uint8_t;
-}
-
 unsafe fn yescrypt_kdf_inner(
     mut shared: *const Shared,
     mut local: *mut Local,
@@ -468,441 +217,6 @@ unsafe fn yescrypt_kdf_inner(
     );
 }
 
-#[allow(dead_code)]
-unsafe fn yescrypt_init_shared(
-    mut shared: *mut Shared,
-    mut seed: *const uint8_t,
-    mut seedlen: size_t,
-    mut params: *const Params,
-) -> libc::c_int {
-    let mut current_block: u64;
-    let mut flags: Flags = (*params).flags;
-    let mut N: uint64_t = (*params).NROM;
-    let mut r: uint32_t = (*params).r;
-    let mut p: uint32_t = (*params).p;
-    let mut t: uint32_t = (*params).t;
-    let mut half1: Shared = Shared {
-        base: 0 as *mut libc::c_void,
-        aligned: 0 as *mut libc::c_void,
-        base_size: 0,
-        aligned_size: 0,
-    };
-    let mut half2: Shared = Shared {
-        base: 0 as *mut libc::c_void,
-        aligned: 0 as *mut libc::c_void,
-        base_size: 0,
-        aligned_size: 0,
-    };
-    let mut salt: [uint8_t; 32] = [0; 32];
-    let mut tag: *mut uint32_t = 0 as *mut uint32_t;
-    if (*params).flags & 0x2 as libc::c_int as libc::c_uint == 0
-        || (*params).N != 0
-        || (*params).g != 0
-    {
-        return -(1 as libc::c_int);
-    }
-    if flags & 0x10000 as libc::c_int as libc::c_uint != 0 {
-        if ((*shared).aligned).is_null() || (*shared).aligned_size == 0 {
-            return -(1 as libc::c_int);
-        }
-        tag = ((*shared).aligned as *mut uint8_t)
-            .offset((*shared).aligned_size as isize)
-            .offset(-(48 as libc::c_int as isize)) as *mut uint32_t;
-        memset(tag as *mut libc::c_void, 0, 48);
-        current_block = 2968425633554183086;
-    } else {
-        (*shared).aligned = 0 as *mut libc::c_void;
-        (*shared).base = (*shared).aligned;
-        (*shared).aligned_size = 0 as libc::c_int as size_t;
-        (*shared).base_size = (*shared).aligned_size;
-        if yescrypt_kdf_body(
-            0 as *const Shared,
-            shared,
-            0 as *const uint8_t,
-            0 as libc::c_int as size_t,
-            0 as *const uint8_t,
-            0 as libc::c_int as size_t,
-            flags
-                | 0x1000000 as libc::c_int as libc::c_uint
-                | 0x8000000 as libc::c_int as libc::c_uint,
-            N,
-            r,
-            p,
-            t,
-            0 as libc::c_int as uint64_t,
-            0 as *mut uint8_t,
-            0 as libc::c_int as size_t,
-        ) != -(2 as libc::c_int)
-            || ((*shared).aligned).is_null()
-        {
-            current_block = 13608846184267058342;
-        } else {
-            current_block = 2968425633554183086;
-        }
-    }
-    match current_block {
-        2968425633554183086 => {
-            half2 = *shared;
-            half1 = half2;
-            half1.aligned_size = (half1.aligned_size as libc::c_ulong)
-                .wrapping_div(2 as libc::c_int as libc::c_ulong)
-                as size_t as size_t;
-            half2.aligned = (half2.aligned as *mut uint8_t).offset(half1.aligned_size as isize)
-                as *mut libc::c_void;
-            half2.aligned_size = half1.aligned_size;
-            N = (N as libc::c_ulong).wrapping_div(2 as libc::c_int as libc::c_ulong) as uint64_t
-                as uint64_t;
-            if !(yescrypt_kdf_body(
-                0 as *const Shared,
-                &mut half1,
-                seed,
-                seedlen,
-                b"yescrypt-ROMhash\0" as *const u8 as *const libc::c_char as *const uint8_t,
-                16 as libc::c_int as size_t,
-                flags | 0x1000000 as libc::c_int as libc::c_uint,
-                N,
-                r,
-                p,
-                t,
-                0 as libc::c_int as uint64_t,
-                salt.as_mut_ptr(),
-                size_of::<[uint8_t; 32]>(),
-            ) != 0)
-            {
-                if !(yescrypt_kdf_body(
-                    &mut half1,
-                    &mut half2,
-                    seed,
-                    seedlen,
-                    salt.as_mut_ptr(),
-                    size_of::<[uint8_t; 32]>(),
-                    flags | 0x1000000 as libc::c_int as libc::c_uint,
-                    N,
-                    r,
-                    p,
-                    t,
-                    N,
-                    salt.as_mut_ptr(),
-                    size_of::<[uint8_t; 32]>(),
-                ) != 0)
-                {
-                    if !(yescrypt_kdf_body(
-                        &mut half2,
-                        &mut half1,
-                        seed,
-                        seedlen,
-                        salt.as_mut_ptr(),
-                        size_of::<[uint8_t; 32]>(),
-                        flags | 0x1000000 as libc::c_int as libc::c_uint,
-                        N,
-                        r,
-                        p,
-                        t,
-                        N,
-                        salt.as_mut_ptr(),
-                        size_of::<[uint8_t; 32]>(),
-                    ) != 0)
-                    {
-                        tag = ((*shared).aligned as *mut uint8_t)
-                            .offset((*shared).aligned_size as isize)
-                            .offset(-(48 as libc::c_int as isize))
-                            as *mut uint32_t;
-                        *tag.offset(0 as libc::c_int as isize) = (0x7470797263736579
-                            as libc::c_ulonglong
-                            & 0xffffffff as libc::c_uint as libc::c_ulonglong)
-                            as uint32_t;
-                        *tag.offset(1 as libc::c_int as isize) =
-                            (0x7470797263736579 as libc::c_ulonglong >> 32 as libc::c_int)
-                                as uint32_t;
-                        *tag.offset(2 as libc::c_int as isize) = (0x687361684d4f522d
-                            as libc::c_ulonglong
-                            & 0xffffffff as libc::c_uint as libc::c_ulonglong)
-                            as uint32_t;
-                        *tag.offset(3 as libc::c_int as isize) =
-                            (0x687361684d4f522d as libc::c_ulonglong >> 32 as libc::c_int)
-                                as uint32_t;
-                        *tag.offset(4 as libc::c_int as isize) =
-                            le32dec(salt.as_mut_ptr() as *const libc::c_void);
-                        *tag.offset(5 as libc::c_int as isize) =
-                            le32dec(salt.as_mut_ptr().offset(4 as libc::c_int as isize)
-                                as *const libc::c_void);
-                        *tag.offset(6 as libc::c_int as isize) =
-                            le32dec(salt.as_mut_ptr().offset(8 as libc::c_int as isize)
-                                as *const libc::c_void);
-                        *tag.offset(7 as libc::c_int as isize) =
-                            le32dec(salt.as_mut_ptr().offset(12 as libc::c_int as isize)
-                                as *const libc::c_void);
-                        *tag.offset(8 as libc::c_int as isize) =
-                            le32dec(salt.as_mut_ptr().offset(16 as libc::c_int as isize)
-                                as *const libc::c_void);
-                        *tag.offset(9 as libc::c_int as isize) =
-                            le32dec(salt.as_mut_ptr().offset(20 as libc::c_int as isize)
-                                as *const libc::c_void);
-                        *tag.offset(10 as libc::c_int as isize) =
-                            le32dec(salt.as_mut_ptr().offset(24 as libc::c_int as isize)
-                                as *const libc::c_void);
-                        *tag.offset(11 as libc::c_int as isize) =
-                            le32dec(salt.as_mut_ptr().offset(28 as libc::c_int as isize)
-                                as *const libc::c_void);
-                        return 0 as libc::c_int;
-                    }
-                }
-            }
-        }
-        _ => {}
-    }
-    if flags & 0x10000 as libc::c_int as libc::c_uint == 0 {
-        free((*shared).base);
-    }
-    return -(1 as libc::c_int);
-}
-
-#[allow(dead_code)]
-unsafe fn yescrypt_digest_shared(mut shared: *mut Shared) -> Binary {
-    static mut digest: Binary = Binary { uc: [0; 32] };
-    let mut tag: *mut uint32_t = 0 as *mut uint32_t;
-    let mut tag1: uint64_t = 0;
-    let mut tag2: uint64_t = 0;
-    if (*shared).aligned_size < 48 {
-        return digest;
-    }
-    tag = ((*shared).aligned as *mut uint8_t)
-        .offset((*shared).aligned_size as isize)
-        .offset(-(48 as libc::c_int as isize)) as *mut uint32_t;
-    tag1 = ((*tag.offset(1 as libc::c_int as isize) as uint64_t) << 32 as libc::c_int)
-        .wrapping_add(*tag.offset(0 as libc::c_int as isize) as libc::c_ulong);
-    tag2 = ((*tag.offset(3 as libc::c_int as isize) as uint64_t) << 32 as libc::c_int)
-        .wrapping_add(*tag.offset(2 as libc::c_int as isize) as libc::c_ulong);
-    if tag1 as libc::c_ulonglong != 0x7470797263736579 as libc::c_ulonglong
-        || tag2 as libc::c_ulonglong != 0x687361684d4f522d as libc::c_ulonglong
-    {
-        return digest;
-    }
-    le32enc(
-        (digest.uc).as_mut_ptr() as *mut libc::c_void,
-        *tag.offset(4 as libc::c_int as isize),
-    );
-    le32enc(
-        (digest.uc).as_mut_ptr().offset(4 as libc::c_int as isize) as *mut libc::c_void,
-        *tag.offset(5 as libc::c_int as isize),
-    );
-    le32enc(
-        (digest.uc).as_mut_ptr().offset(8 as libc::c_int as isize) as *mut libc::c_void,
-        *tag.offset(6 as libc::c_int as isize),
-    );
-    le32enc(
-        (digest.uc).as_mut_ptr().offset(12 as libc::c_int as isize) as *mut libc::c_void,
-        *tag.offset(7 as libc::c_int as isize),
-    );
-    le32enc(
-        (digest.uc).as_mut_ptr().offset(16 as libc::c_int as isize) as *mut libc::c_void,
-        *tag.offset(8 as libc::c_int as isize),
-    );
-    le32enc(
-        (digest.uc).as_mut_ptr().offset(20 as libc::c_int as isize) as *mut libc::c_void,
-        *tag.offset(9 as libc::c_int as isize),
-    );
-    le32enc(
-        (digest.uc).as_mut_ptr().offset(24 as libc::c_int as isize) as *mut libc::c_void,
-        *tag.offset(10 as libc::c_int as isize),
-    );
-    le32enc(
-        (digest.uc).as_mut_ptr().offset(28 as libc::c_int as isize) as *mut libc::c_void,
-        *tag.offset(11 as libc::c_int as isize),
-    );
-
-    return digest;
-}
-
-#[allow(dead_code)]
-unsafe fn yescrypt_encode_params(
-    mut params: *const Params,
-    mut src: *const uint8_t,
-    mut srclen: size_t,
-) -> *mut uint8_t {
-    static mut buf: [uint8_t; 96] = [0; 96];
-    return yescrypt_encode_params_r(
-        params,
-        src,
-        srclen,
-        buf.as_mut_ptr(),
-        size_of::<[uint8_t; 96]>(),
-    );
-}
-
-unsafe fn yescrypt_encode_params_r(
-    mut params: *const Params,
-    mut src: *const uint8_t,
-    mut srclen: size_t,
-    mut buf: *mut uint8_t,
-    mut buflen: size_t,
-) -> *mut uint8_t {
-    let mut flavor: uint32_t = 0;
-    let mut N_log2: uint32_t = 0;
-    let mut NROM_log2: uint32_t = 0;
-    let mut have: uint32_t = 0;
-    let mut dst: *mut uint8_t = 0 as *mut uint8_t;
-    if srclen > usize::MAX / 16 {
-        return 0 as *mut uint8_t;
-    }
-    if (*params).flags < 0x2 as libc::c_int as libc::c_uint {
-        flavor = (*params).flags;
-    } else if (*params).flags & 0x3 as libc::c_int as libc::c_uint
-        == 0x2 as libc::c_int as libc::c_uint
-        && (*params).flags <= (0x2 as libc::c_int | 0x3fc as libc::c_int) as libc::c_uint
-    {
-        flavor =
-            (0x2 as libc::c_int as libc::c_uint).wrapping_add((*params).flags >> 2 as libc::c_int);
-    } else {
-        return 0 as *mut uint8_t;
-    }
-    N_log2 = N2log2((*params).N);
-    if N_log2 == 0 {
-        return 0 as *mut uint8_t;
-    }
-    NROM_log2 = N2log2((*params).NROM);
-    if (*params).NROM != 0 && NROM_log2 == 0 {
-        return 0 as *mut uint8_t;
-    }
-    if ((*params).r as uint64_t).wrapping_mul((*params).p as uint64_t)
-        >= ((1 as libc::c_uint) << 30 as libc::c_int) as libc::c_ulong
-    {
-        return 0 as *mut uint8_t;
-    }
-    dst = buf;
-    let fresh17 = dst;
-    dst = dst.offset(1);
-    *fresh17 = '$' as i32 as uint8_t;
-    let fresh18 = dst;
-    dst = dst.offset(1);
-    *fresh18 = 'y' as i32 as uint8_t;
-    let fresh19 = dst;
-    dst = dst.offset(1);
-    *fresh19 = '$' as i32 as uint8_t;
-    dst = encode64_uint32(
-        dst,
-        buflen.wrapping_sub(dst.offset_from(buf) as usize),
-        flavor,
-        0 as libc::c_int as uint32_t,
-    );
-    if dst.is_null() {
-        return 0 as *mut uint8_t;
-    }
-    dst = encode64_uint32(
-        dst,
-        buflen.wrapping_sub(dst.offset_from(buf) as usize),
-        N_log2,
-        1 as libc::c_int as uint32_t,
-    );
-    if dst.is_null() {
-        return 0 as *mut uint8_t;
-    }
-    dst = encode64_uint32(
-        dst,
-        buflen.wrapping_sub(dst.offset_from(buf) as usize),
-        (*params).r,
-        1 as libc::c_int as uint32_t,
-    );
-    if dst.is_null() {
-        return 0 as *mut uint8_t;
-    }
-    have = 0 as libc::c_int as uint32_t;
-    if (*params).p != 1 as libc::c_int as libc::c_uint {
-        have |= 1 as libc::c_int as libc::c_uint;
-    }
-    if (*params).t != 0 {
-        have |= 2 as libc::c_int as libc::c_uint;
-    }
-    if (*params).g != 0 {
-        have |= 4 as libc::c_int as libc::c_uint;
-    }
-    if NROM_log2 != 0 {
-        have |= 8 as libc::c_int as libc::c_uint;
-    }
-    if have != 0 {
-        dst = encode64_uint32(
-            dst,
-            buflen.wrapping_sub(dst.offset_from(buf) as usize),
-            have,
-            1 as libc::c_int as uint32_t,
-        );
-        if dst.is_null() {
-            return 0 as *mut uint8_t;
-        }
-    }
-    if (*params).p != 1 as libc::c_int as libc::c_uint {
-        dst = encode64_uint32(
-            dst,
-            buflen.wrapping_sub(dst.offset_from(buf) as usize),
-            (*params).p,
-            2 as libc::c_int as uint32_t,
-        );
-        if dst.is_null() {
-            return 0 as *mut uint8_t;
-        }
-    }
-    if (*params).t != 0 {
-        dst = encode64_uint32(
-            dst,
-            buflen.wrapping_sub(dst.offset_from(buf) as usize),
-            (*params).t,
-            1 as libc::c_int as uint32_t,
-        );
-        if dst.is_null() {
-            return 0 as *mut uint8_t;
-        }
-    }
-    if (*params).g != 0 {
-        dst = encode64_uint32(
-            dst,
-            buflen.wrapping_sub(dst.offset_from(buf) as usize),
-            (*params).g,
-            1 as libc::c_int as uint32_t,
-        );
-        if dst.is_null() {
-            return 0 as *mut uint8_t;
-        }
-    }
-    if NROM_log2 != 0 {
-        dst = encode64_uint32(
-            dst,
-            buflen.wrapping_sub(dst.offset_from(buf) as usize),
-            NROM_log2,
-            1 as libc::c_int as uint32_t,
-        );
-        if dst.is_null() {
-            return 0 as *mut uint8_t;
-        }
-    }
-    if dst >= buf.offset(buflen as isize) {
-        return 0 as *mut uint8_t;
-    }
-    let fresh20 = dst;
-    dst = dst.offset(1);
-    *fresh20 = '$' as i32 as uint8_t;
-    dst = encode64(
-        dst,
-        buflen.wrapping_sub(dst.offset_from(buf) as usize),
-        src,
-        srclen,
-    );
-    if dst.is_null() || dst >= buf.offset(buflen as isize) {
-        return 0 as *mut uint8_t;
-    }
-    *dst = 0 as libc::c_int as uint8_t;
-    return buf;
-}
-
-#[allow(dead_code)]
-unsafe fn yescrypt_free_shared(mut shared: *mut Shared) -> libc::c_int {
-    free((*shared).base);
-    (*shared).aligned = 0 as *mut libc::c_void;
-    (*shared).base = (*shared).aligned;
-    (*shared).aligned_size = 0 as libc::c_int as size_t;
-    (*shared).base_size = (*shared).aligned_size;
-    return 0 as libc::c_int;
-}
-
 unsafe fn yescrypt_init_local(mut local: *mut Local) -> libc::c_int {
     (*local).aligned = 0 as *mut libc::c_void;
     (*local).base = (*local).aligned;
@@ -911,155 +225,6 @@ unsafe fn yescrypt_init_local(mut local: *mut Local) -> libc::c_int {
     return 0 as libc::c_int;
 }
 
-unsafe fn yescrypt_free_local(_local: *mut Local) -> libc::c_int {
-    return 0 as libc::c_int;
-}
-
-#[allow(dead_code)]
-unsafe fn yescrypt_reencrypt(
-    mut hash: *mut uint8_t,
-    mut from_key: *const Binary,
-    mut to_key: *const Binary,
-) -> *mut uint8_t {
-    let mut current_block: u64;
-    let mut retval: *mut uint8_t = 0 as *mut uint8_t;
-    let mut saltstart: *mut uint8_t = 0 as *mut uint8_t;
-    let mut hashstart: *mut uint8_t = 0 as *mut uint8_t;
-    let mut hashend: *const uint8_t = 0 as *const uint8_t;
-    let mut saltbin: [libc::c_uchar; 64] = [0; 64];
-    let mut hashbin: [libc::c_uchar; 32] = [0; 32];
-    let mut saltstrlen: size_t = 0;
-    let mut saltlen: size_t = 0 as libc::c_int as size_t;
-    let mut hashlen: size_t = 0;
-    if strncmp(
-        hash as *mut libc::c_char,
-        b"$y$\0" as *const u8 as *const libc::c_char,
-        3,
-    ) != 0
-    {
-        return 0 as *mut uint8_t;
-    }
-    saltstart = 0 as *mut uint8_t;
-    hashstart = strrchr(hash as *mut libc::c_char, '$' as i32) as *mut uint8_t;
-    if !hashstart.is_null() {
-        if hashstart > hash {
-            saltstart = hashstart.offset(-(1 as libc::c_int as isize));
-            while *saltstart as libc::c_int != '$' as i32 && saltstart > hash {
-                saltstart = saltstart.offset(-1);
-                saltstart;
-            }
-            if *saltstart as libc::c_int == '$' as i32 {
-                saltstart = saltstart.offset(1);
-                saltstart;
-            }
-        }
-        hashstart = hashstart.offset(1);
-        hashstart;
-    } else {
-        hashstart = hash;
-    }
-    saltstrlen = (if !saltstart.is_null() {
-        hashstart
-            .offset(-(1 as libc::c_int as isize))
-            .offset_from(saltstart) as libc::c_long
-    } else {
-        0 as libc::c_int as libc::c_long
-    }) as size_t;
-    if saltstrlen > ((64 * 8 + 5) / 6)
-        || strlen(hashstart as *mut libc::c_char)
-            != (size_of::<Binary>())
-                .wrapping_mul(8)
-                .wrapping_add(5)
-                .wrapping_div(6)
-    {
-        return 0 as *mut uint8_t;
-    }
-    if saltstrlen != 0 {
-        let mut saltend: *const uint8_t = 0 as *const uint8_t;
-        saltlen = size_of::<[libc::c_uchar; 64]>();
-        saltend = decode64(saltbin.as_mut_ptr(), &mut saltlen, saltstart, saltstrlen);
-        if saltend.is_null()
-            || *saltend as libc::c_int != '$' as i32
-            || !(1..=64).contains(&saltlen)
-        {
-            current_block = 11385396242402735691;
-        } else {
-            if !from_key.is_null() {
-                encrypt(saltbin.as_mut_ptr(), saltlen, from_key, ENC);
-            }
-            if !to_key.is_null() {
-                encrypt(saltbin.as_mut_ptr(), saltlen, to_key, DEC);
-            }
-            current_block = 14401909646449704462;
-        }
-    } else {
-        current_block = 14401909646449704462;
-    }
-    match current_block {
-        14401909646449704462 => {
-            hashlen = size_of::<[libc::c_uchar; 32]>();
-            hashend = decode64(
-                hashbin.as_mut_ptr(),
-                &mut hashlen,
-                hashstart,
-                (size_of::<Binary>())
-                    .wrapping_mul(8)
-                    .wrapping_add(5)
-                    .wrapping_div(6),
-            );
-            if !(hashend.is_null()
-                || *hashend as libc::c_int != 0
-                || hashlen != size_of::<[libc::c_uchar; 32]>())
-            {
-                if !from_key.is_null() {
-                    encrypt(hashbin.as_mut_ptr(), hashlen, from_key, DEC);
-                }
-                if !to_key.is_null() {
-                    encrypt(hashbin.as_mut_ptr(), hashlen, to_key, ENC);
-                }
-                if saltstrlen != 0 {
-                    if (encode64(
-                        saltstart,
-                        saltstrlen.wrapping_add(1),
-                        saltbin.as_mut_ptr(),
-                        saltlen,
-                    ))
-                    .is_null()
-                    {
-                        current_block = 11385396242402735691;
-                    } else {
-                        *saltstart.offset(saltstrlen as isize) = '$' as i32 as uint8_t;
-                        current_block = 17281240262373992796;
-                    }
-                } else {
-                    current_block = 17281240262373992796;
-                }
-                match current_block {
-                    11385396242402735691 => {}
-                    _ => {
-                        if !(encode64(
-                            hashstart,
-                            (size_of::<Binary>())
-                                .wrapping_mul(8)
-                                .wrapping_add(5)
-                                .wrapping_div(6)
-                                .wrapping_add(1),
-                            hashbin.as_mut_ptr(),
-                            hashlen,
-                        ))
-                        .is_null()
-                        {
-                            retval = hash;
-                        }
-                    }
-                }
-            }
-        }
-        _ => {}
-    }
-    return retval;
-}
-
 unsafe fn yescrypt_kdf_body(
     mut shared: *const Shared,
     mut local: *mut Local,