twizzler_rt_abi/

bindings.rs

/* automatically generated by rust-bindgen 0.72.1 */

pub const __bool_true_false_are_defined: u32 = 1;
pub const true_: u32 = 1;
pub const false_: u32 = 0;
pub const NAME_ENTRY_LEN: u32 = 256;
pub const FD_SETSIZE: u32 = 1024;
pub const _DEFAULT_SOURCE: u32 = 1;
pub const __MLIBC_BSD_OPTION: u32 = 1;
pub const __MLIBC_LINUX_EPOLL_OPTION: u32 = 0;
pub const __MLIBC_LINUX_TIMERFD_OPTION: u32 = 0;
pub const __MLIBC_LINUX_SIGNALFD_OPTION: u32 = 0;
pub const __MLIBC_POSIX_OPTION: u32 = 1;
pub const __MLIBC_LINUX_OPTION: u32 = 0;
pub const __MLIBC_GLIBC_OPTION: u32 = 1;
pub const __MLIBC_SYSDEP_HAS_BITS_SYSCALL_H: u32 = 0;
pub const __MLIBC_TWIZZLER: u32 = 1;
pub const POLL_IN: u32 = 1;
pub const POLL_OUT: u32 = 2;
pub const POLL_MSG: u32 = 3;
pub const POLL_ERR: u32 = 4;
pub const POLL_PRI: u32 = 5;
pub const POLL_HUP: u32 = 6;
pub const SA_NOCLDSTOP: u32 = 1;
pub const SA_NOCLDWAIT: u32 = 2;
pub const SA_SIGINFO: u32 = 4;
pub const SA_ONSTACK: u32 = 134217728;
pub const SA_RESTART: u32 = 268435456;
pub const SA_NODEFER: u32 = 1073741824;
pub const SA_RESETHAND: u32 = 2147483648;
pub const SA_RESTORER: u32 = 67108864;
pub const SA_NOMASK: u32 = 1073741824;
pub const SA_ONESHOT: u32 = 2147483648;
pub const SIGABRT: u32 = 6;
pub const SIGFPE: u32 = 8;
pub const SIGILL: u32 = 4;
pub const SIGINT: u32 = 2;
pub const SIGSEGV: u32 = 11;
pub const SIGTERM: u32 = 15;
pub const SIGPROF: u32 = 27;
pub const SIGIO: u32 = 29;
pub const SIGPWR: u32 = 30;
pub const SIGRTMIN: u32 = 35;
pub const SIGRTMAX: u32 = 64;
pub const SIG_BLOCK: u32 = 0;
pub const SIG_UNBLOCK: u32 = 1;
pub const SIG_SETMASK: u32 = 2;
pub const SIGHUP: u32 = 1;
pub const SIGQUIT: u32 = 3;
pub const SIGTRAP: u32 = 5;
pub const SIGIOT: u32 = 6;
pub const SIGBUS: u32 = 7;
pub const SIGKILL: u32 = 9;
pub const SIGUSR1: u32 = 10;
pub const SIGUSR2: u32 = 12;
pub const SIGPIPE: u32 = 13;
pub const SIGALRM: u32 = 14;
pub const SIGSTKFLT: u32 = 16;
pub const SIGCHLD: u32 = 17;
pub const SIGCONT: u32 = 18;
pub const SIGSTOP: u32 = 19;
pub const SIGTSTP: u32 = 20;
pub const SIGTTIN: u32 = 21;
pub const SIGTTOU: u32 = 22;
pub const SIGURG: u32 = 23;
pub const SIGXCPU: u32 = 24;
pub const SIGXFSZ: u32 = 25;
pub const SIGVTALRM: u32 = 26;
pub const SIGWINCH: u32 = 28;
pub const SIGPOLL: u32 = 29;
pub const SIGSYS: u32 = 31;
pub const SIGUNUSED: u32 = 31;
pub const SIGCANCEL: u32 = 32;
pub const SIGTIMER: u32 = 33;
pub const SIGEV_SIGNAL: u32 = 0;
pub const SIGEV_NONE: u32 = 1;
pub const SIGEV_THREAD: u32 = 2;
pub const SIGEV_THREAD_ID: u32 = 4;
pub const SEGV_MAPERR: u32 = 1;
pub const SEGV_ACCERR: u32 = 2;
pub const BUS_ADRALN: u32 = 1;
pub const BUS_ADRERR: u32 = 2;
pub const BUS_OBJERR: u32 = 3;
pub const BUS_MCEERR_AR: u32 = 4;
pub const BUS_MCEERR_AO: u32 = 5;
pub const ILL_ILLOPC: u32 = 1;
pub const ILL_ILLOPN: u32 = 2;
pub const ILL_ILLADR: u32 = 3;
pub const ILL_ILLTRP: u32 = 4;
pub const ILL_PRVOPC: u32 = 5;
pub const ILL_PRVREG: u32 = 6;
pub const ILL_COPROC: u32 = 7;
pub const ILL_BADSTK: u32 = 8;
pub const ILL_BADIADDR: u32 = 9;
pub const _NSIG: u32 = 65;
pub const NSIG: u32 = 65;
pub const SI_ASYNCNL: i32 = -60;
pub const SI_TKILL: i32 = -6;
pub const SI_SIGIO: i32 = -5;
pub const SI_ASYNCIO: i32 = -4;
pub const SI_MESGQ: i32 = -3;
pub const SI_TIMER: i32 = -2;
pub const SI_QUEUE: i32 = -1;
pub const SI_USER: u32 = 0;
pub const SI_KERNEL: u32 = 128;
pub const __CPU_SETSIZE: u32 = 1024;
pub const __MLIBC_THREAD_CREATE_JOINABLE: u32 = 0;
pub const __MLIBC_THREAD_CREATE_DETACHED: u32 = 1;
pub const __MLIBC_THREAD_MUTEX_DEFAULT: u32 = 0;
pub const __MLIBC_THREAD_MUTEX_NORMAL: u32 = 0;
pub const __MLIBC_THREAD_MUTEX_ERRORCHECK: u32 = 1;
pub const __MLIBC_THREAD_MUTEX_RECURSIVE: u32 = 2;
pub const __MLIBC_THREAD_PROCESS_PRIVATE: u32 = 0;
pub const __MLIBC_THREAD_PROCESS_SHARED: u32 = 1;
pub const __MLIBC_THREAD_MUTEX_STALLED: u32 = 0;
pub const __MLIBC_THREAD_MUTEX_ROBUST: u32 = 1;
pub const __MLIBC_THREAD_PRIO_NONE: u32 = 0;
pub const __MLIBC_THREAD_PRIO_INHERIT: u32 = 1;
pub const __MLIBC_THREAD_PRIO_PROTECT: u32 = 2;
pub const __MLIBC_THREAD_DESTRUCTOR_ITERATIONS: u32 = 8;
pub const __NGREG: u32 = 23;
pub const POLLIN: u32 = 1;
pub const POLLPRI: u32 = 2;
pub const POLLOUT: u32 = 4;
pub const POLLERR: u32 = 8;
pub const POLLHUP: u32 = 16;
pub const POLLNVAL: u32 = 32;
pub const POLLRDNORM: u32 = 64;
pub const POLLRDBAND: u32 = 128;
pub const POLLRDHUP: u32 = 8192;
pub const POLLWRNORM: u32 = 256;
pub const POLLWRBAND: u32 = 512;
pub type wchar_t = ::core::ffi::c_int;
#[repr(C)]
#[repr(align(16))]
#[derive(Debug, Default, Copy, Clone)]
pub struct max_align_t {
    pub __clang_max_align_nonce1: ::core::ffi::c_longlong,
    pub __bindgen_padding_0: u64,
    pub __clang_max_align_nonce2: u128,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of max_align_t"][::core::mem::size_of::<max_align_t>() - 32usize];
    ["Alignment of max_align_t"][::core::mem::align_of::<max_align_t>() - 16usize];
    ["Offset of field: max_align_t::__clang_max_align_nonce1"]
        [::core::mem::offset_of!(max_align_t, __clang_max_align_nonce1) - 0usize];
    ["Offset of field: max_align_t::__clang_max_align_nonce2"]
        [::core::mem::offset_of!(max_align_t, __clang_max_align_nonce2) - 16usize];
};
pub type __mlibc_uint8 = ::core::ffi::c_uchar;
pub type __mlibc_uint16 = ::core::ffi::c_ushort;
pub type __mlibc_uint32 = ::core::ffi::c_uint;
pub type __mlibc_uint64 = ::core::ffi::c_ulong;
pub type __mlibc_int8 = ::core::ffi::c_schar;
pub type __mlibc_int16 = ::core::ffi::c_short;
pub type __mlibc_int32 = ::core::ffi::c_int;
pub type __mlibc_int64 = ::core::ffi::c_long;
pub type __mlibc_int_fast8 = __mlibc_int8;
pub type __mlibc_int_fast16 = __mlibc_int64;
pub type __mlibc_int_fast32 = __mlibc_int64;
pub type __mlibc_int_fast64 = __mlibc_int64;
pub type __mlibc_uint_fast8 = __mlibc_uint8;
pub type __mlibc_uint_fast16 = __mlibc_uint64;
pub type __mlibc_uint_fast32 = __mlibc_uint64;
pub type __mlibc_uint_fast64 = __mlibc_uint64;
pub type __mlibc_intmax = ::core::ffi::c_long;
pub type __mlibc_intptr = ::core::ffi::c_long;
pub type __mlibc_ptrdiff = ::core::ffi::c_long;
pub type __mlibc_uintmax = ::core::ffi::c_ulong;
pub type __mlibc_uintptr = ::core::ffi::c_ulong;
pub type __mlibc_size = ::core::ffi::c_ulong;
pub type int_least8_t = __mlibc_int8;
pub type int_least16_t = __mlibc_int16;
pub type int_least32_t = __mlibc_int32;
pub type int_least64_t = __mlibc_int64;
pub type uint_least8_t = __mlibc_uint8;
pub type uint_least16_t = __mlibc_uint16;
pub type uint_least32_t = __mlibc_uint32;
pub type uint_least64_t = __mlibc_uint64;
pub type int_fast8_t = __mlibc_int_fast8;
pub type int_fast16_t = __mlibc_int_fast16;
pub type int_fast32_t = __mlibc_int_fast32;
pub type int_fast64_t = __mlibc_int_fast64;
pub type uint_fast8_t = __mlibc_uint_fast8;
pub type uint_fast16_t = __mlibc_uint_fast16;
pub type uint_fast32_t = __mlibc_uint_fast32;
pub type uint_fast64_t = __mlibc_uint_fast64;
pub type intmax_t = __mlibc_intmax;
pub type uintmax_t = __mlibc_uintmax;
#[doc = " Object ID"]
pub type objid = __uint128_t;
#[doc = " Duration, containing seconds and nanoseconds."]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct duration {
    pub seconds: u64,
    pub nanos: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of duration"][::core::mem::size_of::<duration>() - 16usize];
    ["Alignment of duration"][::core::mem::align_of::<duration>() - 8usize];
    ["Offset of field: duration::seconds"][::core::mem::offset_of!(duration, seconds) - 0usize];
    ["Offset of field: duration::nanos"][::core::mem::offset_of!(duration, nanos) - 8usize];
};
#[doc = " Optional duration."]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct option_duration {
    pub dur: duration,
    pub is_some: i32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of option_duration"][::core::mem::size_of::<option_duration>() - 24usize];
    ["Alignment of option_duration"][::core::mem::align_of::<option_duration>() - 8usize];
    ["Offset of field: option_duration::dur"]
        [::core::mem::offset_of!(option_duration, dur) - 0usize];
    ["Offset of field: option_duration::is_some"]
        [::core::mem::offset_of!(option_duration, is_some) - 16usize];
};
unsafe extern "C" {
    pub static NO_DURATION: option_duration;
}
pub type twz_error = u64;
pub type twz_error_code = u16;
pub type twz_error_category = u16;
pub const ERROR_CODE_SHIFT: twz_error = 0;
pub const ERROR_CODE_MASK: twz_error = 65535;
pub const ERROR_CATEGORY_MASK: twz_error = 281470681743360;
pub const ERROR_CATEGORY_SHIFT: twz_error = 32;
pub const SUCCESS: twz_error_code = 0;
pub const OTHER_ERROR: twz_error_code = 0;
pub const NOT_SUPPORTED: twz_error_code = 1;
pub const INTERNAL: twz_error_code = 2;
pub const WOULD_BLOCK: twz_error_code = 3;
pub const TIMED_OUT: twz_error_code = 4;
pub const ACCESS_DENIED: twz_error_code = 5;
pub const NO_SUCH_OPERATION: twz_error_code = 6;
pub const INTERRUPTED: twz_error_code = 7;
pub const IN_PROGRESS: twz_error_code = 8;
pub const INVALID_ARGUMENT: twz_error_code = 1;
pub const WRONG_TYPE: twz_error_code = 2;
pub const INVALID_ADDRESS: twz_error_code = 3;
pub const BAD_HANDLE: twz_error_code = 4;
pub const OUT_OF_MEMORY: twz_error_code = 1;
pub const OUT_OF_RESOURCES: twz_error_code = 2;
pub const OUT_OF_NAMES: twz_error_code = 3;
pub const UNAVAILABLE: twz_error_code = 4;
pub const BUSY: twz_error_code = 5;
pub const NOT_CONNECTED: twz_error_code = 6;
pub const UNREACHABLE: twz_error_code = 7;
pub const REFUSED: twz_error_code = 8;
pub const NON_ATOMIC: twz_error_code = 9;
pub const NOT_FOUND: twz_error_code = 1;
pub const ALREADY_EXISTS: twz_error_code = 2;
pub const WRONG_NAME_KIND: twz_error_code = 3;
pub const ALREADY_BOUND: twz_error_code = 4;
pub const INVALID_NAME: twz_error_code = 5;
pub const LINK_LOOP: twz_error_code = 6;
pub const NOT_EMPTY: twz_error_code = 7;
pub const MAPPING_FAILED: twz_error_code = 1;
pub const NOT_MAPPED: twz_error_code = 2;
pub const INVALID_FOTE: twz_error_code = 3;
pub const INVALID_PTR: twz_error_code = 4;
pub const INVALID_META: twz_error_code = 5;
pub const BASETYPE_MISMATCH: twz_error_code = 6;
pub const NO_SUCH_OBJECT: twz_error_code = 7;
pub const OTHER_IO_ERROR: twz_error_code = 1;
pub const DATA_LOSS: twz_error_code = 2;
pub const DEVICE_ERROR: twz_error_code = 3;
pub const SEEK_FAILED: twz_error_code = 4;
pub const RESET: twz_error_code = 5;
pub const INVALID_KEY: twz_error_code = 1;
pub const INVALID_SCHEME: twz_error_code = 2;
pub const SIGNATURE_MISMATCH: twz_error_code = 3;
pub const GATE_DENIED: twz_error_code = 4;
pub const INVALID_GATE: twz_error_code = 5;
pub const UNCATEGORIZED_ERROR: twz_error_category = 0;
pub const GENERIC_ERROR: twz_error_category = 1;
pub const ARGUMENT_ERROR: twz_error_category = 2;
pub const RESOURCE_ERROR: twz_error_category = 3;
pub const NAMING_ERROR: twz_error_category = 4;
pub const OBJECT_ERROR: twz_error_category = 5;
pub const IO_ERROR: twz_error_category = 6;
pub const SECURITY_ERROR: twz_error_category = 7;
#[doc = " Error or value"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct u32_result {
    pub err: twz_error,
    pub val: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of u32_result"][::core::mem::size_of::<u32_result>() - 16usize];
    ["Alignment of u32_result"][::core::mem::align_of::<u32_result>() - 8usize];
    ["Offset of field: u32_result::err"][::core::mem::offset_of!(u32_result, err) - 0usize];
    ["Offset of field: u32_result::val"][::core::mem::offset_of!(u32_result, val) - 8usize];
};
#[doc = " Error or value"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct u64_result {
    pub err: twz_error,
    pub val: u64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of u64_result"][::core::mem::size_of::<u64_result>() - 16usize];
    ["Alignment of u64_result"][::core::mem::align_of::<u64_result>() - 8usize];
    ["Offset of field: u64_result::err"][::core::mem::offset_of!(u64_result, err) - 0usize];
    ["Offset of field: u64_result::val"][::core::mem::offset_of!(u64_result, val) - 8usize];
};
#[doc = " Error or value"]
#[repr(C)]
#[repr(align(16))]
#[derive(Debug, Default, Copy, Clone)]
pub struct objid_result {
    pub err: twz_error,
    pub __bindgen_padding_0: u64,
    pub val: objid,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of objid_result"][::core::mem::size_of::<objid_result>() - 32usize];
    ["Alignment of objid_result"][::core::mem::align_of::<objid_result>() - 16usize];
    ["Offset of field: objid_result::err"][::core::mem::offset_of!(objid_result, err) - 0usize];
    ["Offset of field: objid_result::val"][::core::mem::offset_of!(objid_result, val) - 16usize];
};
#[doc = " Error or value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ptr_result {
    pub err: twz_error,
    pub val: *mut ::core::ffi::c_void,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of ptr_result"][::core::mem::size_of::<ptr_result>() - 16usize];
    ["Alignment of ptr_result"][::core::mem::align_of::<ptr_result>() - 8usize];
    ["Offset of field: ptr_result::err"][::core::mem::offset_of!(ptr_result, err) - 0usize];
    ["Offset of field: ptr_result::val"][::core::mem::offset_of!(ptr_result, val) - 8usize];
};
impl Default for ptr_result {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[doc = " Error or value"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct io_result {
    pub err: twz_error,
    pub val: usize,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of io_result"][::core::mem::size_of::<io_result>() - 16usize];
    ["Alignment of io_result"][::core::mem::align_of::<io_result>() - 8usize];
    ["Offset of field: io_result::err"][::core::mem::offset_of!(io_result, err) - 0usize];
    ["Offset of field: io_result::val"][::core::mem::offset_of!(io_result, val) - 8usize];
};
#[doc = " Allocation flags"]
pub type alloc_flags = u32;
#[doc = " Zero memory during operation"]
pub const ZERO_MEMORY: alloc_flags = 1;
unsafe extern "C-unwind" {
    #[doc = " Allocate memory, zeroing it first if the flag is set."]
    pub fn twz_rt_malloc(sz: usize, align: usize, flags: alloc_flags) -> *mut ::core::ffi::c_void;
}
unsafe extern "C-unwind" {
    #[doc = " Deallocate memory. If ZERO_MEMORY is set, will clear the memory before freeing."]
    pub fn twz_rt_dealloc(
        ptr: *mut ::core::ffi::c_void,
        sz: usize,
        align: usize,
        flags: alloc_flags,
    );
}
unsafe extern "C-unwind" {
    #[doc = " Reallocate memory. If ZERO_MEMORY is set, will zero new memory before returning and zero to-be-freed memory before freeing."]
    pub fn twz_rt_realloc(
        ptr: *mut ::core::ffi::c_void,
        sz: usize,
        align: usize,
        new_size: usize,
        flags: alloc_flags,
    ) -> *mut ::core::ffi::c_void;
}
#[doc = " Exit code type"]
pub type exit_code = i32;
#[doc = " Basic OS information provided to rust libstd"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct basic_aux {
    #[doc = " Number of arguments"]
    pub argc: usize,
    #[doc = " Pointer to args"]
    pub args: *mut *mut ::core::ffi::c_char,
    #[doc = " Environment pointer"]
    pub env: *mut *mut ::core::ffi::c_char,
    #[doc = " entry point"]
    pub entry: usize,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of basic_aux"][::core::mem::size_of::<basic_aux>() - 32usize];
    ["Alignment of basic_aux"][::core::mem::align_of::<basic_aux>() - 8usize];
    ["Offset of field: basic_aux::argc"][::core::mem::offset_of!(basic_aux, argc) - 0usize];
    ["Offset of field: basic_aux::args"][::core::mem::offset_of!(basic_aux, args) - 8usize];
    ["Offset of field: basic_aux::env"][::core::mem::offset_of!(basic_aux, env) - 16usize];
    ["Offset of field: basic_aux::entry"][::core::mem::offset_of!(basic_aux, entry) - 24usize];
};
impl Default for basic_aux {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[doc = " Return info from rust libstd"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct basic_return {
    pub code: exit_code,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of basic_return"][::core::mem::size_of::<basic_return>() - 4usize];
    ["Alignment of basic_return"][::core::mem::align_of::<basic_return>() - 4usize];
    ["Offset of field: basic_return::code"][::core::mem::offset_of!(basic_return, code) - 0usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ctor_set {
    #[doc = " Fn ptr to _init"]
    pub legacy_init: ::core::option::Option<unsafe extern "C-unwind" fn()>,
    #[doc = " Pointer to the init array"]
    pub init_array: *mut ::core::option::Option<unsafe extern "C-unwind" fn()>,
    #[doc = " Length of init array"]
    pub init_array_len: usize,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of ctor_set"][::core::mem::size_of::<ctor_set>() - 24usize];
    ["Alignment of ctor_set"][::core::mem::align_of::<ctor_set>() - 8usize];
    ["Offset of field: ctor_set::legacy_init"]
        [::core::mem::offset_of!(ctor_set, legacy_init) - 0usize];
    ["Offset of field: ctor_set::init_array"]
        [::core::mem::offset_of!(ctor_set, init_array) - 8usize];
    ["Offset of field: ctor_set::init_array_len"]
        [::core::mem::offset_of!(ctor_set, init_array_len) - 16usize];
};
impl Default for ctor_set {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[doc = " Init information for compartments"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct comp_init_info {
    #[doc = " Pointer to ctor_set list"]
    pub ctor_set_array: *mut ctor_set,
    #[doc = " Length of ctor_set array"]
    pub ctor_set_len: usize,
    #[doc = " Pointer to compartment config info"]
    pub comp_config_info: *mut ::core::ffi::c_void,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of comp_init_info"][::core::mem::size_of::<comp_init_info>() - 24usize];
    ["Alignment of comp_init_info"][::core::mem::align_of::<comp_init_info>() - 8usize];
    ["Offset of field: comp_init_info::ctor_set_array"]
        [::core::mem::offset_of!(comp_init_info, ctor_set_array) - 0usize];
    ["Offset of field: comp_init_info::ctor_set_len"]
        [::core::mem::offset_of!(comp_init_info, ctor_set_len) - 8usize];
    ["Offset of field: comp_init_info::comp_config_info"]
        [::core::mem::offset_of!(comp_init_info, comp_config_info) - 16usize];
};
impl Default for comp_init_info {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[doc = " Init information for minimal runtime"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct minimal_init_info {
    #[doc = " Pointer to program headers"]
    pub phdrs: *mut ::core::ffi::c_void,
    #[doc = " Number of program headers"]
    pub nr_phdrs: usize,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of minimal_init_info"][::core::mem::size_of::<minimal_init_info>() - 16usize];
    ["Alignment of minimal_init_info"][::core::mem::align_of::<minimal_init_info>() - 8usize];
    ["Offset of field: minimal_init_info::phdrs"]
        [::core::mem::offset_of!(minimal_init_info, phdrs) - 0usize];
    ["Offset of field: minimal_init_info::nr_phdrs"]
        [::core::mem::offset_of!(minimal_init_info, nr_phdrs) - 8usize];
};
impl Default for minimal_init_info {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[doc = " Possible init info types"]
#[repr(C)]
#[derive(Copy, Clone)]
pub union init_info_ptrs {
    pub comp: *mut comp_init_info,
    pub min: *mut minimal_init_info,
    pub monitor: *mut ::core::ffi::c_void,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of init_info_ptrs"][::core::mem::size_of::<init_info_ptrs>() - 8usize];
    ["Alignment of init_info_ptrs"][::core::mem::align_of::<init_info_ptrs>() - 8usize];
    ["Offset of field: init_info_ptrs::comp"]
        [::core::mem::offset_of!(init_info_ptrs, comp) - 0usize];
    ["Offset of field: init_info_ptrs::min"][::core::mem::offset_of!(init_info_ptrs, min) - 0usize];
    ["Offset of field: init_info_ptrs::monitor"]
        [::core::mem::offset_of!(init_info_ptrs, monitor) - 0usize];
};
impl Default for init_info_ptrs {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[doc = " Runtime initialization info."]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct runtime_info {
    pub flags: i32,
    #[doc = " Discrim. for init_info."]
    pub kind: i32,
    #[doc = " Pointer to args"]
    pub args: *mut *mut ::core::ffi::c_char,
    #[doc = " Number of args"]
    pub argc: usize,
    #[doc = " Environment pointer"]
    pub envp: *mut *mut ::core::ffi::c_char,
    #[doc = " Entry point for ELF file"]
    pub entry: usize,
    pub init_info: init_info_ptrs,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of runtime_info"][::core::mem::size_of::<runtime_info>() - 48usize];
    ["Alignment of runtime_info"][::core::mem::align_of::<runtime_info>() - 8usize];
    ["Offset of field: runtime_info::flags"][::core::mem::offset_of!(runtime_info, flags) - 0usize];
    ["Offset of field: runtime_info::kind"][::core::mem::offset_of!(runtime_info, kind) - 4usize];
    ["Offset of field: runtime_info::args"][::core::mem::offset_of!(runtime_info, args) - 8usize];
    ["Offset of field: runtime_info::argc"][::core::mem::offset_of!(runtime_info, argc) - 16usize];
    ["Offset of field: runtime_info::envp"][::core::mem::offset_of!(runtime_info, envp) - 24usize];
    ["Offset of field: runtime_info::entry"]
        [::core::mem::offset_of!(runtime_info, entry) - 32usize];
    ["Offset of field: runtime_info::init_info"]
        [::core::mem::offset_of!(runtime_info, init_info) - 40usize];
};
impl Default for runtime_info {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[doc = " Minimal runtime info"]
pub const RUNTIME_INIT_MIN: i32 = 0;
#[doc = " Info for monitor"]
pub const RUNTIME_INIT_MONITOR: i32 = 1;
#[doc = " Info for compartments"]
pub const RUNTIME_INIT_COMP: i32 = 2;
#[doc = " Optional exit code"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct option_exit_code {
    pub is_some: i32,
    pub value: exit_code,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of option_exit_code"][::core::mem::size_of::<option_exit_code>() - 8usize];
    ["Alignment of option_exit_code"][::core::mem::align_of::<option_exit_code>() - 4usize];
    ["Offset of field: option_exit_code::is_some"]
        [::core::mem::offset_of!(option_exit_code, is_some) - 0usize];
    ["Offset of field: option_exit_code::value"]
        [::core::mem::offset_of!(option_exit_code, value) - 4usize];
};
unsafe extern "C-unwind" {
    #[doc = " Exit with provided code"]
    pub fn twz_rt_exit(code: exit_code);
}
unsafe extern "C-unwind" {
    #[doc = " Abort immediately"]
    pub fn twz_rt_abort();
}
unsafe extern "C-unwind" {
    #[doc = " Signal the runtime to prep for entry from another compartment"]
    pub fn twz_rt_cross_compartment_entry() -> bool;
}
unsafe extern "C-unwind" {
    #[doc = " Set the handler for an upcall from kernel"]
    pub fn twz_rt_set_upcall_handler(
        handler: ::core::option::Option<
            unsafe extern "C-unwind" fn(
                frame: *mut ::core::ffi::c_void,
                data: *const ::core::ffi::c_void,
            ),
        >,
    );
}
unsafe extern "C-unwind" {
    pub fn twz_rt_pre_main_hook() -> option_exit_code;
}
unsafe extern "C-unwind" {
    pub fn twz_rt_post_main_hook();
}
unsafe extern "C-unwind" {
    pub fn twz_rt_runtime_entry(
        arg: *const runtime_info,
        std_entry: ::core::option::Option<
            unsafe extern "C-unwind" fn(arg1: basic_aux) -> basic_return,
        >,
        main: usize,
    );
}
#[doc = " An open descriptor for a runtime file handle."]
pub type descriptor = i32;
#[doc = " Options for creating the file."]
#[repr(C)]
#[repr(align(16))]
#[derive(Debug, Default, Copy, Clone)]
pub struct create_options {
    #[doc = " Object ID to bind the name to, optional. 0 if not present."]
    pub id: objid,
    #[doc = " The kind of open/create operation. See CREATE_KIND_*."]
    pub kind: u8,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of create_options"][::core::mem::size_of::<create_options>() - 32usize];
    ["Alignment of create_options"][::core::mem::align_of::<create_options>() - 16usize];
    ["Offset of field: create_options::id"][::core::mem::offset_of!(create_options, id) - 0usize];
    ["Offset of field: create_options::kind"]
        [::core::mem::offset_of!(create_options, kind) - 16usize];
};
pub const NAME_DATA_MAX: usize = 2048;
#[doc = " Information for opening a file."]
#[repr(C)]
#[repr(align(16))]
#[derive(Debug, Copy, Clone)]
pub struct open_info {
    #[doc = " Creation options"]
    pub create: create_options,
    #[doc = " Operation flags"]
    pub flags: u32,
    #[doc = " Length of file name in bytes."]
    pub len: usize,
    pub name: [u8; 2048usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of open_info"][::core::mem::size_of::<open_info>() - 2096usize];
    ["Alignment of open_info"][::core::mem::align_of::<open_info>() - 16usize];
    ["Offset of field: open_info::create"][::core::mem::offset_of!(open_info, create) - 0usize];
    ["Offset of field: open_info::flags"][::core::mem::offset_of!(open_info, flags) - 32usize];
    ["Offset of field: open_info::len"][::core::mem::offset_of!(open_info, len) - 40usize];
    ["Offset of field: open_info::name"][::core::mem::offset_of!(open_info, name) - 48usize];
};
impl Default for open_info {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[doc = " Open the file only if it already exists."]
pub const CREATE_KIND_EXISTING: u8 = 0;
#[doc = " Open only if it doesn't exist, and create it."]
pub const CREATE_KIND_NEW: u8 = 1;
#[doc = " Open if it already exists, or create it if it doesn't."]
pub const CREATE_KIND_EITHER: u8 = 2;
#[doc = " Open the file with read access."]
pub const OPEN_FLAG_READ: u32 = 1;
#[doc = " Open the file with write access."]
pub const OPEN_FLAG_WRITE: u32 = 2;
#[doc = " Truncate the file on open. Requires write access."]
pub const OPEN_FLAG_TRUNCATE: u32 = 4;
#[doc = " Always use the end of the file as the position."]
pub const OPEN_FLAG_TAIL: u32 = 8;
#[doc = " If the file is a symlink, open the link instead of the target."]
pub const OPEN_FLAG_SYMLINK: u32 = 16;
#[doc = " Result of open call."]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct open_result {
    #[doc = " If error is Success, this contains a valid descriptor."]
    pub fd: descriptor,
    #[doc = " Error code, or success."]
    pub err: twz_error,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of open_result"][::core::mem::size_of::<open_result>() - 16usize];
    ["Alignment of open_result"][::core::mem::align_of::<open_result>() - 8usize];
    ["Offset of field: open_result::fd"][::core::mem::offset_of!(open_result, fd) - 0usize];
    ["Offset of field: open_result::err"][::core::mem::offset_of!(open_result, err) - 8usize];
};
pub const open_kind_OpenKind_KernelConsole: open_kind = 0;
pub const open_kind_OpenKind_Object: open_kind = 1;
pub const open_kind_OpenKind_Path: open_kind = 2;
pub const open_kind_OpenKind_Pipe: open_kind = 3;
pub const open_kind_OpenKind_SocketConnect: open_kind = 4;
pub const open_kind_OpenKind_SocketBind: open_kind = 5;
pub const open_kind_OpenKind_SocketAccept: open_kind = 6;
pub const open_kind_OpenKind_PtyServer: open_kind = 7;
pub const open_kind_OpenKind_PtyClient: open_kind = 8;
pub const open_kind_OpenKind_Compartment: open_kind = 9;
pub type open_kind = ::core::ffi::c_uint;
pub const addr_kind_AddrKind_Ipv4: addr_kind = 0;
pub const addr_kind_AddrKind_Ipv6: addr_kind = 1;
pub type addr_kind = ::core::ffi::c_uint;
pub const prot_kind_ProtKind_Stream: prot_kind = 0;
pub const prot_kind_ProtKind_Datagram: prot_kind = 1;
pub type prot_kind = ::core::ffi::c_uint;
#[repr(C)]
#[derive(Copy, Clone)]
pub union socket_address_addrs {
    pub v4: [u8; 4usize],
    pub v6: [u8; 16usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of socket_address_addrs"][::core::mem::size_of::<socket_address_addrs>() - 16usize];
    ["Alignment of socket_address_addrs"][::core::mem::align_of::<socket_address_addrs>() - 1usize];
    ["Offset of field: socket_address_addrs::v4"]
        [::core::mem::offset_of!(socket_address_addrs, v4) - 0usize];
    ["Offset of field: socket_address_addrs::v6"]
        [::core::mem::offset_of!(socket_address_addrs, v6) - 0usize];
};
impl Default for socket_address_addrs {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct socket_address {
    pub kind: addr_kind,
    pub addr_octets: socket_address_addrs,
    pub port: u16,
    pub scope_id: u32,
    pub flowinfo: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of socket_address"][::core::mem::size_of::<socket_address>() - 32usize];
    ["Alignment of socket_address"][::core::mem::align_of::<socket_address>() - 4usize];
    ["Offset of field: socket_address::kind"]
        [::core::mem::offset_of!(socket_address, kind) - 0usize];
    ["Offset of field: socket_address::addr_octets"]
        [::core::mem::offset_of!(socket_address, addr_octets) - 4usize];
    ["Offset of field: socket_address::port"]
        [::core::mem::offset_of!(socket_address, port) - 20usize];
    ["Offset of field: socket_address::scope_id"]
        [::core::mem::offset_of!(socket_address, scope_id) - 24usize];
    ["Offset of field: socket_address::flowinfo"]
        [::core::mem::offset_of!(socket_address, flowinfo) - 28usize];
};
impl Default for socket_address {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct socket_bind_info {
    pub addr: socket_address,
    pub prot: prot_kind,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of socket_bind_info"][::core::mem::size_of::<socket_bind_info>() - 36usize];
    ["Alignment of socket_bind_info"][::core::mem::align_of::<socket_bind_info>() - 4usize];
    ["Offset of field: socket_bind_info::addr"]
        [::core::mem::offset_of!(socket_bind_info, addr) - 0usize];
    ["Offset of field: socket_bind_info::prot"]
        [::core::mem::offset_of!(socket_bind_info, prot) - 32usize];
};
impl Default for socket_bind_info {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[repr(align(16))]
#[derive(Debug, Default, Copy, Clone)]
pub struct object_bind_info {
    pub id: objid,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of object_bind_info"][::core::mem::size_of::<object_bind_info>() - 16usize];
    ["Alignment of object_bind_info"][::core::mem::align_of::<object_bind_info>() - 16usize];
    ["Offset of field: object_bind_info::id"]
        [::core::mem::offset_of!(object_bind_info, id) - 0usize];
};
unsafe extern "C-unwind" {
    #[doc = " Open a non-named file. The value pointed to by bind_info is dependent on the kind specified in the first\n argument. For pipe, bind_info is ignored. For Socket* kinds, bind_info points to a socket_address."]
    pub fn twz_rt_fd_open(
        kind: open_kind,
        flags: u32,
        bind_info: *mut ::core::ffi::c_void,
        bind_info_len: usize,
    ) -> open_result;
}
unsafe extern "C-unwind" {
    #[doc = " Reopen a file descriptor with a new anon binding. The anon_kind remains unchanged. The value pointed to by bind_info is dependent on the kind specified in the first\n argument. For pipe, bind_info is ignored. For Socket* kinds, bind_info points to a socket_address."]
    pub fn twz_rt_fd_reopen(
        fd: descriptor,
        kind: open_kind,
        flags: u32,
        bind_info: *mut ::core::ffi::c_void,
        bind_info_len: usize,
    ) -> twz_error;
}
unsafe extern "C-unwind" {
    #[doc = " Close a file descriptor. If the file descriptor is invalid\n or already closed, this function does nothing."]
    pub fn twz_rt_fd_close(fd: descriptor);
}
#[doc = " Flags a descriptor can have."]
pub type fd_flags = u32;
#[doc = " This file descriptor is a terminal."]
pub const FD_IS_TERMINAL: fd_flags = 1;
#[doc = " Regular file"]
pub const fd_kind_FdKind_Regular: fd_kind = 0;
#[doc = " Directory"]
pub const fd_kind_FdKind_Directory: fd_kind = 1;
#[doc = " Symbolic link"]
pub const fd_kind_FdKind_SymLink: fd_kind = 2;
#[doc = " Symbolic link"]
pub const fd_kind_FdKind_Socket: fd_kind = 3;
#[doc = " Symbolic link"]
pub const fd_kind_FdKind_Pipe: fd_kind = 4;
#[doc = " Symbolic link"]
pub const fd_kind_FdKind_Pty: fd_kind = 5;
#[doc = " Symbolic link"]
pub const fd_kind_FdKind_Compartment: fd_kind = 6;
#[doc = " Kinds of underlying fd objects"]
pub type fd_kind = ::core::ffi::c_uint;
#[doc = " Information about a file descriptor."]
#[repr(C)]
#[repr(align(16))]
#[derive(Debug, Copy, Clone)]
pub struct fd_info {
    #[doc = " Underlying root objid."]
    pub id: objid,
    #[doc = " Length of underlying object, or 0 if undefined."]
    pub len: u64,
    #[doc = " Flags for the descriptor."]
    pub flags: fd_flags,
    #[doc = " Underlying fd kind"]
    pub kind: fd_kind,
    pub created: duration,
    pub accessed: duration,
    pub modified: duration,
    pub unix_mode: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of fd_info"][::core::mem::size_of::<fd_info>() - 96usize];
    ["Alignment of fd_info"][::core::mem::align_of::<fd_info>() - 16usize];
    ["Offset of field: fd_info::id"][::core::mem::offset_of!(fd_info, id) - 0usize];
    ["Offset of field: fd_info::len"][::core::mem::offset_of!(fd_info, len) - 16usize];
    ["Offset of field: fd_info::flags"][::core::mem::offset_of!(fd_info, flags) - 24usize];
    ["Offset of field: fd_info::kind"][::core::mem::offset_of!(fd_info, kind) - 28usize];
    ["Offset of field: fd_info::created"][::core::mem::offset_of!(fd_info, created) - 32usize];
    ["Offset of field: fd_info::accessed"][::core::mem::offset_of!(fd_info, accessed) - 48usize];
    ["Offset of field: fd_info::modified"][::core::mem::offset_of!(fd_info, modified) - 64usize];
    ["Offset of field: fd_info::unix_mode"][::core::mem::offset_of!(fd_info, unix_mode) - 80usize];
};
impl Default for fd_info {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
unsafe extern "C-unwind" {
    #[doc = " Get information about a descriptor. If this returns true, the fd was valid\n and the data pointed to by info is filled with fd_info data."]
    pub fn twz_rt_fd_get_info(fd: descriptor, info: *mut fd_info) -> bool;
}
#[doc = " Commands for descriptors."]
pub type fd_cmd = u32;
#[doc = " Duplicate this descriptor. The arg argument is ignored. The ret argument points to a descriptor."]
pub const FD_CMD_DUP: fd_cmd = 0;
#[doc = " Sync the underlying storage of the file descriptor."]
pub const FD_CMD_SYNC: fd_cmd = 1;
#[doc = " Truncate the underlying storage of the file descriptor. The arg argument points to a u64 length."]
pub const FD_CMD_TRUNCATE: fd_cmd = 2;
#[doc = " Close either the read or write end of a file descriptor. The arg points to a u32, the first bit of which indicates read-side, the second indicates write."]
pub const FD_CMD_SHUTDOWN: fd_cmd = 3;
unsafe extern "C-unwind" {
    #[doc = " Perform a command on the descriptor. The arguments arg and ret are interpreted according to\n the command specified."]
    pub fn twz_rt_fd_cmd(
        fd: descriptor,
        cmd: fd_cmd,
        arg: *mut ::core::ffi::c_void,
        ret: *mut ::core::ffi::c_void,
    ) -> twz_error;
}
pub const BIND_DATA_MAX: usize = 4096;
#[repr(C)]
#[repr(align(16))]
#[derive(Debug, Copy, Clone)]
pub struct binding_info {
    pub kind: open_kind,
    pub fd: descriptor,
    pub flags: fd_flags,
    pub bind_len: u32,
    pub bind_data: [u8; 4096usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of binding_info"][::core::mem::size_of::<binding_info>() - 4112usize];
    ["Alignment of binding_info"][::core::mem::align_of::<binding_info>() - 16usize];
    ["Offset of field: binding_info::kind"][::core::mem::offset_of!(binding_info, kind) - 0usize];
    ["Offset of field: binding_info::fd"][::core::mem::offset_of!(binding_info, fd) - 4usize];
    ["Offset of field: binding_info::flags"][::core::mem::offset_of!(binding_info, flags) - 8usize];
    ["Offset of field: binding_info::bind_len"]
        [::core::mem::offset_of!(binding_info, bind_len) - 12usize];
    ["Offset of field: binding_info::bind_data"]
        [::core::mem::offset_of!(binding_info, bind_data) - 16usize];
};
impl Default for binding_info {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
unsafe extern "C-unwind" {
    pub fn twz_rt_fd_read_binds(binds: *mut binding_info, nr_binds: usize) -> usize;
}
#[repr(C)]
#[repr(align(16))]
#[derive(Debug, Copy, Clone)]
pub struct name_entry {
    pub info: fd_info,
    pub name_len: u32,
    pub linkname_len: u32,
    pub name: [u8; 256usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of name_entry"][::core::mem::size_of::<name_entry>() - 368usize];
    ["Alignment of name_entry"][::core::mem::align_of::<name_entry>() - 16usize];
    ["Offset of field: name_entry::info"][::core::mem::offset_of!(name_entry, info) - 0usize];
    ["Offset of field: name_entry::name_len"]
        [::core::mem::offset_of!(name_entry, name_len) - 96usize];
    ["Offset of field: name_entry::linkname_len"]
        [::core::mem::offset_of!(name_entry, linkname_len) - 100usize];
    ["Offset of field: name_entry::name"][::core::mem::offset_of!(name_entry, name) - 104usize];
};
impl Default for name_entry {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
unsafe extern "C-unwind" {
    #[doc = " Enumerate sub-names in an fd (e.g. directory entries). The buf and len arguments form a &mut [name_entry] slice, and the off argument specifies how many names to skip for this read. The return value is the number of entries read, or\n 0 if at end of list."]
    pub fn twz_rt_fd_enumerate_names(
        fd: descriptor,
        buf: *mut name_entry,
        len: usize,
        off: usize,
    ) -> io_result;
}
unsafe extern "C-unwind" {
    #[doc = " Remove a name in the namespace."]
    pub fn twz_rt_fd_remove(name: *const ::core::ffi::c_char, name_len: usize) -> twz_error;
}
unsafe extern "C-unwind" {
    #[doc = " Create a new namespace."]
    pub fn twz_rt_fd_mkns(name: *const ::core::ffi::c_char, name_len: usize) -> twz_error;
}
unsafe extern "C-unwind" {
    #[doc = " Create a new symlink."]
    pub fn twz_rt_fd_symlink(
        name: *const ::core::ffi::c_char,
        name_len: usize,
        target: *const ::core::ffi::c_char,
        target_len: usize,
    ) -> twz_error;
}
unsafe extern "C-unwind" {
    #[doc = " Rename a name in the namespace."]
    pub fn twz_rt_fd_rename(
        old_name: *const ::core::ffi::c_char,
        old_name_len: usize,
        new_name: *const ::core::ffi::c_char,
        new_name_len: usize,
    ) -> twz_error;
}
unsafe extern "C-unwind" {
    #[doc = " Read symlink."]
    pub fn twz_rt_fd_readlink(
        name: *const ::core::ffi::c_char,
        name_len: usize,
        buf: *mut ::core::ffi::c_char,
        buf_len: usize,
        out_buf_len: *mut u64,
    ) -> twz_error;
}
pub const name_root_NameRoot_Root: name_root = 0;
pub const name_root_NameRoot_Home: name_root = 1;
pub const name_root_NameRoot_Current: name_root = 2;
pub const name_root_NameRoot_Temp: name_root = 3;
pub const name_root_NameRoot_Exe: name_root = 4;
pub type name_root = ::core::ffi::c_uint;
unsafe extern "C-unwind" {
    pub fn twz_rt_set_nameroot(
        root: name_root,
        path: *const ::core::ffi::c_char,
        path_len: usize,
    ) -> twz_error;
}
unsafe extern "C-unwind" {
    pub fn twz_rt_get_nameroot(
        root: name_root,
        path: *mut ::core::ffi::c_char,
        path_len: usize,
    ) -> io_result;
}
pub const name_resolver_NameResolver_Default: name_resolver = 0;
pub const name_resolver_NameResolver_Socket: name_resolver = 1;
pub type name_resolver = ::core::ffi::c_uint;
unsafe extern "C-unwind" {
    pub fn twz_rt_resolve_name(
        resolver: name_resolver,
        name: *const ::core::ffi::c_char,
        name_len: usize,
    ) -> objid_result;
}
unsafe extern "C-unwind" {
    pub fn twz_rt_canon_name(
        resolver: name_resolver,
        name: *const ::core::ffi::c_char,
        name_len: usize,
        out: *mut ::core::ffi::c_char,
        out_len: *mut usize,
    ) -> twz_error;
}
pub type exec_flags = u32;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct exec_spawn_args {
    pub prog: *const ::core::ffi::c_char,
    pub args: *const *const ::core::ffi::c_char,
    pub env: *const *const ::core::ffi::c_char,
    pub fd_binds: *const binding_info,
    pub fd_bind_count: usize,
    pub flags: exec_flags,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of exec_spawn_args"][::core::mem::size_of::<exec_spawn_args>() - 48usize];
    ["Alignment of exec_spawn_args"][::core::mem::align_of::<exec_spawn_args>() - 8usize];
    ["Offset of field: exec_spawn_args::prog"]
        [::core::mem::offset_of!(exec_spawn_args, prog) - 0usize];
    ["Offset of field: exec_spawn_args::args"]
        [::core::mem::offset_of!(exec_spawn_args, args) - 8usize];
    ["Offset of field: exec_spawn_args::env"]
        [::core::mem::offset_of!(exec_spawn_args, env) - 16usize];
    ["Offset of field: exec_spawn_args::fd_binds"]
        [::core::mem::offset_of!(exec_spawn_args, fd_binds) - 24usize];
    ["Offset of field: exec_spawn_args::fd_bind_count"]
        [::core::mem::offset_of!(exec_spawn_args, fd_bind_count) - 32usize];
    ["Offset of field: exec_spawn_args::flags"]
        [::core::mem::offset_of!(exec_spawn_args, flags) - 40usize];
};
impl Default for exec_spawn_args {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
unsafe extern "C-unwind" {
    pub fn twz_rt_exec_spawn(args: *const exec_spawn_args) -> open_result;
}
#[doc = " Futex type, based on linux futex."]
pub type futex_word = u32;
unsafe extern "C-unwind" {
    #[doc = " If *ptr == expected, wait until signal, optionally timing out."]
    pub fn twz_rt_futex_wait(
        ptr: *mut futex_word,
        expected: futex_word,
        timeout: option_duration,
    ) -> twz_error;
}
unsafe extern "C-unwind" {
    #[doc = " Wake up up to max threads waiting on ptr. If max is set to FUTEX_WAKE_ALL, wake all threads."]
    pub fn twz_rt_futex_wake(ptr: *mut futex_word, max: i64) -> twz_error;
}
#[doc = " Wake all threads instead of a maximum number"]
pub const FUTEX_WAKE_ALL: i64 = -1;
unsafe extern "C-unwind" {
    #[doc = " Yield the thread now."]
    pub fn twz_rt_yield_now();
}
unsafe extern "C-unwind" {
    #[doc = " Set the name of the calling thread. Must be a C string."]
    pub fn twz_rt_set_name(name: *const ::core::ffi::c_char);
}
unsafe extern "C-unwind" {
    #[doc = " Get the name of the calling thread. A slice of length *len is filled, and *len is updated to\n contain the length actually used. The result is also a C string."]
    pub fn twz_rt_get_name(
        tcb: *const ::core::ffi::c_void,
        name: *mut ::core::ffi::c_char,
        len: *mut usize,
    );
}
unsafe extern "C-unwind" {
    #[doc = " Sleep the calling thread for specified duration."]
    pub fn twz_rt_sleep(dur: duration);
}
#[doc = " TLS index, module ID and offset."]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct tls_index {
    pub mod_id: usize,
    pub offset: usize,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of tls_index"][::core::mem::size_of::<tls_index>() - 16usize];
    ["Alignment of tls_index"][::core::mem::align_of::<tls_index>() - 8usize];
    ["Offset of field: tls_index::mod_id"][::core::mem::offset_of!(tls_index, mod_id) - 0usize];
    ["Offset of field: tls_index::offset"][::core::mem::offset_of!(tls_index, offset) - 8usize];
};
unsafe extern "C-unwind" {
    #[doc = " Resolve the TLS index and get back the TLS data pointer."]
    pub fn twz_rt_tls_get_addr(index: *mut tls_index) -> *mut ::core::ffi::c_void;
}
#[doc = " A TLS desc struct, with a resolver and value"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct tls_desc {
    #[doc = " Pointer to resolver"]
    pub resolver: *mut ::core::ffi::c_void,
    #[doc = " Value to pass to the resolver"]
    pub value: u64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of tls_desc"][::core::mem::size_of::<tls_desc>() - 16usize];
    ["Alignment of tls_desc"][::core::mem::align_of::<tls_desc>() - 8usize];
    ["Offset of field: tls_desc::resolver"][::core::mem::offset_of!(tls_desc, resolver) - 0usize];
    ["Offset of field: tls_desc::value"][::core::mem::offset_of!(tls_desc, value) - 8usize];
};
impl Default for tls_desc {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
unsafe extern "C-unwind" {
    #[doc = " Resolver for tls_desc"]
    pub fn twz_rt_tls_desc_resolve(arg: *mut tls_desc) -> *mut ::core::ffi::c_void;
}
#[doc = " Runtime-internal ID of a thread"]
pub type thread_id = u32;
#[doc = " Arguments to spawn"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct spawn_args {
    #[doc = " Size of stack to allocate"]
    pub stack_size: usize,
    #[doc = " Starting address"]
    pub start: usize,
    #[doc = " Starting argument"]
    pub arg: usize,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of spawn_args"][::core::mem::size_of::<spawn_args>() - 24usize];
    ["Alignment of spawn_args"][::core::mem::align_of::<spawn_args>() - 8usize];
    ["Offset of field: spawn_args::stack_size"]
        [::core::mem::offset_of!(spawn_args, stack_size) - 0usize];
    ["Offset of field: spawn_args::start"][::core::mem::offset_of!(spawn_args, start) - 8usize];
    ["Offset of field: spawn_args::arg"][::core::mem::offset_of!(spawn_args, arg) - 16usize];
};
#[doc = " Spawn result."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct spawn_result {
    #[doc = " Thread id, if err is set to Success."]
    pub id: thread_id,
    pub err: twz_error,
    pub tcb: *mut ::core::ffi::c_void,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of spawn_result"][::core::mem::size_of::<spawn_result>() - 24usize];
    ["Alignment of spawn_result"][::core::mem::align_of::<spawn_result>() - 8usize];
    ["Offset of field: spawn_result::id"][::core::mem::offset_of!(spawn_result, id) - 0usize];
    ["Offset of field: spawn_result::err"][::core::mem::offset_of!(spawn_result, err) - 8usize];
    ["Offset of field: spawn_result::tcb"][::core::mem::offset_of!(spawn_result, tcb) - 16usize];
};
impl Default for spawn_result {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
unsafe extern "C-unwind" {
    #[doc = " Sawn a thread. On success, that thread starts executing concurrently with this function's return."]
    pub fn twz_rt_spawn_thread(args: spawn_args) -> spawn_result;
}
unsafe extern "C-unwind" {
    #[doc = " Wait for a thread to exit, optionally timing out."]
    pub fn twz_rt_join_thread(id: thread_id, timeout: option_duration) -> twz_error;
}
#[repr(C)]
#[repr(align(16))]
#[derive(Debug, Copy, Clone)]
pub struct thread_info {
    pub id: thread_id,
    pub tcb: *mut ::core::ffi::c_void,
    pub objid: objid,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of thread_info"][::core::mem::size_of::<thread_info>() - 32usize];
    ["Alignment of thread_info"][::core::mem::align_of::<thread_info>() - 16usize];
    ["Offset of field: thread_info::id"][::core::mem::offset_of!(thread_info, id) - 0usize];
    ["Offset of field: thread_info::tcb"][::core::mem::offset_of!(thread_info, tcb) - 8usize];
    ["Offset of field: thread_info::objid"][::core::mem::offset_of!(thread_info, objid) - 16usize];
};
impl Default for thread_info {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub const TWZ_RT_THREAD_ID_SELF: thread_id = 4294967295;
unsafe extern "C-unwind" {
    pub fn twz_rt_get_thread_info(id: thread_id) -> thread_info;
}
#[doc = " Mapping flags"]
pub type map_flags = u32;
#[doc = " Object handle"]
#[repr(C)]
#[repr(align(16))]
#[derive(Debug, Copy, Clone)]
pub struct object_handle {
    #[doc = " ID for this handle"]
    pub id: objid,
    #[doc = " Pointer to per-runtime info. The first 64-bits of this data must be an atomic u64 value used for reference counting."]
    pub runtime_info: *mut ::core::ffi::c_void,
    #[doc = " Pointer to start of object data."]
    pub start: *mut ::core::ffi::c_void,
    #[doc = " Pointer to object meta struct."]
    pub meta: *mut ::core::ffi::c_void,
    #[doc = " Mapping flags"]
    pub map_flags: map_flags,
    #[doc = " Number of valid bytes after start pointer for this object handle, in multiples of of LEN_MUL"]
    pub valid_len: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of object_handle"][::core::mem::size_of::<object_handle>() - 48usize];
    ["Alignment of object_handle"][::core::mem::align_of::<object_handle>() - 16usize];
    ["Offset of field: object_handle::id"][::core::mem::offset_of!(object_handle, id) - 0usize];
    ["Offset of field: object_handle::runtime_info"]
        [::core::mem::offset_of!(object_handle, runtime_info) - 16usize];
    ["Offset of field: object_handle::start"]
        [::core::mem::offset_of!(object_handle, start) - 24usize];
    ["Offset of field: object_handle::meta"]
        [::core::mem::offset_of!(object_handle, meta) - 32usize];
    ["Offset of field: object_handle::map_flags"]
        [::core::mem::offset_of!(object_handle, map_flags) - 40usize];
    ["Offset of field: object_handle::valid_len"]
        [::core::mem::offset_of!(object_handle, valid_len) - 44usize];
};
impl Default for object_handle {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[doc = " Multiplier to valid_len."]
pub const LEN_MUL: usize = 4096;
#[repr(C)]
#[repr(align(8))]
#[derive(Debug, Copy, Clone)]
pub struct fd_set {
    pub fds_bits: [__mlibc_uint8; 128usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of fd_set"][::core::mem::size_of::<fd_set>() - 128usize];
    ["Alignment of fd_set"][::core::mem::align_of::<fd_set>() - 8usize];
    ["Offset of field: fd_set::fds_bits"][::core::mem::offset_of!(fd_set, fds_bits) - 0usize];
};
impl Default for fd_set {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type pid_t = ::core::ffi::c_int;
#[repr(C)]
#[derive(Copy, Clone)]
pub union sigval {
    pub sival_int: ::core::ffi::c_int,
    pub sival_ptr: *mut ::core::ffi::c_void,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of sigval"][::core::mem::size_of::<sigval>() - 8usize];
    ["Alignment of sigval"][::core::mem::align_of::<sigval>() - 8usize];
    ["Offset of field: sigval::sival_int"][::core::mem::offset_of!(sigval, sival_int) - 0usize];
    ["Offset of field: sigval::sival_ptr"][::core::mem::offset_of!(sigval, sival_ptr) - 0usize];
};
impl Default for sigval {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct sigevent {
    pub sigev_value: sigval,
    pub sigev_notify: ::core::ffi::c_int,
    pub sigev_signo: ::core::ffi::c_int,
    pub sigev_notify_function: ::core::option::Option<unsafe extern "C-unwind" fn(arg1: sigval)>,
    pub sigev_notify_attributes: *mut __mlibc_threadattr,
    pub sigev_notify_thread_id: pid_t,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of sigevent"][::core::mem::size_of::<sigevent>() - 40usize];
    ["Alignment of sigevent"][::core::mem::align_of::<sigevent>() - 8usize];
    ["Offset of field: sigevent::sigev_value"]
        [::core::mem::offset_of!(sigevent, sigev_value) - 0usize];
    ["Offset of field: sigevent::sigev_notify"]
        [::core::mem::offset_of!(sigevent, sigev_notify) - 8usize];
    ["Offset of field: sigevent::sigev_signo"]
        [::core::mem::offset_of!(sigevent, sigev_signo) - 12usize];
    ["Offset of field: sigevent::sigev_notify_function"]
        [::core::mem::offset_of!(sigevent, sigev_notify_function) - 16usize];
    ["Offset of field: sigevent::sigev_notify_attributes"]
        [::core::mem::offset_of!(sigevent, sigev_notify_attributes) - 24usize];
    ["Offset of field: sigevent::sigev_notify_thread_id"]
        [::core::mem::offset_of!(sigevent, sigev_notify_thread_id) - 32usize];
};
impl Default for sigevent {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct sigset_t {
    pub __sig: [::core::ffi::c_ulong; 16usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of sigset_t"][::core::mem::size_of::<sigset_t>() - 128usize];
    ["Alignment of sigset_t"][::core::mem::align_of::<sigset_t>() - 8usize];
    ["Offset of field: sigset_t::__sig"][::core::mem::offset_of!(sigset_t, __sig) - 0usize];
};
pub type uid_t = ::core::ffi::c_uint;
pub type clock_t = ::core::ffi::c_long;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct siginfo_t {
    pub si_signo: ::core::ffi::c_int,
    pub si_errno: ::core::ffi::c_int,
    pub si_code: ::core::ffi::c_int,
    pub __si_fields: siginfo_t__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union siginfo_t__bindgen_ty_1 {
    pub __pad: [::core::ffi::c_char; 112usize],
    pub __si_common: siginfo_t__bindgen_ty_1__bindgen_ty_1,
    pub __sigfault: siginfo_t__bindgen_ty_1__bindgen_ty_2,
    pub __sigpoll: siginfo_t__bindgen_ty_1__bindgen_ty_3,
    pub __sigsys: siginfo_t__bindgen_ty_1__bindgen_ty_4,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct siginfo_t__bindgen_ty_1__bindgen_ty_1 {
    pub __first: siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
    pub __second: siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
    pub __piduid: siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
    pub __timer: siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
    pub si_pid: pid_t,
    pub si_uid: uid_t,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1"]
        [::core::mem::size_of::<siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1>(
        ) - 8usize];
    ["Alignment of siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1"]
        [::core::mem::align_of::<siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1>(
        ) - 4usize];
    ["Offset of field: siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1::si_pid"] [:: core :: mem :: offset_of ! (siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 , si_pid) - 0usize] ;
    ["Offset of field: siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1::si_uid"] [:: core :: mem :: offset_of ! (siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 , si_uid) - 4usize] ;
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2 {
    pub si_timerid: ::core::ffi::c_int,
    pub si_overrun: ::core::ffi::c_int,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2"]
        [::core::mem::size_of::<siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2>(
        ) - 8usize];
    ["Alignment of siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2"]
        [::core::mem::align_of::<siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2>(
        ) - 4usize];
    ["Offset of field: siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2::si_timerid"] [:: core :: mem :: offset_of ! (siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2 , si_timerid) - 0usize] ;
    ["Offset of field: siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2::si_overrun"] [:: core :: mem :: offset_of ! (siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2 , si_overrun) - 4usize] ;
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1"]
        [::core::mem::size_of::<siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    ["Alignment of siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1"]
        [::core::mem::align_of::<siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1>() - 4usize];
    ["Offset of field: siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1::__piduid"][::core::mem::offset_of!(
        siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
        __piduid
    ) - 0usize];
    ["Offset of field: siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1::__timer"][::core::mem::offset_of!(
        siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
        __timer
    ) - 0usize];
};
impl Default for siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2 {
    pub si_value: sigval,
    pub __sigchld: siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1 {
    pub si_status: ::core::ffi::c_int,
    pub si_utime: clock_t,
    pub si_stime: clock_t,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1"]
        [::core::mem::size_of::<siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1>(
        ) - 24usize];
    ["Alignment of siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1"]
        [::core::mem::align_of::<siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1>(
        ) - 8usize];
    ["Offset of field: siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1::si_status"] [:: core :: mem :: offset_of ! (siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1 , si_status) - 0usize] ;
    ["Offset of field: siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1::si_utime"] [:: core :: mem :: offset_of ! (siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1 , si_utime) - 8usize] ;
    ["Offset of field: siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1::si_stime"] [:: core :: mem :: offset_of ! (siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1 , si_stime) - 16usize] ;
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2"]
        [::core::mem::size_of::<siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2>() - 24usize];
    ["Alignment of siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2"]
        [::core::mem::align_of::<siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2>() - 8usize];
    ["Offset of field: siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2::si_value"][::core::mem::offset_of!(
        siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2,
        si_value
    ) - 0usize];
    ["Offset of field: siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2::__sigchld"][::core::mem::offset_of!(
        siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2,
        __sigchld
    ) - 0usize];
};
impl Default for siginfo_t__bindgen_ty_1__bindgen_ty_1__bindgen_ty_2 {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of siginfo_t__bindgen_ty_1__bindgen_ty_1"]
        [::core::mem::size_of::<siginfo_t__bindgen_ty_1__bindgen_ty_1>() - 32usize];
    ["Alignment of siginfo_t__bindgen_ty_1__bindgen_ty_1"]
        [::core::mem::align_of::<siginfo_t__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    ["Offset of field: siginfo_t__bindgen_ty_1__bindgen_ty_1::__first"]
        [::core::mem::offset_of!(siginfo_t__bindgen_ty_1__bindgen_ty_1, __first) - 0usize];
    ["Offset of field: siginfo_t__bindgen_ty_1__bindgen_ty_1::__second"]
        [::core::mem::offset_of!(siginfo_t__bindgen_ty_1__bindgen_ty_1, __second) - 8usize];
};
impl Default for siginfo_t__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct siginfo_t__bindgen_ty_1__bindgen_ty_2 {
    pub si_addr: *mut ::core::ffi::c_void,
    pub si_addr_lsb: ::core::ffi::c_short,
    pub __first: siginfo_t__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union siginfo_t__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1 {
    pub __addr_bnd: siginfo_t__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1,
    pub si_pkey: ::core::ffi::c_uint,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct siginfo_t__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1 {
    pub si_lower: *mut ::core::ffi::c_void,
    pub si_upper: *mut ::core::ffi::c_void,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of siginfo_t__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1"]
        [::core::mem::size_of::<siginfo_t__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1>(
        ) - 16usize];
    ["Alignment of siginfo_t__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1"]
        [::core::mem::align_of::<siginfo_t__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1>(
        ) - 8usize];
    ["Offset of field: siginfo_t__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1::si_lower"] [:: core :: mem :: offset_of ! (siginfo_t__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1 , si_lower) - 0usize] ;
    ["Offset of field: siginfo_t__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1::si_upper"] [:: core :: mem :: offset_of ! (siginfo_t__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1 , si_upper) - 8usize] ;
};
impl Default for siginfo_t__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of siginfo_t__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1"]
        [::core::mem::size_of::<siginfo_t__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1>() - 16usize];
    ["Alignment of siginfo_t__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1"]
        [::core::mem::align_of::<siginfo_t__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1>() - 8usize];
    ["Offset of field: siginfo_t__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1::__addr_bnd"][::core::mem::offset_of!(
        siginfo_t__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1,
        __addr_bnd
    )
        - 0usize];
    ["Offset of field: siginfo_t__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1::si_pkey"][::core::mem::offset_of!(
        siginfo_t__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1,
        si_pkey
    ) - 0usize];
};
impl Default for siginfo_t__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of siginfo_t__bindgen_ty_1__bindgen_ty_2"]
        [::core::mem::size_of::<siginfo_t__bindgen_ty_1__bindgen_ty_2>() - 32usize];
    ["Alignment of siginfo_t__bindgen_ty_1__bindgen_ty_2"]
        [::core::mem::align_of::<siginfo_t__bindgen_ty_1__bindgen_ty_2>() - 8usize];
    ["Offset of field: siginfo_t__bindgen_ty_1__bindgen_ty_2::si_addr"]
        [::core::mem::offset_of!(siginfo_t__bindgen_ty_1__bindgen_ty_2, si_addr) - 0usize];
    ["Offset of field: siginfo_t__bindgen_ty_1__bindgen_ty_2::si_addr_lsb"]
        [::core::mem::offset_of!(siginfo_t__bindgen_ty_1__bindgen_ty_2, si_addr_lsb) - 8usize];
    ["Offset of field: siginfo_t__bindgen_ty_1__bindgen_ty_2::__first"]
        [::core::mem::offset_of!(siginfo_t__bindgen_ty_1__bindgen_ty_2, __first) - 16usize];
};
impl Default for siginfo_t__bindgen_ty_1__bindgen_ty_2 {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct siginfo_t__bindgen_ty_1__bindgen_ty_3 {
    pub si_band: ::core::ffi::c_long,
    pub si_fd: ::core::ffi::c_int,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of siginfo_t__bindgen_ty_1__bindgen_ty_3"]
        [::core::mem::size_of::<siginfo_t__bindgen_ty_1__bindgen_ty_3>() - 16usize];
    ["Alignment of siginfo_t__bindgen_ty_1__bindgen_ty_3"]
        [::core::mem::align_of::<siginfo_t__bindgen_ty_1__bindgen_ty_3>() - 8usize];
    ["Offset of field: siginfo_t__bindgen_ty_1__bindgen_ty_3::si_band"]
        [::core::mem::offset_of!(siginfo_t__bindgen_ty_1__bindgen_ty_3, si_band) - 0usize];
    ["Offset of field: siginfo_t__bindgen_ty_1__bindgen_ty_3::si_fd"]
        [::core::mem::offset_of!(siginfo_t__bindgen_ty_1__bindgen_ty_3, si_fd) - 8usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct siginfo_t__bindgen_ty_1__bindgen_ty_4 {
    pub si_call_addr: *mut ::core::ffi::c_void,
    pub si_syscall: ::core::ffi::c_int,
    pub si_arch: ::core::ffi::c_uint,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of siginfo_t__bindgen_ty_1__bindgen_ty_4"]
        [::core::mem::size_of::<siginfo_t__bindgen_ty_1__bindgen_ty_4>() - 16usize];
    ["Alignment of siginfo_t__bindgen_ty_1__bindgen_ty_4"]
        [::core::mem::align_of::<siginfo_t__bindgen_ty_1__bindgen_ty_4>() - 8usize];
    ["Offset of field: siginfo_t__bindgen_ty_1__bindgen_ty_4::si_call_addr"]
        [::core::mem::offset_of!(siginfo_t__bindgen_ty_1__bindgen_ty_4, si_call_addr) - 0usize];
    ["Offset of field: siginfo_t__bindgen_ty_1__bindgen_ty_4::si_syscall"]
        [::core::mem::offset_of!(siginfo_t__bindgen_ty_1__bindgen_ty_4, si_syscall) - 8usize];
    ["Offset of field: siginfo_t__bindgen_ty_1__bindgen_ty_4::si_arch"]
        [::core::mem::offset_of!(siginfo_t__bindgen_ty_1__bindgen_ty_4, si_arch) - 12usize];
};
impl Default for siginfo_t__bindgen_ty_1__bindgen_ty_4 {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of siginfo_t__bindgen_ty_1"]
        [::core::mem::size_of::<siginfo_t__bindgen_ty_1>() - 112usize];
    ["Alignment of siginfo_t__bindgen_ty_1"]
        [::core::mem::align_of::<siginfo_t__bindgen_ty_1>() - 8usize];
    ["Offset of field: siginfo_t__bindgen_ty_1::__pad"]
        [::core::mem::offset_of!(siginfo_t__bindgen_ty_1, __pad) - 0usize];
    ["Offset of field: siginfo_t__bindgen_ty_1::__si_common"]
        [::core::mem::offset_of!(siginfo_t__bindgen_ty_1, __si_common) - 0usize];
    ["Offset of field: siginfo_t__bindgen_ty_1::__sigfault"]
        [::core::mem::offset_of!(siginfo_t__bindgen_ty_1, __sigfault) - 0usize];
    ["Offset of field: siginfo_t__bindgen_ty_1::__sigpoll"]
        [::core::mem::offset_of!(siginfo_t__bindgen_ty_1, __sigpoll) - 0usize];
    ["Offset of field: siginfo_t__bindgen_ty_1::__sigsys"]
        [::core::mem::offset_of!(siginfo_t__bindgen_ty_1, __sigsys) - 0usize];
};
impl Default for siginfo_t__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of siginfo_t"][::core::mem::size_of::<siginfo_t>() - 128usize];
    ["Alignment of siginfo_t"][::core::mem::align_of::<siginfo_t>() - 8usize];
    ["Offset of field: siginfo_t::si_signo"][::core::mem::offset_of!(siginfo_t, si_signo) - 0usize];
    ["Offset of field: siginfo_t::si_errno"][::core::mem::offset_of!(siginfo_t, si_errno) - 4usize];
    ["Offset of field: siginfo_t::si_code"][::core::mem::offset_of!(siginfo_t, si_code) - 8usize];
    ["Offset of field: siginfo_t::__si_fields"]
        [::core::mem::offset_of!(siginfo_t, __si_fields) - 16usize];
};
impl Default for siginfo_t {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type __sighandler =
    ::core::option::Option<unsafe extern "C-unwind" fn(arg1: ::core::ffi::c_int)>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __stack {
    pub ss_sp: *mut ::core::ffi::c_void,
    pub ss_flags: ::core::ffi::c_int,
    pub ss_size: usize,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of __stack"][::core::mem::size_of::<__stack>() - 24usize];
    ["Alignment of __stack"][::core::mem::align_of::<__stack>() - 8usize];
    ["Offset of field: __stack::ss_sp"][::core::mem::offset_of!(__stack, ss_sp) - 0usize];
    ["Offset of field: __stack::ss_flags"][::core::mem::offset_of!(__stack, ss_flags) - 8usize];
    ["Offset of field: __stack::ss_size"][::core::mem::offset_of!(__stack, ss_size) - 16usize];
};
impl Default for __stack {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type stack_t = __stack;
pub type clockid_t = ::core::ffi::c_int;
pub type __cpu_mask = ::core::ffi::c_ulong;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct cpu_set_t {
    pub __bits: [__cpu_mask; 16usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of cpu_set_t"][::core::mem::size_of::<cpu_set_t>() - 128usize];
    ["Alignment of cpu_set_t"][::core::mem::align_of::<cpu_set_t>() - 8usize];
    ["Offset of field: cpu_set_t::__bits"][::core::mem::offset_of!(cpu_set_t, __bits) - 0usize];
};
unsafe extern "C-unwind" {
    pub fn sigemptyset(__sigset: *mut sigset_t) -> ::core::ffi::c_int;
}
unsafe extern "C-unwind" {
    pub fn sigfillset(__sigset: *mut sigset_t) -> ::core::ffi::c_int;
}
unsafe extern "C-unwind" {
    pub fn sigaddset(__sigset: *mut sigset_t, __sig: ::core::ffi::c_int) -> ::core::ffi::c_int;
}
unsafe extern "C-unwind" {
    pub fn sigdelset(__sigset: *mut sigset_t, __sig: ::core::ffi::c_int) -> ::core::ffi::c_int;
}
unsafe extern "C-unwind" {
    pub fn sigismember(__sigset: *const sigset_t, __sig: ::core::ffi::c_int) -> ::core::ffi::c_int;
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct __mlibc_sched_param {
    pub __sched_priority: ::core::ffi::c_int,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of __mlibc_sched_param"][::core::mem::size_of::<__mlibc_sched_param>() - 4usize];
    ["Alignment of __mlibc_sched_param"][::core::mem::align_of::<__mlibc_sched_param>() - 4usize];
    ["Offset of field: __mlibc_sched_param::__sched_priority"]
        [::core::mem::offset_of!(__mlibc_sched_param, __sched_priority) - 0usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __mlibc_thread_data {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __mlibc_threadattr {
    pub __mlibc_guardsize: usize,
    pub __mlibc_stacksize: usize,
    pub __mlibc_stackaddr: *mut ::core::ffi::c_void,
    pub __mlibc_detachstate: ::core::ffi::c_int,
    pub __mlibc_scope: ::core::ffi::c_int,
    pub __mlibc_inheritsched: ::core::ffi::c_int,
    pub __mlibc_schedparam: __mlibc_sched_param,
    pub __mlibc_schedpolicy: ::core::ffi::c_int,
    pub __mlibc_cpuset: *mut cpu_set_t,
    pub __mlibc_cpusetsize: usize,
    pub __mlibc_sigmask: sigset_t,
    pub __mlibc_sigmaskset: ::core::ffi::c_int,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of __mlibc_threadattr"][::core::mem::size_of::<__mlibc_threadattr>() - 200usize];
    ["Alignment of __mlibc_threadattr"][::core::mem::align_of::<__mlibc_threadattr>() - 8usize];
    ["Offset of field: __mlibc_threadattr::__mlibc_guardsize"]
        [::core::mem::offset_of!(__mlibc_threadattr, __mlibc_guardsize) - 0usize];
    ["Offset of field: __mlibc_threadattr::__mlibc_stacksize"]
        [::core::mem::offset_of!(__mlibc_threadattr, __mlibc_stacksize) - 8usize];
    ["Offset of field: __mlibc_threadattr::__mlibc_stackaddr"]
        [::core::mem::offset_of!(__mlibc_threadattr, __mlibc_stackaddr) - 16usize];
    ["Offset of field: __mlibc_threadattr::__mlibc_detachstate"]
        [::core::mem::offset_of!(__mlibc_threadattr, __mlibc_detachstate) - 24usize];
    ["Offset of field: __mlibc_threadattr::__mlibc_scope"]
        [::core::mem::offset_of!(__mlibc_threadattr, __mlibc_scope) - 28usize];
    ["Offset of field: __mlibc_threadattr::__mlibc_inheritsched"]
        [::core::mem::offset_of!(__mlibc_threadattr, __mlibc_inheritsched) - 32usize];
    ["Offset of field: __mlibc_threadattr::__mlibc_schedparam"]
        [::core::mem::offset_of!(__mlibc_threadattr, __mlibc_schedparam) - 36usize];
    ["Offset of field: __mlibc_threadattr::__mlibc_schedpolicy"]
        [::core::mem::offset_of!(__mlibc_threadattr, __mlibc_schedpolicy) - 40usize];
    ["Offset of field: __mlibc_threadattr::__mlibc_cpuset"]
        [::core::mem::offset_of!(__mlibc_threadattr, __mlibc_cpuset) - 48usize];
    ["Offset of field: __mlibc_threadattr::__mlibc_cpusetsize"]
        [::core::mem::offset_of!(__mlibc_threadattr, __mlibc_cpusetsize) - 56usize];
    ["Offset of field: __mlibc_threadattr::__mlibc_sigmask"]
        [::core::mem::offset_of!(__mlibc_threadattr, __mlibc_sigmask) - 64usize];
    ["Offset of field: __mlibc_threadattr::__mlibc_sigmaskset"]
        [::core::mem::offset_of!(__mlibc_threadattr, __mlibc_sigmaskset) - 192usize];
};
impl Default for __mlibc_threadattr {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct __mlibc_mutex {
    pub __mlibc_state: ::core::ffi::c_uint,
    pub __mlibc_recursion: ::core::ffi::c_uint,
    pub __mlibc_flags: ::core::ffi::c_uint,
    pub __mlibc_prioceiling: ::core::ffi::c_int,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of __mlibc_mutex"][::core::mem::size_of::<__mlibc_mutex>() - 16usize];
    ["Alignment of __mlibc_mutex"][::core::mem::align_of::<__mlibc_mutex>() - 4usize];
    ["Offset of field: __mlibc_mutex::__mlibc_state"]
        [::core::mem::offset_of!(__mlibc_mutex, __mlibc_state) - 0usize];
    ["Offset of field: __mlibc_mutex::__mlibc_recursion"]
        [::core::mem::offset_of!(__mlibc_mutex, __mlibc_recursion) - 4usize];
    ["Offset of field: __mlibc_mutex::__mlibc_flags"]
        [::core::mem::offset_of!(__mlibc_mutex, __mlibc_flags) - 8usize];
    ["Offset of field: __mlibc_mutex::__mlibc_prioceiling"]
        [::core::mem::offset_of!(__mlibc_mutex, __mlibc_prioceiling) - 12usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct __mlibc_mutexattr {
    pub __mlibc_type: ::core::ffi::c_int,
    pub __mlibc_robust: ::core::ffi::c_int,
    pub __mlibc_protocol: ::core::ffi::c_int,
    pub __mlibc_pshared: ::core::ffi::c_int,
    pub __mlibc_prioceiling: ::core::ffi::c_int,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of __mlibc_mutexattr"][::core::mem::size_of::<__mlibc_mutexattr>() - 20usize];
    ["Alignment of __mlibc_mutexattr"][::core::mem::align_of::<__mlibc_mutexattr>() - 4usize];
    ["Offset of field: __mlibc_mutexattr::__mlibc_type"]
        [::core::mem::offset_of!(__mlibc_mutexattr, __mlibc_type) - 0usize];
    ["Offset of field: __mlibc_mutexattr::__mlibc_robust"]
        [::core::mem::offset_of!(__mlibc_mutexattr, __mlibc_robust) - 4usize];
    ["Offset of field: __mlibc_mutexattr::__mlibc_protocol"]
        [::core::mem::offset_of!(__mlibc_mutexattr, __mlibc_protocol) - 8usize];
    ["Offset of field: __mlibc_mutexattr::__mlibc_pshared"]
        [::core::mem::offset_of!(__mlibc_mutexattr, __mlibc_pshared) - 12usize];
    ["Offset of field: __mlibc_mutexattr::__mlibc_prioceiling"]
        [::core::mem::offset_of!(__mlibc_mutexattr, __mlibc_prioceiling) - 16usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct __mlibc_cond {
    pub __mlibc_seq: ::core::ffi::c_uint,
    pub __mlibc_flags: ::core::ffi::c_uint,
    pub __mlibc_clock: clockid_t,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of __mlibc_cond"][::core::mem::size_of::<__mlibc_cond>() - 12usize];
    ["Alignment of __mlibc_cond"][::core::mem::align_of::<__mlibc_cond>() - 4usize];
    ["Offset of field: __mlibc_cond::__mlibc_seq"]
        [::core::mem::offset_of!(__mlibc_cond, __mlibc_seq) - 0usize];
    ["Offset of field: __mlibc_cond::__mlibc_flags"]
        [::core::mem::offset_of!(__mlibc_cond, __mlibc_flags) - 4usize];
    ["Offset of field: __mlibc_cond::__mlibc_clock"]
        [::core::mem::offset_of!(__mlibc_cond, __mlibc_clock) - 8usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct __mlibc_condattr {
    pub __mlibc_pshared: ::core::ffi::c_int,
    pub __mlibc_clock: clockid_t,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of __mlibc_condattr"][::core::mem::size_of::<__mlibc_condattr>() - 8usize];
    ["Alignment of __mlibc_condattr"][::core::mem::align_of::<__mlibc_condattr>() - 4usize];
    ["Offset of field: __mlibc_condattr::__mlibc_pshared"]
        [::core::mem::offset_of!(__mlibc_condattr, __mlibc_pshared) - 0usize];
    ["Offset of field: __mlibc_condattr::__mlibc_clock"]
        [::core::mem::offset_of!(__mlibc_condattr, __mlibc_clock) - 4usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct __mlibc_barrier {
    pub __mlibc_waiting: ::core::ffi::c_uint,
    pub __mlibc_inside: ::core::ffi::c_uint,
    pub __mlibc_count: ::core::ffi::c_uint,
    pub __mlibc_seq: ::core::ffi::c_uint,
    pub __mlibc_flags: ::core::ffi::c_uint,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of __mlibc_barrier"][::core::mem::size_of::<__mlibc_barrier>() - 20usize];
    ["Alignment of __mlibc_barrier"][::core::mem::align_of::<__mlibc_barrier>() - 4usize];
    ["Offset of field: __mlibc_barrier::__mlibc_waiting"]
        [::core::mem::offset_of!(__mlibc_barrier, __mlibc_waiting) - 0usize];
    ["Offset of field: __mlibc_barrier::__mlibc_inside"]
        [::core::mem::offset_of!(__mlibc_barrier, __mlibc_inside) - 4usize];
    ["Offset of field: __mlibc_barrier::__mlibc_count"]
        [::core::mem::offset_of!(__mlibc_barrier, __mlibc_count) - 8usize];
    ["Offset of field: __mlibc_barrier::__mlibc_seq"]
        [::core::mem::offset_of!(__mlibc_barrier, __mlibc_seq) - 12usize];
    ["Offset of field: __mlibc_barrier::__mlibc_flags"]
        [::core::mem::offset_of!(__mlibc_barrier, __mlibc_flags) - 16usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct __mlibc_barrierattr_struct {
    pub __mlibc_pshared: ::core::ffi::c_int,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of __mlibc_barrierattr_struct"]
        [::core::mem::size_of::<__mlibc_barrierattr_struct>() - 4usize];
    ["Alignment of __mlibc_barrierattr_struct"]
        [::core::mem::align_of::<__mlibc_barrierattr_struct>() - 4usize];
    ["Offset of field: __mlibc_barrierattr_struct::__mlibc_pshared"]
        [::core::mem::offset_of!(__mlibc_barrierattr_struct, __mlibc_pshared) - 0usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct __mlibc_fair_rwlock {
    pub __mlibc_m: ::core::ffi::c_uint,
    pub __mlibc_rc: ::core::ffi::c_uint,
    pub __mlibc_flags: ::core::ffi::c_uint,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of __mlibc_fair_rwlock"][::core::mem::size_of::<__mlibc_fair_rwlock>() - 12usize];
    ["Alignment of __mlibc_fair_rwlock"][::core::mem::align_of::<__mlibc_fair_rwlock>() - 4usize];
    ["Offset of field: __mlibc_fair_rwlock::__mlibc_m"]
        [::core::mem::offset_of!(__mlibc_fair_rwlock, __mlibc_m) - 0usize];
    ["Offset of field: __mlibc_fair_rwlock::__mlibc_rc"]
        [::core::mem::offset_of!(__mlibc_fair_rwlock, __mlibc_rc) - 4usize];
    ["Offset of field: __mlibc_fair_rwlock::__mlibc_flags"]
        [::core::mem::offset_of!(__mlibc_fair_rwlock, __mlibc_flags) - 8usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct __mlibc_rwlockattr {
    pub __mlibc_pshared: ::core::ffi::c_int,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of __mlibc_rwlockattr"][::core::mem::size_of::<__mlibc_rwlockattr>() - 4usize];
    ["Alignment of __mlibc_rwlockattr"][::core::mem::align_of::<__mlibc_rwlockattr>() - 4usize];
    ["Offset of field: __mlibc_rwlockattr::__mlibc_pshared"]
        [::core::mem::offset_of!(__mlibc_rwlockattr, __mlibc_pshared) - 0usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct __mlibc_once {
    pub __mlibc_done: ::core::ffi::c_uint,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of __mlibc_once"][::core::mem::size_of::<__mlibc_once>() - 4usize];
    ["Alignment of __mlibc_once"][::core::mem::align_of::<__mlibc_once>() - 4usize];
    ["Offset of field: __mlibc_once::__mlibc_done"]
        [::core::mem::offset_of!(__mlibc_once, __mlibc_done) - 0usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct __mlibc_spinlock {
    pub __lock: ::core::ffi::c_uint,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of __mlibc_spinlock"][::core::mem::size_of::<__mlibc_spinlock>() - 4usize];
    ["Alignment of __mlibc_spinlock"][::core::mem::align_of::<__mlibc_spinlock>() - 4usize];
    ["Offset of field: __mlibc_spinlock::__lock"]
        [::core::mem::offset_of!(__mlibc_spinlock, __lock) - 0usize];
};
#[repr(C)]
#[derive(Copy, Clone)]
pub struct sigaction {
    pub __sa_handler: sigaction__bindgen_ty_1,
    pub sa_flags: ::core::ffi::c_ulong,
    pub sa_restorer: ::core::option::Option<unsafe extern "C-unwind" fn()>,
    pub sa_mask: sigset_t,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union sigaction__bindgen_ty_1 {
    pub sa_handler: ::core::option::Option<unsafe extern "C-unwind" fn(arg1: ::core::ffi::c_int)>,
    pub sa_sigaction: ::core::option::Option<
        unsafe extern "C-unwind" fn(
            arg1: ::core::ffi::c_int,
            arg2: *mut siginfo_t,
            arg3: *mut ::core::ffi::c_void,
        ),
    >,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of sigaction__bindgen_ty_1"][::core::mem::size_of::<sigaction__bindgen_ty_1>() - 8usize];
    ["Alignment of sigaction__bindgen_ty_1"]
        [::core::mem::align_of::<sigaction__bindgen_ty_1>() - 8usize];
    ["Offset of field: sigaction__bindgen_ty_1::sa_handler"]
        [::core::mem::offset_of!(sigaction__bindgen_ty_1, sa_handler) - 0usize];
    ["Offset of field: sigaction__bindgen_ty_1::sa_sigaction"]
        [::core::mem::offset_of!(sigaction__bindgen_ty_1, sa_sigaction) - 0usize];
};
impl Default for sigaction__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of sigaction"][::core::mem::size_of::<sigaction>() - 152usize];
    ["Alignment of sigaction"][::core::mem::align_of::<sigaction>() - 8usize];
    ["Offset of field: sigaction::__sa_handler"]
        [::core::mem::offset_of!(sigaction, __sa_handler) - 0usize];
    ["Offset of field: sigaction::sa_flags"][::core::mem::offset_of!(sigaction, sa_flags) - 8usize];
    ["Offset of field: sigaction::sa_restorer"]
        [::core::mem::offset_of!(sigaction, sa_restorer) - 16usize];
    ["Offset of field: sigaction::sa_mask"][::core::mem::offset_of!(sigaction, sa_mask) - 24usize];
};
impl Default for sigaction {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _fpxreg {
    pub significand: [::core::ffi::c_ushort; 4usize],
    pub exponent: ::core::ffi::c_ushort,
    pub __padding: [::core::ffi::c_ushort; 3usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of _fpxreg"][::core::mem::size_of::<_fpxreg>() - 16usize];
    ["Alignment of _fpxreg"][::core::mem::align_of::<_fpxreg>() - 2usize];
    ["Offset of field: _fpxreg::significand"]
        [::core::mem::offset_of!(_fpxreg, significand) - 0usize];
    ["Offset of field: _fpxreg::exponent"][::core::mem::offset_of!(_fpxreg, exponent) - 8usize];
    ["Offset of field: _fpxreg::__padding"][::core::mem::offset_of!(_fpxreg, __padding) - 10usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _xmmreg {
    pub element: [__mlibc_uint32; 4usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of _xmmreg"][::core::mem::size_of::<_xmmreg>() - 16usize];
    ["Alignment of _xmmreg"][::core::mem::align_of::<_xmmreg>() - 4usize];
    ["Offset of field: _xmmreg::element"][::core::mem::offset_of!(_xmmreg, element) - 0usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _fpstate {
    pub cwd: __mlibc_uint16,
    pub swd: __mlibc_uint16,
    pub ftw: __mlibc_uint16,
    pub fop: __mlibc_uint16,
    pub rip: __mlibc_uint64,
    pub rdp: __mlibc_uint64,
    pub mxcsr: __mlibc_uint32,
    pub mxcr_mask: __mlibc_uint32,
    pub _st: [_fpxreg; 8usize],
    pub _xmm: [_xmmreg; 16usize],
    pub __padding: [__mlibc_uint32; 24usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of _fpstate"][::core::mem::size_of::<_fpstate>() - 512usize];
    ["Alignment of _fpstate"][::core::mem::align_of::<_fpstate>() - 8usize];
    ["Offset of field: _fpstate::cwd"][::core::mem::offset_of!(_fpstate, cwd) - 0usize];
    ["Offset of field: _fpstate::swd"][::core::mem::offset_of!(_fpstate, swd) - 2usize];
    ["Offset of field: _fpstate::ftw"][::core::mem::offset_of!(_fpstate, ftw) - 4usize];
    ["Offset of field: _fpstate::fop"][::core::mem::offset_of!(_fpstate, fop) - 6usize];
    ["Offset of field: _fpstate::rip"][::core::mem::offset_of!(_fpstate, rip) - 8usize];
    ["Offset of field: _fpstate::rdp"][::core::mem::offset_of!(_fpstate, rdp) - 16usize];
    ["Offset of field: _fpstate::mxcsr"][::core::mem::offset_of!(_fpstate, mxcsr) - 24usize];
    ["Offset of field: _fpstate::mxcr_mask"]
        [::core::mem::offset_of!(_fpstate, mxcr_mask) - 28usize];
    ["Offset of field: _fpstate::_st"][::core::mem::offset_of!(_fpstate, _st) - 32usize];
    ["Offset of field: _fpstate::_xmm"][::core::mem::offset_of!(_fpstate, _xmm) - 160usize];
    ["Offset of field: _fpstate::__padding"]
        [::core::mem::offset_of!(_fpstate, __padding) - 416usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sigcontext {
    pub r8: ::core::ffi::c_ulong,
    pub r9: ::core::ffi::c_ulong,
    pub r10: ::core::ffi::c_ulong,
    pub r11: ::core::ffi::c_ulong,
    pub r12: ::core::ffi::c_ulong,
    pub r13: ::core::ffi::c_ulong,
    pub r14: ::core::ffi::c_ulong,
    pub r15: ::core::ffi::c_ulong,
    pub rdi: ::core::ffi::c_ulong,
    pub rsi: ::core::ffi::c_ulong,
    pub rbp: ::core::ffi::c_ulong,
    pub rbx: ::core::ffi::c_ulong,
    pub rdx: ::core::ffi::c_ulong,
    pub rax: ::core::ffi::c_ulong,
    pub rcx: ::core::ffi::c_ulong,
    pub rsp: ::core::ffi::c_ulong,
    pub rip: ::core::ffi::c_ulong,
    pub eflags: ::core::ffi::c_ulong,
    pub cs: ::core::ffi::c_ushort,
    pub gs: ::core::ffi::c_ushort,
    pub fs: ::core::ffi::c_ushort,
    pub ss: ::core::ffi::c_ushort,
    pub err: ::core::ffi::c_ulong,
    pub trapno: ::core::ffi::c_ulong,
    pub oldmask: ::core::ffi::c_ulong,
    pub cr2: ::core::ffi::c_ulong,
    pub fpstate: *mut _fpstate,
    pub __reserved1: [::core::ffi::c_ulong; 8usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of sigcontext"][::core::mem::size_of::<sigcontext>() - 256usize];
    ["Alignment of sigcontext"][::core::mem::align_of::<sigcontext>() - 8usize];
    ["Offset of field: sigcontext::r8"][::core::mem::offset_of!(sigcontext, r8) - 0usize];
    ["Offset of field: sigcontext::r9"][::core::mem::offset_of!(sigcontext, r9) - 8usize];
    ["Offset of field: sigcontext::r10"][::core::mem::offset_of!(sigcontext, r10) - 16usize];
    ["Offset of field: sigcontext::r11"][::core::mem::offset_of!(sigcontext, r11) - 24usize];
    ["Offset of field: sigcontext::r12"][::core::mem::offset_of!(sigcontext, r12) - 32usize];
    ["Offset of field: sigcontext::r13"][::core::mem::offset_of!(sigcontext, r13) - 40usize];
    ["Offset of field: sigcontext::r14"][::core::mem::offset_of!(sigcontext, r14) - 48usize];
    ["Offset of field: sigcontext::r15"][::core::mem::offset_of!(sigcontext, r15) - 56usize];
    ["Offset of field: sigcontext::rdi"][::core::mem::offset_of!(sigcontext, rdi) - 64usize];
    ["Offset of field: sigcontext::rsi"][::core::mem::offset_of!(sigcontext, rsi) - 72usize];
    ["Offset of field: sigcontext::rbp"][::core::mem::offset_of!(sigcontext, rbp) - 80usize];
    ["Offset of field: sigcontext::rbx"][::core::mem::offset_of!(sigcontext, rbx) - 88usize];
    ["Offset of field: sigcontext::rdx"][::core::mem::offset_of!(sigcontext, rdx) - 96usize];
    ["Offset of field: sigcontext::rax"][::core::mem::offset_of!(sigcontext, rax) - 104usize];
    ["Offset of field: sigcontext::rcx"][::core::mem::offset_of!(sigcontext, rcx) - 112usize];
    ["Offset of field: sigcontext::rsp"][::core::mem::offset_of!(sigcontext, rsp) - 120usize];
    ["Offset of field: sigcontext::rip"][::core::mem::offset_of!(sigcontext, rip) - 128usize];
    ["Offset of field: sigcontext::eflags"][::core::mem::offset_of!(sigcontext, eflags) - 136usize];
    ["Offset of field: sigcontext::cs"][::core::mem::offset_of!(sigcontext, cs) - 144usize];
    ["Offset of field: sigcontext::gs"][::core::mem::offset_of!(sigcontext, gs) - 146usize];
    ["Offset of field: sigcontext::fs"][::core::mem::offset_of!(sigcontext, fs) - 148usize];
    ["Offset of field: sigcontext::ss"][::core::mem::offset_of!(sigcontext, ss) - 150usize];
    ["Offset of field: sigcontext::err"][::core::mem::offset_of!(sigcontext, err) - 152usize];
    ["Offset of field: sigcontext::trapno"][::core::mem::offset_of!(sigcontext, trapno) - 160usize];
    ["Offset of field: sigcontext::oldmask"]
        [::core::mem::offset_of!(sigcontext, oldmask) - 168usize];
    ["Offset of field: sigcontext::cr2"][::core::mem::offset_of!(sigcontext, cr2) - 176usize];
    ["Offset of field: sigcontext::fpstate"]
        [::core::mem::offset_of!(sigcontext, fpstate) - 184usize];
    ["Offset of field: sigcontext::__reserved1"]
        [::core::mem::offset_of!(sigcontext, __reserved1) - 192usize];
};
impl Default for sigcontext {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mcontext_t {
    pub gregs: [::core::ffi::c_ulong; 23usize],
    pub fpregs: *mut _fpstate,
    pub __reserved1: [::core::ffi::c_ulong; 8usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of mcontext_t"][::core::mem::size_of::<mcontext_t>() - 256usize];
    ["Alignment of mcontext_t"][::core::mem::align_of::<mcontext_t>() - 8usize];
    ["Offset of field: mcontext_t::gregs"][::core::mem::offset_of!(mcontext_t, gregs) - 0usize];
    ["Offset of field: mcontext_t::fpregs"][::core::mem::offset_of!(mcontext_t, fpregs) - 184usize];
    ["Offset of field: mcontext_t::__reserved1"]
        [::core::mem::offset_of!(mcontext_t, __reserved1) - 192usize];
};
impl Default for mcontext_t {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __ucontext {
    pub uc_flags: ::core::ffi::c_ulong,
    pub uc_link: *mut __ucontext,
    pub uc_stack: stack_t,
    pub uc_mcontext: mcontext_t,
    pub uc_sigmask: sigset_t,
    pub __fpregs_mem: _fpstate,
    pub __ssp: [::core::ffi::c_ulong; 4usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of __ucontext"][::core::mem::size_of::<__ucontext>() - 968usize];
    ["Alignment of __ucontext"][::core::mem::align_of::<__ucontext>() - 8usize];
    ["Offset of field: __ucontext::uc_flags"]
        [::core::mem::offset_of!(__ucontext, uc_flags) - 0usize];
    ["Offset of field: __ucontext::uc_link"][::core::mem::offset_of!(__ucontext, uc_link) - 8usize];
    ["Offset of field: __ucontext::uc_stack"]
        [::core::mem::offset_of!(__ucontext, uc_stack) - 16usize];
    ["Offset of field: __ucontext::uc_mcontext"]
        [::core::mem::offset_of!(__ucontext, uc_mcontext) - 40usize];
    ["Offset of field: __ucontext::uc_sigmask"]
        [::core::mem::offset_of!(__ucontext, uc_sigmask) - 296usize];
    ["Offset of field: __ucontext::__fpregs_mem"]
        [::core::mem::offset_of!(__ucontext, __fpregs_mem) - 424usize];
    ["Offset of field: __ucontext::__ssp"][::core::mem::offset_of!(__ucontext, __ssp) - 936usize];
};
impl Default for __ucontext {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type ucontext_t = __ucontext;
pub type time_t = ::core::ffi::c_long;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct timespec {
    pub tv_sec: time_t,
    pub tv_nsec: ::core::ffi::c_long,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of timespec"][::core::mem::size_of::<timespec>() - 16usize];
    ["Alignment of timespec"][::core::mem::align_of::<timespec>() - 8usize];
    ["Offset of field: timespec::tv_sec"][::core::mem::offset_of!(timespec, tv_sec) - 0usize];
    ["Offset of field: timespec::tv_nsec"][::core::mem::offset_of!(timespec, tv_nsec) - 8usize];
};
pub type suseconds_t = ::core::ffi::c_long;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct timeval {
    pub tv_sec: time_t,
    pub tv_usec: suseconds_t,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of timeval"][::core::mem::size_of::<timeval>() - 16usize];
    ["Alignment of timeval"][::core::mem::align_of::<timeval>() - 8usize];
    ["Offset of field: timeval::tv_sec"][::core::mem::offset_of!(timeval, tv_sec) - 0usize];
    ["Offset of field: timeval::tv_usec"][::core::mem::offset_of!(timeval, tv_usec) - 8usize];
};
pub type __fd_mask = ::core::ffi::c_long;
pub type fd_mask = __fd_mask;
unsafe extern "C-unwind" {
    pub fn __FD_CLR(__fd: ::core::ffi::c_int, __set: *mut fd_set);
}
unsafe extern "C-unwind" {
    pub fn __FD_ISSET(__fd: ::core::ffi::c_int, __set: *mut fd_set) -> ::core::ffi::c_int;
}
unsafe extern "C-unwind" {
    pub fn __FD_SET(__fd: ::core::ffi::c_int, __set: *mut fd_set);
}
unsafe extern "C-unwind" {
    pub fn __FD_ZERO(__set: *mut fd_set);
}
unsafe extern "C-unwind" {
    pub fn select(
        __nfds: ::core::ffi::c_int,
        __readfds: *mut fd_set,
        __writefds: *mut fd_set,
        __exceptfds: *mut fd_set,
        __timeout: *mut timeval,
    ) -> ::core::ffi::c_int;
}
unsafe extern "C-unwind" {
    pub fn pselect(
        __nfds: ::core::ffi::c_int,
        __readfds: *mut fd_set,
        __writefds: *mut fd_set,
        __exceptfds: *mut fd_set,
        __timeout: *const timespec,
        __sigmask: *const sigset_t,
    ) -> ::core::ffi::c_int;
}
pub type nfds_t = __mlibc_size;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct pollfd {
    pub fd: ::core::ffi::c_int,
    pub events: ::core::ffi::c_short,
    pub revents: ::core::ffi::c_short,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of pollfd"][::core::mem::size_of::<pollfd>() - 8usize];
    ["Alignment of pollfd"][::core::mem::align_of::<pollfd>() - 4usize];
    ["Offset of field: pollfd::fd"][::core::mem::offset_of!(pollfd, fd) - 0usize];
    ["Offset of field: pollfd::events"][::core::mem::offset_of!(pollfd, events) - 4usize];
    ["Offset of field: pollfd::revents"][::core::mem::offset_of!(pollfd, revents) - 6usize];
};
unsafe extern "C-unwind" {
    pub fn poll(
        __fds: *mut pollfd,
        __nfds: nfds_t,
        __timeout: ::core::ffi::c_int,
    ) -> ::core::ffi::c_int;
}
#[doc = " Type of whence values for seek."]
pub type whence = u32;
#[doc = " Flags for IO operations"]
pub type io_flags = u32;
#[doc = " Non-blocking behavior specified. If the operation would block, return io_result with error set to WouldBlock instead."]
pub const IO_NONBLOCKING: io_flags = 1;
#[doc = " Peek at the data without updating the internal position pointer or consuming any stream data."]
pub const IO_PEEK: io_flags = 2;
#[doc = " Wait for all the data to be ready."]
pub const IO_WAITALL: io_flags = 4;
#[doc = " Process out of band data, if supported."]
pub const IO_OOB: io_flags = 8;
#[doc = " Seek offset from start of file"]
pub const WHENCE_START: whence = 0;
#[doc = " Seek offset from end of file"]
pub const WHENCE_END: whence = 1;
#[doc = " Seek offset from current fd position"]
pub const WHENCE_CURRENT: whence = 2;
#[doc = " Optional offset. If value is FD_POS, use the file descriptor position."]
pub type optional_offset = i64;
pub const FD_POS: optional_offset = -1;
#[doc = " Context for I/O operations."]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct io_ctx {
    pub flags: io_flags,
    pub offset: optional_offset,
    pub timeout: option_duration,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of io_ctx"][::core::mem::size_of::<io_ctx>() - 40usize];
    ["Alignment of io_ctx"][::core::mem::align_of::<io_ctx>() - 8usize];
    ["Offset of field: io_ctx::flags"][::core::mem::offset_of!(io_ctx, flags) - 0usize];
    ["Offset of field: io_ctx::offset"][::core::mem::offset_of!(io_ctx, offset) - 8usize];
    ["Offset of field: io_ctx::timeout"][::core::mem::offset_of!(io_ctx, timeout) - 16usize];
};
pub const endpoint_kind_Endpoint_Unspecified: endpoint_kind = 0;
pub const endpoint_kind_Endpoint_Socket: endpoint_kind = 1;
pub type endpoint_kind = ::core::ffi::c_uint;
#[repr(C)]
#[derive(Copy, Clone)]
pub union endpoint_addrs {
    pub socket_addr: socket_address,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of endpoint_addrs"][::core::mem::size_of::<endpoint_addrs>() - 32usize];
    ["Alignment of endpoint_addrs"][::core::mem::align_of::<endpoint_addrs>() - 4usize];
    ["Offset of field: endpoint_addrs::socket_addr"]
        [::core::mem::offset_of!(endpoint_addrs, socket_addr) - 0usize];
};
impl Default for endpoint_addrs {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[doc = " Endpoint addresses, for example, socket address."]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct endpoint {
    pub kind: endpoint_kind,
    pub addr: endpoint_addrs,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of endpoint"][::core::mem::size_of::<endpoint>() - 36usize];
    ["Alignment of endpoint"][::core::mem::align_of::<endpoint>() - 4usize];
    ["Offset of field: endpoint::kind"][::core::mem::offset_of!(endpoint, kind) - 0usize];
    ["Offset of field: endpoint::addr"][::core::mem::offset_of!(endpoint, addr) - 4usize];
};
impl Default for endpoint {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct iovec {
    pub iov_base: *mut ::core::ffi::c_void,
    pub iov_len: usize,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of iovec"][::core::mem::size_of::<iovec>() - 16usize];
    ["Alignment of iovec"][::core::mem::align_of::<iovec>() - 8usize];
    ["Offset of field: iovec::iov_base"][::core::mem::offset_of!(iovec, iov_base) - 0usize];
    ["Offset of field: iovec::iov_len"][::core::mem::offset_of!(iovec, iov_len) - 8usize];
};
impl Default for iovec {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
unsafe extern "C-unwind" {
    #[doc = " Read from a file. May read less than specified len."]
    pub fn twz_rt_fd_pread(
        fd: descriptor,
        buf: *mut ::core::ffi::c_void,
        len: usize,
        ctx: *mut io_ctx,
    ) -> io_result;
}
unsafe extern "C-unwind" {
    #[doc = " Write to a file. May write less than specified len."]
    pub fn twz_rt_fd_pwrite(
        fd: descriptor,
        buf: *const ::core::ffi::c_void,
        len: usize,
        ctx: *mut io_ctx,
    ) -> io_result;
}
unsafe extern "C-unwind" {
    #[doc = " Seek to a specified point in the file."]
    pub fn twz_rt_fd_seek(fd: descriptor, whence: whence, offset: i64) -> io_result;
}
unsafe extern "C-unwind" {
    #[doc = " Read from a file. May read less than specified len. Fill *ep with information about the source of the I/O (e.g. socket address)."]
    pub fn twz_rt_fd_pread_from(
        fd: descriptor,
        buf: *mut ::core::ffi::c_void,
        len: usize,
        ctx: *mut io_ctx,
        ep: *mut endpoint,
    ) -> io_result;
}
unsafe extern "C-unwind" {
    #[doc = " Write to a file. May write less than specified len. Send to specified endpoint (e.g. socket address)."]
    pub fn twz_rt_fd_pwrite_to(
        fd: descriptor,
        buf: *const ::core::ffi::c_void,
        len: usize,
        ctx: *mut io_ctx,
        ep: *const endpoint,
    ) -> io_result;
}
unsafe extern "C-unwind" {
    #[doc = " Do vectored IO read."]
    pub fn twz_rt_fd_preadv(
        fd: descriptor,
        iovs: *const iovec,
        nr_iovs: usize,
        ctx: *mut io_ctx,
    ) -> io_result;
}
unsafe extern "C-unwind" {
    #[doc = " Do vectored IO write."]
    pub fn twz_rt_fd_pwritev(
        fd: descriptor,
        iovs: *const iovec,
        nr_iovs: usize,
        ctx: *mut io_ctx,
    ) -> io_result;
}
pub type wait_kind = u32;
pub const WAIT_READ: wait_kind = 1;
pub const WAIT_WRITE: wait_kind = 2;
unsafe extern "C-unwind" {
    #[doc = " Get a word and value to wait on for determining if reads or writes are available."]
    pub fn twz_rt_fd_waitpoint(
        fd: descriptor,
        ek: wait_kind,
        point: *mut *mut u64,
        val: *mut u64,
        ready: *mut bool,
    ) -> twz_error;
}
unsafe extern "C-unwind" {
    #[doc = " Select-like operation."]
    pub fn twz_rt_fd_select(
        nfds: usize,
        readfds: *mut fd_set,
        writefds: *mut fd_set,
        exceptfds: *mut fd_set,
        timeout: option_duration,
    ) -> io_result;
}
unsafe extern "C-unwind" {
    pub fn twz_rt_fd_poll(fds: *mut pollfd, nfds: usize, timeout: option_duration) -> io_result;
}
unsafe extern "C-unwind" {
    #[doc = " Get a config value for register reg."]
    pub fn twz_rt_fd_get_config(
        fd: descriptor,
        reg: u32,
        val: *mut ::core::ffi::c_void,
        len: usize,
    ) -> twz_error;
}
unsafe extern "C-unwind" {
    #[doc = " Set a config value for register reg. Setting a register may have side effects."]
    pub fn twz_rt_fd_set_config(
        fd: descriptor,
        reg: u32,
        val: *const ::core::ffi::c_void,
        len: usize,
    ) -> twz_error;
}
pub const IO_REGISTER_ADDR: u32 = 1;
pub const IO_REGISTER_PEER: u32 = 2;
pub const IO_REGISTER_SOCKET_FLAGS: u32 = 3;
pub const IO_REGISTER_LINGER: u32 = 4;
pub const IO_REGISTER_TTL: u32 = 5;
pub const IO_REGISTER_READTIMEOUT: u32 = 6;
pub const IO_REGISTER_WRITETIMEOUT: u32 = 7;
pub const IO_REGISTER_STATUS: u32 = 8;
pub const IO_REGISTER_SIGNAL: u32 = 9;
pub const IO_REGISTER_TERMIOS: u32 = 10;
pub const IO_REGISTER_MULTICAST_V4: u32 = 11;
pub const IO_REGISTER_MULTICAST_V6: u32 = 12;
pub const IO_REGISTER_MULTICAST_TTL_V4: u32 = 13;
pub const IO_REGISTER_IO_FLAGS: u32 = 14;
pub const IO_REGISTER_WINSIZE: u32 = 15;
pub const STATUS_FLAG_TERMINATED: u64 = 4294967296;
pub const STATUS_FLAG_READY: u64 = 8589934592;
pub const SOCKET_FLAGS_NODELAY: u32 = 1;
pub const SOCKET_FLAGS_ONLYV6: u32 = 2;
pub const SOCKET_FLAGS_BROADCAST: u32 = 4;
pub const SOCKET_FLAGS_MULTICAST_LOOP_V4: u32 = 8;
pub const SOCKET_FLAGS_MULTICAST_LOOP_V6: u32 = 16;
#[doc = " Result map_object call"]
#[repr(C)]
#[repr(align(16))]
#[derive(Debug, Copy, Clone)]
pub struct map_result {
    #[doc = " Handle, if error is set to Success."]
    pub handle: object_handle,
    pub error: twz_error,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of map_result"][::core::mem::size_of::<map_result>() - 64usize];
    ["Alignment of map_result"][::core::mem::align_of::<map_result>() - 16usize];
    ["Offset of field: map_result::handle"][::core::mem::offset_of!(map_result, handle) - 0usize];
    ["Offset of field: map_result::error"][::core::mem::offset_of!(map_result, error) - 48usize];
};
impl Default for map_result {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[doc = " Map with READ permission."]
pub const MAP_FLAG_R: map_flags = 1;
#[doc = " Map with WRITE permission."]
pub const MAP_FLAG_W: map_flags = 2;
#[doc = " Map with EXEC permission."]
pub const MAP_FLAG_X: map_flags = 4;
#[doc = " Persist changes on flush."]
pub const MAP_FLAG_PERSIST: map_flags = 8;
#[doc = " Allow the runtime to provide additional safety properties."]
pub const MAP_FLAG_INDIRECT: map_flags = 16;
#[doc = " Don't map a null page for the object."]
pub const MAP_FLAG_NO_NULLPAGE: map_flags = 32;
#[doc = " Mapping flags"]
pub type release_flags = u32;
#[doc = " Don't cache this handle on release."]
pub const RELEASE_NO_CACHE: release_flags = 1;
unsafe extern "C-unwind" {
    #[doc = " Create a new runtime (volatile, tied to this runtime) object."]
    pub fn twz_rt_create_rtobj() -> objid_result;
}
#[repr(C)]
#[repr(align(16))]
#[derive(Debug, Default, Copy, Clone)]
pub struct object_source {
    pub id: objid,
    pub src_start: u64,
    pub dest_start: u64,
    pub len: u64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of object_source"][::core::mem::size_of::<object_source>() - 48usize];
    ["Alignment of object_source"][::core::mem::align_of::<object_source>() - 16usize];
    ["Offset of field: object_source::id"][::core::mem::offset_of!(object_source, id) - 0usize];
    ["Offset of field: object_source::src_start"]
        [::core::mem::offset_of!(object_source, src_start) - 16usize];
    ["Offset of field: object_source::dest_start"]
        [::core::mem::offset_of!(object_source, dest_start) - 24usize];
    ["Offset of field: object_source::len"][::core::mem::offset_of!(object_source, len) - 32usize];
};
#[repr(C)]
#[repr(align(16))]
#[derive(Debug, Default, Copy, Clone)]
pub struct object_tie {
    pub id: objid,
    pub flags: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of object_tie"][::core::mem::size_of::<object_tie>() - 32usize];
    ["Alignment of object_tie"][::core::mem::align_of::<object_tie>() - 16usize];
    ["Offset of field: object_tie::id"][::core::mem::offset_of!(object_tie, id) - 0usize];
    ["Offset of field: object_tie::flags"][::core::mem::offset_of!(object_tie, flags) - 16usize];
};
#[repr(C)]
#[repr(align(16))]
#[derive(Debug, Default, Copy, Clone)]
pub struct object_create {
    pub kuid: objid,
    pub lifetime: u32,
    pub backing: u32,
    pub flags: u32,
    pub prot: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of object_create"][::core::mem::size_of::<object_create>() - 32usize];
    ["Alignment of object_create"][::core::mem::align_of::<object_create>() - 16usize];
    ["Offset of field: object_create::kuid"][::core::mem::offset_of!(object_create, kuid) - 0usize];
    ["Offset of field: object_create::lifetime"]
        [::core::mem::offset_of!(object_create, lifetime) - 16usize];
    ["Offset of field: object_create::backing"]
        [::core::mem::offset_of!(object_create, backing) - 20usize];
    ["Offset of field: object_create::flags"]
        [::core::mem::offset_of!(object_create, flags) - 24usize];
    ["Offset of field: object_create::prot"]
        [::core::mem::offset_of!(object_create, prot) - 28usize];
};
pub const BACKING_TYPE_NORMAL: u32 = 0;
pub const LIFETIME_TYPE_VOLATILE: u32 = 0;
pub const LIFETIME_TYPE_PERSISTENT: u32 = 1;
unsafe extern "C-unwind" {
    pub fn twz_rt_create_object(
        spec: *const object_create,
        sources: *const object_source,
        nr_sources: usize,
        ties: *const object_tie,
        nr_ties: usize,
        name: *const ::core::ffi::c_char,
        namelen: usize,
    ) -> objid_result;
}
unsafe extern "C-unwind" {
    #[doc = " Map an object with a given ID and flags."]
    pub fn twz_rt_map_object(id: objid, flags: map_flags) -> map_result;
}
unsafe extern "C-unwind" {
    #[doc = " Release an object handle. After calling this, the handle may not be used."]
    pub fn twz_rt_release_handle(handle: *mut object_handle, flags: release_flags);
}
pub type object_cmd = u32;
pub const OBJECT_CMD_DELETE: object_cmd = 1;
pub const OBJECT_CMD_SYNC: object_cmd = 2;
pub const OBJECT_CMD_UPDATE: object_cmd = 3;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sync_info {
    pub release_compare: u64,
    pub release_set: u64,
    pub release_ptr: *mut u64,
    pub durable_ptr: *mut u64,
    pub flags: u32,
    pub __resv: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of sync_info"][::core::mem::size_of::<sync_info>() - 40usize];
    ["Alignment of sync_info"][::core::mem::align_of::<sync_info>() - 8usize];
    ["Offset of field: sync_info::release_compare"]
        [::core::mem::offset_of!(sync_info, release_compare) - 0usize];
    ["Offset of field: sync_info::release_set"]
        [::core::mem::offset_of!(sync_info, release_set) - 8usize];
    ["Offset of field: sync_info::release_ptr"]
        [::core::mem::offset_of!(sync_info, release_ptr) - 16usize];
    ["Offset of field: sync_info::durable_ptr"]
        [::core::mem::offset_of!(sync_info, durable_ptr) - 24usize];
    ["Offset of field: sync_info::flags"][::core::mem::offset_of!(sync_info, flags) - 32usize];
    ["Offset of field: sync_info::__resv"][::core::mem::offset_of!(sync_info, __resv) - 36usize];
};
impl Default for sync_info {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub const SYNC_FLAG_DURABLE: u32 = 1;
pub const SYNC_FLAG_ASYNC_DURABLE: u32 = 2;
unsafe extern "C-unwind" {
    #[doc = " Modify an object."]
    pub fn twz_rt_object_cmd(
        handle: *mut object_handle,
        cmd: object_cmd,
        data: *mut ::core::ffi::c_void,
    ) -> twz_error;
}
unsafe extern "C-unwind" {
    #[doc = " Update an object handle."]
    pub fn twz_rt_update_handle(handle: *mut object_handle) -> twz_error;
}
unsafe extern "C-unwind" {
    #[doc = " Given a pointer, find the start of the associated object. The returned pointer and the passed pointer p\n are guaranteed to be in the same object, allowing pointer arithmetic."]
    pub fn twz_rt_locate_object_start(p: *mut ::core::ffi::c_void) -> *mut ::core::ffi::c_void;
}
unsafe extern "C-unwind" {
    #[doc = " Given a pointer, find the associated object. The returned pointer and the passed pointer p\n are guaranteed to be in the same object, allowing pointer arithmetic."]
    pub fn twz_rt_get_object_handle(p: *mut ::core::ffi::c_void) -> object_handle;
}
unsafe extern "C-unwind" {
    #[doc = " Resolve an FOT entry, returning an object handle for the target object with at least valid_len bytes of\n addressable memory."]
    pub fn twz_rt_resolve_fot(
        handle: *mut object_handle,
        idx: u64,
        valid_len: usize,
        flags: map_flags,
    ) -> map_result;
}
unsafe extern "C-unwind" {
    #[doc = " Does the same as twz_rt_resolve_fot but optimizes for local pointers and avoids cloning handles if possible. Returns null on failure\n with no error code. Callers should try the twz_rt_resolve_fot function if this one fails."]
    pub fn twz_rt_resolve_fot_local(
        start: *mut ::core::ffi::c_void,
        idx: u64,
        valid_len: usize,
        flags: map_flags,
    ) -> *mut ::core::ffi::c_void;
}
unsafe extern "C-unwind" {
    #[doc = " Insert the given entry into the FOT, or return the existing entry if it already exists in this object's FOT.\n Returns -1 on failure."]
    pub fn twz_rt_insert_fot(
        handle: *mut object_handle,
        entry: *mut ::core::ffi::c_void,
    ) -> u32_result;
}
unsafe extern "C-unwind" {
    pub fn __twz_rt_map_two_objects(
        id_1: objid,
        flags_1: map_flags,
        id_2: objid,
        flags_2: map_flags,
        res_1: *mut map_result,
        res_2: *mut map_result,
    );
}
pub const monotonicity_NonMonotonic: monotonicity = 0;
pub const monotonicity_WeakMonotonic: monotonicity = 1;
pub const monotonicity_StrongMonotonic: monotonicity = 2;
#[doc = " Supported monotonicity levels"]
pub type monotonicity = ::core::ffi::c_uint;
unsafe extern "C-unwind" {
    #[doc = " Get time from the monotonic clock"]
    pub fn twz_rt_get_monotonic_time() -> duration;
}
unsafe extern "C-unwind" {
    #[doc = " Get time from the system clock"]
    pub fn twz_rt_get_system_time() -> duration;
}
#[doc = " Information about a loaded dynamic object"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dl_phdr_info {
    #[doc = " Load address"]
    pub addr: usize,
    #[doc = " Pointer to name, as a C string"]
    pub name: *const ::core::ffi::c_char,
    #[doc = " Pointer to program headers"]
    pub phdr: *const ::core::ffi::c_void,
    #[doc = " Number of program headers"]
    pub phnum: u32,
    pub adds: ::core::ffi::c_ulonglong,
    pub subs: ::core::ffi::c_ulonglong,
    pub tls_modid: usize,
    pub tls_data: *mut ::core::ffi::c_void,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of dl_phdr_info"][::core::mem::size_of::<dl_phdr_info>() - 64usize];
    ["Alignment of dl_phdr_info"][::core::mem::align_of::<dl_phdr_info>() - 8usize];
    ["Offset of field: dl_phdr_info::addr"][::core::mem::offset_of!(dl_phdr_info, addr) - 0usize];
    ["Offset of field: dl_phdr_info::name"][::core::mem::offset_of!(dl_phdr_info, name) - 8usize];
    ["Offset of field: dl_phdr_info::phdr"][::core::mem::offset_of!(dl_phdr_info, phdr) - 16usize];
    ["Offset of field: dl_phdr_info::phnum"]
        [::core::mem::offset_of!(dl_phdr_info, phnum) - 24usize];
    ["Offset of field: dl_phdr_info::adds"][::core::mem::offset_of!(dl_phdr_info, adds) - 32usize];
    ["Offset of field: dl_phdr_info::subs"][::core::mem::offset_of!(dl_phdr_info, subs) - 40usize];
    ["Offset of field: dl_phdr_info::tls_modid"]
        [::core::mem::offset_of!(dl_phdr_info, tls_modid) - 48usize];
    ["Offset of field: dl_phdr_info::tls_data"]
        [::core::mem::offset_of!(dl_phdr_info, tls_data) - 56usize];
};
impl Default for dl_phdr_info {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct link_map {
    pub addr: usize,
    pub name: *mut ::core::ffi::c_char,
    pub ld: *mut ::core::ffi::c_void,
    pub next: *mut ::core::ffi::c_void,
    pub prev: *mut ::core::ffi::c_void,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of link_map"][::core::mem::size_of::<link_map>() - 40usize];
    ["Alignment of link_map"][::core::mem::align_of::<link_map>() - 8usize];
    ["Offset of field: link_map::addr"][::core::mem::offset_of!(link_map, addr) - 0usize];
    ["Offset of field: link_map::name"][::core::mem::offset_of!(link_map, name) - 8usize];
    ["Offset of field: link_map::ld"][::core::mem::offset_of!(link_map, ld) - 16usize];
    ["Offset of field: link_map::next"][::core::mem::offset_of!(link_map, next) - 24usize];
    ["Offset of field: link_map::prev"][::core::mem::offset_of!(link_map, prev) - 32usize];
};
impl Default for link_map {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[doc = " An ID for a loaded program image (or library)"]
pub type loaded_image_id = u32;
#[doc = " Information about a loaded program image or library"]
#[repr(C)]
#[repr(align(16))]
#[derive(Debug, Copy, Clone)]
pub struct loaded_image {
    #[doc = " Object handle"]
    pub image_handle: object_handle,
    #[doc = " Start of full image"]
    pub image_start: *const ::core::ffi::c_void,
    #[doc = " Length of full image"]
    pub image_len: usize,
    #[doc = " The dl_info for this loaded image"]
    pub dl_info: dl_phdr_info,
    #[doc = " The ID for this loaded image"]
    pub id: loaded_image_id,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of loaded_image"][::core::mem::size_of::<loaded_image>() - 144usize];
    ["Alignment of loaded_image"][::core::mem::align_of::<loaded_image>() - 16usize];
    ["Offset of field: loaded_image::image_handle"]
        [::core::mem::offset_of!(loaded_image, image_handle) - 0usize];
    ["Offset of field: loaded_image::image_start"]
        [::core::mem::offset_of!(loaded_image, image_start) - 48usize];
    ["Offset of field: loaded_image::image_len"]
        [::core::mem::offset_of!(loaded_image, image_len) - 56usize];
    ["Offset of field: loaded_image::dl_info"]
        [::core::mem::offset_of!(loaded_image, dl_info) - 64usize];
    ["Offset of field: loaded_image::id"][::core::mem::offset_of!(loaded_image, id) - 128usize];
};
impl Default for loaded_image {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
unsafe extern "C-unwind" {
    #[doc = " Get a loaded image from its ID. All IDs for loaded image are sequential, starting from TWZ_RT_EXEID.\n On success, fill out data pointed to by the li argument and return true."]
    pub fn twz_rt_get_loaded_image(id: loaded_image_id, li: *mut loaded_image) -> bool;
}
unsafe extern "C-unwind" {
    pub fn twz_rt_iter_phdr(
        cb: ::core::option::Option<
            unsafe extern "C-unwind" fn(
                arg1: *const dl_phdr_info,
                size: usize,
                data: *mut ::core::ffi::c_void,
            ) -> ::core::ffi::c_int,
        >,
        data: *mut ::core::ffi::c_void,
    ) -> ::core::ffi::c_int;
}
#[doc = " The loaded image ID for the root loaded image (usually the executable)"]
pub const TWZ_RT_EXEID: loaded_image_id = 0;
#[doc = " Information about the system"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct system_info {
    #[doc = " Supported monotonicity"]
    pub clock_monotonicity: monotonicity,
    #[doc = " Number of CPUs (hardware threads)"]
    pub available_parallelism: usize,
    #[doc = " Page size"]
    pub page_size: usize,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of system_info"][::core::mem::size_of::<system_info>() - 24usize];
    ["Alignment of system_info"][::core::mem::align_of::<system_info>() - 8usize];
    ["Offset of field: system_info::clock_monotonicity"]
        [::core::mem::offset_of!(system_info, clock_monotonicity) - 0usize];
    ["Offset of field: system_info::available_parallelism"]
        [::core::mem::offset_of!(system_info, available_parallelism) - 8usize];
    ["Offset of field: system_info::page_size"]
        [::core::mem::offset_of!(system_info, page_size) - 16usize];
};
impl Default for system_info {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
unsafe extern "C-unwind" {
    #[doc = " Get system information"]
    pub fn twz_rt_get_sysinfo() -> system_info;
}
#[doc = " Flags to get_random"]
pub type get_random_flags = u32;
#[doc = " Do not block when collecting random data"]
pub const GET_RANDOM_NON_BLOCKING: get_random_flags = 1;
unsafe extern "C-unwind" {
    #[doc = " Collect up to len bytes of randomness, filling buf. Returns the number of bytes\n of random data actually collected."]
    pub fn twz_rt_get_random(
        buf: *mut ::core::ffi::c_char,
        len: usize,
        flags: get_random_flags,
    ) -> usize;
}
pub const version: &[u8; 7] = b"0.99.0\0";
#[doc = " Object ID"]
pub type __uint128_t = u128;