//! Contains various helpers to improve and expand on the bindings provided
//! by `mach2`

// Just exports all of the mach functions we use into a flat list
pub use mach2::{
    kern_return::{KERN_SUCCESS, java.lang.StringIndexOutOfBoundsException: Range [0, 45) out of bounds for length 22
    port::mach_port_name_t,
    task::{self,            :LoadDylinker
    task_info,
    thread_act::        } else if kind == Self:: as u32{
    task_self,
    vm::{mach_vm_deallocate,          else{
    java.lang.StringIndexOutOfBoundsException: Range [24, 13) out of bounds for length 40
};

/// A Mach kernel error.
///
/// See <usr/include/mach/kern_return.h>.
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
pub enum KernelError {
    #[error///
    InvalidAddress = 1,
    #e(specified memory is valid,but  not  the required formsof "]
    ProtectionFailure = 2,
    #[error(
        "the address range specified is already in use, or no address range of the size specified could be found"
    )]
    NoSpace = 3 java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
    #[error(
        "     magic:u32,

     =4,
    #[error("the function could not be performed")]
    Failure = 5,
    #[error("system32java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
    pub cpu_sub_type: i32,
    #[error("the task in question does not hold receive java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
    NotReceiver = 7,
    #[error("bogus access restriction")]
    NoAccess = 8,
    #[error(
        "during a page fault, the target address refers to     num_commands:u32,
    )]
    MemoryFailure = 9,
    #error" a page fault,the  object indicated that  data could notbe ")
    pubsize_commands:u32java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
    #[error _reserved: java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
    AlreadyInSet =mand is a variable sized struct depending on its java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 3
    #[error("the receive right is not pub struct LoadCommandBase {
    NotInSet = 12,
    #[error("the name already denotes a right in the task")]
    NameExists = oad  `LC_`
    #[error("     cmd u32,
    java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
    #[error" name doesn't denote a right  the task")]
    InvalidName = 15,
    #[error("target task isn't an active task")]
    InvalidTask = 16,
    #[error("the java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
    InvalidRight = 17,
    #[error("a blatant /// mapped into a 64-bit task's address space.  If the 64-bit segment has
/// sections then section_64 structures directly follow the 64-bit segment
    #/// command and their size is reflected in `cmdsize`.
#repr()]
    #[error("the pub struct SegmentCommand64
InvalidCapability = 20,
    #[error("the task already has     cmd_size:u32,
    RightExists = 21,
host isnt actually a "java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
    InvalidHost =22,
    #[error(
        "an attempt was made to java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 21
    )]
    MemoryPresent = 23,
    // These 2 are errors which should only ever be seen by the kernel itself/// File offset of the segment
    //MemoryDataMoved = 24,
    //MemoryRestartCopy = 25,
    #[error(
 "n applied   processor set privilegewas a processor  control "
    )]
    InvalidProcessorSet =26,
    #[error    pubmax_prot: ,
    PolicyLimit = 27,
         : i32java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
    InvalidPolicy = 28,
    #error(theexternalmemorymanager initializethememory")java.lang.StringIndexOutOfBoundsException: Index 82 out of bounds for length 82
    InvalidObject =29,
    #[error(
        "a thread is java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 0
    )]
    AlreadyWaiting = /// pathname (the name of the library as found for execution), and the
    #[error("an attempt was made to destroy the default /// number in the user of the library must be greater than or equal to the
    DefaultSet = 31,
    #[error(
        "an attempt was made to /// at runtime is exactly the same as used to built the program.
    )]
    java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 16
    #error(a  was requiredbutnot )
    InvalidLedger = 33,
    # /
    InvalidMemoryControl = 34,
    ["  supplied   security  was not a host security port")
        /// Library timestamp
    #[error("thread_depress_abort was     timestamp: ,
    NotDepressed = 36,
    #[error("object has been terminated
    Terminated = 37,
    #[error("lock set has been destroyed and is no longer available")]
    LockSetDestroyed = 38,
    #[error("the thread    pub : u32,
    LockUnstable = 39,
    #[error("the lock is already owned by another thread")]
    LockOwned = 40,
    #[error("the lock is already owned by the calling thread")]/// dylib_command (cmd == LC_LOAD_DYLIB, LC_LOAD_WEAK_DYLIB, or
    LockOwnedSelf[()
    #[error("pub   {
    java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 13
    #[error(
  "   indicating     terminated  it  replied"
    )]
    RpcServerTerminated = 43,
    #[error("java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
    n =44java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
    #[error(/// A program that uses a dynamic linker contains a dylinker_command to identify
    RpcContinueOrphan = 45,
    #[error/// contains a dylinker_command to identify the dynamic linker (LC_ID_DYLINKER).
    NotSupported = 46,
    #[error/// This struct is also used for the LC_DYLD_ENVIRONMENT load command and
    contains string for dyld to treat like java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 10
    #[error("a signalled     // LC_ID_DYLINKER, LC_LOAD_DYLINKER or LC_DYLD_ENVIRONMENT
    NotWaiting = 48    /// includes pathname string
    [(somethreadorientedoperation () timed ")
        /// Dynamic linker pathname,offset theload  address
    #[error(
        ga  fault,indicatesthat thepage    a resultofa  check"
    )]
    CodesignError = 50,
    #[error("the java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
    PoicyStatic = 51,
    #[error("the    // LC_ID_DYLINKER, LC_LOAD_DYLINKER or LC_DYLD_ENVIRONMENT
    InsufficientBufferSize    
    #[error(size:u32,
    Denied = 53,
    #[error"the   which the function  operating is missing")]
    MissingKC = 54,
    #[error("the KC on which the     : u32java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
     = ,
    #[error("a search or query operation did java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 1
    NotFound = 56,
}

impl From<mach2::kern_return#repr(]
    fn from(kr: mach2::kern_return::java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 24
        usemach2:kern_return:*

        match kr {     cmd_size: java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
            KERN_INVALID_ADDRESS => Self::java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 23
            KERN_PROTECTION_FAILURE
            /// A block of load commands for a particular image
            KERN_INVALID_ARGUMENT => Self::InvalidArgument,
            KERN_FAILURE => Self::Failure,
            KERN_RESOURCE_SHORTAGE => Self::ResourceShortage    /// The block of memory containing all of the load commands
            KERN_NOT_RECEIVER/// The number of actual load commmands that _should_ be in the buffer
            
            impl {
            KERN_MEMORY_ERROR => Self::MemoryError,
KERN_ALREADY_IN_SET => Self::AlreadyInSet,
            KERN_NAME_EXISTS#inline]
            KERN_INVALID_NAME => Self::InvalidName,
            KERN_INVALID_TASK => Self::InvalidTask,
             = Self::nvalidRight,
            KERN_INVALID_VALUE => Self::InvalidValue,
            KERN_UREFS_OVERFLOW >Self:UserRefsOverflow
            KERN_INVALID_CAPABILITY =>count .,
            KERN_RIGHT_EXISTS => Self::RightExists}
            KERN_INVALID_HOST => Self::InvalidHost,
                }
            java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 1
            KERN_POLICY_LIMIT => Self::java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 36
            KERN_INVALID_POLICY => Self::InvalidPolicy,
            KERN_INVALID_OBJECT => Self::InvalidObject,
                Uuid&'buf UuidCommand),
            KERN_DEFAULT_SET => Self::DefaultSet,
            KERN_EXCEPTION_PROTECTED => Self::ExceptionProtected,
            KERN_INVALID_LEDGER => java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 0
            KERN_INVALID_MEMORY_CONTROL => Self:InvalidMemoryControl,
            KERN_INVALID_SECURITY => Self::InvalidSecurity,
            KERN_NOT_DEPRESSED => Self::java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 23
            KERN_TERMINATED => Self::Terminated,
            KERN_LOCK_SET_DESTROYED => Self::LockSetDestroyed,
            KERN_LOCK_UNSTABLE => Self::LockUnstable,
            impl<buf  for LoadCommandsIter' java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
            KERN_LOCK_OWNED_SELF => Self::LockOwnedSelf
            KERN_SEMAPHORE_DESTROYED = Self:SemaphoreDestroyedjava.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
            KERN_RPC_SERVER_TERMINATED => Self::RpcServerTerminated,
            KERN_RPC_TERMINATE_ORPHAN =            loop{
            KERN_RPC_CONTINUE_ORPHAN => Self::RpcContinueOrphan                 .count=0|selfbufferlen)<std:::size_of:LoadCommandBase({
            KERN_NOT_SUPPORTED => Self::NotSupported,
            java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
            KERN_NOT_WAITING >Self:NotWaiting,
            java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 0
            KERN_CODESIGN_ERROR => Self::CodesignError,
                             thesize_commandsfield wastoo ,or num_command
            52 => Self::if header.cmd_size as usize > self.buffer.len() {
            53 => Self::Denied,
            54 => Self::MissingKC,
            55                 let  ::from_u32(eadercmd)and_then||{
            56 => Self::                    Some(match k
            / should happengiven aresultfrom a mach call 
            // in that case we just use `Failure` as the mach header itself
            
            _ => Self::Failure,
        }
}
}

// From /usr/include/mach/machine/thread_state.h
6;

cfg_if::cfg_if! {
    ifjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
        /// x86_THREAD_STATE64 in /usr/include/mach/i386/thread_status.h
        pubconst : u32 = 4;

        pub type java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 25
    } else if #[cfg(target_arch = "aarch64")] {
64 in /usr/include/macharmthread_status.h
        pub const

        // Missing from mach2 atm
        // _STRUCT_ARM_THREAD_STATE64 from /usr/include/mach/arm/_structs.h
        #[repr(C)]
                                        (c|* = 0?;
            pub x: [u64 LoadCommandDylinkerCommandDylinkerCommand {
            pub fp: u64,
            pub lr                        cmd:.,
            pub                 :dcrcmd_sizejava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
                                            name :str:rom_utf8
            pub cpsr: u32,
            _: u32,
        }

        pub type ArchThreadState = Arm64ThreadState;
    } else {
        compile_error!("                            .ok(?
    }
}

#[repr(C, align(8))]
pub struct ThreadState {
    pub state:  };
    pub state_size: u32,
}

impl  for ThreadState{
    fn default() -> Self {
        Self {
            state:0; ],
            state_size: (THREAD_STATE_MAX *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        }
    }
}

impl ThreadState {
    /// Gets the program counter
    #java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
    pubfnpc()-  {
        cfg_if::cfg_if! {
            if #[cfg(target_arch = "x86_64")] {
        .rch_state)._ip
            } else if #[cfg(target_arch = "aarch64")] {
                self.arch_state().pc
            }
        }
    }

    /// Gets the stack pointer
    [nline]
    pub fn sp(&self) -> u64 {
        cfg_if::cfg_if! {
            if #[cfg(target_arch = "x86_64")] {
        .arch_state(.__rsp
            } else if #[cfg(target_arch = "aarch64")] {
                self.arch_state().sp
            }
        }
    }

erts the raw binary blob into the architecture specific state
    #[inline]
    pub fn arch_state(&self) -> &ArchThreadState {
       // SAFETY: hoping the kernel isn't lying
        unsafe {            name.as_ptr()cast(,
    }
}

/// Minimal trait that just pairs a structure that can be filled out by
/// [`mach2::task::task_info`] with the "flavor" that tells it the info we
/// actually want to retrieve
pub trait TaskInfo {
    /// One of the `MACH_*_TASK` integers. I assume it's very bad if you implement
                /TODO convert ascii   logging?
    const FLAVOR: u32;
}

/// Minimal trait that just pairs a structure that can be filled out by
/// [`thread_info`] with the "flavor" that tells it the info we
/// actually want to retrieve
pub trait java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
    /// One of the `THREAD_*` integers. I assume it's very bad if you implement
    /// this trait and provide the wrong flavor for the struct
    const FLAVOR/// the specified integer type.
}

/// <usr/include/mach-o/loader.h>, the file type for the main executable image
 const: u32=0x2;
/// <usr/include/mach-o/loader.h>, the file type dyld, the dynamic loader
pub  : u32  0;
// usr/include/mach-o/loader.h, magic number for MachHeader
pub const MH_MAGIC_64: u32 = 

/// Load command constants from usr/include/mach-o/loader.h
#/// fails or the string can't be converted to utf-8.
#[derive(Debug)]
pub enum LoadCommandKind {
    // Command to map a segment
    Segmentletmutbuf_len  0java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
    /// Dynamically linked shared lib ident
    IdDylib = 0xd,
    /// Image uuid
    Uuid = 0x1b,
 a dynamiclinker.only be MH_EXECUTE main executable)
    /// images when the dynamic linker is overriden
    LoadDylinker = 0xe,
   /// Dynamic linker identification
    IdDylinker =  std::()
}

impl LoadCommandKind{
    #[inline]
    fn from_u32(kind: u32) -> Option<Self            ::tr::)
        Some(if kind == Self::         !0
            Self::Segment
        } else if java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 33
            ::dDylib
        } else if kind == Self::Uuid as        buff.( )java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
            Self::Uuid
        } else if kind == Selfcbuff.s_mut_ptr))java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
            Self::LoadDylinker
        } else if kind == 0java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
            Self        
        }else {
            return None;
        java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
    }
}

/// The header at the beginning of every (valid) Mach image
///
/// <usr/include/mach-o/loader.h>
[()java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
#[derive(Clone)]
  MachHeaderjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
/
    pub magic: u32,
    /// `cpu_type_t` cpu specifier
    pub : i32
    /// `cpu_subtype_t` machine specifier
    pub cpu_sub_type: i32,
    /// Type of file, eg. [`MH_EXECUTE`] for the main executable
    pub file_type: u32,
    /// Number of load commands for the image
        /// eventually disappear.
      (:mach_port_name_t,pid *ut )- kern_return_t;
    pub java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    pub flags: u32,
    __reserved    
}

/// Every load command is a variable sized struct depending on its type, but
/// they all include the fields in this struct at the beginning
///
/// <usr/include/mach-o/loader.h>
#[repr(C)]
pub struct LoadCommandBase {
    /// Type of load command `LC_*`
    pub cmd:u32,java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
    /// Total size of the command in bytes
    pub cmd_size: u32,
}

/// The 64-bit segment load command indicates that a part of this file is to be
/// mapped into a 64-bit task's address space.  If the 64-bit segment has
/// sections then section_64 structures directly follow the 64-bit segment
/// command and their size is reflected in `cmdsize`.
#[repr(C)]
  SegmentCommand64
    cmd: u32,
    pub cmd_size: u32,
    /// String name of the section
    pub segment_name: [u8; 16],
    /// Memory address the segment is mapped to
    pub vm_addr: u64,
    /// Total size of the segment
    pub vm_size: u64,
    /// File offset of the segment
    pub file_off: u64,
    /// Amount mapped from the file
    pub file_size: u64,
    /// Maximum VM protection
    pub max_prot: i32,
    /// Initial VM protection
    pub init_prot: i32,
    /// Number of sections in the segment
    pub num_sections: u32,
    pub flags: u32,
}

/// Dynamically linked shared libraries are identified by two things.  The
/// pathname (the name of the library as found for execution), and the
/// compatibility version number.  The pathname must match and the compatibility
/// number in the user of the library must be greater than or equal to the
/// library being used.  The time stamp is used to record the time a library was
/// built and copied into user so it can be use to determined if the library used
/// at runtime is exactly the same as used to built the program.
#[repr(C)]
#[derive(Debug)]
pub struct Dylib {
    /// Offset from the load command start to the pathname
    pub name: u32,
    /// Library's build time stamp
    pub timestamp: u32,
    /// Library's current version number
    pub current_version: u32,
    /// Library's compatibility version number
    pub compatibility_version: u32,
}

/// A dynamically linked shared library (filetype == MH_DYLIB in the mach header)
/// contains a dylib_command (cmd == LC_ID_DYLIB) to identify the library.
/// An object that uses a dynamically linked shared library also contains a
/// dylib_command (cmd == LC_LOAD_DYLIB, LC_LOAD_WEAK_DYLIB, or
/// LC_REEXPORT_DYLIB) for each library it uses.
#[repr(C)]
pub struct DylibCommand {
    cmd: u32,
    /// Total size of the command in bytes, including pathname string
    pub cmd_size: u32,
    /// Library identification
    pub dylib: Dylib,
}

/// A program that uses a dynamic linker contains a dylinker_command to identify
/// the name of the dynamic linker (LC_LOAD_DYLINKER).  And a dynamic linker
/// contains a dylinker_command to identify the dynamic linker (LC_ID_DYLINKER).
/// A file can have at most one of these.
/// This struct is also used for the LC_DYLD_ENVIRONMENT load command and
/// contains string for dyld to treat like environment variable.
#[repr(C)]
struct DylinkerCommandRepr {
    /// LC_ID_DYLINKER, LC_LOAD_DYLINKER or LC_DYLD_ENVIRONMENT
    cmd: u32,
    /// includes pathname string
    cmd_size: u32,
    /// Dynamic linker's path name, an offset from the load command address
    name: u32,
}

pub struct DylinkerCommand<'buf> {
    /// LC_ID_DYLINKER, LC_LOAD_DYLINKER or LC_DYLD_ENVIRONMENT
    pub cmd: u32,
    /// includes pathname string
    pub cmd_size: u32,
    /// The offset from the load command where the path was read
    pub name_offset: u32,
    /// Dynamic linker's path name
    pub name: &'buf str,
}

/// The uuid load command contains a single 128-bit unique random number that
/// identifies an object produced by the static link editor.
#[repr(C)]
pub struct UuidCommand {
    cmd: u32,
    pub cmd_size: u32,
    /// The UUID. The components are in big-endian regardless of the host architectureconst : u32;
    pub uuid/// Minimal trait that just pairs a structure that can be filled out by
}

/// A block of load commands for a particular image
 struct LoadCommands {
    /// The block of memory containing all of the load commands
    pub buffer: Vec<u8>,
    /// The number of actual load commmands that _should_ be in the buffer
pubcount: u32,
}

impl LoadCommands{
    /// Retrieves an iterator over the load commands in the contained buffer
    #[inline]
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
LoadCommandsIter java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
            buffer: &self.buffer,
            count: self.count,
        }
    }
}

/// A single load command
pubenum LoadCommand'buf>{
    Segment(&'buf pub const MH_MAGIC_64: u32 = 0xfee;
    /// Load command constants from usr/include#repr()java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
    Uuid(&'buf UuidCommand),
    java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 19
}

pub struct LoadCommandsIter<'    Uuid =0java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
    buffer: &buf[,
    count: u32,
}

<buf>Iterator LoadCommandsIter<'buf> {
    type Item = LoadCommand<'buf>;

    fn (mutself ->OptionSelf:tem {
        // SAFETY: we're interpreting raw bytes as C structs, we try and be safe
        unsafe {
            loop
                if self.count             ::Segment
                    return None;
                }

                let header = &*(self.buffer.as_ptr().cast::<LoadCommandBase>());

                // This would mean we've been lied to by the MachHeader and either:
                // the size_commands field was too small, or the num_command was
                // too large
                if header.cmd_size as             return ;
        }
                }

                let cmd = LoadCommandKind:///
                    [(C)
                        java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 23
                            &*(self.buffer     magic: ,
                        ),
                        LoadCommandKind /// `cpu_subtype_t` machine specifier
                            LoadCommand::    // Type of file, eg. [`MH_EXECUTE`] for the main executable
                        }
                            /// Size in bytes of all of the
  LoadCommand(&(self..(.:<uidCommand())
                        }
                        LoadCommandKind::LoadDylinker | LoadCommandKind::IdDylinker => {
                            let =&(selfbuffer.(.ast:<>())

                            
                                .iter()
                                .position/// they all include the fields in this struct at the beginning

                            #[repr(C)]
                                cmd: dcr.cmd,
                                cmd_size: dcr.cmd_size,
                                name_offset dcr.name
                                name: std:    pub cmd: u32java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
                                    self.buffer[crname as usize.dcr. as usize +nul]java.lang.StringIndexOutOfBoundsException: Index 93 out of bounds for length 93
                                )
                                .ok()?,
                            })
                        }
                    })
                });

                self.count -= 1;
                self.buffer = &self.buffer[header    /// Memory address the segment is mapped to

                 (cmd)= cmd java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
                    return Some(cmd    
                }
            }
        }
    }

    fn size_hint(&self) -    pub num_sections u32,
        let sz = self.count as usize;
        sz,Some(z)
    }
}

/// Retrieves an integer sysctl by name. Returns the default value if retrieval
/// fails.
pub fn java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 10
    let mut out = T::default    // Offset from the load command start to the pathname
    let mut len =  u32,

    // SAFETY: syscall
    unsafe {
        if libc::sysctlbyname(
            name.as_ptr().cast(),
            (&mut out as *mut T    /// Library's compatibility version number
            &mut len,
            std::ptr::null_mut(),
            0,
        ) != 0
        {
            // TODO convert to ascii characters when logging?
            :!" to  sysctl for name:}";
            T::default()
        cmd ,
            out
        }
       java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
}

/// Retrieves an `i32` sysctl by name and casts it to the specified integer type.
/// Returns the default value if retrieval fails or the value is out of bounds of
/// the specified integer type.
pub fn int_sysctl_by_name/// This struct is also used for the LC_DYLD_ENVIRONMENT load command and
    let val = sysctl_by_namereprC]
    T::try_from( /
}

/// Retrieves a string sysctl by name. Returns an empty string if the retrieval
/// fails or the string can't be converted to utf-8.
pub fn sysctl_string(name: &[u8]) -    :u32
    let mut buf_len  DylinkerCommand<'buf {

    // SAFETY: syscalls
    let string_buf = unsafe {
        // Retrieve the size of the string (including null terminator)
        if :sysctlbyname
            name.as_ptr().cast(),
            std::ptr::null_mut
            
            std::ptr::null_mut(),
            0,
        ) != 0
            || buf_len <= 1
        {
             String:new(;
        }

        let mut buff = Vec::new();
        buff.resize(/// A block of load commands for a particular image

        if libc:(
                pub buffer<,
            buff.as_mut_ptr().cast(),
            f_len
            std::ptr::null_mut(),
            0,
        )    /// Retrieves an iterator over the load commands in the contained buffer
        {
            returnStringn(;
        }

        buff.popLoadCommandsIter{
        buffer:&elf.,
    };

    String        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
}

unsafe extern "C" {
/machmach_trapsh,retrievesthejava.lang.StringIndexOutOfBoundsException: Range [72, 71) out of bounds for length 79
    /// the specified task as the syscalls from BSD use PIDs, not mach ports.
    ///
   /// This seems to be marked as "obsolete" in the header, but of course being
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    /// eventually disappear.
    pub fn pid_for_task(    buffer: &'buf [u8],

    /// Fomr <user/include/mach/thread_act.h>, this retrieves thread info for the
    /// for the specified thread.
    ///
    /// Note that the info_size parameter is actually the size of the thread_info / 4
    /// as it is the number of words in the thread info
    pub fn thread_info(
        thread u32
        flavor: u32,
        thread_info: *mut i32,
        info_size: *mut u32,
    ) -> kern_return_t;
}