// Copyright 2018 Google LLC
//
// Use of this source code is governed by an MIT-style
// license that can be found in the LICENSE file or at
// https://opensource.org/licenses/MIT.

// Some symbols are only used with certain features enabled, so we need to
// suppress the unused warning when those features aren't enabled.
#![allow(unused)]
// Only necessary for test_symbol_conflict.sh, which exposes these symbols
// through Mundane's public interface.
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]

#[link(name = "crypto_0_2_2")]
extern "C" {}

/* automatically generated by rust-bindgen */

#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct __BindgenBitfieldUnit<Storage, Align>
where
    Storage: AsRef<[u8]> + AsMut<[u8]>,
{
    storage: Storage,
    align: [Align; 0],
}

impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
where
    Storage: AsRef<[u8]> + AsMut<[u8]>,
{
    #[inline]
    pub fn new(storage: Storage) -> Self {
        Self { storage, align: [] }
    }

    #[inline]
    pub fn get_bit(&self, index: usize) -> bool {
        debug_assert!(index / 8 < self.storage.as_ref().len());

        let byte_index = index / 8;
        let byte = self.storage.as_ref()[byte_index];

        let bit_index = if cfg!(target_endian = "big") {
            7 - (index % 8)
        } else {
            index % 8
        };

        let mask = 1 << bit_index;

        byte & mask == mask
    }

    #[inline]
    pub fn set_bit(&mut self, index: usize, val: bool) {
        debug_assert!(index / 8 < self.storage.as_ref().len());

        let byte_index = index / 8;
        let byte = &mut self.storage.as_mut()[byte_index];

        let bit_index = if cfg!(target_endian = "big") {
            7 - (index % 8)
        } else {
            index % 8
        };

        let mask = 1 << bit_index;
        if val {
            *byte |= mask;
        } else {
            *byte &= !mask;
        }
    }

    #[inline]
    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
        debug_assert!(bit_width <= 64);
        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
        debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());

        let mut val = 0;

        for i in 0..(bit_width as usize) {
            if self.get_bit(i + bit_offset) {
                let index = if cfg!(target_endian = "big") {
                    bit_width as usize - 1 - i
                } else {
                    i
                };
                val |= 1 << index;
            }
        }

        val
    }

    #[inline]
    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
        debug_assert!(bit_width <= 64);
        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
        debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());

        for i in 0..(bit_width as usize) {
            let mask = 1 << i;
            let val_bit_is_set = val & mask == mask;
            let index = if cfg!(target_endian = "big") {
                bit_width as usize - 1 - i
            } else {
                i
            };
            self.set_bit(index + bit_offset, val_bit_is_set);
        }
    }
}
pub const ED25519_PRIVATE_KEY_LEN: u32 = 64;
pub const ED25519_PUBLIC_KEY_LEN: u32 = 32;
pub const ED25519_SIGNATURE_LEN: u32 = 64;
pub const NID_sha1: u32 = 64;
pub const NID_X9_62_prime256v1: u32 = 415;
pub const NID_sha256: u32 = 672;
pub const NID_sha384: u32 = 673;
pub const NID_sha512: u32 = 674;
pub const NID_secp384r1: u32 = 715;
pub const NID_secp521r1: u32 = 716;
pub const RSA_F4: u32 = 65537;
pub const SHA_DIGEST_LENGTH: u32 = 20;
pub const SHA256_DIGEST_LENGTH: u32 = 32;
pub const SHA384_DIGEST_LENGTH: u32 = 48;
pub const SHA512_DIGEST_LENGTH: u32 = 64;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _opaque_pthread_rwlock_t {
    pub __sig: ::std::os::raw::c_long,
    pub __opaque: [::std::os::raw::c_char; 192usize],
}
#[test]
fn bindgen_test_layout__opaque_pthread_rwlock_t() {
    assert_eq!(
        ::std::mem::size_of::<_opaque_pthread_rwlock_t>(),
        200usize,
        concat!("Size of: ", stringify!(_opaque_pthread_rwlock_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_opaque_pthread_rwlock_t>(),
        8usize,
        concat!("Alignment of ", stringify!(_opaque_pthread_rwlock_t))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_opaque_pthread_rwlock_t>())).__sig as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_opaque_pthread_rwlock_t),
            "::",
            stringify!(__sig)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<_opaque_pthread_rwlock_t>())).__opaque as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_opaque_pthread_rwlock_t),
            "::",
            stringify!(__opaque)
        )
    );
}
pub type __darwin_pthread_rwlock_t = _opaque_pthread_rwlock_t;
pub type pthread_rwlock_t = __darwin_pthread_rwlock_t;
pub type BIGNUM = bignum_st;
pub type BN_GENCB = bn_gencb_st;
pub type BN_MONT_CTX = bn_mont_ctx_st;
pub type CBB = cbb_st;
pub type CBS = cbs_st;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dh_st {
    _unused: [u8; 0],
}
pub type DH = dh_st;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dsa_st {
    _unused: [u8; 0],
}
pub type DSA = dsa_st;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ec_group_st {
    _unused: [u8; 0],
}
pub type EC_GROUP = ec_group_st;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ec_key_st {
    _unused: [u8; 0],
}
pub type EC_KEY = ec_key_st;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct engine_st {
    _unused: [u8; 0],
}
pub type ENGINE = engine_st;
pub type EVP_MD_CTX = env_md_ctx_st;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct env_md_st {
    _unused: [u8; 0],
}
pub type EVP_MD = env_md_st;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct evp_pkey_asn1_method_st {
    _unused: [u8; 0],
}
pub type EVP_PKEY_ASN1_METHOD = evp_pkey_asn1_method_st;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct evp_pkey_ctx_st {
    _unused: [u8; 0],
}
pub type EVP_PKEY_CTX = evp_pkey_ctx_st;
pub type EVP_PKEY = evp_pkey_st;
pub type HMAC_CTX = hmac_ctx_st;
pub type RSA_METHOD = rsa_meth_st;
pub type RSA = rsa_st;
pub type SHA256_CTX = sha256_state_st;
pub type SHA512_CTX = sha512_state_st;
pub type SHA_CTX = sha_state_st;
pub type CRYPTO_MUTEX = pthread_rwlock_t;
pub type CRYPTO_refcount_t = u32;
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_BN_init"]
    pub fn BN_init(bn: *mut BIGNUM);
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_BN_free"]
    pub fn BN_free(bn: *mut BIGNUM);
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_BN_set_u64"]
    pub fn BN_set_u64(bn: *mut BIGNUM, value: u64) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bn_gencb_st {
    pub arg: *mut ::std::os::raw::c_void,
    pub callback: ::std::option::Option<
        unsafe extern "C" fn(
            event: ::std::os::raw::c_int,
            n: ::std::os::raw::c_int,
            arg1: *mut bn_gencb_st,
        ) -> ::std::os::raw::c_int,
    >,
}
#[test]
fn bindgen_test_layout_bn_gencb_st() {
    assert_eq!(
        ::std::mem::size_of::<bn_gencb_st>(),
        16usize,
        concat!("Size of: ", stringify!(bn_gencb_st))
    );
    assert_eq!(
        ::std::mem::align_of::<bn_gencb_st>(),
        8usize,
        concat!("Alignment of ", stringify!(bn_gencb_st))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<bn_gencb_st>())).arg as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(bn_gencb_st),
            "::",
            stringify!(arg)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<bn_gencb_st>())).callback as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(bn_gencb_st),
            "::",
            stringify!(callback)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bignum_st {
    pub d: *mut u64,
    pub width: ::std::os::raw::c_int,
    pub dmax: ::std::os::raw::c_int,
    pub neg: ::std::os::raw::c_int,
    pub flags: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_bignum_st() {
    assert_eq!(
        ::std::mem::size_of::<bignum_st>(),
        24usize,
        concat!("Size of: ", stringify!(bignum_st))
    );
    assert_eq!(
        ::std::mem::align_of::<bignum_st>(),
        8usize,
        concat!("Alignment of ", stringify!(bignum_st))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<bignum_st>())).d as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(bignum_st),
            "::",
            stringify!(d)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<bignum_st>())).width as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(bignum_st),
            "::",
            stringify!(width)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<bignum_st>())).dmax as *const _ as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(bignum_st),
            "::",
            stringify!(dmax)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<bignum_st>())).neg as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(bignum_st),
            "::",
            stringify!(neg)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<bignum_st>())).flags as *const _ as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(bignum_st),
            "::",
            stringify!(flags)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bn_mont_ctx_st {
    pub RR: BIGNUM,
    pub N: BIGNUM,
    pub n0: [u64; 2usize],
}
#[test]
fn bindgen_test_layout_bn_mont_ctx_st() {
    assert_eq!(
        ::std::mem::size_of::<bn_mont_ctx_st>(),
        64usize,
        concat!("Size of: ", stringify!(bn_mont_ctx_st))
    );
    assert_eq!(
        ::std::mem::align_of::<bn_mont_ctx_st>(),
        8usize,
        concat!("Alignment of ", stringify!(bn_mont_ctx_st))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<bn_mont_ctx_st>())).RR as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(bn_mont_ctx_st),
            "::",
            stringify!(RR)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<bn_mont_ctx_st>())).N as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(bn_mont_ctx_st),
            "::",
            stringify!(N)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<bn_mont_ctx_st>())).n0 as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(bn_mont_ctx_st),
            "::",
            stringify!(n0)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cbs_st {
    pub data: *const u8,
    pub len: usize,
}
#[test]
fn bindgen_test_layout_cbs_st() {
    assert_eq!(
        ::std::mem::size_of::<cbs_st>(),
        16usize,
        concat!("Size of: ", stringify!(cbs_st))
    );
    assert_eq!(
        ::std::mem::align_of::<cbs_st>(),
        8usize,
        concat!("Alignment of ", stringify!(cbs_st))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<cbs_st>())).data as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(cbs_st),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<cbs_st>())).len as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(cbs_st),
            "::",
            stringify!(len)
        )
    );
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_CBS_init"]
    pub fn CBS_init(cbs: *mut CBS, data: *const u8, len: usize);
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_CBS_len"]
    pub fn CBS_len(cbs: *const CBS) -> usize;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cbb_buffer_st {
    pub buf: *mut u8,
    pub len: usize,
    pub cap: usize,
    pub can_resize: ::std::os::raw::c_char,
    pub error: ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_cbb_buffer_st() {
    assert_eq!(
        ::std::mem::size_of::<cbb_buffer_st>(),
        32usize,
        concat!("Size of: ", stringify!(cbb_buffer_st))
    );
    assert_eq!(
        ::std::mem::align_of::<cbb_buffer_st>(),
        8usize,
        concat!("Alignment of ", stringify!(cbb_buffer_st))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<cbb_buffer_st>())).buf as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(cbb_buffer_st),
            "::",
            stringify!(buf)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<cbb_buffer_st>())).len as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(cbb_buffer_st),
            "::",
            stringify!(len)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<cbb_buffer_st>())).cap as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(cbb_buffer_st),
            "::",
            stringify!(cap)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<cbb_buffer_st>())).can_resize as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(cbb_buffer_st),
            "::",
            stringify!(can_resize)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<cbb_buffer_st>())).error as *const _ as usize },
        25usize,
        concat!(
            "Offset of field: ",
            stringify!(cbb_buffer_st),
            "::",
            stringify!(error)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cbb_st {
    pub base: *mut cbb_buffer_st,
    pub child: *mut CBB,
    pub offset: usize,
    pub pending_len_len: u8,
    pub pending_is_asn1: ::std::os::raw::c_char,
    pub is_top_level: ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_cbb_st() {
    assert_eq!(
        ::std::mem::size_of::<cbb_st>(),
        32usize,
        concat!("Size of: ", stringify!(cbb_st))
    );
    assert_eq!(
        ::std::mem::align_of::<cbb_st>(),
        8usize,
        concat!("Alignment of ", stringify!(cbb_st))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<cbb_st>())).base as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(cbb_st),
            "::",
            stringify!(base)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<cbb_st>())).child as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(cbb_st),
            "::",
            stringify!(child)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<cbb_st>())).offset as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(cbb_st),
            "::",
            stringify!(offset)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<cbb_st>())).pending_len_len as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(cbb_st),
            "::",
            stringify!(pending_len_len)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<cbb_st>())).pending_is_asn1 as *const _ as usize },
        25usize,
        concat!(
            "Offset of field: ",
            stringify!(cbb_st),
            "::",
            stringify!(pending_is_asn1)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<cbb_st>())).is_top_level as *const _ as usize },
        26usize,
        concat!(
            "Offset of field: ",
            stringify!(cbb_st),
            "::",
            stringify!(is_top_level)
        )
    );
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_CBB_init"]
    pub fn CBB_init(cbb: *mut CBB, initial_capacity: usize) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_CBB_cleanup"]
    pub fn CBB_cleanup(cbb: *mut CBB);
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_CBB_data"]
    pub fn CBB_data(cbb: *const CBB) -> *const u8;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_CBB_len"]
    pub fn CBB_len(cbb: *const CBB) -> usize;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_ED25519_keypair"]
    pub fn ED25519_keypair(out_public_key: *mut u8, out_private_key: *mut u8);
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_ED25519_sign"]
    pub fn ED25519_sign(
        out_sig: *mut u8,
        message: *const u8,
        message_len: usize,
        private_key: *const u8,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_ED25519_verify"]
    pub fn ED25519_verify(
        message: *const u8,
        message_len: usize,
        signature: *const u8,
        public_key: *const u8,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_ED25519_keypair_from_seed"]
    pub fn ED25519_keypair_from_seed(
        out_public_key: *mut u8,
        out_private_key: *mut u8,
        seed: *const u8,
    );
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_EC_GROUP_new_by_curve_name"]
    pub fn EC_GROUP_new_by_curve_name(nid: ::std::os::raw::c_int) -> *mut EC_GROUP;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_EC_GROUP_get_curve_name"]
    pub fn EC_GROUP_get_curve_name(group: *const EC_GROUP) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_EC_curve_nid2nist"]
    pub fn EC_curve_nid2nist(nid: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct openssl_method_common_st {
    pub references: ::std::os::raw::c_int,
    pub is_static: ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_openssl_method_common_st() {
    assert_eq!(
        ::std::mem::size_of::<openssl_method_common_st>(),
        8usize,
        concat!("Size of: ", stringify!(openssl_method_common_st))
    );
    assert_eq!(
        ::std::mem::align_of::<openssl_method_common_st>(),
        4usize,
        concat!("Alignment of ", stringify!(openssl_method_common_st))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<openssl_method_common_st>())).references as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(openssl_method_common_st),
            "::",
            stringify!(references)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<openssl_method_common_st>())).is_static as *const _ as usize
        },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(openssl_method_common_st),
            "::",
            stringify!(is_static)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct stack_st_void {
    _unused: [u8; 0],
}
pub type CRYPTO_EX_DATA = crypto_ex_data_st;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct crypto_ex_data_st {
    pub sk: *mut stack_st_void,
}
#[test]
fn bindgen_test_layout_crypto_ex_data_st() {
    assert_eq!(
        ::std::mem::size_of::<crypto_ex_data_st>(),
        8usize,
        concat!("Size of: ", stringify!(crypto_ex_data_st))
    );
    assert_eq!(
        ::std::mem::align_of::<crypto_ex_data_st>(),
        8usize,
        concat!("Alignment of ", stringify!(crypto_ex_data_st))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<crypto_ex_data_st>())).sk as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(crypto_ex_data_st),
            "::",
            stringify!(sk)
        )
    );
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_EC_KEY_new"]
    pub fn EC_KEY_new() -> *mut EC_KEY;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_EC_KEY_free"]
    pub fn EC_KEY_free(key: *mut EC_KEY);
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_EC_KEY_up_ref"]
    pub fn EC_KEY_up_ref(key: *mut EC_KEY) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_EC_KEY_get0_group"]
    pub fn EC_KEY_get0_group(key: *const EC_KEY) -> *const EC_GROUP;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_EC_KEY_set_group"]
    pub fn EC_KEY_set_group(key: *mut EC_KEY, group: *const EC_GROUP) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_EC_KEY_generate_key"]
    pub fn EC_KEY_generate_key(key: *mut EC_KEY) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_EC_KEY_parse_private_key"]
    pub fn EC_KEY_parse_private_key(cbs: *mut CBS, group: *const EC_GROUP) -> *mut EC_KEY;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_EC_KEY_marshal_private_key"]
    pub fn EC_KEY_marshal_private_key(
        cbb: *mut CBB,
        key: *const EC_KEY,
        enc_flags: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_ECDSA_sign"]
    pub fn ECDSA_sign(
        type_: ::std::os::raw::c_int,
        digest: *const u8,
        digest_len: usize,
        sig: *mut u8,
        sig_len: *mut ::std::os::raw::c_uint,
        key: *const EC_KEY,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_ECDSA_verify"]
    pub fn ECDSA_verify(
        type_: ::std::os::raw::c_int,
        digest: *const u8,
        digest_len: usize,
        sig: *const u8,
        sig_len: usize,
        key: *const EC_KEY,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_ECDSA_size"]
    pub fn ECDSA_size(key: *const EC_KEY) -> usize;
}
pub type ERR_print_errors_callback_t = ::std::option::Option<
    unsafe extern "C" fn(
        str: *const ::std::os::raw::c_char,
        len: usize,
        ctx: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int,
>;
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_ERR_print_errors_cb"]
    pub fn ERR_print_errors_cb(
        callback: ERR_print_errors_callback_t,
        ctx: *mut ::std::os::raw::c_void,
    );
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_EVP_sha1"]
    pub fn EVP_sha1() -> *const EVP_MD;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_EVP_sha256"]
    pub fn EVP_sha256() -> *const EVP_MD;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_EVP_sha384"]
    pub fn EVP_sha384() -> *const EVP_MD;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_EVP_sha512"]
    pub fn EVP_sha512() -> *const EVP_MD;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct evp_md_pctx_ops {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct env_md_ctx_st {
    pub digest: *const EVP_MD,
    pub md_data: *mut ::std::os::raw::c_void,
    pub pctx: *mut EVP_PKEY_CTX,
    pub pctx_ops: *const evp_md_pctx_ops,
}
#[test]
fn bindgen_test_layout_env_md_ctx_st() {
    assert_eq!(
        ::std::mem::size_of::<env_md_ctx_st>(),
        32usize,
        concat!("Size of: ", stringify!(env_md_ctx_st))
    );
    assert_eq!(
        ::std::mem::align_of::<env_md_ctx_st>(),
        8usize,
        concat!("Alignment of ", stringify!(env_md_ctx_st))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<env_md_ctx_st>())).digest as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(env_md_ctx_st),
            "::",
            stringify!(digest)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<env_md_ctx_st>())).md_data as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(env_md_ctx_st),
            "::",
            stringify!(md_data)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<env_md_ctx_st>())).pctx as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(env_md_ctx_st),
            "::",
            stringify!(pctx)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<env_md_ctx_st>())).pctx_ops as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(env_md_ctx_st),
            "::",
            stringify!(pctx_ops)
        )
    );
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_EVP_PKEY_new"]
    pub fn EVP_PKEY_new() -> *mut EVP_PKEY;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_EVP_PKEY_free"]
    pub fn EVP_PKEY_free(pkey: *mut EVP_PKEY);
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_EVP_PKEY_up_ref"]
    pub fn EVP_PKEY_up_ref(pkey: *mut EVP_PKEY) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_EVP_PKEY_assign_RSA"]
    pub fn EVP_PKEY_assign_RSA(pkey: *mut EVP_PKEY, key: *mut RSA) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_EVP_PKEY_get1_RSA"]
    pub fn EVP_PKEY_get1_RSA(pkey: *const EVP_PKEY) -> *mut RSA;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_EVP_PKEY_assign_EC_KEY"]
    pub fn EVP_PKEY_assign_EC_KEY(pkey: *mut EVP_PKEY, key: *mut EC_KEY) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_EVP_PKEY_get1_EC_KEY"]
    pub fn EVP_PKEY_get1_EC_KEY(pkey: *const EVP_PKEY) -> *mut EC_KEY;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_EVP_parse_public_key"]
    pub fn EVP_parse_public_key(cbs: *mut CBS) -> *mut EVP_PKEY;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_EVP_marshal_public_key"]
    pub fn EVP_marshal_public_key(cbb: *mut CBB, key: *const EVP_PKEY) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_PKCS5_PBKDF2_HMAC"]
    pub fn PKCS5_PBKDF2_HMAC(
        password: *const ::std::os::raw::c_char,
        password_len: usize,
        salt: *const u8,
        salt_len: usize,
        iterations: ::std::os::raw::c_uint,
        digest: *const EVP_MD,
        key_len: usize,
        out_key: *mut u8,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_EVP_PBE_scrypt"]
    pub fn EVP_PBE_scrypt(
        password: *const ::std::os::raw::c_char,
        password_len: usize,
        salt: *const u8,
        salt_len: usize,
        N: u64,
        r: u64,
        p: u64,
        max_mem: usize,
        out_key: *mut u8,
        key_len: usize,
    ) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct evp_pkey_st {
    pub references: CRYPTO_refcount_t,
    pub type_: ::std::os::raw::c_int,
    pub pkey: evp_pkey_st__bindgen_ty_1,
    pub ameth: *const EVP_PKEY_ASN1_METHOD,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union evp_pkey_st__bindgen_ty_1 {
    pub ptr: *mut ::std::os::raw::c_void,
    pub rsa: *mut RSA,
    pub dsa: *mut DSA,
    pub dh: *mut DH,
    pub ec: *mut EC_KEY,
    _bindgen_union_align: u64,
}
#[test]
fn bindgen_test_layout_evp_pkey_st__bindgen_ty_1() {
    assert_eq!(
        ::std::mem::size_of::<evp_pkey_st__bindgen_ty_1>(),
        8usize,
        concat!("Size of: ", stringify!(evp_pkey_st__bindgen_ty_1))
    );
    assert_eq!(
        ::std::mem::align_of::<evp_pkey_st__bindgen_ty_1>(),
        8usize,
        concat!("Alignment of ", stringify!(evp_pkey_st__bindgen_ty_1))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<evp_pkey_st__bindgen_ty_1>())).ptr as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(evp_pkey_st__bindgen_ty_1),
            "::",
            stringify!(ptr)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<evp_pkey_st__bindgen_ty_1>())).rsa as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(evp_pkey_st__bindgen_ty_1),
            "::",
            stringify!(rsa)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<evp_pkey_st__bindgen_ty_1>())).dsa as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(evp_pkey_st__bindgen_ty_1),
            "::",
            stringify!(dsa)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<evp_pkey_st__bindgen_ty_1>())).dh as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(evp_pkey_st__bindgen_ty_1),
            "::",
            stringify!(dh)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<evp_pkey_st__bindgen_ty_1>())).ec as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(evp_pkey_st__bindgen_ty_1),
            "::",
            stringify!(ec)
        )
    );
}
#[test]
fn bindgen_test_layout_evp_pkey_st() {
    assert_eq!(
        ::std::mem::size_of::<evp_pkey_st>(),
        24usize,
        concat!("Size of: ", stringify!(evp_pkey_st))
    );
    assert_eq!(
        ::std::mem::align_of::<evp_pkey_st>(),
        8usize,
        concat!("Alignment of ", stringify!(evp_pkey_st))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<evp_pkey_st>())).references as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(evp_pkey_st),
            "::",
            stringify!(references)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<evp_pkey_st>())).type_ as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(evp_pkey_st),
            "::",
            stringify!(type_)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<evp_pkey_st>())).pkey as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(evp_pkey_st),
            "::",
            stringify!(pkey)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<evp_pkey_st>())).ameth as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(evp_pkey_st),
            "::",
            stringify!(ameth)
        )
    );
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_HMAC_CTX_init"]
    pub fn HMAC_CTX_init(ctx: *mut HMAC_CTX);
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_HMAC_CTX_cleanup"]
    pub fn HMAC_CTX_cleanup(ctx: *mut HMAC_CTX);
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_HMAC_Init_ex"]
    pub fn HMAC_Init_ex(
        ctx: *mut HMAC_CTX,
        key: *const ::std::os::raw::c_void,
        key_len: usize,
        md: *const EVP_MD,
        impl_: *mut ENGINE,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_HMAC_Update"]
    pub fn HMAC_Update(
        ctx: *mut HMAC_CTX,
        data: *const u8,
        data_len: usize,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_HMAC_Final"]
    pub fn HMAC_Final(
        ctx: *mut HMAC_CTX,
        out: *mut u8,
        out_len: *mut ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_HMAC_size"]
    pub fn HMAC_size(ctx: *const HMAC_CTX) -> usize;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct hmac_ctx_st {
    pub md: *const EVP_MD,
    pub md_ctx: EVP_MD_CTX,
    pub i_ctx: EVP_MD_CTX,
    pub o_ctx: EVP_MD_CTX,
}
#[test]
fn bindgen_test_layout_hmac_ctx_st() {
    assert_eq!(
        ::std::mem::size_of::<hmac_ctx_st>(),
        104usize,
        concat!("Size of: ", stringify!(hmac_ctx_st))
    );
    assert_eq!(
        ::std::mem::align_of::<hmac_ctx_st>(),
        8usize,
        concat!("Alignment of ", stringify!(hmac_ctx_st))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<hmac_ctx_st>())).md as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(hmac_ctx_st),
            "::",
            stringify!(md)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<hmac_ctx_st>())).md_ctx as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(hmac_ctx_st),
            "::",
            stringify!(md_ctx)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<hmac_ctx_st>())).i_ctx as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(hmac_ctx_st),
            "::",
            stringify!(i_ctx)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<hmac_ctx_st>())).o_ctx as *const _ as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(hmac_ctx_st),
            "::",
            stringify!(o_ctx)
        )
    );
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_CRYPTO_memcmp"]
    pub fn CRYPTO_memcmp(
        a: *const ::std::os::raw::c_void,
        b: *const ::std::os::raw::c_void,
        len: usize,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_RAND_bytes"]
    pub fn RAND_bytes(buf: *mut u8, len: usize) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_RSA_new"]
    pub fn RSA_new() -> *mut RSA;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_RSA_free"]
    pub fn RSA_free(rsa: *mut RSA);
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_RSA_up_ref"]
    pub fn RSA_up_ref(rsa: *mut RSA) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_RSA_bits"]
    pub fn RSA_bits(rsa: *const RSA) -> ::std::os::raw::c_uint;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_RSA_generate_key_ex"]
    pub fn RSA_generate_key_ex(
        rsa: *mut RSA,
        bits: ::std::os::raw::c_int,
        e: *const BIGNUM,
        cb: *mut BN_GENCB,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_RSA_sign"]
    pub fn RSA_sign(
        hash_nid: ::std::os::raw::c_int,
        in_: *const u8,
        in_len: ::std::os::raw::c_uint,
        out: *mut u8,
        out_len: *mut ::std::os::raw::c_uint,
        rsa: *mut RSA,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_RSA_sign_pss_mgf1"]
    pub fn RSA_sign_pss_mgf1(
        rsa: *mut RSA,
        out_len: *mut usize,
        out: *mut u8,
        max_out: usize,
        in_: *const u8,
        in_len: usize,
        md: *const EVP_MD,
        mgf1_md: *const EVP_MD,
        salt_len: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_RSA_verify"]
    pub fn RSA_verify(
        hash_nid: ::std::os::raw::c_int,
        msg: *const u8,
        msg_len: usize,
        sig: *const u8,
        sig_len: usize,
        rsa: *mut RSA,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_RSA_verify_pss_mgf1"]
    pub fn RSA_verify_pss_mgf1(
        rsa: *mut RSA,
        msg: *const u8,
        msg_len: usize,
        md: *const EVP_MD,
        mgf1_md: *const EVP_MD,
        salt_len: ::std::os::raw::c_int,
        sig: *const u8,
        sig_len: usize,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_RSA_size"]
    pub fn RSA_size(rsa: *const RSA) -> ::std::os::raw::c_uint;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_RSA_parse_private_key"]
    pub fn RSA_parse_private_key(cbs: *mut CBS) -> *mut RSA;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_RSA_marshal_private_key"]
    pub fn RSA_marshal_private_key(cbb: *mut CBB, rsa: *const RSA) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rsa_meth_st {
    pub common: openssl_method_common_st,
    pub app_data: *mut ::std::os::raw::c_void,
    pub init: ::std::option::Option<unsafe extern "C" fn(rsa: *mut RSA) -> ::std::os::raw::c_int>,
    pub finish: ::std::option::Option<unsafe extern "C" fn(rsa: *mut RSA) -> ::std::os::raw::c_int>,
    pub size: ::std::option::Option<unsafe extern "C" fn(rsa: *const RSA) -> usize>,
    pub sign: ::std::option::Option<
        unsafe extern "C" fn(
            type_: ::std::os::raw::c_int,
            m: *const u8,
            m_length: ::std::os::raw::c_uint,
            sigret: *mut u8,
            siglen: *mut ::std::os::raw::c_uint,
            rsa: *const RSA,
        ) -> ::std::os::raw::c_int,
    >,
    pub sign_raw: ::std::option::Option<
        unsafe extern "C" fn(
            rsa: *mut RSA,
            out_len: *mut usize,
            out: *mut u8,
            max_out: usize,
            in_: *const u8,
            in_len: usize,
            padding: ::std::os::raw::c_int,
        ) -> ::std::os::raw::c_int,
    >,
    pub decrypt: ::std::option::Option<
        unsafe extern "C" fn(
            rsa: *mut RSA,
            out_len: *mut usize,
            out: *mut u8,
            max_out: usize,
            in_: *const u8,
            in_len: usize,
            padding: ::std::os::raw::c_int,
        ) -> ::std::os::raw::c_int,
    >,
    pub private_transform: ::std::option::Option<
        unsafe extern "C" fn(
            rsa: *mut RSA,
            out: *mut u8,
            in_: *const u8,
            len: usize,
        ) -> ::std::os::raw::c_int,
    >,
    pub flags: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_rsa_meth_st() {
    assert_eq!(
        ::std::mem::size_of::<rsa_meth_st>(),
        80usize,
        concat!("Size of: ", stringify!(rsa_meth_st))
    );
    assert_eq!(
        ::std::mem::align_of::<rsa_meth_st>(),
        8usize,
        concat!("Alignment of ", stringify!(rsa_meth_st))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<rsa_meth_st>())).common as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rsa_meth_st),
            "::",
            stringify!(common)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<rsa_meth_st>())).app_data as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(rsa_meth_st),
            "::",
            stringify!(app_data)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<rsa_meth_st>())).init as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(rsa_meth_st),
            "::",
            stringify!(init)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<rsa_meth_st>())).finish as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(rsa_meth_st),
            "::",
            stringify!(finish)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<rsa_meth_st>())).size as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(rsa_meth_st),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<rsa_meth_st>())).sign as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(rsa_meth_st),
            "::",
            stringify!(sign)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<rsa_meth_st>())).sign_raw as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(rsa_meth_st),
            "::",
            stringify!(sign_raw)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<rsa_meth_st>())).decrypt as *const _ as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(rsa_meth_st),
            "::",
            stringify!(decrypt)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<rsa_meth_st>())).private_transform as *const _ as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(rsa_meth_st),
            "::",
            stringify!(private_transform)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<rsa_meth_st>())).flags as *const _ as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(rsa_meth_st),
            "::",
            stringify!(flags)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bn_blinding_st {
    _unused: [u8; 0],
}
pub type BN_BLINDING = bn_blinding_st;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct rsa_st {
    pub meth: *mut RSA_METHOD,
    pub n: *mut BIGNUM,
    pub e: *mut BIGNUM,
    pub d: *mut BIGNUM,
    pub p: *mut BIGNUM,
    pub q: *mut BIGNUM,
    pub dmp1: *mut BIGNUM,
    pub dmq1: *mut BIGNUM,
    pub iqmp: *mut BIGNUM,
    pub ex_data: CRYPTO_EX_DATA,
    pub references: CRYPTO_refcount_t,
    pub flags: ::std::os::raw::c_int,
    pub lock: CRYPTO_MUTEX,
    pub mont_n: *mut BN_MONT_CTX,
    pub mont_p: *mut BN_MONT_CTX,
    pub mont_q: *mut BN_MONT_CTX,
    pub d_fixed: *mut BIGNUM,
    pub dmp1_fixed: *mut BIGNUM,
    pub dmq1_fixed: *mut BIGNUM,
    pub inv_small_mod_large_mont: *mut BIGNUM,
    pub num_blindings: ::std::os::raw::c_uint,
    pub blindings: *mut *mut BN_BLINDING,
    pub blindings_inuse: *mut ::std::os::raw::c_uchar,
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
    pub __bindgen_padding_0: [u8; 7usize],
}
#[test]
fn bindgen_test_layout_rsa_st() {
    assert_eq!(
        ::std::mem::size_of::<rsa_st>(),
        376usize,
        concat!("Size of: ", stringify!(rsa_st))
    );
    assert_eq!(
        ::std::mem::align_of::<rsa_st>(),
        8usize,
        concat!("Alignment of ", stringify!(rsa_st))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<rsa_st>())).meth as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rsa_st),
            "::",
            stringify!(meth)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<rsa_st>())).n as *const _ as usize },
        8usize,
        concat!("Offset of field: ", stringify!(rsa_st), "::", stringify!(n))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<rsa_st>())).e as *const _ as usize },
        16usize,
        concat!("Offset of field: ", stringify!(rsa_st), "::", stringify!(e))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<rsa_st>())).d as *const _ as usize },
        24usize,
        concat!("Offset of field: ", stringify!(rsa_st), "::", stringify!(d))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<rsa_st>())).p as *const _ as usize },
        32usize,
        concat!("Offset of field: ", stringify!(rsa_st), "::", stringify!(p))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<rsa_st>())).q as *const _ as usize },
        40usize,
        concat!("Offset of field: ", stringify!(rsa_st), "::", stringify!(q))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<rsa_st>())).dmp1 as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(rsa_st),
            "::",
            stringify!(dmp1)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<rsa_st>())).dmq1 as *const _ as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(rsa_st),
            "::",
            stringify!(dmq1)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<rsa_st>())).iqmp as *const _ as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(rsa_st),
            "::",
            stringify!(iqmp)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<rsa_st>())).ex_data as *const _ as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(rsa_st),
            "::",
            stringify!(ex_data)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<rsa_st>())).references as *const _ as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(rsa_st),
            "::",
            stringify!(references)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<rsa_st>())).flags as *const _ as usize },
        84usize,
        concat!(
            "Offset of field: ",
            stringify!(rsa_st),
            "::",
            stringify!(flags)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<rsa_st>())).lock as *const _ as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(rsa_st),
            "::",
            stringify!(lock)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<rsa_st>())).mont_n as *const _ as usize },
        288usize,
        concat!(
            "Offset of field: ",
            stringify!(rsa_st),
            "::",
            stringify!(mont_n)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<rsa_st>())).mont_p as *const _ as usize },
        296usize,
        concat!(
            "Offset of field: ",
            stringify!(rsa_st),
            "::",
            stringify!(mont_p)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<rsa_st>())).mont_q as *const _ as usize },
        304usize,
        concat!(
            "Offset of field: ",
            stringify!(rsa_st),
            "::",
            stringify!(mont_q)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<rsa_st>())).d_fixed as *const _ as usize },
        312usize,
        concat!(
            "Offset of field: ",
            stringify!(rsa_st),
            "::",
            stringify!(d_fixed)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<rsa_st>())).dmp1_fixed as *const _ as usize },
        320usize,
        concat!(
            "Offset of field: ",
            stringify!(rsa_st),
            "::",
            stringify!(dmp1_fixed)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<rsa_st>())).dmq1_fixed as *const _ as usize },
        328usize,
        concat!(
            "Offset of field: ",
            stringify!(rsa_st),
            "::",
            stringify!(dmq1_fixed)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<rsa_st>())).inv_small_mod_large_mont as *const _ as usize },
        336usize,
        concat!(
            "Offset of field: ",
            stringify!(rsa_st),
            "::",
            stringify!(inv_small_mod_large_mont)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<rsa_st>())).num_blindings as *const _ as usize },
        344usize,
        concat!(
            "Offset of field: ",
            stringify!(rsa_st),
            "::",
            stringify!(num_blindings)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<rsa_st>())).blindings as *const _ as usize },
        352usize,
        concat!(
            "Offset of field: ",
            stringify!(rsa_st),
            "::",
            stringify!(blindings)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<rsa_st>())).blindings_inuse as *const _ as usize },
        360usize,
        concat!(
            "Offset of field: ",
            stringify!(rsa_st),
            "::",
            stringify!(blindings_inuse)
        )
    );
}
impl rsa_st {
    #[inline]
    pub fn private_key_frozen(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_private_key_frozen(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        private_key_frozen: ::std::os::raw::c_uint,
    ) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize], u8> =
            Default::default();
        __bindgen_bitfield_unit.set(0usize, 1u8, {
            let private_key_frozen: u32 = unsafe { ::std::mem::transmute(private_key_frozen) };
            private_key_frozen as u64
        });
        __bindgen_bitfield_unit
    }
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_SHA1_Init"]
    pub fn SHA1_Init(sha: *mut SHA_CTX) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_SHA1_Update"]
    pub fn SHA1_Update(
        sha: *mut SHA_CTX,
        data: *const ::std::os::raw::c_void,
        len: usize,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_SHA1_Final"]
    pub fn SHA1_Final(md: *mut u8, sha: *mut SHA_CTX) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct sha_state_st {
    pub __bindgen_anon_1: sha_state_st__bindgen_ty_1,
    pub Nl: u32,
    pub Nh: u32,
    pub data: [u8; 64usize],
    pub num: ::std::os::raw::c_uint,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union sha_state_st__bindgen_ty_1 {
    pub h: [u32; 5usize],
    pub __bindgen_anon_1: sha_state_st__bindgen_ty_1__bindgen_ty_1,
    _bindgen_union_align: [u32; 5usize],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sha_state_st__bindgen_ty_1__bindgen_ty_1 {
    pub h0: u32,
    pub h1: u32,
    pub h2: u32,
    pub h3: u32,
    pub h4: u32,
}
#[test]
fn bindgen_test_layout_sha_state_st__bindgen_ty_1__bindgen_ty_1() {
    assert_eq!(
        ::std::mem::size_of::<sha_state_st__bindgen_ty_1__bindgen_ty_1>(),
        20usize,
        concat!(
            "Size of: ",
            stringify!(sha_state_st__bindgen_ty_1__bindgen_ty_1)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<sha_state_st__bindgen_ty_1__bindgen_ty_1>(),
        4usize,
        concat!(
            "Alignment of ",
            stringify!(sha_state_st__bindgen_ty_1__bindgen_ty_1)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sha_state_st__bindgen_ty_1__bindgen_ty_1>())).h0 as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sha_state_st__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(h0)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sha_state_st__bindgen_ty_1__bindgen_ty_1>())).h1 as *const _
                as usize
        },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(sha_state_st__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(h1)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sha_state_st__bindgen_ty_1__bindgen_ty_1>())).h2 as *const _
                as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(sha_state_st__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(h2)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sha_state_st__bindgen_ty_1__bindgen_ty_1>())).h3 as *const _
                as usize
        },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(sha_state_st__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(h3)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<sha_state_st__bindgen_ty_1__bindgen_ty_1>())).h4 as *const _
                as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(sha_state_st__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(h4)
        )
    );
}
#[test]
fn bindgen_test_layout_sha_state_st__bindgen_ty_1() {
    assert_eq!(
        ::std::mem::size_of::<sha_state_st__bindgen_ty_1>(),
        20usize,
        concat!("Size of: ", stringify!(sha_state_st__bindgen_ty_1))
    );
    assert_eq!(
        ::std::mem::align_of::<sha_state_st__bindgen_ty_1>(),
        4usize,
        concat!("Alignment of ", stringify!(sha_state_st__bindgen_ty_1))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sha_state_st__bindgen_ty_1>())).h as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sha_state_st__bindgen_ty_1),
            "::",
            stringify!(h)
        )
    );
}
#[test]
fn bindgen_test_layout_sha_state_st() {
    assert_eq!(
        ::std::mem::size_of::<sha_state_st>(),
        96usize,
        concat!("Size of: ", stringify!(sha_state_st))
    );
    assert_eq!(
        ::std::mem::align_of::<sha_state_st>(),
        4usize,
        concat!("Alignment of ", stringify!(sha_state_st))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sha_state_st>())).Nl as *const _ as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(sha_state_st),
            "::",
            stringify!(Nl)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sha_state_st>())).Nh as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(sha_state_st),
            "::",
            stringify!(Nh)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sha_state_st>())).data as *const _ as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(sha_state_st),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sha_state_st>())).num as *const _ as usize },
        92usize,
        concat!(
            "Offset of field: ",
            stringify!(sha_state_st),
            "::",
            stringify!(num)
        )
    );
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_SHA256_Init"]
    pub fn SHA256_Init(sha: *mut SHA256_CTX) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_SHA256_Update"]
    pub fn SHA256_Update(
        sha: *mut SHA256_CTX,
        data: *const ::std::os::raw::c_void,
        len: usize,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_SHA256_Final"]
    pub fn SHA256_Final(md: *mut u8, sha: *mut SHA256_CTX) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct sha256_state_st {
    pub h: [u32; 8usize],
    pub Nl: u32,
    pub Nh: u32,
    pub data: [u8; 64usize],
    pub num: ::std::os::raw::c_uint,
    pub md_len: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_sha256_state_st() {
    assert_eq!(
        ::std::mem::size_of::<sha256_state_st>(),
        112usize,
        concat!("Size of: ", stringify!(sha256_state_st))
    );
    assert_eq!(
        ::std::mem::align_of::<sha256_state_st>(),
        4usize,
        concat!("Alignment of ", stringify!(sha256_state_st))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sha256_state_st>())).h as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sha256_state_st),
            "::",
            stringify!(h)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sha256_state_st>())).Nl as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(sha256_state_st),
            "::",
            stringify!(Nl)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sha256_state_st>())).Nh as *const _ as usize },
        36usize,
        concat!(
            "Offset of field: ",
            stringify!(sha256_state_st),
            "::",
            stringify!(Nh)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sha256_state_st>())).data as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(sha256_state_st),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sha256_state_st>())).num as *const _ as usize },
        104usize,
        concat!(
            "Offset of field: ",
            stringify!(sha256_state_st),
            "::",
            stringify!(num)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sha256_state_st>())).md_len as *const _ as usize },
        108usize,
        concat!(
            "Offset of field: ",
            stringify!(sha256_state_st),
            "::",
            stringify!(md_len)
        )
    );
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_SHA384_Init"]
    pub fn SHA384_Init(sha: *mut SHA512_CTX) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_SHA384_Update"]
    pub fn SHA384_Update(
        sha: *mut SHA512_CTX,
        data: *const ::std::os::raw::c_void,
        len: usize,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_SHA384_Final"]
    pub fn SHA384_Final(md: *mut u8, sha: *mut SHA512_CTX) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_SHA512_Init"]
    pub fn SHA512_Init(sha: *mut SHA512_CTX) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_SHA512_Update"]
    pub fn SHA512_Update(
        sha: *mut SHA512_CTX,
        data: *const ::std::os::raw::c_void,
        len: usize,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "__RUST_MUNDANE_0_2_2_SHA512_Final"]
    pub fn SHA512_Final(md: *mut u8, sha: *mut SHA512_CTX) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct sha512_state_st {
    pub h: [u64; 8usize],
    pub Nl: u64,
    pub Nh: u64,
    pub u: sha512_state_st__bindgen_ty_1,
    pub num: ::std::os::raw::c_uint,
    pub md_len: ::std::os::raw::c_uint,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union sha512_state_st__bindgen_ty_1 {
    pub d: [u64; 16usize],
    pub p: [u8; 128usize],
    _bindgen_union_align: [u64; 16usize],
}
#[test]
fn bindgen_test_layout_sha512_state_st__bindgen_ty_1() {
    assert_eq!(
        ::std::mem::size_of::<sha512_state_st__bindgen_ty_1>(),
        128usize,
        concat!("Size of: ", stringify!(sha512_state_st__bindgen_ty_1))
    );
    assert_eq!(
        ::std::mem::align_of::<sha512_state_st__bindgen_ty_1>(),
        8usize,
        concat!("Alignment of ", stringify!(sha512_state_st__bindgen_ty_1))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sha512_state_st__bindgen_ty_1>())).d as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sha512_state_st__bindgen_ty_1),
            "::",
            stringify!(d)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sha512_state_st__bindgen_ty_1>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sha512_state_st__bindgen_ty_1),
            "::",
            stringify!(p)
        )
    );
}
#[test]
fn bindgen_test_layout_sha512_state_st() {
    assert_eq!(
        ::std::mem::size_of::<sha512_state_st>(),
        216usize,
        concat!("Size of: ", stringify!(sha512_state_st))
    );
    assert_eq!(
        ::std::mem::align_of::<sha512_state_st>(),
        8usize,
        concat!("Alignment of ", stringify!(sha512_state_st))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sha512_state_st>())).h as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sha512_state_st),
            "::",
            stringify!(h)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sha512_state_st>())).Nl as *const _ as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(sha512_state_st),
            "::",
            stringify!(Nl)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sha512_state_st>())).Nh as *const _ as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(sha512_state_st),
            "::",
            stringify!(Nh)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sha512_state_st>())).u as *const _ as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(sha512_state_st),
            "::",
            stringify!(u)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sha512_state_st>())).num as *const _ as usize },
        208usize,
        concat!(
            "Offset of field: ",
            stringify!(sha512_state_st),
            "::",
            stringify!(num)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<sha512_state_st>())).md_len as *const _ as usize },
        212usize,
        concat!(
            "Offset of field: ",
            stringify!(sha512_state_st),
            "::",
            stringify!(md_len)
        )
    );
}