### FUNC 00105cb8 (26 bytes) name=_init

int _init(EVP_PKEY_CTX *ctx)

{
  int iVar1;
  
  iVar1 = 0;
  if (PTR___gmon_start___0033ef98 != (undefined *)0x0) {
    iVar1 = __gmon_start__();
  }
  return iVar1;
}


==================================================================

### FUNC 00105ce0 (12 bytes) name=FUN_00105ce0

void FUN_00105ce0(void)

{
  (*(code *)PTR_0033f010)();
  return;
}


==================================================================

### FUNC 00105cf0 (6 bytes) name=exp

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

double exp(double __x)

{
  double dVar1;
  
  dVar1 = (double)(*(code *)PTR_exp_0033f018)();
  return dVar1;
}


==================================================================

### FUNC 00105d00 (6 bytes) name=pthread_getspecific

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

void * pthread_getspecific(pthread_key_t __key)

{
  void *pvVar1;
  
  pvVar1 = (void *)(*(code *)PTR_pthread_getspecific_0033f020)();
  return pvVar1;
}


==================================================================

### FUNC 00105d10 (6 bytes) name=pthread_cond_destroy

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int pthread_cond_destroy(pthread_cond_t *__cond)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_pthread_cond_destroy_0033f028)();
  return iVar1;
}


==================================================================

### FUNC 00105d20 (6 bytes) name=libusb_cancel_transfer

void libusb_cancel_transfer(void)

{
  (*(code *)PTR_libusb_cancel_transfer_0033f030)();
  return;
}


==================================================================

### FUNC 00105d30 (6 bytes) name=libusb_get_device_address

void libusb_get_device_address(void)

{
  (*(code *)PTR_libusb_get_device_address_0033f038)();
  return;
}


==================================================================

### FUNC 00105d40 (6 bytes) name=memset

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

void * memset(void *__s,int __c,size_t __n)

{
  void *pvVar1;
  
  pvVar1 = (void *)(*(code *)PTR_memset_0033f040)();
  return pvVar1;
}


==================================================================

### FUNC 00105d50 (6 bytes) name=ftell

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

long ftell(FILE *__stream)

{
  long lVar1;
  
  lVar1 = (*(code *)PTR_ftell_0033f048)();
  return lVar1;
}


==================================================================

### FUNC 00105d60 (6 bytes) name=libusb_close

void libusb_close(void)

{
  (*(code *)PTR_libusb_close_0033f050)();
  return;
}


==================================================================

### FUNC 00105d70 (6 bytes) name=libusb_get_active_config_descriptor

void libusb_get_active_config_descriptor(void)

{
  (*(code *)PTR_libusb_get_active_config_descriptor_0033f058)();
  return;
}


==================================================================

### FUNC 00105d80 (6 bytes) name=libusb_unref_device

void libusb_unref_device(void)

{
  (*(code *)PTR_libusb_unref_device_0033f060)();
  return;
}


==================================================================

### FUNC 00105d90 (6 bytes) name=close

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int close(int __fd)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_close_0033f068)();
  return iVar1;
}


==================================================================

### FUNC 00105da0 (6 bytes) name=libusb_unlock_event_waiters

void libusb_unlock_event_waiters(void)

{
  (*(code *)PTR_libusb_unlock_event_waiters_0033f070)();
  return;
}


==================================================================

### FUNC 00105db0 (6 bytes) name=libusb_open

void libusb_open(void)

{
  (*(code *)PTR_libusb_open_0033f078)();
  return;
}


==================================================================

### FUNC 00105dc0 (6 bytes) name=MAG_Free

void MAG_Free(void)

{
  (*(code *)PTR_MAG_Free_0033f080)();
  return;
}


==================================================================

### FUNC 00105dd0 (6 bytes) name=ioctl

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int ioctl(int __fd,ulong __request,...)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_ioctl_0033f088)();
  return iVar1;
}


==================================================================

### FUNC 00105de0 (6 bytes) name=libusb_claim_interface

void libusb_claim_interface(void)

{
  (*(code *)PTR_libusb_claim_interface_0033f090)();
  return;
}


==================================================================

### FUNC 00105df0 (6 bytes) name=pthread_setspecific

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int pthread_setspecific(pthread_key_t __key,void *__pointer)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_pthread_setspecific_0033f098)();
  return iVar1;
}


==================================================================

### FUNC 00105e00 (6 bytes) name=libusb_alloc_transfer

void libusb_alloc_transfer(void)

{
  (*(code *)PTR_libusb_alloc_transfer_0033f0a0)();
  return;
}


==================================================================

### FUNC 00105e10 (6 bytes) name=libusb_set_configuration

void libusb_set_configuration(void)

{
  (*(code *)PTR_libusb_set_configuration_0033f0a8)();
  return;
}


==================================================================

### FUNC 00105e20 (6 bytes) name=__gmon_start__

void __gmon_start__(void)

{
  (*(code *)PTR___gmon_start___0033f0b0)();
  return;
}


==================================================================

### FUNC 00105e30 (6 bytes) name=recvmsg

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

ssize_t recvmsg(int __fd,msghdr *__message,int __flags)

{
  ssize_t sVar1;
  
  sVar1 = (*(code *)PTR_recvmsg_0033f0b8)();
  return sVar1;
}


==================================================================

### FUNC 00105e40 (6 bytes) name=operator.new[]

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

void * operator_new__(ulong param_1)

{
  void *pvVar1;
  
  pvVar1 = (void *)(*(code *)PTR_operator_new___0033f0c0)();
  return pvVar1;
}


==================================================================

### FUNC 00105e50 (6 bytes) name=uname

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int uname(utsname *__name)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_uname_0033f0c8)();
  return iVar1;
}


==================================================================

### FUNC 00105e60 (6 bytes) name=fseek

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int fseek(FILE *__stream,long __off,int __whence)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_fseek_0033f0d0)();
  return iVar1;
}


==================================================================

### FUNC 00105e70 (6 bytes) name=pthread_cond_signal

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int pthread_cond_signal(pthread_cond_t *__cond)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_pthread_cond_signal_0033f0d8)();
  return iVar1;
}


==================================================================

### FUNC 00105e80 (6 bytes) name=operator.delete

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

void operator_delete(void *param_1)

{
  (*(code *)PTR_operator_delete_0033f0e0)();
  return;
}


==================================================================

### FUNC 00105e90 (6 bytes) name=_M_dispose

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

void std::string::_Rep::_M_dispose(allocator *param_1)

{
  (*(code *)PTR__M_dispose_0033f0e8)();
  return;
}


==================================================================

### FUNC 00105ea0 (6 bytes) name=pthread_mutexattr_destroy

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int pthread_mutexattr_destroy(pthread_mutexattr_t *__attr)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_pthread_mutexattr_destroy_0033f0f0)();
  return iVar1;
}


==================================================================

### FUNC 00105eb0 (6 bytes) name=libusb_free_device_list

void libusb_free_device_list(void)

{
  (*(code *)PTR_libusb_free_device_list_0033f0f8)();
  return;
}


==================================================================

### FUNC 00105ec0 (6 bytes) name=__assert_fail

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

void __assert_fail(char *__assertion,char *__file,uint __line,char *__function)

{
  (*(code *)PTR___assert_fail_0033f100)();
  return;
}


==================================================================

### FUNC 00105ed0 (6 bytes) name=__printf_chk

void __printf_chk(void)

{
  (*(code *)PTR___printf_chk_0033f108)();
  return;
}


==================================================================

### FUNC 00105ee0 (6 bytes) name=gettimeofday

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int gettimeofday(timeval *__tv,__timezone_ptr_t __tz)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_gettimeofday_0033f110)();
  return iVar1;
}


==================================================================

### FUNC 00105ef0 (6 bytes) name=MAG_GetRectTemperatureInfo

void MAG_GetRectTemperatureInfo(void)

{
  (*(code *)PTR_MAG_GetRectTemperatureInfo_0033f118)();
  return;
}


==================================================================

### FUNC 00105f00 (6 bytes) name=libusb_get_device_list

void libusb_get_device_list(void)

{
  (*(code *)PTR_libusb_get_device_list_0033f120)();
  return;
}


==================================================================

### FUNC 00105f10 (6 bytes) name=Init

void __thiscall std::ios_base::Init::Init(Init *this)

{
  (*(code *)PTR_Init_0033f128)();
  return;
}


==================================================================

### FUNC 00105f20 (6 bytes) name=MAG_GetCamInfo

void MAG_GetCamInfo(void)

{
  (*(code *)PTR_MAG_GetCamInfo_0033f130)();
  return;
}


==================================================================

### FUNC 00105f30 (6 bytes) name=read

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

ssize_t read(int __fd,void *__buf,size_t __nbytes)

{
  ssize_t sVar1;
  
  sVar1 = (*(code *)PTR_read_0033f138)();
  return sVar1;
}


==================================================================

### FUNC 00105f40 (6 bytes) name=strncmp

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int strncmp(char *__s1,char *__s2,size_t __n)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_strncmp_0033f140)();
  return iVar1;
}


==================================================================

### FUNC 00105f50 (6 bytes) name=malloc

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

void * malloc(size_t __size)

{
  void *pvVar1;
  
  pvVar1 = (void *)(*(code *)PTR_malloc_0033f148)();
  return pvVar1;
}


==================================================================

### FUNC 00105f60 (6 bytes) name=fopen

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

FILE * fopen(char *__filename,char *__modes)

{
  FILE *pFVar1;
  
  pFVar1 = (FILE *)(*(code *)PTR_fopen_0033f150)();
  return pFVar1;
}


==================================================================

### FUNC 00105f70 (6 bytes) name=libusb_control_transfer

void libusb_control_transfer(void)

{
  (*(code *)PTR_libusb_control_transfer_0033f158)();
  return;
}


==================================================================

### FUNC 00105f80 (6 bytes) name=pthread_cond_timedwait

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int pthread_cond_timedwait(pthread_cond_t *__cond,pthread_mutex_t *__mutex,timespec *__abstime)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_pthread_cond_timedwait_0033f160)();
  return iVar1;
}


==================================================================

### FUNC 00105f90 (6 bytes) name=__memcpy_chk

void __memcpy_chk(void)

{
  (*(code *)PTR___memcpy_chk_0033f168)();
  return;
}


==================================================================

### FUNC 00105fa0 (6 bytes) name=libusb_get_config_descriptor

void libusb_get_config_descriptor(void)

{
  (*(code *)PTR_libusb_get_config_descriptor_0033f170)();
  return;
}


==================================================================

### FUNC 00105fb0 (6 bytes) name=__cxa_atexit

void __cxa_atexit(void)

{
  (*(code *)PTR___cxa_atexit_0033f178)();
  return;
}


==================================================================

### FUNC 00105fc0 (6 bytes) name=libusb_try_lock_events

void libusb_try_lock_events(void)

{
  (*(code *)PTR_libusb_try_lock_events_0033f180)();
  return;
}


==================================================================

### FUNC 00105fd0 (6 bytes) name=setsockopt

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int setsockopt(int __fd,int __level,int __optname,void *__optval,socklen_t __optlen)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_setsockopt_0033f188)();
  return iVar1;
}


==================================================================

### FUNC 00105fe0 (6 bytes) name=MAG_StopProcessImage

void MAG_StopProcessImage(void)

{
  (*(code *)PTR_MAG_StopProcessImage_0033f190)();
  return;
}


==================================================================

### FUNC 00105ff0 (6 bytes) name=pthread_mutex_init

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int pthread_mutex_init(pthread_mutex_t *__mutex,pthread_mutexattr_t *__mutexattr)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_pthread_mutex_init_0033f198)();
  return iVar1;
}


==================================================================

### FUNC 00106000 (6 bytes) name=fgets

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

char * fgets(char *__s,int __n,FILE *__stream)

{
  char *pcVar1;
  
  pcVar1 = (char *)(*(code *)PTR_fgets_0033f1a0)();
  return pcVar1;
}


==================================================================

### FUNC 00106010 (6 bytes) name=__vsnprintf_chk

void __vsnprintf_chk(void)

{
  (*(code *)PTR___vsnprintf_chk_0033f1a8)();
  return;
}


==================================================================

### FUNC 00106020 (6 bytes) name=libusb_handle_events_timeout_completed

void libusb_handle_events_timeout_completed(void)

{
  (*(code *)PTR_libusb_handle_events_timeout_completed_0033f1b0)();
  return;
}


==================================================================

### FUNC 00106030 (6 bytes) name=pthread_attr_destroy

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int pthread_attr_destroy(pthread_attr_t *__attr)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_pthread_attr_destroy_0033f1b8)();
  return iVar1;
}


==================================================================

### FUNC 00106040 (6 bytes) name=libusb_has_capability

void libusb_has_capability(void)

{
  (*(code *)PTR_libusb_has_capability_0033f1c0)();
  return;
}


==================================================================

### FUNC 00106050 (6 bytes) name=getpwuid

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

passwd * getpwuid(__uid_t __uid)

{
  passwd *ppVar1;
  
  ppVar1 = (passwd *)(*(code *)PTR_getpwuid_0033f1c8)();
  return ppVar1;
}


==================================================================

### FUNC 00106060 (6 bytes) name=operator<<

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

ostream * std::operator<<(ostream *param_1,char *param_2)

{
  ostream *poVar1;
  
  poVar1 = (ostream *)(*(code *)PTR_operator<<_0033f1d0)();
  return poVar1;
}


==================================================================

### FUNC 00106070 (6 bytes) name=__strdup

void __strdup(void)

{
  (*(code *)PTR___strdup_0033f1d8)();
  return;
}


==================================================================

### FUNC 00106080 (6 bytes) name=free

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

void free(void *__ptr)

{
  (*(code *)PTR_free_0033f1e0)();
  return;
}


==================================================================

### FUNC 00106090 (6 bytes) name=libusb_get_bus_number

void libusb_get_bus_number(void)

{
  (*(code *)PTR_libusb_get_bus_number_0033f1e8)();
  return;
}


==================================================================

### FUNC 001060a0 (6 bytes) name=strlen

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

size_t strlen(char *__s)

{
  size_t sVar1;
  
  sVar1 = (*(code *)PTR_strlen_0033f1f0)();
  return sVar1;
}


==================================================================

### FUNC 001060b0 (6 bytes) name=libusb_free_config_descriptor

void libusb_free_config_descriptor(void)

{
  (*(code *)PTR_libusb_free_config_descriptor_0033f1f8)();
  return;
}


==================================================================

### FUNC 001060c0 (6 bytes) name=_M_destroy

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

void std::string::_Rep::_M_destroy(allocator *param_1)

{
  (*(code *)PTR__M_destroy_0033f200)();
  return;
}


==================================================================

### FUNC 001060d0 (6 bytes) name=__asprintf_chk

void __asprintf_chk(void)

{
  (*(code *)PTR___asprintf_chk_0033f208)();
  return;
}


==================================================================

### FUNC 001060e0 (6 bytes) name=pthread_create

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int pthread_create(pthread_t *__newthread,pthread_attr_t *__attr,__start_routine *__start_routine,
                  void *__arg)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_pthread_create_0033f210)();
  return iVar1;
}


==================================================================

### FUNC 001060f0 (6 bytes) name=opendir

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

DIR * opendir(char *__name)

{
  DIR *pDVar1;
  
  pDVar1 = (DIR *)(*(code *)PTR_opendir_0033f218)();
  return pDVar1;
}


==================================================================

### FUNC 00106100 (6 bytes) name=__xstat

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int __xstat(int __ver,char *__filename,stat *__stat_buf)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR___xstat_0033f220)();
  return iVar1;
}


==================================================================

### FUNC 00106110 (6 bytes) name=pthread_cond_init

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int pthread_cond_init(pthread_cond_t *__cond,pthread_condattr_t *__cond_attr)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_pthread_cond_init_0033f228)();
  return iVar1;
}


==================================================================

### FUNC 00106120 (6 bytes) name=libusb_submit_transfer

void libusb_submit_transfer(void)

{
  (*(code *)PTR_libusb_submit_transfer_0033f230)();
  return;
}


==================================================================

### FUNC 00106130 (6 bytes) name=__ctype_b_loc

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

ushort ** __ctype_b_loc(void)

{
  ushort **ppuVar1;
  
  ppuVar1 = (ushort **)(*(code *)PTR___ctype_b_loc_0033f238)();
  return ppuVar1;
}


==================================================================

### FUNC 00106140 (6 bytes) name=__cxa_finalize

void __cxa_finalize(void)

{
  (*(code *)PTR___cxa_finalize_0033f240)();
  return;
}


==================================================================

### FUNC 00106150 (6 bytes) name=libusb_event_handler_active

void libusb_event_handler_active(void)

{
  (*(code *)PTR_libusb_event_handler_active_0033f248)();
  return;
}


==================================================================

### FUNC 00106160 (6 bytes) name=pthread_key_delete

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int pthread_key_delete(pthread_key_t __key)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_pthread_key_delete_0033f250)();
  return iVar1;
}


==================================================================

### FUNC 00106170 (6 bytes) name=readdir

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

dirent * readdir(DIR *__dirp)

{
  dirent *pdVar1;
  
  pdVar1 = (dirent *)(*(code *)PTR_readdir_0033f258)();
  return pdVar1;
}


==================================================================

### FUNC 00106180 (6 bytes) name=libusb_ref_device

void libusb_ref_device(void)

{
  (*(code *)PTR_libusb_ref_device_0033f260)();
  return;
}


==================================================================

### FUNC 00106190 (6 bytes) name=libusb_handle_events_timeout

void libusb_handle_events_timeout(void)

{
  (*(code *)PTR_libusb_handle_events_timeout_0033f268)();
  return;
}


==================================================================

### FUNC 001061a0 (6 bytes) name=libusb_exit

void libusb_exit(void)

{
  (*(code *)PTR_libusb_exit_0033f270)();
  return;
}


==================================================================

### FUNC 001061b0 (6 bytes) name=strrchr

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

char * strrchr(char *__s,int __c)

{
  char *pcVar1;
  
  pcVar1 = (char *)(*(code *)PTR_strrchr_0033f278)();
  return pcVar1;
}


==================================================================

### FUNC 001061c0 (6 bytes) name=syscall

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

long syscall(long __sysno,...)

{
  long lVar1;
  
  lVar1 = (*(code *)PTR_syscall_0033f280)();
  return lVar1;
}


==================================================================

### FUNC 001061d0 (6 bytes) name=libusb_free_bos_descriptor

void libusb_free_bos_descriptor(void)

{
  (*(code *)PTR_libusb_free_bos_descriptor_0033f288)();
  return;
}


==================================================================

### FUNC 001061e0 (6 bytes) name=sscanf

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int sscanf(char *__s,char *__format,...)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_sscanf_0033f290)();
  return iVar1;
}


==================================================================

### FUNC 001061f0 (6 bytes) name=libusb_wait_for_event

void libusb_wait_for_event(void)

{
  (*(code *)PTR_libusb_wait_for_event_0033f298)();
  return;
}


==================================================================

### FUNC 00106200 (6 bytes) name=libusb_init

void libusb_init(void)

{
  (*(code *)PTR_libusb_init_0033f2a0)();
  return;
}


==================================================================

### FUNC 00106210 (6 bytes) name=pipe

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int pipe(int *__pipedes)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_pipe_0033f2a8)();
  return iVar1;
}


==================================================================

### FUNC 00106220 (6 bytes) name=libusb_free_transfer

void libusb_free_transfer(void)

{
  (*(code *)PTR_libusb_free_transfer_0033f2b0)();
  return;
}


==================================================================

### FUNC 00106230 (6 bytes) name=pthread_join

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int pthread_join(pthread_t __th,void **__thread_return)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_pthread_join_0033f2b8)();
  return iVar1;
}


==================================================================

### FUNC 00106240 (6 bytes) name=poll

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int poll(pollfd *__fds,nfds_t __nfds,int __timeout)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_poll_0033f2c0)();
  return iVar1;
}


==================================================================

### FUNC 00106250 (6 bytes) name=pthread_mutex_trylock

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int pthread_mutex_trylock(pthread_mutex_t *__mutex)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_pthread_mutex_trylock_0033f2c8)();
  return iVar1;
}


==================================================================

### FUNC 00106260 (6 bytes) name=libusb_unlock_events

void libusb_unlock_events(void)

{
  (*(code *)PTR_libusb_unlock_events_0033f2d0)();
  return;
}


==================================================================

### FUNC 00106270 (6 bytes) name=pow

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

double pow(double __x,double __y)

{
  double dVar1;
  
  dVar1 = (double)(*(code *)PTR_pow_0033f2d8)();
  return dVar1;
}


==================================================================

### FUNC 00106280 (6 bytes) name=libusb_set_auto_detach_kernel_driver

void libusb_set_auto_detach_kernel_driver(void)

{
  (*(code *)PTR_libusb_set_auto_detach_kernel_driver_0033f2e0)();
  return;
}


==================================================================

### FUNC 00106290 (6 bytes) name=usleep

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int usleep(__useconds_t __useconds)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_usleep_0033f2e8)();
  return iVar1;
}


==================================================================

### FUNC 001062a0 (6 bytes) name=strerror

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

char * strerror(int __errnum)

{
  char *pcVar1;
  
  pcVar1 = (char *)(*(code *)PTR_strerror_0033f2f0)();
  return pcVar1;
}


==================================================================

### FUNC 001062b0 (6 bytes) name=MAG_IsLinked

void MAG_IsLinked(void)

{
  (*(code *)PTR_MAG_IsLinked_0033f2f8)();
  return;
}


==================================================================

### FUNC 001062c0 (6 bytes) name=fputs

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int fputs(char *__s,FILE *__stream)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_fputs_0033f300)();
  return iVar1;
}


==================================================================

### FUNC 001062d0 (6 bytes) name=lseek

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

__off_t lseek(int __fd,__off_t __offset,int __whence)

{
  __off_t _Var1;
  
  _Var1 = (*(code *)PTR_lseek_0033f308)();
  return _Var1;
}


==================================================================

### FUNC 001062e0 (6 bytes) name=strtol

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

long strtol(char *__nptr,char **__endptr,int __base)

{
  long lVar1;
  
  lVar1 = (*(code *)PTR_strtol_0033f310)();
  return lVar1;
}


==================================================================

### FUNC 001062f0 (6 bytes) name=readlink

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

ssize_t readlink(char *__path,char *__buf,size_t __len)

{
  ssize_t sVar1;
  
  sVar1 = (*(code *)PTR_readlink_0033f318)();
  return sVar1;
}


==================================================================

### FUNC 00106300 (6 bytes) name=libusb_hotplug_deregister_callback

void libusb_hotplug_deregister_callback(void)

{
  (*(code *)PTR_libusb_hotplug_deregister_callback_0033f320)();
  return;
}


==================================================================

### FUNC 00106310 (6 bytes) name=__strcpy_chk

void __strcpy_chk(void)

{
  (*(code *)PTR___strcpy_chk_0033f328)();
  return;
}


==================================================================

### FUNC 00106320 (6 bytes) name=__ostream_insert<char,std::char_traits<char>>

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

ostream * std::__ostream_insert<char,std::char_traits<char>>
                    (ostream *param_1,char *param_2,long param_3)

{
  ostream *poVar1;
  
  poVar1 = (ostream *)(*(code *)PTR___ostream_insert<char,std_char_traits<char>>_0033f330)();
  return poVar1;
}


==================================================================

### FUNC 00106330 (6 bytes) name=memmove

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

void * memmove(void *__dest,void *__src,size_t __n)

{
  void *pvVar1;
  
  pvVar1 = (void *)(*(code *)PTR_memmove_0033f338)();
  return pvVar1;
}


==================================================================

### FUNC 00106340 (6 bytes) name=strchr

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

char * strchr(char *__s,int __c)

{
  char *pcVar1;
  
  pcVar1 = (char *)(*(code *)PTR_strchr_0033f340)();
  return pcVar1;
}


==================================================================

### FUNC 00106350 (6 bytes) name=socket

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int socket(int __domain,int __type,int __protocol)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_socket_0033f348)();
  return iVar1;
}


==================================================================

### FUNC 00106360 (6 bytes) name=fread

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

size_t fread(void *__ptr,size_t __size,size_t __n,FILE *__stream)

{
  size_t sVar1;
  
  sVar1 = (*(code *)PTR_fread_0033f350)();
  return sVar1;
}


==================================================================

### FUNC 00106370 (6 bytes) name=getenv

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

char * getenv(char *__name)

{
  char *pcVar1;
  
  pcVar1 = (char *)(*(code *)PTR_getenv_0033f358)();
  return pcVar1;
}


==================================================================

### FUNC 00106380 (6 bytes) name=libusb_get_next_timeout

void libusb_get_next_timeout(void)

{
  (*(code *)PTR_libusb_get_next_timeout_0033f360)();
  return;
}


==================================================================

### FUNC 00106390 (6 bytes) name=__errno_location

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int * __errno_location(void)

{
  int *piVar1;
  
  piVar1 = (int *)(*(code *)PTR___errno_location_0033f368)();
  return piVar1;
}


==================================================================

### FUNC 001063a0 (6 bytes) name=pthread_mutexattr_settype

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int pthread_mutexattr_settype(pthread_mutexattr_t *__attr,int __kind)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_pthread_mutexattr_settype_0033f370)();
  return iVar1;
}


==================================================================

### FUNC 001063b0 (6 bytes) name=__stack_chk_fail

void __stack_chk_fail(void)

{
  (*(code *)PTR___stack_chk_fail_0033f378)();
  return;
}


==================================================================

### FUNC 001063c0 (6 bytes) name=strcmp

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int strcmp(char *__s1,char *__s2)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_strcmp_0033f380)();
  return iVar1;
}


==================================================================

### FUNC 001063d0 (6 bytes) name=__cxa_allocate_exception

void __cxa_allocate_exception(void)

{
  (*(code *)PTR___cxa_allocate_exception_0033f388)();
  return;
}


==================================================================

### FUNC 001063e0 (6 bytes) name=libusb_error_name

void libusb_error_name(void)

{
  (*(code *)PTR_libusb_error_name_0033f390)();
  return;
}


==================================================================

### FUNC 001063f0 (6 bytes) name=assign

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

void std::string::assign(char *param_1,ulong param_2)

{
  (*(code *)PTR_assign_0033f398)();
  return;
}


==================================================================

### FUNC 00106400 (6 bytes) name=MAG_IsChannelAvailable

void MAG_IsChannelAvailable(void)

{
  (*(code *)PTR_MAG_IsChannelAvailable_0033f3a0)();
  return;
}


==================================================================

### FUNC 00106410 (6 bytes) name=nanosleep

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int nanosleep(timespec *__requested_time,timespec *__remaining)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_nanosleep_0033f3a8)();
  return iVar1;
}


==================================================================

### FUNC 00106420 (6 bytes) name=getuid

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

__uid_t getuid(void)

{
  __uid_t _Var1;
  
  _Var1 = (*(code *)PTR_getuid_0033f3b0)();
  return _Var1;
}


==================================================================

### FUNC 00106430 (6 bytes) name=pthread_cond_wait

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int pthread_cond_wait(pthread_cond_t *__cond,pthread_mutex_t *__mutex)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_pthread_cond_wait_0033f3b8)();
  return iVar1;
}


==================================================================

### FUNC 00106440 (6 bytes) name=operator.delete[]

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

void operator_delete__(void *param_1)

{
  (*(code *)PTR_operator_delete___0033f3c0)();
  return;
}


==================================================================

### FUNC 00106450 (6 bytes) name=libusb_get_device_descriptor

void libusb_get_device_descriptor(void)

{
  (*(code *)PTR_libusb_get_device_descriptor_0033f3c8)();
  return;
}


==================================================================

### FUNC 00106460 (6 bytes) name=calloc

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

void * calloc(size_t __nmemb,size_t __size)

{
  void *pvVar1;
  
  pvVar1 = (void *)(*(code *)PTR_calloc_0033f3d0)();
  return pvVar1;
}


==================================================================

### FUNC 00106470 (6 bytes) name=munmap

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int munmap(void *__addr,size_t __len)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_munmap_0033f3d8)();
  return iVar1;
}


==================================================================

### FUNC 00106480 (6 bytes) name=feof

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int feof(FILE *__stream)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_feof_0033f3e0)();
  return iVar1;
}


==================================================================

### FUNC 00106490 (6 bytes) name=__cxa_throw

void __cxa_throw(void)

{
  (*(code *)PTR___cxa_throw_0033f3e8)();
  return;
}


==================================================================

### FUNC 001064a0 (6 bytes) name=fclose

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int fclose(FILE *__stream)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_fclose_0033f3f0)();
  return iVar1;
}


==================================================================

### FUNC 001064b0 (6 bytes) name=libusb_handle_events_completed

void libusb_handle_events_completed(void)

{
  (*(code *)PTR_libusb_handle_events_completed_0033f3f8)();
  return;
}


==================================================================

### FUNC 001064c0 (6 bytes) name=strncpy

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

char * strncpy(char *__dest,char *__src,size_t __n)

{
  char *pcVar1;
  
  pcVar1 = (char *)(*(code *)PTR_strncpy_0033f400)();
  return pcVar1;
}


==================================================================

### FUNC 001064d0 (6 bytes) name=pthread_attr_init

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int pthread_attr_init(pthread_attr_t *__attr)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_pthread_attr_init_0033f408)();
  return iVar1;
}


==================================================================

### FUNC 001064e0 (6 bytes) name=localtime_r

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

tm * localtime_r(time_t *__timer,tm *__tp)

{
  tm *ptVar1;
  
  ptVar1 = (tm *)(*(code *)PTR_localtime_r_0033f410)();
  return ptVar1;
}


==================================================================

### FUNC 001064f0 (6 bytes) name=__cxa_end_catch

void __cxa_end_catch(void)

{
  (*(code *)PTR___cxa_end_catch_0033f418)();
  return;
}


==================================================================

### FUNC 00106500 (6 bytes) name=__throw_bad_alloc

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

void std::__throw_bad_alloc(void)

{
  (*(code *)PTR___throw_bad_alloc_0033f420)();
  return;
}


==================================================================

### FUNC 00106510 (6 bytes) name=fscanf

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int fscanf(FILE *__stream,char *__format,...)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_fscanf_0033f428)();
  return iVar1;
}


==================================================================

### FUNC 00106520 (6 bytes) name=closedir

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int closedir(DIR *__dirp)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_closedir_0033f430)();
  return iVar1;
}


==================================================================

### FUNC 00106530 (6 bytes) name=__sprintf_chk

void __sprintf_chk(void)

{
  (*(code *)PTR___sprintf_chk_0033f438)();
  return;
}


==================================================================

### FUNC 00106540 (6 bytes) name=libusb_get_port_numbers

void libusb_get_port_numbers(void)

{
  (*(code *)PTR_libusb_get_port_numbers_0033f440)();
  return;
}


==================================================================

### FUNC 00106550 (6 bytes) name=MAG_LinkCameraEx

void MAG_LinkCameraEx(void)

{
  (*(code *)PTR_MAG_LinkCameraEx_0033f448)();
  return;
}


==================================================================

### FUNC 00106560 (6 bytes) name=__snprintf_chk

void __snprintf_chk(void)

{
  (*(code *)PTR___snprintf_chk_0033f450)();
  return;
}


==================================================================

### FUNC 00106570 (6 bytes) name=access

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int access(char *__name,int __type)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_access_0033f458)();
  return iVar1;
}


==================================================================

### FUNC 00106580 (6 bytes) name=endl<char,std::char_traits<char>>

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

ostream * std::endl<char,std::char_traits<char>>(ostream *param_1)

{
  ostream *poVar1;
  
  poVar1 = (ostream *)(*(code *)PTR_endl<char,std_char_traits<char>>_0033f460)();
  return poVar1;
}


==================================================================

### FUNC 00106590 (6 bytes) name=__cxa_begin_catch

void __cxa_begin_catch(void)

{
  (*(code *)PTR___cxa_begin_catch_0033f468)();
  return;
}


==================================================================

### FUNC 001065a0 (6 bytes) name=bind

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int bind(int __fd,sockaddr *__addr,socklen_t __len)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_bind_0033f470)();
  return iVar1;
}


==================================================================

### FUNC 001065b0 (6 bytes) name=libusb_bulk_transfer

void libusb_bulk_transfer(void)

{
  (*(code *)PTR_libusb_bulk_transfer_0033f478)();
  return;
}


==================================================================

### FUNC 001065c0 (6 bytes) name=fwrite

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

size_t fwrite(void *__ptr,size_t __size,size_t __n,FILE *__s)

{
  size_t sVar1;
  
  sVar1 = (*(code *)PTR_fwrite_0033f480)();
  return sVar1;
}


==================================================================

### FUNC 001065d0 (6 bytes) name=pthread_mutex_lock

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int pthread_mutex_lock(pthread_mutex_t *__mutex)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_pthread_mutex_lock_0033f488)();
  return iVar1;
}


==================================================================

### FUNC 001065e0 (6 bytes) name=realloc

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

void * realloc(void *__ptr,size_t __size)

{
  void *pvVar1;
  
  pvVar1 = (void *)(*(code *)PTR_realloc_0033f490)();
  return pvVar1;
}


==================================================================

### FUNC 001065f0 (6 bytes) name=timerfd_create

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int timerfd_create(clockid_t __clock_id,int __flags)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_timerfd_create_0033f498)();
  return iVar1;
}


==================================================================

### FUNC 00106600 (6 bytes) name=pthread_mutexattr_init

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int pthread_mutexattr_init(pthread_mutexattr_t *__attr)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_pthread_mutexattr_init_0033f4a0)();
  return iVar1;
}


==================================================================

### FUNC 00106610 (6 bytes) name=pthread_key_create

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int pthread_key_create(pthread_key_t *__key,__destr_function *__destr_function)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_pthread_key_create_0033f4a8)();
  return iVar1;
}


==================================================================

### FUNC 00106620 (6 bytes) name=libusb_lock_events

void libusb_lock_events(void)

{
  (*(code *)PTR_libusb_lock_events_0033f4b0)();
  return;
}


==================================================================

### FUNC 00106630 (6 bytes) name=timerfd_settime

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int timerfd_settime(int __ufd,int __flags,itimerspec *__utmr,itimerspec *__otmr)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_timerfd_settime_0033f4b8)();
  return iVar1;
}


==================================================================

### FUNC 00106640 (6 bytes) name=localtime

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

tm * localtime(time_t *__timer)

{
  tm *ptVar1;
  
  ptVar1 = (tm *)(*(code *)PTR_localtime_0033f4c0)();
  return ptVar1;
}


==================================================================

### FUNC 00106650 (6 bytes) name=pthread_mutex_destroy

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int pthread_mutex_destroy(pthread_mutex_t *__mutex)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_pthread_mutex_destroy_0033f4c8)();
  return iVar1;
}


==================================================================

### FUNC 00106660 (6 bytes) name=write

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

ssize_t write(int __fd,void *__buf,size_t __n)

{
  ssize_t sVar1;
  
  sVar1 = (*(code *)PTR_write_0033f4d0)();
  return sVar1;
}


==================================================================

### FUNC 00106670 (6 bytes) name=operator.new

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

void * operator_new(ulong param_1)

{
  void *pvVar1;
  
  pvVar1 = (void *)(*(code *)PTR_operator_new_0033f4d8)();
  return pvVar1;
}


==================================================================

### FUNC 00106680 (6 bytes) name=_Unwind_Resume

void _Unwind_Resume(void)

{
  (*(code *)PTR__Unwind_Resume_0033f4e0)();
  return;
}


==================================================================

### FUNC 00106690 (6 bytes) name=pthread_cond_broadcast

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int pthread_cond_broadcast(pthread_cond_t *__cond)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_pthread_cond_broadcast_0033f4e8)();
  return iVar1;
}


==================================================================

### FUNC 001066a0 (6 bytes) name=clock_gettime

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int clock_gettime(clockid_t __clock_id,timespec *__tp)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_clock_gettime_0033f4f0)();
  return iVar1;
}


==================================================================

### FUNC 001066b0 (6 bytes) name=sqrt

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

double sqrt(double __x)

{
  double dVar1;
  
  dVar1 = (double)(*(code *)PTR_sqrt_0033f4f8)();
  return dVar1;
}


==================================================================

### FUNC 001066c0 (6 bytes) name=strtoul

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

ulong strtoul(char *__nptr,char **__endptr,int __base)

{
  ulong uVar1;
  
  uVar1 = (*(code *)PTR_strtoul_0033f500)();
  return uVar1;
}


==================================================================

### FUNC 001066d0 (6 bytes) name=pthread_mutex_unlock

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int pthread_mutex_unlock(pthread_mutex_t *__mutex)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_pthread_mutex_unlock_0033f508)();
  return iVar1;
}


==================================================================

### FUNC 001066e0 (6 bytes) name=memcpy

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

void * memcpy(void *__dest,void *__src,size_t __n)

{
  void *pvVar1;
  
  pvVar1 = (void *)(*(code *)PTR_memcpy_0033f510)();
  return pvVar1;
}


==================================================================

### FUNC 001066f0 (6 bytes) name=fcntl

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int fcntl(int __fd,int __cmd,...)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_fcntl_0033f518)();
  return iVar1;
}


==================================================================

### FUNC 00106700 (6 bytes) name=libusb_release_interface

void libusb_release_interface(void)

{
  (*(code *)PTR_libusb_release_interface_0033f520)();
  return;
}


==================================================================

### FUNC 00106710 (6 bytes) name=open

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int open(char *__file,int __oflag,...)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_open_0033f528)();
  return iVar1;
}


==================================================================

### FUNC 00106720 (6 bytes) name=__open_2

void __open_2(void)

{
  (*(code *)PTR___open_2_0033f530)();
  return;
}


==================================================================

### FUNC 00106730 (6 bytes) name=mmap

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

void * mmap(void *__addr,size_t __len,int __prot,int __flags,int __fd,__off_t __offset)

{
  void *pvVar1;
  
  pvVar1 = (void *)(*(code *)PTR_mmap_0033f538)();
  return pvVar1;
}


==================================================================

### FUNC 00106740 (6 bytes) name=libusb_lock_event_waiters

void libusb_lock_event_waiters(void)

{
  (*(code *)PTR_libusb_lock_event_waiters_0033f540)();
  return;
}


==================================================================

### FUNC 00106750 (6 bytes) name=mkdir

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int mkdir(char *__path,__mode_t __mode)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_mkdir_0033f548)();
  return iVar1;
}


==================================================================

### FUNC 00106760 (6 bytes) name=time

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

time_t time(time_t *__timer)

{
  time_t tVar1;
  
  tVar1 = (*(code *)PTR_time_0033f550)();
  return tVar1;
}


==================================================================

### FUNC 00106770 (6 bytes) name=fflush

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int fflush(FILE *__stream)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_fflush_0033f558)();
  return iVar1;
}


==================================================================

### FUNC 00106780 (6 bytes) name=sqrtf

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

float sqrtf(float __x)

{
  float fVar1;
  
  fVar1 = (float)(*(code *)PTR_sqrtf_0033f560)();
  return fVar1;
}


==================================================================

### FUNC 00106790 (6 bytes) name=pthread_attr_setdetachstate

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int pthread_attr_setdetachstate(pthread_attr_t *__attr,int __detachstate)

{
  int iVar1;
  
  iVar1 = (*(code *)PTR_pthread_attr_setdetachstate_0033f568)();
  return iVar1;
}


==================================================================

### FUNC 001067a0 (46 bytes) name=entry

void processEntry entry(void)

{
  std::ios_base::Init::Init((Init *)&DAT_00340a9c);
  __cxa_atexit(PTR__Init_0033efa8,&DAT_00340a9c,&PTR_LOOP_0033f580);
  return;
}


==================================================================

### FUNC 001067d0 (64 bytes) name=_INIT_2

void _INIT_2(void)

{
  std::ios_base::Init::Init((Init *)&DAT_00340aa8);
  __cxa_atexit(PTR__Init_0033efa8,&DAT_00340aa8,&PTR_LOOP_0033f580);
  DAT_00340aa0 = *(undefined8 *)PTR_stdout_0033efe8;
  return;
}


==================================================================

### FUNC 00106810 (46 bytes) name=_INIT_3

void _INIT_3(void)

{
  std::ios_base::Init::Init((Init *)&DAT_00340ad0);
  __cxa_atexit(PTR__Init_0033efa8,&DAT_00340ad0,&PTR_LOOP_0033f580);
  return;
}


==================================================================

### FUNC 00106840 (46 bytes) name=_INIT_4

void _INIT_4(void)

{
  std::ios_base::Init::Init((Init *)&DAT_003665a8);
  __cxa_atexit(PTR__Init_0033efa8,&DAT_003665a8,&PTR_LOOP_0033f580);
  return;
}


==================================================================

### FUNC 00106870 (46 bytes) name=_INIT_5

void _INIT_5(void)

{
  std::ios_base::Init::Init((Init *)&DAT_003665a9);
  __cxa_atexit(PTR__Init_0033efa8,&DAT_003665a9,&PTR_LOOP_0033f580);
  return;
}


==================================================================

### FUNC 001068a0 (44 bytes) name=FUN_001068a0

/* WARNING: Removing unreachable block (ram,0x001068bd) */
/* WARNING: Removing unreachable block (ram,0x001068c9) */

void FUN_001068a0(void)

{
  return;
}


==================================================================

### FUNC 001068d0 (60 bytes) name=FUN_001068d0

/* WARNING: Removing unreachable block (ram,0x001068fa) */
/* WARNING: Removing unreachable block (ram,0x00106906) */

void FUN_001068d0(void)

{
  return;
}


==================================================================

### FUNC 00106910 (50 bytes) name=_FINI_0

void _FINI_0(void)

{
  if (DAT_0033f620 == '\0') {
    if (PTR___cxa_finalize_0033efc0 != (undefined *)0x0) {
      __cxa_finalize(PTR_LOOP_0033f580);
    }
    FUN_001068a0();
    DAT_0033f620 = '\x01';
  }
  return;
}


==================================================================

### FUNC 00106950 (46 bytes) name=_INIT_0

void _INIT_0(void)

{
  if ((DAT_0033e9f8 != 0) && (PTR__Jv_RegisterClasses_0033efa0 != (undefined *)0x0)) {
    (*(code *)PTR__Jv_RegisterClasses_0033efa0)(&DAT_0033e9f8);
    FUN_001068d0();
    return;
  }
  FUN_001068d0();
  return;
}


==================================================================

### FUNC 00106990 (68 bytes) name=FUN_00106990

void FUN_00106990(undefined8 *param_1)

{
  *param_1 = &PTR_FUN_0033ebb0;
  if ((void *)param_1[1] != (void *)0x0) {
    operator_delete__((void *)param_1[1]);
    param_1[1] = 0;
  }
  param_1[2] = 0;
  if ((void *)param_1[3] != (void *)0x0) {
    operator_delete__((void *)param_1[3]);
    param_1[3] = 0;
  }
  return;
}


==================================================================

### FUNC 001069e0 (18 bytes) name=FUN_001069e0

void FUN_001069e0(void *param_1)

{
  FUN_00106990();
  operator_delete(param_1);
  return;
}


==================================================================

### FUNC 00106a00 (63 bytes) name=FUN_00106a00

void FUN_00106a00(undefined8 *param_1)

{
  param_1[1] = 0;
  param_1[2] = 0;
  param_1[3] = 0;
  *(undefined4 *)(param_1 + 4) = 0;
  *param_1 = &PTR_FUN_0033ebb0;
  *(undefined4 *)((long)param_1 + 0x24) = 0;
  *(undefined4 *)(param_1 + 5) = 0;
  *(undefined4 *)((long)param_1 + 0x2c) = 0;
  return;
}


==================================================================

### FUNC 00106a40 (252 bytes) name=FUN_00106a40

undefined8 FUN_00106a40(long param_1,uint param_2,uint param_3,uint param_4)

{
  void *pvVar1;
  
  *(undefined4 *)(param_1 + 0x2c) = 0;
  if (*(void **)(param_1 + 8) != (void *)0x0) {
    operator_delete__(*(void **)(param_1 + 8));
    *(undefined8 *)(param_1 + 8) = 0;
  }
  *(undefined8 *)(param_1 + 0x10) = 0;
  if (*(void **)(param_1 + 0x18) != (void *)0x0) {
    operator_delete__(*(void **)(param_1 + 0x18));
    *(undefined8 *)(param_1 + 0x18) = 0;
  }
  if (((param_2 != 0) && (param_3 < 0x41)) && ((param_3 - 1 & param_3) == 0)) {
    *(undefined4 *)(param_1 + 0x20) = 0;
    *(uint *)(param_1 + 0x24) = param_2;
    *(uint *)(param_1 + 0x28) = param_3;
    pvVar1 = operator_new__((((ulong)param_4 + 3 >> 2) + (ulong)(param_2 >> 1)) * 4);
    *(void **)(param_1 + 8) = pvVar1;
    if (pvVar1 != (void *)0x0) {
      *(ulong *)(param_1 + 0x10) = (long)pvVar1 + (ulong)(param_4 & 0xfffffffe);
      if (2 < param_3) {
        pvVar1 = operator_new__((ulong)param_2 * 4);
        *(void **)(param_1 + 0x18) = pvVar1;
        if (pvVar1 == (void *)0x0) {
          return 0;
        }
      }
      *(undefined4 *)(param_1 + 0x2c) = 1;
      return 1;
    }
    *(undefined8 *)(param_1 + 0x10) = 0;
  }
  return 0;
}


==================================================================

### FUNC 00106b40 (469 bytes) name=FUN_00106b40

undefined8 FUN_00106b40(long param_1,ushort *param_2)

{
  long lVar1;
  ushort *puVar2;
  int iVar3;
  uint *puVar4;
  sbyte sVar5;
  uint uVar6;
  long lVar7;
  int iVar8;
  
  if (*(int *)(param_1 + 0x2c) == 0) {
    return 0;
  }
  iVar3 = *(int *)(param_1 + 0x28);
  iVar8 = *(int *)(param_1 + 0x20) + 1;
  *(int *)(param_1 + 0x20) = iVar8;
  if (iVar3 == 1) {
LAB_00106d10:
    memcpy(*(void **)(param_1 + 0x10),param_2,(ulong)*(uint *)(param_1 + 0x24) * 2);
    iVar8 = *(int *)(param_1 + 0x20);
    iVar3 = *(int *)(param_1 + 0x28);
  }
  else if (iVar3 == 2) {
    if (iVar8 == 1) goto LAB_00106d10;
    puVar2 = *(ushort **)(param_1 + 0x10);
    for (uVar6 = *(uint *)(param_1 + 0x24) >> 2; uVar6 != 0; uVar6 = uVar6 - 1) {
      *puVar2 = (ushort)((int)((uint)*param_2 + (uint)*puVar2) >> 1);
      puVar2[1] = (ushort)((int)((uint)param_2[1] + (uint)puVar2[1]) >> 1);
      puVar2[2] = (ushort)((int)((uint)param_2[2] + (uint)puVar2[2]) >> 1);
      puVar2[3] = (ushort)((int)((uint)param_2[3] + (uint)puVar2[3]) >> 1);
      puVar2 = puVar2 + 4;
      param_2 = param_2 + 4;
    }
    iVar3 = 2;
  }
  else {
    puVar4 = *(uint **)(param_1 + 0x18);
    if (iVar8 == 1) {
      uVar6 = *(uint *)(param_1 + 0x24) >> 2;
      if (*(uint *)(param_1 + 0x24) >> 2 == 0) {
        return 0;
      }
      do {
        *puVar4 = (uint)*param_2;
        puVar4[1] = (uint)param_2[1];
        puVar4[2] = (uint)param_2[2];
        uVar6 = uVar6 - 1;
        puVar4[3] = (uint)param_2[3];
        puVar4 = puVar4 + 4;
        param_2 = param_2 + 4;
      } while (uVar6 != 0);
    }
    else if (iVar8 == iVar3) {
      lVar1 = *(long *)(param_1 + 0x10);
      sVar5 = 2;
      if ((((iVar8 != 4) && (sVar5 = 3, iVar8 != 8)) && (sVar5 = 4, iVar8 != 0x10)) &&
         ((sVar5 = 5, iVar8 != 0x20 && (sVar5 = 6, iVar8 != 0x40)))) {
        sVar5 = 0;
      }
      iVar8 = *(int *)(param_1 + 0x24);
      if (iVar8 == 0) goto LAB_00106bc3;
      lVar7 = 0;
      do {
        uVar6 = (uint)*(ushort *)((long)param_2 + lVar7) + *(int *)((long)puVar4 + lVar7 * 2);
        *(short *)(lVar1 + lVar7) = (short)(uVar6 >> sVar5);
        *(uint *)((long)puVar4 + lVar7 * 2) = uVar6;
        lVar7 = lVar7 + 2;
      } while (lVar7 != (ulong)(iVar8 - 1) * 2 + 2);
    }
    else {
      uVar6 = *(uint *)(param_1 + 0x24) >> 2;
      if (*(uint *)(param_1 + 0x24) >> 2 == 0) {
        return 0;
      }
      do {
        *puVar4 = *puVar4 + (uint)*param_2;
        puVar4[1] = puVar4[1] + (uint)param_2[1];
        puVar4[2] = puVar4[2] + (uint)param_2[2];
        puVar4[3] = puVar4[3] + (uint)param_2[3];
        uVar6 = uVar6 - 1;
        puVar4 = puVar4 + 4;
        param_2 = param_2 + 4;
      } while (uVar6 != 0);
    }
    iVar8 = *(int *)(param_1 + 0x20);
    iVar3 = *(int *)(param_1 + 0x28);
  }
  if (iVar8 != iVar3) {
    return 0;
  }
LAB_00106bc3:
  *(undefined4 *)(param_1 + 0x20) = 0;
  return 1;
}


==================================================================

### FUNC 00106d30 (16 bytes) name=FUN_00106d30

void FUN_00106d30(long param_1)

{
  if (*(int *)(param_1 + 0x2c) != 0) {
    *(undefined4 *)(param_1 + 0x20) = 0;
  }
  return;
}


==================================================================

### FUNC 00106d40 (5 bytes) name=FUN_00106d40

undefined8 FUN_00106d40(long param_1)

{
  return *(undefined8 *)(param_1 + 0x10);
}


==================================================================

### FUNC 00106d50 (26 bytes) name=FUN_00106d50

void FUN_00106d50(undefined8 *param_1)

{
  *param_1 = &PTR_FUN_0033ec30;
  if ((FILE *)param_1[1] != (FILE *)0x0) {
    fclose((FILE *)param_1[1]);
    return;
  }
  return;
}


==================================================================

### FUNC 00106d80 (26 bytes) name=FUN_00106d80

void FUN_00106d80(undefined8 *param_1)

{
  *param_1 = &PTR_FUN_0033ec30;
  if ((FILE *)param_1[1] != (FILE *)0x0) {
    fclose((FILE *)param_1[1]);
    return;
  }
  return;
}


==================================================================

### FUNC 00106db0 (26 bytes) name=FUN_00106db0

void FUN_00106db0(undefined8 *param_1)

{
  *param_1 = &PTR_FUN_0033ec30;
  if ((FILE *)param_1[1] != (FILE *)0x0) {
    fclose((FILE *)param_1[1]);
    return;
  }
  return;
}


==================================================================

### FUNC 00106de0 (37 bytes) name=FUN_00106de0

void FUN_00106de0(undefined8 *param_1)

{
  *param_1 = &PTR_FUN_0033ec30;
  if ((FILE *)param_1[1] != (FILE *)0x0) {
    fclose((FILE *)param_1[1]);
  }
  operator_delete(param_1);
  return;
}


==================================================================

### FUNC 00106e10 (37 bytes) name=FUN_00106e10

void FUN_00106e10(undefined8 *param_1)

{
  *param_1 = &PTR_FUN_0033ec30;
  if ((FILE *)param_1[1] != (FILE *)0x0) {
    fclose((FILE *)param_1[1]);
  }
  operator_delete(param_1);
  return;
}


==================================================================

### FUNC 00106e40 (37 bytes) name=FUN_00106e40

void FUN_00106e40(undefined8 *param_1)

{
  *param_1 = &PTR_FUN_0033ec30;
  if ((FILE *)param_1[1] != (FILE *)0x0) {
    fclose((FILE *)param_1[1]);
  }
  operator_delete(param_1);
  return;
}


==================================================================

### FUNC 00106e70 (100 bytes) name=FUN_00106e70

long FUN_00106e70(long param_1)

{
  int iVar1;
  long lVar2;
  long lVar3;
  
  fflush(*(FILE **)(param_1 + 8));
  iVar1 = feof(*(FILE **)(param_1 + 8));
  if (iVar1 == 0) {
    lVar2 = ftell(*(FILE **)(param_1 + 8));
    fseek(*(FILE **)(param_1 + 8),0,2);
    lVar3 = ftell(*(FILE **)(param_1 + 8));
    fseek(*(FILE **)(param_1 + 8),lVar2,0);
    return lVar3;
  }
  lVar2 = ftell(*(FILE **)(param_1 + 8));
  return lVar2;
}


==================================================================

### FUNC 00106ee0 (11 bytes) name=FUN_00106ee0

void FUN_00106ee0(undefined8 *param_1)

{
  *param_1 = &PTR_FUN_0033ec30;
  return;
}


==================================================================

### FUNC 00106ef0 (5 bytes) name=FUN_00106ef0

undefined8 FUN_00106ef0(long param_1)

{
  return *(undefined8 *)(param_1 + 8);
}


==================================================================

### FUNC 00106f00 (23 bytes) name=FUN_00106f00

bool FUN_00106f00(long param_1)

{
  int iVar1;
  
  iVar1 = feof(*(FILE **)(param_1 + 8));
  return iVar1 != 0;
}


==================================================================

### FUNC 00106f20 (56 bytes) name=FUN_00106f20

ulong FUN_00106f20(long param_1,char *param_2,int param_3)

{
  int iVar1;
  char *pcVar2;
  ulong uVar3;
  
  iVar1 = feof(*(FILE **)(param_1 + 8));
  uVar3 = 0;
  if (iVar1 == 0) {
    pcVar2 = fgets(param_2,param_3,*(FILE **)(param_1 + 8));
    uVar3 = CONCAT71((int7)(uVar3 >> 8),pcVar2 != (char *)0x0);
  }
  return uVar3 & 0xffffffff;
}


==================================================================

### FUNC 00106f60 (31 bytes) name=FUN_00106f60

long FUN_00106f60(long param_1,void *param_2,size_t param_3,size_t param_4)

{
  size_t sVar1;
  
  sVar1 = fread(param_2,param_3,param_4,*(FILE **)(param_1 + 8));
  return sVar1 * param_3;
}


==================================================================

### FUNC 00106f80 (9 bytes) name=FUN_00106f80

void FUN_00106f80(long param_1)

{
  ftell(*(FILE **)(param_1 + 8));
  return;
}


==================================================================

### FUNC 00106f90 (23 bytes) name=FUN_00106f90

bool FUN_00106f90(long param_1,long param_2,int param_3)

{
  int iVar1;
  
  iVar1 = fseek(*(FILE **)(param_1 + 8),param_2,param_3);
  return iVar1 == 0;
}


==================================================================

### FUNC 00106fb0 (149 bytes) name=FUN_00106fb0

void FUN_00106fb0(undefined8 *param_1,char *param_2,char param_3)

{
  FILE *pFVar1;
  undefined8 *puVar2;
  
  *param_1 = &PTR_FUN_0033ec70;
  if (param_3 == '\0') {
    pFVar1 = fopen(param_2,"wb");
    param_1[1] = pFVar1;
    if (pFVar1 == (FILE *)0x0) {
      puVar2 = (undefined8 *)__cxa_allocate_exception(8);
      *puVar2 = "IOError: open file failed2.[IFStream::IFStream]";
                    /* WARNING: Subroutine does not return */
      __cxa_throw(puVar2,&PTR_vtable_0033ec10,0);
    }
  }
  else {
    pFVar1 = fopen(param_2,"rb+");
    param_1[1] = pFVar1;
    if (pFVar1 == (FILE *)0x0) {
      puVar2 = (undefined8 *)__cxa_allocate_exception(8);
      *puVar2 = "IOError: open file failed1.[IFStream::IFStream]";
                    /* WARNING: Subroutine does not return */
      __cxa_throw(puVar2,&PTR_vtable_0033ec10,0);
    }
  }
  return;
}


==================================================================

### FUNC 00107080 (23 bytes) name=FUN_00107080

bool FUN_00107080(long param_1)

{
  int iVar1;
  
  iVar1 = fflush(*(FILE **)(param_1 + 8));
  return iVar1 == 0;
}


==================================================================

### FUNC 001070a0 (29 bytes) name=FUN_001070a0

uint FUN_001070a0(long param_1,char *param_2)

{
  uint uVar1;
  
  uVar1 = fputs(param_2,*(FILE **)(param_1 + 8));
  return ~uVar1 >> 0x1f;
}


==================================================================

### FUNC 001070c0 (36 bytes) name=FUN_001070c0

bool FUN_001070c0(long param_1,void *param_2,size_t param_3,size_t param_4)

{
  size_t sVar1;
  
  sVar1 = fwrite(param_2,param_3,param_4,*(FILE **)(param_1 + 8));
  return sVar1 != 0;
}


==================================================================

### FUNC 001070f0 (51 bytes) name=FUN_001070f0

undefined8 FUN_001070f0(long param_1,char *param_2)

{
  int iVar1;
  
  iVar1 = fputs(param_2,*(FILE **)(param_1 + 8));
  if (-1 < iVar1) {
    iVar1 = fputs("\n",*(FILE **)(param_1 + 8));
    if (-1 < iVar1) {
      return 1;
    }
  }
  return 0;
}


==================================================================

### FUNC 00107130 (135 bytes) name=FUN_00107130

void FUN_00107130(undefined8 *param_1,char *param_2)

{
  FILE *__stream;
  long lVar1;
  undefined8 *puVar2;
  
  *param_1 = &PTR_FUN_0033ecb0;
  param_1[2] = 0;
  __stream = fopen(param_2,"rb");
  param_1[1] = __stream;
  if (__stream != (FILE *)0x0) {
    fseek(__stream,0,2);
    lVar1 = ftell((FILE *)param_1[1]);
    param_1[2] = lVar1;
    fseek((FILE *)param_1[1],0,0);
    return;
  }
  puVar2 = (undefined8 *)__cxa_allocate_exception(8);
  *puVar2 = "IOError: open file failed.[IFStream::IFStream]";
                    /* WARNING: Subroutine does not return */
  __cxa_throw(puVar2,&PTR_vtable_0033ec10,0);
}


==================================================================

### FUNC 001071e0 (827 bytes) name=FUN_001071e0

void FUN_001071e0(long param_1)

{
  ulong uVar1;
  int iVar2;
  uint uVar3;
  undefined8 *puVar5;
  undefined8 *puVar6;
  bool bVar7;
  byte bVar8;
  ulong uVar4;
  
  bVar8 = 0;
  pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0x218));
  *(undefined4 *)(param_1 + 0x1ef8) = 0;
  *(undefined4 *)(param_1 + 0x208) = 0;
  *(undefined4 *)(param_1 + 0x20c) = 0;
  *(undefined4 *)(param_1 + 0x214) = 0;
  *(undefined4 *)(param_1 + 0x210) = 0;
  *(undefined4 *)(param_1 + 0x1328) = 0;
  *(undefined4 *)(param_1 + 0x1760) = 0;
  if (*(void **)(param_1 + 0x240) != (void *)0x0) {
    operator_delete__(*(void **)(param_1 + 0x240));
    *(undefined8 *)(param_1 + 0x240) = 0;
  }
  if (*(void **)(param_1 + 0x248) != (void *)0x0) {
    operator_delete__(*(void **)(param_1 + 0x248));
    *(undefined8 *)(param_1 + 0x248) = 0;
  }
  if (*(void **)(param_1 + 0x250) != (void *)0x0) {
    operator_delete__(*(void **)(param_1 + 0x250));
    *(undefined8 *)(param_1 + 0x250) = 0;
  }
  *(undefined8 *)(param_1 + 600) = 0;
  *(undefined8 *)(param_1 + 0x260) = 0;
  *(undefined8 *)(param_1 + 0x268) = 0;
  *(undefined8 *)(param_1 + 0x270) = 0;
  if (*(void **)(param_1 + 0x278) != (void *)0x0) {
    operator_delete__(*(void **)(param_1 + 0x278));
    *(undefined8 *)(param_1 + 0x278) = 0;
  }
  *(undefined8 *)(param_1 + 0x280) = 0;
  if (*(void **)(param_1 + 0x298) != (void *)0x0) {
    operator_delete__(*(void **)(param_1 + 0x298));
    *(undefined8 *)(param_1 + 0x298) = 0;
  }
  if (*(void **)(param_1 + 0x2a0) != (void *)0x0) {
    operator_delete__(*(void **)(param_1 + 0x2a0));
    *(undefined8 *)(param_1 + 0x2a0) = 0;
  }
  if (*(void **)(param_1 + 0x200) != (void *)0x0) {
    operator_delete__(*(void **)(param_1 + 0x200));
    *(undefined8 *)(param_1 + 0x200) = 0;
  }
  if (*(void **)(param_1 + 0x2a8) != (void *)0x0) {
    operator_delete__(*(void **)(param_1 + 0x2a8));
    *(undefined8 *)(param_1 + 0x2a8) = 0;
  }
  if (*(void **)(param_1 + 0x288) != (void *)0x0) {
    operator_delete__(*(void **)(param_1 + 0x288));
    *(undefined8 *)(param_1 + 0x288) = 0;
  }
  if (*(void **)(param_1 + 0x290) != (void *)0x0) {
    operator_delete__(*(void **)(param_1 + 0x290));
    *(undefined8 *)(param_1 + 0x290) = 0;
  }
  if (*(void **)(param_1 + 0x1580) != (void *)0x0) {
    operator_delete__(*(void **)(param_1 + 0x1580));
    *(undefined8 *)(param_1 + 0x1580) = 0;
  }
  if (*(void **)(param_1 + 0x1588) != (void *)0x0) {
    operator_delete__(*(void **)(param_1 + 0x1588));
    *(undefined8 *)(param_1 + 0x1588) = 0;
  }
  if (*(void **)(param_1 + 0x1590) != (void *)0x0) {
    operator_delete__(*(void **)(param_1 + 0x1590));
    *(undefined8 *)(param_1 + 0x1590) = 0;
  }
  puVar5 = (undefined8 *)(param_1 + 0x1328);
  uVar4 = 0x438;
  iVar2 = 0x438;
  bVar7 = ((ulong)puVar5 & 1) != 0;
  if (bVar7) {
    puVar5 = (undefined8 *)(param_1 + 0x1329);
    *(undefined1 *)(param_1 + 0x1328) = 0;
    uVar4 = 0x437;
    iVar2 = 0x437;
  }
  if (((ulong)puVar5 & 2) == 0) {
    uVar3 = (uint)uVar4;
  }
  else {
    uVar3 = iVar2 - 2;
    uVar4 = (ulong)uVar3;
    *(undefined2 *)puVar5 = 0;
    puVar5 = (undefined8 *)((long)puVar5 + 2);
  }
  if (((ulong)puVar5 & 4) != 0) {
    *(undefined4 *)puVar5 = 0;
    uVar4 = (ulong)(uVar3 - 4);
    puVar5 = (undefined8 *)((long)puVar5 + 4);
  }
  for (uVar1 = uVar4 >> 3; uVar1 != 0; uVar1 = uVar1 - 1) {
    *puVar5 = 0;
    puVar5 = puVar5 + (ulong)bVar8 * -2 + 1;
  }
  if ((uVar4 & 4) != 0) {
    *(undefined4 *)puVar5 = 0;
    puVar5 = (undefined8 *)((long)puVar5 + 4);
  }
  puVar6 = puVar5;
  if ((uVar4 & 2) != 0) {
    puVar6 = (undefined8 *)((long)puVar5 + 2);
    *(undefined2 *)puVar5 = 0;
  }
  if (bVar7) {
    *(undefined1 *)puVar6 = 0;
  }
  FUN_00106a40(param_1 + 0x1dc0,0,0,0);
  FUN_00106a40(param_1 + 0x1df0,0,0,0);
  FUN_00106a40(param_1 + 0x1e20,0,0,0);
  FUN_00119ee0(param_1 + 0x1e50,0,0,0,0);
  FUN_00119ee0(param_1 + 0x1e90,0,0,0,0);
  memset((void *)(param_1 + 0x1f08),0,0x2c78);
  memset((void *)(param_1 + 0x4b80),0,0x2c78);
  pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0x218));
  return;
}


==================================================================

### FUNC 00107530 (252 bytes) name=FUN_00107530

undefined8 FUN_00107530(long param_1,uint param_2,int param_3)

{
  pthread_mutex_t *__mutex;
  void *pvVar1;
  uint uVar2;
  undefined1 auStack_48 [32];
  
  __mutex = (pthread_mutex_t *)(param_1 + 0x218);
  pthread_mutex_lock(__mutex);
  if ((((*(int *)(param_1 + 0x208) != 0) && ((param_2 & 3) == 0)) && (3 < param_2)) &&
     (param_3 != 0)) {
    uVar2 = param_2 * param_3;
    if ((uint)(*(int *)(param_1 + 0x1edc) * *(int *)(param_1 + 0x1ed8)) < uVar2) {
      if (*(void **)(param_1 + 0x200) != (void *)0x0) {
        operator_delete__(*(void **)(param_1 + 0x200));
        *(undefined8 *)(param_1 + 0x200) = 0;
      }
      pvVar1 = operator_new__((ulong)uVar2);
      *(void **)(param_1 + 0x200) = pvVar1;
      if (pvVar1 == (void *)0x0) {
        FUN_00113aa0(auStack_48,4);
        FUN_00116630(auStack_48,"Insufficient memory");
        FUN_00113b30(auStack_48);
        FUN_001071e0(param_1);
        pthread_mutex_unlock(__mutex);
        return 0;
      }
    }
    *(uint *)(param_1 + 0x1ed8) = param_2;
    *(int *)(param_1 + 0x1edc) = param_3;
    *(uint *)(param_1 + 0x77fc) = uVar2;
    *(uint *)(param_1 + 0xadc) = param_2;
    *(int *)(param_1 + 0xae0) = param_3;
  }
  pthread_mutex_unlock(__mutex);
  return 1;
}


==================================================================

### FUNC 00107640 (269 bytes) name=FUN_00107640

int FUN_00107640(long param_1,undefined8 param_2,int param_3)

{
  pthread_mutex_t *__mutex;
  int iVar1;
  
  __mutex = (pthread_mutex_t *)(param_1 + 0x218);
  pthread_mutex_lock(__mutex);
  if (*(int *)(param_1 + 0x208) == 0) {
    pthread_mutex_unlock(__mutex);
    return 0;
  }
  if (param_3 != 0) {
    *(undefined4 *)(param_1 + 0x20c) = 0;
    *(undefined4 *)(param_1 + 0x1f0c) = 0;
    *(undefined4 *)(param_1 + 0x1f10) = 0;
    *(undefined4 *)(param_1 + 0x1f14) = 0;
    *(undefined4 *)(param_1 + 0x1f18) = 0;
    FUN_00106d30(param_1 + 0x1dc0);
    FUN_00106d30(param_1 + 0x1df0);
    if (1 < *(uint *)(param_1 + 0x1eec)) {
      FUN_00106d30(param_1 + 0x1e20);
    }
    if (1 < *(uint *)(param_1 + 0x1ef0)) {
      FUN_0011a230(param_1 + 0x1e50);
    }
    FUN_0011a230(param_1 + 0x1e90);
  }
  iVar1 = FUN_00106b40(param_1 + 0x1dc0,param_2);
  if (iVar1 != 0) {
    *(undefined4 *)(param_1 + 0x20c) = 1;
  }
  pthread_mutex_unlock(__mutex);
  return iVar1;
}


==================================================================

### FUNC 00107760 (601 bytes) name=FUN_00107760

void FUN_00107760(long param_1)

{
  long lVar1;
  long lVar2;
  int iVar3;
  ulong uVar4;
  FILE *__stream;
  size_t sVar5;
  long lVar6;
  size_t sVar7;
  int iVar8;
  uint uVar9;
  int *piVar10;
  uint uVar11;
  uint uVar12;
  long lVar14;
  ulong uVar13;
  
  *(undefined4 *)(param_1 + 0x1330) = 0;
  piVar10 = (int *)(param_1 + 0x1448);
  uVar4 = 0;
  do {
    uVar13 = uVar4;
    uVar11 = (uint)uVar13;
    uVar4 = (ulong)(uVar11 + 1);
    if (uVar11 == *(int *)(param_1 + 0x1438) - 2U) break;
    iVar3 = *piVar10;
    piVar10 = piVar10 + 1;
  } while (iVar3 < *(int *)(param_1 + 0x3c));
  iVar3 = *(int *)(param_1 + 0x77f8);
  iVar8 = *(int *)(param_1 + 0x1434);
  uVar12 = *(uint *)(param_1 + 0x143c);
  *(uint *)(param_1 + 0x1720) = uVar11;
  uVar9 = iVar3 * 2 * (iVar8 * 3 + -1) + *(int *)(param_1 + 0x1440) + uVar12;
  if (uVar11 <= uVar11 + 1) {
    do {
      lVar1 = param_1 + uVar13 * 4;
      if (*(int *)(lVar1 + 0x1598) == 0) {
        iVar3 = access((char *)(param_1 + 0x1334),0);
        if (iVar3 != 0) {
LAB_001079a7:
          *(undefined4 *)(param_1 + 0x1328) = 0;
          return;
        }
        __stream = fopen((char *)(param_1 + 0x1334),"rb");
        fseek(__stream,(ulong)*(uint *)(lVar1 + 0x15e8),0);
        sVar5 = fread((void *)((ulong)*(uint *)(lVar1 + 0x1638) + *(long *)(param_1 + 0x1580)),1,
                      (ulong)uVar9,__stream);
        if ((*(int *)(lVar1 + 0x1534) != 0) && ((uint)uVar13 <= *(int *)(param_1 + 0x1438) - 2U)) {
          fseek(__stream,(ulong)*(uint *)(lVar1 + 0x1688),0);
          sVar7 = fread((void *)((ulong)*(uint *)(lVar1 + 0x16d4) + *(long *)(param_1 + 0x1590)),4,
                        (ulong)(uint)(*(int *)(lVar1 + 0x1534) * 10),__stream);
          if ((ulong)(uint)(*(int *)(lVar1 + 0x1534) * 10) != (sVar7 & 0xffffffff)) {
            fclose(__stream);
            goto LAB_001079a7;
          }
        }
        fclose(__stream);
        if (uVar9 != (uint)sVar5) goto LAB_001079a7;
        *(undefined4 *)(lVar1 + 0x1598) = 1;
      }
      uVar11 = *(uint *)(param_1 + 0x1720);
      uVar12 = (uint)uVar13 + 1;
      uVar13 = (ulong)uVar12;
      uVar4 = (ulong)(uVar11 + 1);
    } while (uVar12 <= uVar11 + 1);
    iVar3 = *(int *)(param_1 + 0x77f8);
    iVar8 = *(int *)(param_1 + 0x1434);
    uVar12 = *(uint *)(param_1 + 0x143c);
  }
  lVar1 = param_1 + (ulong)uVar11 * 4;
  uVar11 = *(uint *)(lVar1 + 0x1638);
  lVar6 = (ulong)*(uint *)(param_1 + 0x1638 + uVar4 * 4) + *(long *)(param_1 + 0x1580);
  *(long *)(param_1 + 0x1730) = lVar6;
  lVar2 = ((ulong)(uVar12 >> 1) + (ulong)(uint)(iVar3 * (iVar8 + -1))) * 2;
  lVar14 = (ulong)uVar11 + *(long *)(param_1 + 0x1580);
  *(long *)(param_1 + 0x1728) = lVar14;
  *(long *)(param_1 + 0x1748) = lVar6 + lVar2;
  *(long *)(param_1 + 0x1740) = lVar14 + lVar2;
  *(ulong *)(param_1 + 0x1758) = (ulong)*(uint *)(lVar1 + 0x16d4) + *(long *)(param_1 + 0x1590);
  return;
}


==================================================================

### FUNC 001079d0 (3935 bytes) name=FUN_001079d0

void FUN_001079d0(long param_1,undefined4 param_2)

{
  pthread_mutex_t *__mutex;
  undefined2 uVar1;
  undefined4 uVar2;
  ulong uVar3;
  undefined1 uVar4;
  uint uVar5;
  char *pcVar6;
  undefined1 *puVar7;
  int *piVar8;
  char cVar9;
  ulong uVar10;
  int iVar11;
  int iVar12;
  long lVar13;
  int iVar14;
  undefined8 *puVar15;
  undefined8 *puVar16;
  undefined8 *puVar17;
  undefined8 *puVar18;
  undefined8 *puVar19;
  undefined8 *puVar20;
  int iVar21;
  bool bVar22;
  byte bVar23;
  
  bVar23 = 0;
  __mutex = (pthread_mutex_t *)(param_1 + 0x218);
  pthread_mutex_lock(__mutex);
  puVar15 = (undefined8 *)(param_1 + 0x2b0);
  puVar17 = (undefined8 *)(param_1 + 0x6d8);
  puVar16 = (undefined8 *)(param_1 + 0xb00);
  puVar18 = (undefined8 *)(param_1 + 0xf28);
  switch(param_2) {
  case 0:
    iVar11 = 0;
    puVar7 = (undefined1 *)(param_1 + 0x2b2);
    do {
      uVar4 = (undefined1)iVar11;
      *puVar7 = uVar4;
      puVar7[-1] = uVar4;
      puVar7[-2] = uVar4;
      iVar11 = iVar11 + 1;
      puVar7[1] = 0;
      puVar7 = puVar7 + 4;
    } while (iVar11 != 0x100);
    break;
  case 1:
    iVar11 = 0xff;
    puVar7 = (undefined1 *)(param_1 + 0x2b2);
    do {
      uVar4 = (undefined1)iVar11;
      *puVar7 = uVar4;
      puVar7[-1] = uVar4;
      puVar7[-2] = uVar4;
      iVar11 = iVar11 + -1;
      puVar7[1] = 0;
      puVar7 = puVar7 + 4;
    } while (iVar11 != -1);
    break;
  case 2:
    puVar7 = (undefined1 *)(param_1 + 0x2b2);
    iVar11 = 0;
    do {
      *puVar7 = 0;
      puVar7[-1] = 0;
      iVar14 = iVar11 + 0x75;
      puVar7[1] = 0;
      puVar7[-2] = (char)(iVar11 / 0x16);
      puVar7 = puVar7 + 4;
      iVar11 = iVar14;
    } while (iVar14 != 0xa0e);
    puVar7 = (undefined1 *)(param_1 + 0x30a);
    iVar11 = 0;
    iVar14 = 0;
    do {
      puVar7[-1] = 0;
      puVar7[1] = 0;
      iVar21 = iVar14 + 0xbc;
      *puVar7 = (char)(iVar14 / 0x47);
      puVar7[-2] = (char)(iVar11 / 0x47) + 'u';
      puVar7 = puVar7 + 4;
      iVar11 = iVar11 + 0x25;
      iVar14 = iVar21;
    } while (iVar21 != 0x3424);
    pcVar6 = (char *)(param_1 + 0x426);
    iVar11 = 0;
    iVar14 = 0;
    iVar21 = 0;
    do {
      pcVar6[1] = '\0';
      iVar12 = iVar21 + 0x27;
      *pcVar6 = (char)(iVar21 / 0x1d) + -0x44;
      pcVar6[-1] = (char)(iVar11 / 0x94);
      pcVar6[-2] = (char)(iVar14 / 0x1d) + -0x66;
      pcVar6 = pcVar6 + 4;
      iVar11 = iVar11 + 0xff;
      iVar14 = iVar14 + -0x3b;
      iVar21 = iVar12;
    } while (iVar12 != 0x46b);
    pcVar6 = (char *)(param_1 + 0x49a);
    iVar11 = 0;
    iVar14 = 0x1ce3;
    iVar21 = 0;
    do {
      pcVar6[1] = '\0';
      iVar12 = iVar21 + 0x1c;
      *pcVar6 = (char)(iVar21 / 0x1e) + -0x1d;
      pcVar6[-1] = (char)(iVar14 / 0x94);
      pcVar6[-2] = (char)(iVar11 / 0x12) + '_';
      pcVar6 = pcVar6 + 4;
      iVar11 = iVar11 + -0x50;
      iVar14 = iVar14 + 0xff;
      iVar21 = iVar12;
    } while (iVar12 != 0x1f8);
    puVar19 = puVar15;
    iVar11 = 0x2ed1;
    iVar14 = 0x1f8;
    do {
      *(undefined1 *)(puVar19 + 0x46) = 0xf;
      *(undefined1 *)((long)puVar19 + 0x233) = 0;
      iVar21 = iVar14 + 0x1c;
      *(char *)((long)puVar19 + 0x232) = (char)(iVar14 / 0x1e) + -0x1d;
      *(char *)((long)puVar19 + 0x231) = (char)(iVar11 / 0x94);
      puVar19 = (undefined8 *)((long)puVar19 + 4);
      iVar11 = iVar11 + 0xff;
      iVar14 = iVar21;
    } while (iVar21 != 0x348);
    puVar7 = (undefined1 *)(param_1 + 0x512);
    iVar11 = 0x3ac5;
    do {
      *puVar7 = 0xff;
      puVar7[-2] = 0xf;
      puVar7[1] = 0;
      iVar14 = iVar11 + 0xff;
      puVar7[-1] = (char)(iVar11 / 0x94);
      puVar7 = puVar7 + 4;
      iVar11 = iVar14;
    } while (iVar14 != 0x817e);
    puVar7 = (undefined1 *)(param_1 + 0x62e);
    iVar11 = 0;
    iVar14 = 0x817e;
    do {
      *puVar7 = 0xff;
      puVar7[1] = 0;
      iVar21 = iVar14 + 0xff;
      puVar7[-1] = (char)(iVar14 / 0x94);
      puVar7[-2] = (char)(iVar11 >> 5) + '\x0f';
      puVar7 = puVar7 + 4;
      iVar11 = iVar11 + 0xf0;
      iVar14 = iVar21;
    } while (iVar21 != 0x936c);
    puVar19 = puVar15;
    iVar11 = 0x10e0;
    do {
      iVar14 = iVar11 + 0xf0;
      *(undefined1 *)((long)puVar19 + 0x3c6) = 0xff;
      *(undefined1 *)((long)puVar19 + 0x3c5) = 0xff;
      *(undefined1 *)((long)puVar19 + 0x3c7) = 0;
      *(char *)((long)puVar19 + 0x3c4) = (char)(iVar11 >> 5) + '\x0f';
      puVar19 = (undefined8 *)((long)puVar19 + 4);
      iVar11 = iVar14;
    } while (iVar14 != 0x1ef0);
    break;
  case 3:
    puVar7 = (undefined1 *)(param_1 + 0x2b2);
    iVar11 = 0;
    iVar14 = 0;
    do {
      iVar21 = iVar11 + 0xff;
      *puVar7 = 0;
      puVar7[1] = 0;
      puVar7[-1] = (char)(iVar11 >> 7);
      puVar7[-2] = (char)(iVar14 >> 6) + '2';
      puVar7 = puVar7 + 4;
      iVar11 = iVar21;
      iVar14 = iVar14 + 0xcd;
    } while (iVar21 != 0x3fc0);
    iVar11 = 0;
    puVar7 = (undefined1 *)(param_1 + 0x3b2);
    do {
      puVar7[1] = 0;
      *puVar7 = (char)(iVar11 >> 6);
      puVar7[-1] = (char)(iVar11 + 0x3fc0 >> 7);
      iVar14 = -iVar11;
      if (iVar14 < 0) {
        iVar14 = iVar14 + 0x3f;
      }
      iVar11 = iVar11 + 0xff;
      puVar7[-2] = (char)(iVar14 >> 6) + -1;
      puVar7 = puVar7 + 4;
    } while (iVar11 != 0x3fc0);
    puVar7 = (undefined1 *)(param_1 + 0x4b2);
    iVar11 = 0;
    do {
      *puVar7 = 0xff;
      puVar7[1] = 0;
      iVar14 = iVar11 + 0x3f;
      if (-1 < iVar11) {
        iVar14 = iVar11;
      }
      puVar7[-1] = (char)(iVar14 >> 6) + -1;
      iVar14 = iVar11 + -0xff;
      puVar7[-2] = (char)(-iVar11 >> 7);
      puVar7 = puVar7 + 4;
      iVar11 = iVar14;
    } while (iVar14 != -0x3fc0);
    iVar11 = 0;
    puVar7 = (undefined1 *)(param_1 + 0x5b2);
    do {
      *puVar7 = 0xff;
      puVar7[1] = 0;
      puVar7[-1] = (char)(iVar11 >> 6);
      iVar14 = iVar11 + 0x3fc0;
      iVar11 = iVar11 + 0xff;
      puVar7[-2] = (char)(iVar14 >> 7);
      puVar7 = puVar7 + 4;
    } while (iVar11 != 0x3fc0);
    break;
  case 4:
    puVar7 = (undefined1 *)(param_1 + 0x2b2);
    iVar11 = 0;
    do {
      puVar7[-1] = (char)iVar11;
      iVar11 = iVar11 + 1;
      *puVar7 = 0x32;
      puVar7[-2] = 0;
      puVar7[1] = 0;
      puVar7 = puVar7 + 4;
    } while (iVar11 != 0x32);
    iVar11 = 0x32;
    pcVar6 = (char *)(param_1 + 0x37a);
    iVar14 = 0;
    do {
      pcVar6[-1] = (char)iVar11;
      iVar11 = iVar11 + 1;
      pcVar6[-2] = '\0';
      pcVar6[1] = '\0';
      *pcVar6 = (char)(iVar14 / 0x96) + '2';
      pcVar6 = pcVar6 + 4;
      iVar14 = iVar14 + 0xcd;
    } while (iVar11 != 200);
    puVar7 = (undefined1 *)(param_1 + 0x5d2);
    iVar11 = 200;
    do {
      puVar7[-1] = (char)iVar11;
      iVar11 = iVar11 + 1;
      *puVar7 = 0xff;
      puVar7[-2] = 0;
      puVar7[1] = 0;
      puVar7 = puVar7 + 4;
    } while (iVar11 != 0x100);
    break;
  case 5:
    puVar7 = (undefined1 *)(param_1 + 0x2b2);
    iVar11 = 0;
    iVar14 = 0;
    iVar21 = 0;
    do {
      iVar12 = iVar21 + 0xcb;
      puVar7[1] = 0;
      *puVar7 = (char)(iVar21 >> 6);
      puVar7[-1] = (char)(iVar11 >> 6);
      puVar7[-2] = (char)(iVar14 >> 6);
      puVar7 = puVar7 + 4;
      iVar11 = iVar11 + 0x16;
      iVar14 = iVar14 + 0x24;
      iVar21 = iVar12;
    } while (iVar12 != 0x32c0);
    iVar14 = 0;
    iVar21 = 0;
    iVar11 = 0;
    pcVar6 = (char *)(param_1 + 0x3b2);
    do {
      pcVar6[1] = '\0';
      *pcVar6 = (char)(iVar11 >> 6) + -0x35;
      pcVar6[-1] = (char)(iVar21 >> 6) + '\x16';
      iVar12 = iVar14 + 0x3f;
      if (-1 < iVar14) {
        iVar12 = iVar14;
      }
      iVar11 = iVar11 + 0x34;
      iVar21 = iVar21 + 0x44;
      iVar14 = iVar14 + -0x24;
      pcVar6[-2] = (char)(iVar12 >> 6) + '$';
      pcVar6 = pcVar6 + 4;
    } while (iVar11 != 0xd00);
    puVar7 = (undefined1 *)(param_1 + 0x4b2);
    iVar11 = 0;
    do {
      iVar14 = iVar11 + 0x7c;
      *puVar7 = 0xff;
      puVar7[-2] = 0;
      puVar7[1] = 0;
      puVar7[-1] = (char)(iVar11 >> 6) + 'Z';
      puVar7 = puVar7 + 4;
      iVar11 = iVar14;
    } while (iVar14 != 0x1f00);
    puVar7 = (undefined1 *)(param_1 + 0x5b2);
    iVar11 = 0;
    iVar14 = 0;
    do {
      iVar21 = iVar14 + 0x29;
      *puVar7 = 0xff;
      puVar7[1] = 0;
      puVar7[-1] = (char)(iVar14 >> 6) + -0x2a;
      puVar7[-2] = (char)(iVar11 >> 6);
      puVar7 = puVar7 + 4;
      iVar11 = iVar11 + 0xff;
      iVar14 = iVar21;
    } while (iVar21 != 0xa40);
    break;
  case 6:
    pcVar6 = (char *)(param_1 + 0x2b2);
    iVar11 = 0;
    do {
      pcVar6[1] = '\0';
      iVar14 = iVar11 + -0xff;
      *pcVar6 = (char)(iVar11 / 100) + -1;
      pcVar6[-1] = ~(byte)iVar11;
      pcVar6[-2] = ~(byte)iVar11;
      pcVar6 = pcVar6 + 4;
      iVar11 = iVar14;
    } while (iVar14 != -0x639c);
    iVar11 = 0;
    puVar7 = (undefined1 *)(param_1 + 0x442);
    do {
      puVar7[1] = 0;
      iVar14 = iVar11 / 0x69;
      cVar9 = (char)iVar11 + -0x65;
      iVar11 = iVar11 + 0xff;
      *puVar7 = (char)iVar14;
      puVar7[-1] = cVar9;
      puVar7[-2] = cVar9;
      puVar7 = puVar7 + 4;
    } while (iVar11 != 0x6897);
    puVar7 = (undefined1 *)(param_1 + 0x5e6);
    iVar11 = 0x32;
    do {
      puVar7[-1] = (char)iVar11;
      puVar7[-2] = (char)iVar11;
      iVar11 = iVar11 + -1;
      *puVar7 = 0xff;
      puVar7[1] = 0;
      puVar7 = puVar7 + 4;
    } while (iVar11 != -1);
    break;
  case 7:
    iVar11 = 0;
    pcVar6 = (char *)(param_1 + 0x2b2);
    do {
      cVar9 = (char)iVar11;
      iVar11 = iVar11 + 1;
      pcVar6[-1] = '\0';
      pcVar6[-2] = '\0';
      pcVar6[1] = '\0';
      *pcVar6 = cVar9 * '\x02';
      pcVar6 = pcVar6 + 4;
    } while (iVar11 != 0x80);
    puVar7 = (undefined1 *)(param_1 + 0x4b2);
    iVar11 = 0;
    do {
      *puVar7 = 0xff;
      puVar7[1] = 0;
      iVar14 = iVar11 + 0xff;
      uVar4 = (undefined1)(iVar11 / 0x7f);
      puVar7[-1] = uVar4;
      puVar7[-2] = uVar4;
      puVar7 = puVar7 + 4;
      iVar11 = iVar14;
    } while (iVar14 != 0x7f80);
    break;
  case 8:
    puVar7 = (undefined1 *)(param_1 + 0x2b2);
    cVar9 = '\x7f';
    do {
      puVar7[-2] = cVar9;
      cVar9 = cVar9 + '\x04';
      *puVar7 = 0;
      puVar7[-1] = 0;
      puVar7[1] = 0;
      puVar7 = puVar7 + 4;
    } while (cVar9 != -1);
    puVar7 = (undefined1 *)(param_1 + 0x332);
    iVar11 = 0;
    do {
      iVar14 = iVar11 + 0xff;
      *puVar7 = 0;
      puVar7[-2] = 0xff;
      puVar7[1] = 0;
      puVar7[-1] = (char)(iVar11 >> 6);
      puVar7 = puVar7 + 4;
      iVar11 = iVar14;
    } while (iVar14 != 0x3fc0);
    iVar11 = 0;
    puVar7 = (undefined1 *)(param_1 + 0x432);
    do {
      puVar7[-1] = 0xff;
      puVar7[1] = 0;
      *puVar7 = (char)(iVar11 >> 6);
      iVar14 = -iVar11;
      if (iVar14 < 0) {
        iVar14 = iVar14 + 0x3f;
      }
      iVar11 = iVar11 + 0xff;
      puVar7[-2] = (char)(iVar14 >> 6) + -1;
      puVar7 = puVar7 + 4;
    } while (iVar11 != 0x3fc0);
    iVar11 = 0;
    puVar7 = (undefined1 *)(param_1 + 0x532);
    do {
      *puVar7 = 0xff;
      puVar7[-2] = 0;
      puVar7[1] = 0;
      iVar14 = iVar11 + 0x3f;
      if (-1 < iVar11) {
        iVar14 = iVar11;
      }
      iVar11 = iVar11 + -0xff;
      puVar7[-1] = (char)(iVar14 >> 6) + -1;
      puVar7 = puVar7 + 4;
    } while (iVar11 != -0x3fc0);
    pcVar6 = (char *)(param_1 + 0x632);
    cVar9 = -1;
    do {
      *pcVar6 = cVar9;
      cVar9 = cVar9 + -4;
      pcVar6[-1] = '\0';
      pcVar6[-2] = '\0';
      pcVar6[1] = '\0';
      pcVar6 = pcVar6 + 4;
    } while (cVar9 != '\x7f');
    break;
  case 9:
    puVar7 = (undefined1 *)(param_1 + 0x2b2);
    iVar11 = 0;
    do {
      puVar7[1] = 0;
      iVar14 = iVar11 + 0xff;
      uVar4 = (undefined1)(iVar11 / 200);
      *puVar7 = uVar4;
      puVar7[-1] = uVar4;
      puVar7[-2] = uVar4;
      puVar7 = puVar7 + 4;
      iVar11 = iVar14;
    } while (iVar14 != 0x9867);
    puVar7 = (undefined1 *)(param_1 + 0x516);
    iVar11 = 0x9867;
    do {
      puVar7[-1] = 0xc3;
      puVar7[-2] = 0xc3;
      iVar14 = iVar11 + 0xff;
      puVar7[1] = 0;
      *puVar7 = (char)(iVar11 / 200);
      puVar7 = puVar7 + 4;
      iVar11 = iVar14;
    } while (iVar14 != 51000);
    puVar7 = (undefined1 *)(param_1 + 0x5d2);
    iVar11 = 0;
    do {
      *puVar7 = 0xff;
      puVar7[1] = 0;
      iVar14 = iVar11 + -0xc3;
      cVar9 = (char)(iVar11 / 0x37) + -0x3d;
      puVar7[-1] = cVar9;
      puVar7[-2] = cVar9;
      puVar7 = puVar7 + 4;
      iVar11 = iVar14;
    } while (iVar14 != -0x2aa8);
    break;
  case 10:
    pcVar6 = (char *)(param_1 + 0x2b2);
    cVar9 = '\0';
    do {
      *pcVar6 = cVar9;
      pcVar6[-2] = cVar9;
      cVar9 = cVar9 + '\a';
      pcVar6[-1] = '\0';
      pcVar6[1] = '\0';
      pcVar6 = pcVar6 + 4;
    } while (cVar9 != -4);
    iVar11 = 0;
    pcVar6 = (char *)(param_1 + 0x342);
    do {
      pcVar6[-1] = '\0';
      cVar9 = (char)iVar11;
      pcVar6[1] = '\0';
      iVar14 = iVar11 + 3;
      if (-1 < iVar11) {
        iVar14 = iVar11;
      }
      iVar11 = iVar11 + 7;
      *pcVar6 = -4 - cVar9;
      pcVar6[-2] = -4 - (char)(iVar14 >> 2);
      pcVar6 = pcVar6 + 4;
    } while (iVar11 != 0x103);
    iVar11 = 0xf5;
    puVar7 = (undefined1 *)(param_1 + 0x3d6);
    do {
      *puVar7 = 0;
      puVar7[1] = 0;
      puVar7[-1] = -4 - (char)iVar11;
      iVar14 = iVar11 + 3;
      if (-1 < iVar11) {
        iVar14 = iVar11;
      }
      iVar11 = iVar11 + -7;
      puVar7[-2] = -4 - (char)(iVar14 >> 2);
      puVar7 = puVar7 + 4;
    } while (iVar11 != -7);
    uVar10 = 0;
    puVar7 = (undefined1 *)(param_1 + 0x466);
    do {
      *puVar7 = 0;
      puVar7[1] = 0;
      puVar7[-1] = -4 - (char)((int)(uVar10 >> 0x1f) + (int)uVar10 >> 1);
      cVar9 = (char)uVar10;
      uVar5 = (int)uVar10 + 7;
      uVar10 = (ulong)uVar5;
      puVar7[-2] = -4 - cVar9;
      puVar7 = puVar7 + 4;
    } while (uVar5 != 0x103);
    uVar10 = 0xf5;
    pcVar6 = (char *)(param_1 + 0x4fa);
    do {
      pcVar6[-2] = '\0';
      pcVar6[1] = '\0';
      iVar11 = (int)uVar10;
      *pcVar6 = -4 - (char)uVar10;
      uVar3 = uVar10 >> 0x1f;
      uVar5 = iVar11 - 7;
      uVar10 = (ulong)uVar5;
      pcVar6[-1] = -4 - (char)((int)uVar3 + iVar11 >> 1);
      pcVar6 = pcVar6 + 4;
    } while (uVar5 != 0xfffffff9);
    iVar11 = 0;
    pcVar6 = (char *)(param_1 + 0x58a);
    do {
      pcVar6[-2] = '\0';
      pcVar6[1] = '\0';
      iVar14 = iVar11 + 3;
      if (-1 < iVar11) {
        iVar14 = iVar11;
      }
      *pcVar6 = -4 - (char)(iVar14 >> 2);
      cVar9 = (char)iVar11;
      iVar11 = iVar11 + 7;
      pcVar6[-1] = -4 - cVar9;
      pcVar6 = pcVar6 + 4;
    } while (iVar11 != 0x103);
    iVar11 = 0xfc;
    pcVar6 = (char *)(param_1 + 0x61e);
    do {
      pcVar6[1] = '\0';
      iVar14 = iVar11 + 3;
      if (-1 < iVar11) {
        iVar14 = iVar11;
      }
      *pcVar6 = -4 - (char)(iVar14 >> 2);
      cVar9 = -4 - (char)iVar11;
      iVar11 = iVar11 + -7;
      pcVar6[-1] = cVar9;
      pcVar6[-2] = cVar9;
      pcVar6 = pcVar6 + 4;
    } while (iVar11 != -7);
    break;
  case 0xb:
    puVar7 = (undefined1 *)(param_1 + 0x2b2);
    cVar9 = '\0';
    do {
      puVar7[-2] = cVar9;
      cVar9 = cVar9 + '\a';
      *puVar7 = 0;
      puVar7[-1] = 0;
      puVar7[1] = 0;
      puVar7 = puVar7 + 4;
    } while (cVar9 != -4);
    puVar7 = (undefined1 *)(param_1 + 0x342);
    cVar9 = '\0';
    do {
      puVar7[-1] = cVar9;
      cVar9 = cVar9 + '\a';
      *puVar7 = 0;
      puVar7[-2] = 0xff;
      puVar7[1] = 0;
      puVar7 = puVar7 + 4;
    } while (cVar9 != '\x03');
    puVar7 = (undefined1 *)(param_1 + 0x3d6);
    cVar9 = -0xb;
    do {
      puVar7[-2] = cVar9;
      cVar9 = cVar9 + -7;
      *puVar7 = 0;
      puVar7[-1] = 0xff;
      puVar7[1] = 0;
      puVar7 = puVar7 + 4;
    } while (cVar9 != -7);
    pcVar6 = (char *)(param_1 + 0x466);
    cVar9 = '\0';
    do {
      *pcVar6 = cVar9;
      cVar9 = cVar9 + '\a';
      pcVar6[-1] = -1;
      pcVar6[-2] = '\0';
      pcVar6[1] = '\0';
      pcVar6 = pcVar6 + 4;
    } while (cVar9 != '\x03');
    puVar7 = (undefined1 *)(param_1 + 0x4fa);
    cVar9 = -0xb;
    do {
      puVar7[-1] = cVar9;
      cVar9 = cVar9 + -7;
      *puVar7 = 0xff;
      puVar7[-2] = 0;
      puVar7[1] = 0;
      puVar7 = puVar7 + 4;
    } while (cVar9 != -7);
    puVar7 = (undefined1 *)(param_1 + 0x58a);
    cVar9 = '\0';
    do {
      puVar7[-2] = cVar9;
      cVar9 = cVar9 + '\a';
      *puVar7 = 0xff;
      puVar7[-1] = 0;
      puVar7[1] = 0;
      puVar7 = puVar7 + 4;
    } while (cVar9 != '\x03');
    puVar7 = (undefined1 *)(param_1 + 0x61e);
    cVar9 = '\0';
    do {
      puVar7[-1] = cVar9;
      cVar9 = cVar9 + '\a';
      *puVar7 = 0xff;
      puVar7[-2] = 0xff;
      puVar7[1] = 0;
      puVar7 = puVar7 + 4;
    } while (cVar9 != '\x03');
    break;
  case 0xc:
    puVar7 = (undefined1 *)(param_1 + 0x2b2);
    lVar13 = 0;
    do {
      puVar7[-1] = (char)lVar13;
      lVar13 = lVar13 + 4;
      *puVar7 = 0;
      puVar7[-2] = 0xff;
      puVar7[1] = 0;
      puVar7 = puVar7 + 4;
    } while (lVar13 != 0x100);
    iVar11 = 0x3f;
    puVar7 = (undefined1 *)(param_1 + 0x3b2);
    do {
      cVar9 = (char)iVar11;
      iVar11 = iVar11 + -1;
      *puVar7 = 0;
      puVar7[-1] = 0xff;
      puVar7[1] = 0;
      puVar7[-2] = cVar9 * '\x04';
      puVar7 = puVar7 + 4;
    } while (iVar11 != -1);
    puVar7 = (undefined1 *)(param_1 + 0x4b2);
    lVar13 = 0;
    do {
      *puVar7 = (char)lVar13;
      lVar13 = lVar13 + 4;
      puVar7[-1] = 0xff;
      puVar7[-2] = 0;
      puVar7[1] = 0;
      puVar7 = puVar7 + 4;
    } while (lVar13 != 0x100);
    iVar11 = 0x3f;
    puVar7 = (undefined1 *)(param_1 + 0x5b2);
    do {
      cVar9 = (char)iVar11;
      iVar11 = iVar11 + -1;
      *puVar7 = 0xff;
      puVar7[-2] = 0;
      puVar7[1] = 0;
      puVar7[-1] = cVar9 * '\x04';
      puVar7 = puVar7 + 4;
    } while (iVar11 != -1);
    break;
  default:
    pthread_mutex_unlock(__mutex);
    piVar8 = __errno_location();
    *piVar8 = -0x1b51ffff;
    return;
  }
  bVar22 = ((ulong)puVar17 & 1) != 0;
  uVar5 = 0x400;
  puVar19 = puVar15;
  if (bVar22) {
    puVar17 = (undefined8 *)(param_1 + 0x6d9);
    puVar19 = (undefined8 *)(param_1 + 0x2b1);
    *(undefined1 *)(param_1 + 0x6d8) = *(undefined1 *)(param_1 + 0x2b0);
    uVar5 = 0x3ff;
  }
  puVar20 = puVar17;
  if (((ulong)puVar17 & 2) != 0) {
    uVar1 = *(undefined2 *)puVar19;
    puVar20 = (undefined8 *)((long)puVar17 + 2);
    puVar19 = (undefined8 *)((long)puVar19 + 2);
    uVar5 = uVar5 - 2;
    *(undefined2 *)puVar17 = uVar1;
  }
  puVar17 = puVar20;
  if (((ulong)puVar20 & 4) != 0) {
    uVar2 = *(undefined4 *)puVar19;
    puVar17 = (undefined8 *)((long)puVar20 + 4);
    puVar19 = (undefined8 *)((long)puVar19 + 4);
    uVar5 = uVar5 - 4;
    *(undefined4 *)puVar20 = uVar2;
  }
  lVar13 = 0;
  for (uVar10 = (ulong)(uVar5 >> 3); uVar10 != 0; uVar10 = uVar10 - 1) {
    *puVar17 = *puVar19;
    puVar19 = puVar19 + (ulong)bVar23 * -2 + 1;
    puVar17 = puVar17 + (ulong)bVar23 * -2 + 1;
  }
  if ((uVar5 & 4) != 0) {
    *(undefined4 *)puVar17 = *(undefined4 *)puVar19;
    lVar13 = 4;
  }
  if ((uVar5 & 2) != 0) {
    *(undefined2 *)((long)puVar17 + lVar13) = *(undefined2 *)((long)puVar19 + lVar13);
    lVar13 = lVar13 + 2;
  }
  if (bVar22) {
    *(undefined1 *)((long)puVar17 + lVar13) = *(undefined1 *)((long)puVar19 + lVar13);
  }
  bVar22 = ((ulong)puVar16 & 1) != 0;
  uVar5 = 0x400;
  puVar17 = puVar15;
  if (bVar22) {
    puVar16 = (undefined8 *)(param_1 + 0xb01);
    puVar17 = (undefined8 *)(param_1 + 0x2b1);
    *(undefined1 *)(param_1 + 0xb00) = *(undefined1 *)(param_1 + 0x2b0);
    uVar5 = 0x3ff;
  }
  puVar19 = puVar16;
  if (((ulong)puVar16 & 2) != 0) {
    uVar1 = *(undefined2 *)puVar17;
    puVar19 = (undefined8 *)((long)puVar16 + 2);
    puVar17 = (undefined8 *)((long)puVar17 + 2);
    uVar5 = uVar5 - 2;
    *(undefined2 *)puVar16 = uVar1;
  }
  puVar16 = puVar19;
  if (((ulong)puVar19 & 4) != 0) {
    uVar2 = *(undefined4 *)puVar17;
    puVar16 = (undefined8 *)((long)puVar19 + 4);
    puVar17 = (undefined8 *)((long)puVar17 + 4);
    uVar5 = uVar5 - 4;
    *(undefined4 *)puVar19 = uVar2;
  }
  lVar13 = 0;
  for (uVar10 = (ulong)(uVar5 >> 3); uVar10 != 0; uVar10 = uVar10 - 1) {
    *puVar16 = *puVar17;
    puVar17 = puVar17 + (ulong)bVar23 * -2 + 1;
    puVar16 = puVar16 + (ulong)bVar23 * -2 + 1;
  }
  if ((uVar5 & 4) != 0) {
    *(undefined4 *)puVar16 = *(undefined4 *)puVar17;
    lVar13 = 4;
  }
  if ((uVar5 & 2) != 0) {
    *(undefined2 *)((long)puVar16 + lVar13) = *(undefined2 *)((long)puVar17 + lVar13);
    lVar13 = lVar13 + 2;
  }
  if (bVar22) {
    *(undefined1 *)((long)puVar16 + lVar13) = *(undefined1 *)((long)puVar17 + lVar13);
  }
  bVar22 = ((ulong)puVar18 & 1) != 0;
  uVar5 = 0x400;
  if (bVar22) {
    puVar18 = (undefined8 *)(param_1 + 0xf29);
    puVar15 = (undefined8 *)(param_1 + 0x2b1);
    *(undefined1 *)(param_1 + 0xf28) = *(undefined1 *)(param_1 + 0x2b0);
    uVar5 = 0x3ff;
  }
  puVar17 = puVar18;
  if (((ulong)puVar18 & 2) != 0) {
    uVar1 = *(undefined2 *)puVar15;
    puVar17 = (undefined8 *)((long)puVar18 + 2);
    puVar15 = (undefined8 *)((long)puVar15 + 2);
    uVar5 = uVar5 - 2;
    *(undefined2 *)puVar18 = uVar1;
  }
  puVar16 = puVar17;
  if (((ulong)puVar17 & 4) != 0) {
    uVar2 = *(undefined4 *)puVar15;
    puVar16 = (undefined8 *)((long)puVar17 + 4);
    puVar15 = (undefined8 *)((long)puVar15 + 4);
    uVar5 = uVar5 - 4;
    *(undefined4 *)puVar17 = uVar2;
  }
  lVar13 = 0;
  for (uVar10 = (ulong)(uVar5 >> 3); uVar10 != 0; uVar10 = uVar10 - 1) {
    *puVar16 = *puVar15;
    puVar15 = puVar15 + (ulong)bVar23 * -2 + 1;
    puVar16 = puVar16 + (ulong)bVar23 * -2 + 1;
  }
  if ((uVar5 & 4) != 0) {
    *(undefined4 *)puVar16 = *(undefined4 *)puVar15;
    lVar13 = 4;
  }
  if ((uVar5 & 2) != 0) {
    *(undefined2 *)((long)puVar16 + lVar13) = *(undefined2 *)((long)puVar15 + lVar13);
    lVar13 = lVar13 + 2;
  }
  if (bVar22) {
    *(undefined1 *)((long)puVar16 + lVar13) = *(undefined1 *)((long)puVar15 + lVar13);
  }
  pthread_mutex_unlock(__mutex);
  return;
}


==================================================================

### FUNC 00108990 (51 bytes) name=FUN_00108990

void FUN_00108990(long param_1)

{
  ushort uVar1;
  uint uVar2;
  int iVar3;
  ushort *puVar4;
  
  iVar3 = *(int *)(param_1 + 0x77f8);
  puVar4 = *(ushort **)(param_1 + 0x268);
  uVar1 = *puVar4;
  uVar2 = (uint)uVar1;
  if (iVar3 != 0) {
    while( true ) {
      if ((ushort)uVar2 < uVar1) {
        uVar2 = (uint)uVar1;
      }
      iVar3 = iVar3 + -1;
      if (iVar3 == 0) break;
      uVar1 = puVar4[1];
      puVar4 = puVar4 + 1;
    }
  }
  *(uint *)(param_1 + 0x1f20) = uVar2;
  return;
}


==================================================================

### FUNC 001089d0 (269 bytes) name=FUN_001089d0

void FUN_001089d0(long param_1,ushort *param_2)

{
  ushort uVar1;
  uint uVar2;
  int iVar3;
  long lVar4;
  ulong uVar5;
  long lVar6;
  uint uVar7;
  ulong uVar8;
  int iVar9;
  int iVar10;
  uint uVar11;
  ulong uVar12;
  int iVar13;
  double dVar14;
  double dVar15;
  
  uVar2 = *(uint *)(param_1 + 0x77f8);
  uVar1 = *param_2;
  uVar5 = (ulong)uVar1;
  uVar7 = (uint)uVar1;
  if (uVar2 == 0) {
    dVar14 = 0.0;
    uVar11 = (uint)uVar1;
    lVar4 = 0;
    iVar13 = 0;
    iVar9 = 0;
    dVar15 = dVar14;
  }
  else {
    iVar10 = 0;
    lVar6 = 0;
    lVar4 = 0;
    iVar13 = 0;
    iVar9 = 0;
    uVar8 = uVar5;
    uVar12 = uVar5;
    while( true ) {
      uVar7 = (uint)uVar8;
      param_2 = param_2 + 1;
      lVar4 = lVar4 + uVar5;
      uVar11 = (uint)uVar5;
      lVar6 = lVar6 + (ulong)(uVar11 * uVar11);
      iVar3 = iVar10;
      if ((ushort)uVar5 <= (ushort)uVar12) {
        if ((ushort)uVar5 < (ushort)uVar8) {
          uVar8 = uVar5;
          iVar13 = iVar10;
        }
        uVar7 = (uint)uVar8;
        uVar5 = uVar12;
        uVar11 = (uint)uVar12;
        iVar3 = iVar9;
      }
      iVar9 = iVar3;
      uVar12 = uVar5;
      if (iVar10 + 1U == uVar2) break;
      iVar10 = iVar10 + 1;
      uVar5 = (ulong)*param_2;
    }
    dVar14 = (double)lVar4 * (double)lVar4;
    dVar15 = (double)lVar6;
  }
  *(uint *)(param_1 + 0x1f20) = uVar11;
  *(uint *)(param_1 + 0x1f24) = uVar7;
  *(int *)(param_1 + 0x1f30) = iVar9;
  *(int *)(param_1 + 0x1f34) = iVar13;
  *(int *)(param_1 + 0x1f28) = (int)(lVar4 / (long)(ulong)uVar2);
  dVar15 = (dVar15 - dVar14 / (double)uVar2) / (double)(uVar2 - 1);
  dVar14 = SQRT(dVar15);
  if (NAN(dVar14)) {
    dVar14 = sqrt(dVar15);
  }
  *(int *)(param_1 + 0x1f2c) = (int)dVar14;
  return;
}


==================================================================

### FUNC 00108ae0 (724 bytes) name=FUN_00108ae0

void FUN_00108ae0(long param_1)

{
  undefined8 *puVar1;
  int *piVar2;
  int iVar3;
  long lVar4;
  long lVar5;
  int iVar6;
  int iVar7;
  uint uVar8;
  uint uVar9;
  ulong uVar10;
  ulong uVar11;
  long lVar12;
  undefined8 *puVar13;
  undefined8 *puVar14;
  uint uVar15;
  uint uVar16;
  int iVar17;
  bool bVar18;
  uint local_44;
  
  puVar1 = (undefined8 *)(param_1 + 0x1f60);
  uVar11 = 0x400;
  iVar7 = 0x400;
  iVar17 = *(int *)(param_1 + 0x1f3c);
  iVar6 = *(int *)(param_1 + 8000);
  lVar4 = *(long *)(param_1 + 0x268);
  bVar18 = ((ulong)puVar1 & 1) != 0;
  lVar5 = *(long *)(param_1 + 0x298);
  puVar13 = puVar1;
  if (bVar18) {
    *(undefined1 *)(param_1 + 0x1f60) = 0;
    uVar11 = 0x3ff;
    iVar7 = 0x3ff;
    puVar13 = (undefined8 *)(param_1 + 0x1f61);
  }
  if (((ulong)puVar13 & 2) == 0) {
    uVar9 = (uint)uVar11;
  }
  else {
    uVar9 = iVar7 - 2;
    uVar11 = (ulong)uVar9;
    *(undefined2 *)puVar13 = 0;
    puVar13 = (undefined8 *)((long)puVar13 + 2);
  }
  if (((ulong)puVar13 & 4) != 0) {
    *(undefined4 *)puVar13 = 0;
    uVar11 = (ulong)(uVar9 - 4);
    puVar13 = (undefined8 *)((long)puVar13 + 4);
  }
  for (uVar10 = uVar11 >> 3; uVar10 != 0; uVar10 = uVar10 - 1) {
    *puVar13 = 0;
    puVar13 = puVar13 + 1;
  }
  if ((uVar11 & 4) != 0) {
    *(undefined4 *)puVar13 = 0;
    puVar13 = (undefined8 *)((long)puVar13 + 4);
  }
  puVar14 = puVar13;
  if ((uVar11 & 2) != 0) {
    puVar14 = (undefined8 *)((long)puVar13 + 2);
    *(undefined2 *)puVar13 = 0;
  }
  if (bVar18) {
    *(undefined1 *)puVar14 = 0;
  }
  iVar7 = *(int *)(param_1 + 0x77f8);
  iVar3 = *(int *)(param_1 + 8000);
  if (iVar7 != 0) {
    lVar12 = 0;
    do {
      uVar9 = ((uint)*(ushort *)(lVar4 + lVar12 * 2) - iVar3) *
              (int)(0xffc00000 / (ulong)(uint)(iVar17 - iVar6));
      *(undefined1 *)(lVar5 + lVar12) = *(undefined1 *)(param_1 + 0x2760 + (ulong)(uVar9 >> 0x16));
      lVar12 = lVar12 + 1;
      piVar2 = (int *)((long)puVar1 + (ulong)(uVar9 >> 0x18) * 4);
      *piVar2 = *piVar2 + 1;
    } while (lVar12 != (ulong)(iVar7 - 1) + 1);
  }
  *(undefined4 *)(param_1 + 0x1f4c) = 1;
  uVar9 = *(uint *)(param_1 + 0x1ee0);
  lVar4 = *(long *)(param_1 + 0x2a8);
  if (*(int *)(param_1 + 0x74) == 0) {
    uVar15 = *(uint *)(param_1 + 0x1ee4);
    if (uVar15 < 2) {
      iVar17 = 0;
    }
    else {
      iVar17 = (int)(0xff0000 / (ulong)(uVar15 - 1));
    }
    iVar6 = uVar15 - 1;
    if (-1 < iVar6) {
      uVar16 = iVar6 * iVar17;
      uVar15 = iVar6 * uVar9;
      do {
        uVar11 = (ulong)uVar15;
        uVar8 = uVar16 >> 0x10;
        iVar6 = iVar6 + -1;
        uVar16 = uVar16 - iVar17;
        uVar15 = uVar15 - uVar9;
        memset((void *)(uVar11 + lVar4),uVar8 & 0xff,(ulong)uVar9);
      } while (iVar6 != -1);
      return;
    }
  }
  else {
    iVar17 = *(int *)(param_1 + 8000);
    iVar6 = 0;
    if ((*(int *)(param_1 + 0x1f24) != iVar17) && (iVar17 != *(int *)(param_1 + 0x1f3c))) {
      iVar6 = ((*(int *)(param_1 + 0x1f24) - iVar17) * 0x3ff) /
              (*(int *)(param_1 + 0x1f3c) - iVar17);
    }
    iVar7 = 0x3ff;
    if ((iVar17 != *(int *)(param_1 + 0x1f20)) && (iVar17 != *(int *)(param_1 + 0x1f3c))) {
      iVar7 = ((*(int *)(param_1 + 0x1f20) - iVar17) * 0x3ff) /
              (*(int *)(param_1 + 0x1f3c) - iVar17);
    }
    uVar15 = *(uint *)(param_1 + 0x1ee4);
    if (uVar15 < 2) {
      local_44 = 0;
    }
    else {
      local_44 = (uint)((iVar7 - iVar6) * 0x10000) / (uVar15 - 1);
    }
    iVar17 = uVar15 - 1;
    if (-1 < iVar17) {
      uVar16 = iVar17 * uVar9;
      uVar15 = local_44 * iVar17;
      do {
        uVar10 = (ulong)uVar16;
        uVar8 = (uVar15 >> 0x10) + iVar6;
        uVar11 = (ulong)uVar8;
        if (0x3ff < uVar8) {
          uVar11 = 0x3ff;
        }
        iVar17 = iVar17 + -1;
        uVar16 = uVar16 - uVar9;
        memset((void *)(uVar10 + lVar4),(uint)*(byte *)(param_1 + 0x2760 + uVar11),(ulong)uVar9);
        uVar15 = uVar15 - local_44;
      } while (iVar17 != -1);
    }
  }
  return;
}


==================================================================

### FUNC 00108dc0 (56 bytes) name=FUN_00108dc0

undefined8 FUN_00108dc0(long param_1)

{
  if ((*(int *)(param_1 + 0x208) != 0) && (*(int *)(param_1 + 0x214) != 0)) {
    if (*(int *)(param_1 + 0x1f4c) == 0) {
      FUN_00108ae0(param_1,0);
    }
    return *(undefined8 *)(param_1 + 0x298);
  }
  return 0;
}


==================================================================

### FUNC 00108e10 (832 bytes) name=FUN_00108e10

void FUN_00108e10(long param_1)

{
  uint uVar1;
  uint uVar2;
  uint uVar3;
  uint uVar4;
  ulong uVar5;
  uint uVar6;
  uint uVar7;
  ushort *puVar8;
  long lVar9;
  uint uVar10;
  ulong uVar11;
  uint *puVar12;
  uint *puVar13;
  ushort *puVar14;
  uint uVar15;
  uint *puVar16;
  float fVar17;
  float fVar18;
  uint local_2044;
  uint local_2038 [1024];
  float afStack_1038 [1026];
  
  puVar14 = *(ushort **)(param_1 + 0x268);
  uVar4 = *(uint *)(param_1 + 0x1ed4);
  if (uVar4 == 0) {
    uVar10 = 0;
    uVar15 = 0;
    uVar3 = 0;
    uVar1 = 0;
    local_2044 = 0xffffffff;
  }
  else {
    puVar16 = local_2038;
    uVar3 = *(uint *)(param_1 + 0x1ed0);
    local_2044 = uVar4 - 1;
    puVar12 = puVar16;
    do {
      if (uVar3 >> 2 == 0) {
        uVar1 = 0;
      }
      else {
        uVar1 = 0;
        puVar8 = puVar14;
        uVar10 = uVar3 >> 2;
        do {
          uVar1 = uVar1 + (uint)*puVar8 + (uint)puVar8[1] + (uint)puVar8[2] + (uint)puVar8[3];
          uVar10 = uVar10 - 1;
          puVar8 = puVar8 + 4;
        } while (uVar10 != 0);
        puVar14 = puVar14 + (ulong)((uVar3 >> 2) - 1) * 4 + 4;
      }
      puVar13 = puVar12 + 1;
      *puVar12 = uVar1 / uVar3;
      puVar12 = puVar13;
    } while (puVar13 != local_2038 + (ulong)local_2044 + 1);
    uVar10 = uVar4 >> 2;
    uVar15 = uVar4 * 7 >> 3;
    if (uVar4 >> 2 == 0) {
      uVar2 = 0;
      uVar3 = 0;
      if (uVar4 <= uVar10) goto LAB_00109157;
LAB_00108f16:
      uVar1 = 0;
      uVar6 = uVar10;
      do {
        uVar11 = (ulong)uVar6;
        uVar6 = uVar6 + 1;
        uVar1 = uVar1 + local_2038[uVar11];
        uVar3 = uVar2;
      } while (uVar6 != uVar4);
    }
    else {
      uVar2 = 0;
      do {
        uVar2 = uVar2 + *puVar16;
        puVar16 = puVar16 + 1;
      } while (puVar16 != local_2038 + (ulong)(uVar10 - 1) + 1);
      uVar3 = uVar2;
      if (uVar10 < uVar4) goto LAB_00108f16;
LAB_00109157:
      uVar1 = 0;
    }
    if (uVar15 < uVar10) goto LAB_001090f1;
  }
  uVar6 = local_2044 - uVar10;
  uVar2 = uVar10;
  do {
    uVar7 = uVar2 + 1;
    uVar3 = uVar3 + local_2038[uVar2];
    uVar1 = uVar1 - local_2038[uVar2];
    fVar18 = (float)(int)uVar7 / (float)uVar4;
    uVar11 = (ulong)uVar6;
    uVar6 = uVar6 - 1;
    fVar17 = (float)uVar3 / (float)(int)uVar7 - (float)uVar1 / (float)uVar11;
    afStack_1038[uVar2] = (DAT_00131e20 - fVar18) * fVar18 * fVar17 * fVar17;
    uVar2 = uVar7;
  } while (uVar7 <= uVar15);
  uVar11 = (ulong)uVar10;
  fVar17 = afStack_1038[uVar10];
  uVar5 = (ulong)uVar10;
  fVar18 = fVar17;
  while( true ) {
    if (fVar18 <= fVar17) {
      uVar11 = uVar5;
      fVar18 = fVar17;
    }
    uVar3 = (uint)uVar11;
    uVar1 = (int)uVar5 + 1;
    uVar5 = (ulong)uVar1;
    if (uVar1 == uVar15 + 1) break;
    fVar17 = afStack_1038[uVar5];
  }
  if ((uVar15 != uVar3) && (uVar3 != uVar10)) {
    lVar9 = 0;
    uVar1 = 0;
    do {
      uVar1 = uVar1 + local_2038[lVar9];
      lVar9 = lVar9 + 1;
    } while ((uint)lVar9 <= uVar3);
    uVar15 = uVar3 + 1;
    if (uVar15 < uVar4) {
      uVar2 = 0;
      uVar6 = uVar15;
      do {
        uVar5 = (ulong)uVar6;
        uVar6 = uVar6 + 1;
        uVar2 = uVar2 + local_2038[uVar5];
      } while (uVar6 != uVar4);
    }
    else {
      uVar2 = 0;
    }
    uVar1 = uVar1 / uVar15;
    uVar2 = uVar2 / (local_2044 - uVar3);
    uVar6 = (int)(uVar1 - uVar2) >> 0x1f;
    if (((int)(uVar1 + uVar2) <= (int)(((uVar1 - uVar2 ^ uVar6) - uVar6) * 0x80)) &&
       ((int)uVar2 <= (int)uVar1)) {
      *(uint *)(param_1 + 0x4b70) = local_2038[uVar11];
      uVar1 = *(uint *)(param_1 + 0x4b68);
      if ((uVar10 < uVar1) && (uVar1 <= local_2044)) {
        uVar10 = uVar4 >> 7;
        if (uVar4 >> 7 == 0) {
          uVar10 = 1;
        }
        if (uVar10 + uVar1 < uVar3) {
          uVar3 = uVar10 + uVar1;
        }
        if (uVar3 < uVar1 - uVar10) {
          uVar3 = uVar1 - uVar10;
        }
        uVar15 = uVar3 + 1;
      }
      lVar9 = 0;
      uVar4 = 0;
      do {
        uVar4 = uVar4 + local_2038[lVar9];
        lVar9 = lVar9 + 1;
      } while ((uint)lVar9 <= uVar3);
      *(uint *)(param_1 + 0x4b68) = uVar3;
      *(uint *)(param_1 + 0x4b6c) = uVar4 / uVar15;
      return;
    }
  }
LAB_001090f1:
  *(undefined4 *)(param_1 + 0x4b70) = 0;
  *(uint *)(param_1 + 0x4b68) = local_2044;
  *(undefined4 *)(param_1 + 0x4b6c) = *(undefined4 *)(param_1 + 0x1f28);
  return;
}


==================================================================

### FUNC 00109160 (323 bytes) name=FUN_00109160

void FUN_00109160(long param_1,ushort *param_2,ushort *param_3)

{
  undefined8 *puVar1;
  int *piVar2;
  ushort uVar3;
  ushort uVar4;
  undefined2 *puVar5;
  ulong uVar6;
  uint uVar7;
  undefined8 *puVar8;
  undefined8 *puVar9;
  int iVar10;
  bool bVar12;
  ulong uVar11;
  
  puVar1 = (undefined8 *)(param_1 + 0x2360);
  uVar11 = 0x400;
  iVar10 = 0x400;
  bVar12 = ((ulong)puVar1 & 1) != 0;
  puVar8 = puVar1;
  if (bVar12) {
    *(undefined1 *)(param_1 + 0x2360) = 0;
    uVar11 = 0x3ff;
    iVar10 = 0x3ff;
    puVar8 = (undefined8 *)(param_1 + 0x2361);
  }
  if (((ulong)puVar8 & 2) == 0) {
    uVar7 = (uint)uVar11;
  }
  else {
    uVar7 = iVar10 - 2;
    uVar11 = (ulong)uVar7;
    *(undefined2 *)puVar8 = 0;
    puVar8 = (undefined8 *)((long)puVar8 + 2);
  }
  if (((ulong)puVar8 & 4) != 0) {
    *(undefined4 *)puVar8 = 0;
    uVar11 = (ulong)(uVar7 - 4);
    puVar8 = (undefined8 *)((long)puVar8 + 4);
  }
  for (uVar6 = uVar11 >> 3; uVar6 != 0; uVar6 = uVar6 - 1) {
    *puVar8 = 0;
    puVar8 = puVar8 + 1;
  }
  if ((uVar11 & 4) != 0) {
    *(undefined4 *)puVar8 = 0;
    puVar8 = (undefined8 *)((long)puVar8 + 4);
  }
  puVar9 = puVar8;
  if ((uVar11 & 2) != 0) {
    puVar9 = (undefined8 *)((long)puVar8 + 2);
    *(undefined2 *)puVar8 = 0;
  }
  if (bVar12) {
    *(undefined1 *)puVar9 = 0;
  }
  puVar5 = *(undefined2 **)(param_1 + 0x240);
  for (uVar7 = *(uint *)(param_1 + 0x77f8) >> 2; uVar7 != 0; uVar7 = uVar7 - 1) {
    uVar3 = *param_2;
    uVar4 = *param_3;
    piVar2 = (int *)((long)puVar1 + (ulong)(byte)(uVar3 >> 8) * 4);
    *piVar2 = *piVar2 + 1;
    *puVar5 = (short)((uint)uVar3 - (uint)uVar4 >> 1);
    uVar3 = param_2[1];
    uVar4 = param_3[1];
    piVar2 = (int *)((long)puVar1 + (ulong)(byte)(uVar3 >> 8) * 4);
    *piVar2 = *piVar2 + 1;
    puVar5[1] = (short)((uint)uVar3 - (uint)uVar4 >> 1);
    uVar3 = param_2[2];
    uVar4 = param_3[2];
    piVar2 = (int *)((long)puVar1 + (ulong)(byte)(uVar3 >> 8) * 4);
    *piVar2 = *piVar2 + 1;
    puVar5[2] = (short)((uint)uVar3 - (uint)uVar4 >> 1);
    uVar3 = param_2[3];
    uVar4 = param_3[3];
    piVar2 = (int *)((long)puVar1 + (ulong)(byte)(uVar3 >> 8) * 4);
    *piVar2 = *piVar2 + 1;
    puVar5[3] = (short)((uint)uVar3 - (uint)uVar4 >> 1);
    puVar5 = puVar5 + 4;
    param_2 = param_2 + 4;
    param_3 = param_3 + 4;
  }
  return;
}


==================================================================

### FUNC 001092b0 (352 bytes) name=FUN_001092b0

void FUN_001092b0(long param_1,int *param_2,int *param_3)

{
  int *piVar1;
  sbyte sVar2;
  sbyte sVar3;
  uint uVar4;
  
  uVar4 = *(uint *)(param_1 + 0x1ee8);
  if (uVar4 == 0x10) {
    sVar2 = 2;
  }
  else if (uVar4 < 0x11) {
    if (uVar4 == 4) {
      sVar2 = 4;
    }
    else {
      sVar2 = 3;
      if (uVar4 != 8) {
        return;
      }
    }
  }
  else {
    if (uVar4 == 0x20) {
      uVar4 = *(uint *)(param_1 + 0x1eec);
      sVar2 = 1;
      goto joined_r0x001093e7;
    }
    sVar2 = 0;
    if (uVar4 != 0x40) {
      return;
    }
  }
  uVar4 = *(uint *)(param_1 + 0x1eec);
joined_r0x001093e7:
  if (uVar4 == 0x10) {
    sVar3 = 2;
  }
  else if (uVar4 < 0x10) {
    if (uVar4 == 4) {
      sVar3 = 4;
    }
    else {
      sVar3 = 3;
      if (uVar4 != 8) {
        return;
      }
    }
  }
  else if (uVar4 == 0x20) {
    sVar3 = 1;
  }
  else {
    sVar3 = 0;
    if (uVar4 != 0x40) {
      return;
    }
  }
  piVar1 = *(int **)(param_1 + 0x248);
  for (uVar4 = *(uint *)(param_1 + 0x77f8) >> 2; uVar4 != 0; uVar4 = uVar4 - 1) {
    *piVar1 = (*param_2 << sVar3) - (*param_3 << sVar2);
    piVar1[1] = (param_2[1] << sVar3) - (param_3[1] << sVar2);
    piVar1[2] = (param_2[2] << sVar3) - (param_3[2] << sVar2);
    piVar1[3] = (param_2[3] << sVar3) - (param_3[3] << sVar2);
    piVar1 = piVar1 + 4;
    param_3 = param_3 + 4;
    param_2 = param_2 + 4;
  }
  return;
}


==================================================================

### FUNC 00109440 (513 bytes) name=FUN_00109440

/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

ulong FUN_00109440(undefined8 param_1,float *param_2)

{
  int iVar1;
  int *piVar2;
  int iVar3;
  long lVar4;
  float *pfVar5;
  float *pfVar6;
  float fVar7;
  double dVar8;
  float fVar9;
  double dVar10;
  float local_108 [64];
  
  fVar7 = DAT_00131e20;
  pfVar5 = (float *)&DAT_0012c960;
  pfVar6 = local_108;
  for (lVar4 = 0x1e; lVar4 != 0; lVar4 = lVar4 + -1) {
    *(undefined8 *)pfVar6 = *(undefined8 *)pfVar5;
    pfVar5 = pfVar5 + 2;
    pfVar6 = pfVar6 + 2;
  }
  *pfVar6 = *pfVar5;
  if (param_2 == (float *)0x0) {
    piVar2 = __errno_location();
    *piVar2 = -0x1b51ffff;
    return 0;
  }
  if ((((0.0 < *param_2) && (0.0 < param_2[4])) && (fVar9 = param_2[3], 0.0 <= fVar9)) &&
     (fVar9 <= DAT_00131e20)) {
    iVar1 = 0x23;
    if ((int)param_2[2] < 0x24) {
      iVar1 = (int)param_2[2];
    }
    iVar3 = -0x19;
    if (-0x1a < iVar1) {
      iVar3 = iVar1;
    }
    fVar7 = SQRT(local_108[iVar3 + 0x19] * fVar9);
    if (NAN(fVar7)) {
      fVar7 = sqrtf(fVar9 * local_108[iVar3 + 0x19]);
    }
    dVar10 = 0.0;
    fVar9 = DAT_00131e30 / param_2[4];
    fVar7 = DAT_00131e28 * fVar7 + _DAT_00131e2c;
    if (0.0 < param_2[5]) {
      dVar10 = pow((double)param_2[5],DAT_00131e58);
      dVar10 = DAT_00131e58 * dVar10;
    }
    if (param_2[6] <= 0.0) {
      dVar8 = 0.0;
    }
    else {
      dVar8 = pow((double)param_2[6],DAT_00131e60);
      dVar8 = dVar8 * _DAT_00131e68;
    }
    dVar10 = exp((double)((float)((uint)(fVar9 + fVar7 + (float)(dVar8 + dVar10)) ^ DAT_00131e70) *
                          *param_2 * DAT_00131e34));
    param_2[9] = (float)dVar10;
    return CONCAT44((float)dVar10,(float)dVar10);
  }
  param_2[9] = 1.0;
  piVar2 = __errno_location();
  *piVar2 = -0x1b51ffff;
  return (ulong)(uint)fVar7;
}


==================================================================

### FUNC 00109670 (1608 bytes) name=FUN_00109670

undefined4 FUN_00109670(long param_1,undefined8 *param_2)

{
  pthread_mutex_t *__mutex;
  uint uVar1;
  uint uVar2;
  uint uVar3;
  long lVar4;
  int iVar5;
  int *piVar6;
  void *pvVar7;
  ulong uVar8;
  long lVar9;
  ulong uVar10;
  undefined4 *puVar11;
  undefined4 *puVar12;
  bool bVar13;
  byte bVar14;
  undefined1 auStack_38 [32];
  
  bVar14 = 0;
  __mutex = (pthread_mutex_t *)(param_1 + 0x218);
  FUN_001071e0();
  pthread_mutex_lock(__mutex);
  *(undefined4 *)(param_1 + 0x7804) = 8;
  *(undefined4 *)(param_1 + 0x7808) = 0xffff3cb0;
  *(undefined4 *)(param_1 + 0x780c) = 3;
  *(undefined4 *)(param_1 + 0x7810) = 0;
  *(undefined4 *)(param_1 + 0x7814) = 0;
  *(undefined8 *)(param_1 + 0x1ed0) = *param_2;
  *(undefined8 *)(param_1 + 0x1ed8) = param_2[1];
  *(undefined8 *)(param_1 + 0x1ee0) = param_2[2];
  *(undefined8 *)(param_1 + 0x1ee8) = param_2[3];
  uVar1 = *(uint *)(param_1 + 0x1ee8);
  *(undefined8 *)(param_1 + 0x1ef0) = param_2[4];
  if ((uVar1 - 4 < 0x3d) && ((uVar1 - 1 & uVar1) == 0)) {
    uVar1 = *(uint *)(param_1 + 0x1eec) - 1;
    if ((((uVar1 < 0x40) &&
         ((((((uVar1 & *(uint *)(param_1 + 0x1eec)) == 0 && (*(int *)(param_1 + 0x1ef0) - 1U < 2))
            && (*(int *)(param_1 + 0x1ef4) != 0)) &&
           ((uVar1 = *(uint *)(param_1 + 0x1ed0), (uVar1 & 3) == 0 && (3 < uVar1)))) &&
          (*(int *)(param_1 + 0x1ed4) != 0)))) &&
        (((uVar2 = *(uint *)(param_1 + 0x1ed8), (uVar2 & 3) == 0 && (3 < uVar2)) &&
         (*(int *)(param_1 + 0x1edc) != 0)))) &&
       (((uVar3 = *(uint *)(param_1 + 0x1ee0), (uVar3 & 3) == 0 && (3 < uVar3)) &&
        (*(int *)(param_1 + 0x1ee4) != 0)))) {
      iVar5 = uVar1 * *(int *)(param_1 + 0x1ed4);
      *(int *)(param_1 + 0x77f8) = iVar5;
      *(uint *)(param_1 + 0x7800) = uVar3 * *(int *)(param_1 + 0x1ee4);
      *(uint *)(param_1 + 0x77fc) = uVar2 * *(int *)(param_1 + 0x1edc);
      pvVar7 = operator_new__((ulong)(uint)(iVar5 * 3) * 2);
      *(void **)(param_1 + 0x250) = pvVar7;
      pvVar7 = operator_new__((ulong)*(uint *)(param_1 + 0x77f8) * 2);
      *(void **)(param_1 + 0x290) = pvVar7;
      pvVar7 = operator_new__((ulong)*(uint *)(param_1 + 0x77f8));
      *(void **)(param_1 + 0x298) = pvVar7;
      pvVar7 = operator_new__((ulong)*(uint *)(param_1 + 0x77f8) << 2);
      *(void **)(param_1 + 0x2a0) = pvVar7;
      pvVar7 = operator_new__((ulong)*(uint *)(param_1 + 0x77f8));
      *(void **)(param_1 + 0x288) = pvVar7;
      pvVar7 = operator_new__((ulong)*(uint *)(param_1 + 0x7800));
      *(void **)(param_1 + 0x2a8) = pvVar7;
      pvVar7 = operator_new__((ulong)*(uint *)(param_1 + 0x77f8) * 2);
      *(void **)(param_1 + 0x240) = pvVar7;
      pvVar7 = operator_new__((ulong)*(uint *)(param_1 + 0x77f8) << 2);
      *(void **)(param_1 + 0x248) = pvVar7;
      pvVar7 = operator_new__((ulong)(uint)(*(int *)(param_1 + 0x1ed8) * 3 +
                                           *(int *)(param_1 + 0x77fc)));
      lVar9 = *(long *)(param_1 + 0x250);
      *(void **)(param_1 + 0x200) = pvVar7;
      if ((((lVar9 != 0) && (*(long *)(param_1 + 0x290) != 0)) &&
          ((*(long *)(param_1 + 0x298) != 0 &&
           ((*(long *)(param_1 + 0x2a0) != 0 && (*(long *)(param_1 + 0x2a8) != 0)))))) &&
         ((*(long *)(param_1 + 0x288) != 0 &&
          (((*(long *)(param_1 + 0x240) != 0 && (*(long *)(param_1 + 0x248) != 0)) &&
           (pvVar7 != (void *)0x0)))))) {
        *(long *)(param_1 + 600) = lVar9;
        lVar4 = (ulong)*(uint *)(param_1 + 0x77f8) * 2;
        lVar9 = lVar9 + lVar4;
        *(long *)(param_1 + 0x260) = lVar9;
        *(long *)(param_1 + 0x270) = lVar4 + lVar9;
        iVar5 = FUN_00106a40(param_1 + 0x1dc0,(ulong)*(uint *)(param_1 + 0x77f8),
                             *(undefined4 *)(param_1 + 0x1ee8),0);
        if (iVar5 == 0) {
          FUN_00113aa0(auStack_38,4);
          FUN_00116630(auStack_38,"Failed to create baseline accmulator");
        }
        else {
          iVar5 = FUN_00106a40(param_1 + 0x1df0,*(undefined4 *)(param_1 + 0x77f8),
                               *(undefined4 *)(param_1 + 0x1eec),0);
          if (iVar5 == 0) {
            FUN_00113aa0(auStack_38,4);
            FUN_00116630(auStack_38,"Failed to create frame accmulator");
          }
          else if ((*(uint *)(param_1 + 0x1eec) < 2) ||
                  (iVar5 = FUN_00106a40(param_1 + 0x1e20,*(undefined4 *)(param_1 + 0x77f8),
                                        *(uint *)(param_1 + 0x1eec),0), iVar5 != 0)) {
            if ((*(uint *)(param_1 + 0x1ef0) < 2) ||
               (iVar5 = FUN_00119ee0(param_1 + 0x1e50,*(undefined4 *)(param_1 + 0x77f8),
                                     *(uint *)(param_1 + 0x1ef0) - 1,0,0), iVar5 != 0)) {
              if ((*(uint *)(param_1 + 0x1ef4) < 2) ||
                 (iVar5 = FUN_00119ee0(param_1 + 0x1e90,*(undefined4 *)(param_1 + 0x77f8),
                                       *(uint *)(param_1 + 0x1ef4),1,0), iVar5 != 0)) {
                puVar12 = (undefined4 *)(param_1 + 0x6b0);
                uVar10 = 0x28;
                bVar13 = ((ulong)puVar12 & 1) != 0;
                puVar11 = puVar12;
                if (bVar13) {
                  puVar11 = (undefined4 *)(param_1 + 0x6b1 + (ulong)bVar14 * -2);
                  *(undefined1 *)puVar12 = 0;
                  uVar10 = 0x27;
                }
                puVar12 = puVar11;
                if (((ulong)puVar11 & 2) != 0) {
                  uVar10 = (ulong)((int)uVar10 - 2);
                  puVar12 = (undefined4 *)((long)puVar11 + (ulong)bVar14 * -4 + 2);
                  *(undefined2 *)puVar11 = 0;
                }
                for (uVar8 = uVar10 >> 2; uVar8 != 0; uVar8 = uVar8 - 1) {
                  *puVar12 = 0;
                  puVar12 = puVar12 + (ulong)bVar14 * -2 + 1;
                }
                puVar11 = puVar12;
                if ((uVar10 & 2) != 0) {
                  puVar11 = (undefined4 *)((long)puVar12 + (ulong)bVar14 * -4 + 2);
                  *(undefined2 *)puVar12 = 0;
                }
                if (bVar13) {
                  *(undefined1 *)puVar11 = 0;
                }
                puVar12 = (undefined4 *)(param_1 + 0xad8);
                *(undefined4 *)(param_1 + 0x6b0) = 0x28;
                *(undefined2 *)(param_1 + 0x6bc) = 1;
                *(undefined2 *)(param_1 + 0x6be) = 8;
                uVar10 = 0x28;
                *(undefined4 *)(param_1 + 0x6c0) = 0;
                *(undefined4 *)(param_1 + 0x6b4) = *(undefined4 *)(param_1 + 0x1ed0);
                *(undefined4 *)(param_1 + 0x6b8) = *(undefined4 *)(param_1 + 0x1ed4);
                bVar13 = ((ulong)puVar12 & 1) != 0;
                puVar11 = puVar12;
                if (bVar13) {
                  puVar11 = (undefined4 *)(param_1 + 0xad9 + (ulong)bVar14 * -2);
                  *(undefined1 *)puVar12 = 0;
                  uVar10 = 0x27;
                }
                puVar12 = puVar11;
                if (((ulong)puVar11 & 2) != 0) {
                  uVar10 = (ulong)((int)uVar10 - 2);
                  puVar12 = (undefined4 *)((long)puVar11 + (ulong)bVar14 * -4 + 2);
                  *(undefined2 *)puVar11 = 0;
                }
                for (uVar8 = uVar10 >> 2; uVar8 != 0; uVar8 = uVar8 - 1) {
                  *puVar12 = 0;
                  puVar12 = puVar12 + (ulong)bVar14 * -2 + 1;
                }
                puVar11 = puVar12;
                if ((uVar10 & 2) != 0) {
                  puVar11 = (undefined4 *)((long)puVar12 + (ulong)bVar14 * -4 + 2);
                  *(undefined2 *)puVar12 = 0;
                }
                if (bVar13) {
                  *(undefined1 *)puVar11 = 0;
                }
                puVar12 = (undefined4 *)(param_1 + 0xf00);
                *(undefined4 *)(param_1 + 0xad8) = 0x28;
                *(undefined2 *)(param_1 + 0xae4) = 1;
                *(undefined2 *)(param_1 + 0xae6) = 8;
                uVar10 = 0x28;
                *(undefined4 *)(param_1 + 0xae8) = 0;
                *(undefined4 *)(param_1 + 0xadc) = *(undefined4 *)(param_1 + 0x1ed8);
                *(undefined4 *)(param_1 + 0xae0) = *(undefined4 *)(param_1 + 0x1edc);
                bVar13 = ((ulong)puVar12 & 1) != 0;
                puVar11 = puVar12;
                if (bVar13) {
                  puVar11 = (undefined4 *)(param_1 + 0xf01 + (ulong)bVar14 * -2);
                  *(undefined1 *)puVar12 = 0;
                  uVar10 = 0x27;
                }
                puVar12 = puVar11;
                if (((ulong)puVar11 & 2) != 0) {
                  uVar10 = (ulong)((int)uVar10 - 2);
                  puVar12 = (undefined4 *)((long)puVar11 + (ulong)bVar14 * -4 + 2);
                  *(undefined2 *)puVar11 = 0;
                }
                for (uVar8 = uVar10 >> 2; uVar8 != 0; uVar8 = uVar8 - 1) {
                  *puVar12 = 0;
                  puVar12 = puVar12 + (ulong)bVar14 * -2 + 1;
                }
                puVar11 = puVar12;
                if ((uVar10 & 2) != 0) {
                  puVar11 = (undefined4 *)((long)puVar12 + (ulong)bVar14 * -4 + 2);
                  *(undefined2 *)puVar12 = 0;
                }
                if (bVar13) {
                  *(undefined1 *)puVar11 = 0;
                }
                *(undefined4 *)(param_1 + 0xf00) = 0x28;
                *(undefined2 *)(param_1 + 0xf0c) = 1;
                *(undefined2 *)(param_1 + 0xf0e) = 8;
                *(undefined4 *)(param_1 + 0xf10) = 0;
                *(undefined4 *)(param_1 + 0xf04) = *(undefined4 *)(param_1 + 0x1ee0);
                *(undefined4 *)(param_1 + 0xf08) = *(undefined4 *)(param_1 + 0x1ee4);
                FUN_00109440(param_1,param_1 + 0xb4);
                *(undefined4 *)(param_1 + 0x208) = 1;
                pthread_mutex_unlock(__mutex);
                return *(undefined4 *)(param_1 + 0x208);
              }
              FUN_00113aa0(auStack_38,4);
              FUN_00116630(auStack_38,"Failed to create std smoother");
            }
            else {
              FUN_00113aa0(auStack_38,4);
              FUN_00116630(auStack_38,"Failed to create temperature smoother");
            }
          }
          else {
            FUN_00113aa0(auStack_38,4);
            FUN_00116630(auStack_38,"Failed to create frame accmulator");
          }
        }
        FUN_00113b30(auStack_38);
        pthread_mutex_unlock(__mutex);
        piVar6 = __errno_location();
        *piVar6 = -0x1b51fffd;
        return 0;
      }
      FUN_00113aa0(auStack_38,4);
      FUN_00116630(auStack_38,"Failed to allocate memory");
      FUN_00113b30(auStack_38);
      pthread_mutex_unlock(__mutex);
      piVar6 = __errno_location();
      *piVar6 = -0x1b51fffe;
      return 0;
    }
  }
  FUN_00113aa0(auStack_38,4);
  FUN_00116630(auStack_38,"Failed to configurate CFunctions due to parameter error");
  FUN_00113b30(auStack_38);
  pthread_mutex_unlock(__mutex);
  piVar6 = __errno_location();
  *piVar6 = -0x1b51ffff;
  return 0;
}


==================================================================

### FUNC 00109d40 (299 bytes) name=FUN_00109d40

undefined8 FUN_00109d40(long param_1,int param_2)

{
  pthread_mutex_t *__mutex;
  int *piVar1;
  int iVar2;
  long lVar3;
  undefined8 *puVar4;
  undefined8 *puVar5;
  uint uVar6;
  byte bVar7;
  
  bVar7 = 0;
  __mutex = (pthread_mutex_t *)(param_1 + 0x218);
  pthread_mutex_lock(__mutex);
  if (param_2 == 0) {
    param_2 = 7;
switchD_00109d75_caseD_7:
    puVar4 = &DAT_0012d4e0;
  }
  else {
    switch(param_2) {
    case 1:
      puVar4 = &DAT_001311a0;
      break;
    case 2:
      puVar4 = &DAT_00130780;
      break;
    case 3:
      puVar4 = &DAT_0012fd60;
      break;
    case 4:
      puVar4 = &DAT_0012f340;
      break;
    case 5:
      puVar4 = &DAT_0012e920;
      break;
    case 6:
      puVar4 = &DAT_0012df00;
      break;
    case 7:
      goto switchD_00109d75_caseD_7;
    case 8:
      puVar4 = &DAT_0012cac0;
      break;
    default:
      pthread_mutex_unlock(__mutex);
      return 0;
    }
  }
  puVar5 = (undefined8 *)&DAT_00340080;
  for (lVar3 = 0x143; lVar3 != 0; lVar3 = lVar3 + -1) {
    *puVar5 = *puVar4;
    puVar4 = puVar4 + (ulong)bVar7 * -2 + 1;
    puVar5 = puVar5 + (ulong)bVar7 * -2 + 1;
  }
  lVar3 = 0;
  *(undefined4 *)puVar5 = *(undefined4 *)puVar4;
  iVar2 = DAT_00340080;
  do {
    piVar1 = (int *)(&DAT_00340084 + lVar3);
    uVar6 = *piVar1 - iVar2;
    *(uint *)((long)&DAT_0033f660 + lVar3) = ((uVar6 >> 1) + 0x1000000) / uVar6;
    lVar3 = lVar3 + 4;
    iVar2 = *piVar1;
  } while (lVar3 != 0xa18);
  lVar3 = (long)DAT_00340074;
  *(int *)(param_1 + 0x50) = param_2;
  DAT_0033f654 = (undefined4)(0x7fffffff / lVar3);
  pthread_mutex_unlock(__mutex);
  return 1;
}


==================================================================

### FUNC 00109e70 (92 bytes) name=FUN_00109e70

int FUN_00109e70(undefined8 param_1,int param_2)

{
  int iVar1;
  int iVar2;
  int iVar3;
  
  iVar3 = param_2 + 150000;
  iVar2 = param_2 + 0x259ef;
  if (-1 < iVar3) {
    iVar2 = iVar3;
  }
  iVar1 = 0x285;
  if (iVar2 >> 0xc < 0x286) {
    iVar1 = iVar2 >> 0xc;
  }
  if (iVar1 < 0) {
    iVar1 = 0;
  }
  iVar2 = ((&DAT_00340080)[iVar1 + 1] - (&DAT_00340080)[iVar1]) * (iVar3 + iVar1 * -0x1000);
  if (iVar2 < 0) {
    iVar2 = iVar2 + 0xfff;
  }
  iVar3 = (iVar2 >> 0xc) + (&DAT_00340080)[iVar1];
  iVar2 = 0;
  if (-1 < iVar3) {
    iVar2 = iVar3;
  }
  return iVar2;
}


==================================================================

### FUNC 00109ed0 (62 bytes) name=FUN_00109ed0

int FUN_00109ed0(long param_1,int param_2)

{
  int iVar1;
  
  if (*(int *)(param_1 + 0x7810) == 0) {
    iVar1 = param_2 - *(int *)(param_1 + 0x7808) >> ((byte)*(undefined4 *)(param_1 + 0x780c) & 0x1f)
    ;
    if (iVar1 < 0) {
      iVar1 = 0;
    }
    return iVar1;
  }
  iVar1 = FUN_00109e70();
  return iVar1 >> (7U - (char)*(undefined4 *)(param_1 + 0x7814) & 0x1f);
}


==================================================================

### FUNC 00109f20 (409 bytes) name=FUN_00109f20

/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

void FUN_00109f20(long param_1)

{
  int iVar1;
  int iVar2;
  undefined4 uVar3;
  uint uVar4;
  int iVar5;
  int iVar6;
  long lVar7;
  float fVar8;
  float fVar9;
  int local_98 [12];
  int local_68 [14];
  
  if ((*(int *)(param_1 + 0x1328) != 0) && (*(int *)(param_1 + 0x132c) != 0)) {
    iVar6 = (*(int *)(param_1 + 0x1448) + *(int *)(param_1 + 0x1444)) / 2;
    if (*(float *)(param_1 + 0x7c) == _DAT_00131e24) {
      *(undefined4 *)(param_1 + 0x17a4) = 1;
      *(undefined4 *)(param_1 + 0x183c) = *(undefined4 *)(param_1 + 0x7804);
      *(int *)(param_1 + 0x1840) = (*(int *)(param_1 + 0x7808) + *(int *)(param_1 + 0x3c)) - iVar6;
      return;
    }
    iVar1 = *(int *)(param_1 + 0x3c);
    *(undefined4 *)(param_1 + 0x17a4) = 10;
    iVar5 = 0;
    lVar7 = 0;
    fVar8 = (*(float *)(param_1 + 0x7c) * (float)(iVar1 - iVar6)) / DAT_00131e3c + DAT_00131e20;
    fVar9 = DAT_00131e38;
    if (DAT_00131e38 <= fVar8) {
      fVar9 = fVar8;
    }
    do {
      *(int *)((long)local_98 + lVar7) = iVar5;
      iVar2 = iVar5 - iVar1;
      iVar5 = iVar5 + 10000;
      uVar3 = FUN_00109ed0(param_1,(int)((float)iVar2 * fVar9) + iVar6);
      *(undefined4 *)((long)local_68 + lVar7) = uVar3;
      lVar7 = lVar7 + 4;
    } while (iVar5 != 110000);
    lVar7 = 0;
    do {
      iVar6 = *(int *)((long)local_68 + lVar7 + 4);
      iVar1 = *(int *)((long)local_98 + lVar7 + 4);
      *(int *)(param_1 + 0x17a8 + lVar7) = iVar6;
      uVar4 = ((iVar1 - local_98[0]) + ((uint)(iVar6 - local_68[0]) >> 1)) /
              (uint)(iVar6 - local_68[0]);
      *(uint *)(param_1 + 0x183c + lVar7 * 2) = uVar4;
      *(uint *)(param_1 + 0x1840 + lVar7 * 2) = local_98[0] - uVar4 * local_68[0];
      lVar7 = lVar7 + 4;
      local_98[0] = iVar1;
      local_68[0] = iVar6;
    } while (lVar7 != 0x28);
  }
  return;
}


==================================================================

### FUNC 0010a0d0 (120 bytes) name=FUN_0010a0d0

int FUN_0010a0d0(undefined8 param_1,int param_2)

{
  uint uVar1;
  uint uVar2;
  uint uVar3;
  
  uVar3 = 0x286;
  uVar1 = 0;
  while (uVar2 = uVar1, uVar2 + 1 < uVar3) {
    while (uVar1 = (int)(uVar3 + uVar2) >> 1, param_2 < (int)(&DAT_00340080)[(int)uVar1]) {
      uVar3 = uVar1;
      if (uVar1 <= uVar2 + 1) goto LAB_0010a0fe;
    }
  }
LAB_0010a0fe:
  param_2 = param_2 - (&DAT_00340080)[(int)uVar2];
  if (param_2 <= DAT_0033f654) {
    return uVar2 * 0x1000 + -150000 + (param_2 * (&DAT_0033f660)[(int)uVar2] >> 0xc);
  }
  return uVar2 * 0x1000 + -150000 +
         (int)((long)param_2 * (long)(int)(&DAT_0033f660)[(int)uVar2] >> 0xc);
}


==================================================================

### FUNC 0010a150 (45 bytes) name=FUN_0010a150

ulong FUN_0010a150(long param_1,int param_2)

{
  ulong uVar1;
  
  if (*(int *)(param_1 + 0x7810) == 0) {
    return (ulong)(uint)((param_2 << ((byte)*(undefined4 *)(param_1 + 0x780c) & 0x1f)) +
                        *(int *)(param_1 + 0x7808));
  }
  uVar1 = FUN_0010a0d0(param_1,param_2 << (7U - (char)*(undefined4 *)(param_1 + 0x7814) & 0x1f));
  return uVar1;
}


==================================================================

### FUNC 0010a190 (20 bytes) name=FUN_0010a190

void FUN_0010a190(undefined8 param_1)

{
  undefined4 uVar1;
  
  uVar1 = FUN_0010a150();
  FUN_00109e70(param_1,uVar1);
  return;
}


==================================================================

### FUNC 0010a1b0 (28 bytes) name=FUN_0010a1b0

ulong FUN_0010a1b0(long param_1,int param_2)

{
  ulong uVar1;
  
  if (*(int *)(param_1 + 0x7810) != 0) {
    return (ulong)(uint)(param_2 << (7U - (char)*(undefined4 *)(param_1 + 0x7814) & 0x1f));
  }
  uVar1 = FUN_0010a190();
  return uVar1;
}


==================================================================

### FUNC 0010a1e0 (20 bytes) name=FUN_0010a1e0

void FUN_0010a1e0(undefined8 param_1)

{
  undefined4 uVar1;
  
  uVar1 = FUN_0010a0d0();
  FUN_00109ed0(param_1,uVar1);
  return;
}


==================================================================

### FUNC 0010a200 (28 bytes) name=FUN_0010a200

ulong FUN_0010a200(long param_1,int param_2)

{
  ulong uVar1;
  
  if (*(int *)(param_1 + 0x7810) != 0) {
    return (ulong)(uint)(param_2 >> (7U - (char)*(undefined4 *)(param_1 + 0x7814) & 0x1f));
  }
  uVar1 = FUN_0010a1e0();
  return uVar1;
}


==================================================================

### FUNC 0010a230 (384 bytes) name=FUN_0010a230

int FUN_0010a230(float param_1,long param_2,int param_3)

{
  float fVar1;
  float fVar2;
  float fVar3;
  int iVar4;
  int iVar5;
  int *piVar6;
  int iVar7;
  
  fVar3 = DAT_00131e20;
  fVar1 = *(float *)(param_2 + 0xd8);
  if ((((fVar1 <= 0.0) || (DAT_00131e20 < fVar1)) || (param_1 <= 0.0)) ||
     (((DAT_00131e20 < param_1 || (fVar2 = *(float *)(param_2 + 0xdc), fVar2 <= 0.0)) ||
      (DAT_00131e20 < fVar2)))) {
    piVar6 = __errno_location();
    *piVar6 = -0x1b51ffff;
  }
  else {
    iVar4 = FUN_00109e70();
    iVar5 = FUN_00109e70(param_2,(int)(DAT_00131e3c * *(float *)(param_2 + 0xbc)));
    param_1 = fVar1 * fVar2 * param_1;
    iVar4 = FUN_0010a0d0(param_2,(int)(((float)iVar4 - (float)iVar5 * (fVar3 - param_1)) / param_1))
    ;
    param_3 = -0x42afe;
    if (-0x42aff < iVar4) {
      param_3 = iVar4;
    }
    iVar4 = *(int *)(param_2 + 0x44) + -15000;
    iVar5 = iVar4 / 5000;
    iVar7 = 6;
    if (iVar5 < 7) {
      iVar7 = iVar5;
    }
    iVar5 = 0;
    if (-1 < iVar7) {
      iVar5 = iVar7;
    }
    iVar7 = *(int *)(param_2 + 0x90 + (long)iVar5 * 4);
    param_3 = iVar7 + ((iVar4 + iVar5 * -5000) *
                      (*(int *)(param_2 + 0x90 + (long)(iVar5 + 1) * 4) - iVar7)) / 5000 + param_3;
    if (*(int *)(param_2 + 0x54) != 0) {
      param_3 = param_3 + (int)((float)param_3 * *(float *)(param_2 + 0xd0)) +
                (int)(DAT_00131e3c * *(float *)(param_2 + 0xd4));
    }
  }
  return param_3;
}


==================================================================

### FUNC 0010a3c0 (223 bytes) name=FUN_0010a3c0

int FUN_0010a3c0(undefined8 param_1,int param_2,int param_3)

{
  int iVar1;
  int iVar2;
  int iVar3;
  int iVar4;
  
  iVar4 = param_2 + 150000;
  iVar3 = iVar4 + param_3;
  iVar2 = param_2 + 0x259ef;
  if (-1 < iVar4) {
    iVar2 = iVar4;
  }
  iVar2 = iVar2 >> 0xc;
  if (0x285 < iVar2) {
    iVar2 = 0x285;
  }
  if (iVar2 < 0) {
    iVar2 = 0;
  }
  iVar1 = iVar3 + 0xfff;
  if (-1 < iVar3) {
    iVar1 = iVar3;
  }
  iVar1 = iVar1 >> 0xc;
  if (0x285 < iVar1) {
    iVar1 = 0x285;
  }
  if (iVar1 < 0) {
    iVar1 = 0;
  }
  if (iVar1 != iVar2) {
    iVar3 = ((&DAT_00340080)[iVar1 + 1] - (&DAT_00340080)[iVar1]) * (iVar3 + iVar1 * -0x1000);
    if (iVar3 < 0) {
      iVar3 = iVar3 + 0xfff;
    }
    iVar4 = ((&DAT_00340080)[iVar2 + 1] - (&DAT_00340080)[iVar2]) * (iVar4 + iVar2 * -0x1000);
    if (iVar4 < 0) {
      iVar4 = iVar4 + 0xfff;
    }
    return ((&DAT_00340080)[iVar1] + (iVar3 >> 0xc)) - ((iVar4 >> 0xc) + (&DAT_00340080)[iVar2]);
  }
  param_3 = ((&DAT_00340080)[iVar1 + 1] - (&DAT_00340080)[iVar1]) * param_3;
  iVar3 = param_3 + 0xfff;
  if (-1 < param_3) {
    iVar3 = param_3;
  }
  return iVar3 >> 0xc;
}


==================================================================

### FUNC 0010a4b0 (71 bytes) name=FUN_0010a4b0

uint FUN_0010a4b0(long param_1,undefined8 param_2,uint param_3)

{
  int iVar1;
  uint uVar2;
  
  if (*(int *)(param_1 + 0x7810) != 0) {
    iVar1 = FUN_0010a3c0();
    uVar2 = iVar1 >> (7U - (char)*(undefined4 *)(param_1 + 0x7814) & 0x1f);
    if (0xffff < (int)uVar2) {
      uVar2 = 0xffff;
    }
    return uVar2;
  }
  param_3 = param_3 >> ((byte)*(undefined4 *)(param_1 + 0x780c) & 0x1f);
  uVar2 = 0xffff;
  if (param_3 < 0x10000) {
    uVar2 = param_3;
  }
  return uVar2;
}


==================================================================

### FUNC 0010a500 (251 bytes) name=FUN_0010a500

/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

int FUN_0010a500(long param_1)

{
  ushort uVar1;
  int iVar2;
  int iVar3;
  int iVar4;
  
  iVar3 = *(int *)(param_1 + 0x34);
  uVar1 = FUN_0010a4b0(param_1,30000,*(int *)(param_1 + 0x24) * 1000);
  if (iVar3 < 0) {
    iVar2 = 0x51eb851f;
    iVar4 = -100;
    if (-0x65 < iVar3) {
      iVar4 = iVar3;
    }
  }
  else {
    iVar2 = 0x1b4e81b5;
    iVar4 = 100;
    if (iVar3 < 0x65) {
      iVar4 = iVar3;
    }
  }
  iVar4 = iVar4 * (uint)uVar1;
  iVar3 = (uint)uVar1 + ((iVar4 >> 0x1f) - (int)((long)iVar4 * (long)iVar2 >> 0x24));
  if ((*(int *)(param_1 + 0x1328) == 0) || (*(float *)(param_1 + 0x7c) <= _DAT_00131e24))
  goto LAB_0010a578;
  if (*(int *)(param_1 + 0x1438) == 1) {
    iVar4 = *(int *)(param_1 + 0x1448);
    iVar2 = *(int *)(param_1 + 0x1444);
  }
  else {
    if (*(int *)(param_1 + 0x1438) != 2) goto LAB_0010a578;
    iVar4 = *(int *)(param_1 + 0x1448);
    iVar2 = *(int *)(param_1 + 0x1444);
    if (iVar4 - iVar2 != 50000) goto LAB_0010a578;
  }
  iVar3 = iVar3 + (int)(((float)((*(int *)(param_1 + 0x3c) - (iVar4 + iVar2) / 2) * iVar3) *
                        *(float *)(param_1 + 0x7c)) / DAT_00131e3c);
LAB_0010a578:
  iVar4 = 0x80;
  if (0x7f < iVar3) {
    iVar4 = iVar3;
  }
  return iVar4;
}


==================================================================

### FUNC 0010a610 (1519 bytes) name=FUN_0010a610

void FUN_0010a610(long param_1)

{
  int *piVar1;
  long lVar2;
  ushort *puVar3;
  bool bVar4;
  int iVar5;
  uint uVar6;
  uint *puVar7;
  uint *puVar8;
  uint uVar9;
  uint uVar10;
  int iVar11;
  ulong uVar12;
  ulong uVar13;
  long lVar14;
  int iVar15;
  int *piVar16;
  int *piVar17;
  ulong uVar18;
  int iVar19;
  uint uVar20;
  uint uVar21;
  uint uVar22;
  bool bVar23;
  int local_1040;
  int local_103c;
  uint local_1038 [1024];
  uint local_38 [2];
  
  piVar1 = (int *)(param_1 + 0x2b60);
  lVar2 = param_1 + 0x3b60;
  uVar9 = *(uint *)(param_1 + 0x77f8);
  if ((*(int *)(param_1 + 0x6c) != 0) && (*(int *)(param_1 + 0x10) == 0)) {
    uVar9 = (*(int *)(param_1 + 0x4b68) + 1) * *(int *)(param_1 + 0x1ed0);
  }
  iVar15 = *(int *)(param_1 + 8000);
  uVar18 = 1;
  if (uVar9 >> 0xc != 0) {
    uVar18 = (ulong)(uVar9 >> 0xc);
  }
  uVar21 = *(int *)(param_1 + 0x1f3c) - iVar15;
  uVar13 = 0x1000;
  bVar23 = false;
  iVar11 = 0x1000;
  if (((ulong)piVar1 & 1) == 0) {
    piVar17 = piVar1;
    bVar4 = false;
    if (((ulong)piVar1 & 2) == 0) goto LAB_0010a699;
LAB_0010aba1:
    bVar23 = bVar4;
    uVar22 = iVar11 - 2;
    uVar13 = (ulong)uVar22;
    *(undefined2 *)piVar17 = 0;
    piVar17 = (int *)((long)piVar17 + 2);
  }
  else {
    piVar17 = (int *)(param_1 + 0x2b61);
    *(undefined1 *)(param_1 + 0x2b60) = 0;
    uVar13 = 0xfff;
    bVar23 = true;
    iVar11 = 0xfff;
    bVar4 = true;
    if (((ulong)piVar17 & 2) != 0) goto LAB_0010aba1;
LAB_0010a699:
    uVar22 = (uint)uVar13;
  }
  if (((ulong)piVar17 & 4) != 0) {
    *piVar17 = 0;
    uVar13 = (ulong)(uVar22 - 4);
    piVar17 = piVar17 + 1;
  }
  for (uVar12 = uVar13 >> 3; uVar12 != 0; uVar12 = uVar12 - 1) {
    piVar17[0] = 0;
    piVar17[1] = 0;
    piVar17 = piVar17 + 2;
  }
  if ((uVar13 & 4) != 0) {
    *piVar17 = 0;
    piVar17 = piVar17 + 1;
  }
  piVar16 = piVar17;
  if ((uVar13 & 2) != 0) {
    piVar16 = (int *)((long)piVar17 + 2);
    *(undefined2 *)piVar17 = 0;
  }
  if (bVar23) {
    *(undefined1 *)piVar16 = 0;
  }
  puVar3 = *(ushort **)(param_1 + 0x268);
  for (; uVar9 != 0; uVar9 = uVar9 - 1) {
    piVar1[((uint)*puVar3 - iVar15) * (int)(0xffc00000 / (ulong)uVar21) >> 0x16] =
         piVar1[((uint)*puVar3 - iVar15) * (int)(0xffc00000 / (ulong)uVar21) >> 0x16] + 1;
    puVar3 = puVar3 + 1;
  }
  if (*(int *)(param_1 + 0x6c) == 0) {
LAB_0010a78a:
    iVar11 = *(int *)(param_1 + 0x1f28);
  }
  else if ((*(int *)(param_1 + 0x10) == 0) &&
          (*(uint *)(param_1 + 0x4b68) < *(int *)(param_1 + 0x1ed4) - 1U)) {
    iVar11 = *(int *)(param_1 + 0x4b6c);
    iVar5 = *(int *)(param_1 + 0x4b70) * 0x20;
    if (iVar5 < iVar11 * 0x1f) {
      uVar21 = (uint)((*(int *)(param_1 + 0x4b70) - iVar15) * 0x3ff) / uVar21;
      if (uVar21 != 0) {
        lVar14 = 0;
        do {
          piVar1[lVar14] = 0;
          lVar14 = lVar14 + 1;
        } while ((uint)lVar14 < uVar21);
LAB_0010a777:
        if (*(int *)(param_1 + 0x6c) == 0) goto LAB_0010a78a;
        goto LAB_0010a780;
      }
    }
    else if (iVar11 * 0x21 < iVar5) {
      lVar14 = 0;
      do {
        *(undefined4 *)((long)piVar1 + lVar14) = 0;
        lVar14 = lVar14 + 4;
      } while (lVar14 != 0x1000);
      goto LAB_0010a777;
    }
  }
  else {
LAB_0010a780:
    iVar11 = *(int *)(param_1 + 0x4b6c);
  }
  uVar13 = (ulong)(uint)((iVar11 - *(int *)(param_1 + 8000)) * 0x3ff) /
           (ulong)(uint)(*(int *)(param_1 + 0x1f3c) - *(int *)(param_1 + 8000));
  uVar9 = (uint)uVar13;
  uVar12 = uVar13;
  if (*(int *)(param_1 + 0x70) != 0) {
    if (uVar9 == 0) {
      bVar23 = false;
      uVar22 = 0;
      uVar21 = 0;
      iVar15 = 1;
    }
    else {
      uVar22 = 0;
      uVar21 = 0;
      piVar17 = piVar1;
      uVar6 = 0;
      do {
        iVar15 = *piVar17;
        uVar10 = uVar6 + 1;
        piVar17 = piVar17 + 1;
        uVar21 = uVar21 + iVar15;
        uVar22 = uVar22 + iVar15 * uVar6;
        uVar6 = uVar10;
      } while (uVar10 != uVar9);
      iVar15 = uVar9 + 1;
      if (0x3ff < iVar15) goto LAB_0010a863;
      bVar23 = uVar21 != 0;
    }
    uVar10 = 0;
    piVar17 = piVar1 + iVar15;
    uVar6 = 0;
    iVar11 = iVar15;
    do {
      iVar5 = *piVar17;
      piVar17 = piVar17 + 1;
      uVar10 = uVar10 + iVar5;
      iVar5 = iVar5 * iVar11;
      iVar11 = iVar11 + 1;
      uVar6 = uVar6 + iVar5;
    } while (iVar11 < 0x400);
    if ((uVar10 == 0) || (!bVar23)) goto LAB_0010a863;
    uVar21 = uVar6 / uVar10 + uVar22 / uVar21 >> 1;
    uVar12 = (ulong)uVar21;
    if (uVar21 <= uVar9) {
      uVar12 = uVar13;
    }
  }
  iVar15 = (int)uVar12 + 1;
LAB_0010a863:
  iVar11 = *(int *)(param_1 + 0x30);
  if (iVar11 < 0x65) {
    if (iVar11 < -100) {
      local_103c = 0xe0;
      local_1040 = -0xdf;
    }
    else {
      local_1040 = (iVar11 * 0x1bf) / 200;
      local_103c = local_1040 + 0x1bf;
    }
  }
  else {
    local_103c = 0x29e;
    local_1040 = 0xdf;
  }
  lVar14 = 0;
  do {
    *(uint *)((long)piVar1 + lVar14) =
         (uint)(*(int *)(param_1 + 0x2b64 + lVar14) + *(int *)((long)piVar1 + lVar14)) >> 1;
    lVar14 = lVar14 + 4;
  } while (lVar14 != 0xffc);
  *(undefined4 *)(param_1 + 0x3b5c) = *(undefined4 *)(param_1 + 0x3b58);
  iVar5 = (int)uVar12;
  iVar11 = (int)(0x10000 / uVar18);
  uVar9 = (uint)uVar18;
  if (-1 < iVar5) {
    lVar14 = 0;
    uVar21 = 0;
    iVar19 = 0;
    do {
      uVar21 = uVar21 + *(int *)((long)piVar1 + lVar14 + uVar12 * 4);
      if (uVar21 < uVar9) {
        uVar22 = uVar21 * iVar11 >> 8;
      }
      else {
        iVar19 = iVar19 + 1;
        uVar22 = 0;
        uVar21 = 0;
      }
      *(uint *)(uVar12 * 4 + lVar2 + lVar14) = uVar22 + iVar19 * 0x100;
      lVar14 = lVar14 + -4;
    } while (lVar14 != ~uVar12 * 4);
  }
  if (iVar15 < 0x400) {
    uVar21 = 0;
    lVar14 = 0;
    iVar19 = 0;
    do {
      uVar21 = uVar21 + *(int *)((long)piVar1 + lVar14 + (long)iVar15 * 4);
      if (uVar21 < uVar9 * 8) {
        if (uVar21 < uVar9) {
          uVar22 = uVar21 * iVar11 >> 8;
        }
        else {
          iVar19 = iVar19 + 1;
          uVar22 = 0;
          uVar21 = 0;
        }
      }
      else {
        iVar19 = iVar19 + 2;
        uVar22 = 0;
        uVar21 = 0;
      }
      *(uint *)((long)iVar15 * 4 + lVar2 + lVar14) = uVar22 + iVar19 * 0x100;
      lVar14 = lVar14 + 4;
    } while (lVar14 != (ulong)(0x3ff - iVar15) * 4 + 4);
  }
  uVar9 = FUN_0010a500(param_1);
  iVar11 = 4;
  uVar9 = (uint)((*(int *)(param_1 + 0x1f3c) - *(int *)(param_1 + 8000)) * 0x10) / uVar9;
  if (uVar9 != 0) {
    uVar21 = 0x200;
    if (uVar9 < 0x201) {
      uVar21 = uVar9;
    }
    iVar11 = uVar21 << 2;
  }
  uVar9 = iVar11 * 0x600;
  puVar7 = local_1038;
  do {
    uVar21 = uVar9 >> 0xd;
    if (uVar21 == 0) {
      uVar21 = 1;
    }
    puVar8 = puVar7 + 1;
    uVar9 = uVar9 + iVar11;
    *puVar7 = uVar21;
    puVar7 = puVar8;
  } while (puVar8 != local_38);
  uVar9 = *(uint *)(param_1 + 0x3b60);
  if (uVar9 != 0) {
    uVar21 = (local_1040 + 0x1c0) * 0x10;
    if (-1 < iVar5) {
      uVar18 = 0;
      uVar22 = uVar21;
      do {
        uVar10 = uVar21 - (*(int *)(lVar2 + uVar12 * 4 + uVar18 * 4) *
                           ((uint)((local_1040 + 0x1c0) * 0x40000) / uVar9) >> 0xe);
        uVar6 = uVar22 - local_1038[iVar5 + (int)uVar18];
        uVar20 = uVar22 - uVar10;
        uVar22 = uVar10;
        if (local_1038[iVar5 + (int)uVar18] < uVar20) {
          uVar22 = uVar6;
        }
        *(char *)(param_1 + 0x2760 + uVar12 + uVar18) = (char)(uVar22 >> 6);
        uVar18 = uVar18 - 1;
      } while (uVar18 != ~uVar12);
    }
  }
  uVar9 = *(uint *)(param_1 + 0x4b5c);
  if (uVar9 != 0) {
    if (iVar15 < 0x400) {
      lVar14 = 0;
      uVar21 = local_103c * 0x10;
      do {
        uVar22 = (*(int *)(lVar2 + (long)iVar15 * 4 + lVar14 * 4) *
                  ((uint)((0x240 - local_1040) * 0x40000) / uVar9) >> 0xe) + local_103c * 0x10;
        uVar10 = uVar22 - uVar21;
        uVar6 = uVar21 + local_1038[iVar15 + (int)lVar14];
        uVar21 = uVar22;
        if (local_1038[iVar15 + (int)lVar14] < uVar10) {
          uVar21 = uVar6;
        }
        *(char *)(param_1 + 0x2760 + (long)iVar15 + lVar14) = (char)(uVar21 >> 6);
        lVar14 = lVar14 + 1;
      } while (lVar14 != (ulong)(0x3ff - iVar15) + 1);
    }
  }
  return;
}


==================================================================

### FUNC 0010ac30 (173 bytes) name=FUN_0010ac30

int FUN_0010ac30(undefined8 param_1,int param_2,uint param_3)

{
  int iVar1;
  int iVar2;
  int iVar3;
  int iVar4;
  
  iVar4 = param_2 + 150000;
  iVar1 = param_2 + 0x259ef;
  if (-1 < iVar4) {
    iVar1 = iVar4;
  }
  iVar2 = 0x285;
  if (iVar1 >> 0xc < 0x286) {
    iVar2 = iVar1 >> 0xc;
  }
  iVar1 = 0;
  if (-1 < iVar2) {
    iVar1 = iVar2;
  }
  iVar2 = (&DAT_00340080)[iVar1];
  iVar3 = (&DAT_00340080)[iVar1 + 1] - iVar2;
  if (iVar3 < (int)((((int)param_3 >> 0x1f ^ param_3) - ((int)param_3 >> 0x1f)) * 2)) {
    iVar3 = iVar3 * (iVar4 + iVar1 * -0x1000);
    if (iVar3 < 0) {
      iVar3 = iVar3 + 0xfff;
    }
    iVar4 = (iVar3 >> 0xc) + iVar2 + param_3;
    if ((iVar4 < iVar2) || ((int)(&DAT_00340080)[iVar1 + 1] < iVar4)) {
      iVar1 = FUN_0010a0d0();
      return iVar1 - param_2;
    }
  }
  return (int)(param_3 * (&DAT_0033f660)[iVar1]) >> 0xc;
}


==================================================================

### FUNC 0010acf0 (43 bytes) name=FUN_0010acf0

ulong FUN_0010acf0(long param_1,undefined8 param_2,uint param_3)

{
  ulong uVar1;
  
  if (*(int *)(param_1 + 0x7810) == 0) {
    return (ulong)((param_3 & 0xffff) << ((byte)*(undefined4 *)(param_1 + 0x780c) & 0x1f));
  }
  uVar1 = FUN_0010ac30(param_1,param_2,
                       (param_3 & 0xffff) << (7U - (char)*(undefined4 *)(param_1 + 0x7814) & 0x1f));
  return uVar1;
}


==================================================================

### FUNC 0010ad30 (18 bytes) name=FUN_0010ad30

ulong FUN_0010ad30(long param_1,uint param_2)

{
  ulong uVar1;
  
  if (*(int *)(param_1 + 0xb0) != 0) {
    uVar1 = FUN_0010a230();
    return uVar1;
  }
  return (ulong)param_2;
}


==================================================================

### FUNC 0010ad50 (47 bytes) name=FUN_0010ad50

float FUN_0010ad50(float param_1,undefined8 param_2,long param_3)

{
  if (*(float *)(param_3 + 0xb0) < param_1) {
    return param_1 * *(float *)(param_3 + 0xbc) + *(float *)(param_3 + 0xc0);
  }
  return param_1 * *(float *)(param_3 + 0xb4) + *(float *)(param_3 + 0xb8);
}


==================================================================

### FUNC 0010ad90 (779 bytes) name=FUN_0010ad90

/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

undefined8 FUN_0010ad90(float param_1,long param_2,uint param_3,float *param_4,uint *param_5)

{
  long lVar1;
  ushort uVar2;
  int iVar3;
  uint uVar4;
  long lVar5;
  uint uVar6;
  uint uVar7;
  int iVar8;
  int iVar9;
  int iVar10;
  long lVar11;
  ulong uVar12;
  long lVar13;
  uint uVar14;
  uint uVar15;
  ulong uVar16;
  uint uVar17;
  int iVar18;
  uint uVar19;
  float fVar20;
  byte local_38;
  
  uVar17 = *(uint *)(param_2 + 0x4b60);
  if (uVar17 == 0) {
    iVar3 = *(int *)(param_2 + 0x1f20);
    iVar10 = FUN_0010a150(param_2,iVar3);
    iVar8 = *(int *)(param_2 + 0x1f28);
    iVar9 = FUN_0010a150(param_2,iVar8);
    if (iVar10 - iVar9 < 10000) {
      *(undefined4 *)(param_2 + 0x4b60) = 0xffff;
      return 0;
    }
    uVar17 = iVar8 + (iVar3 - iVar8) / 3;
    *(uint *)(param_2 + 0x4b60) = uVar17;
  }
  lVar5 = *(long *)(param_2 + 0x268);
  uVar2 = *(ushort *)(lVar5 + (ulong)param_3 * 2);
  if (uVar17 < uVar2) {
    iVar3 = *(int *)(param_2 + 0x1ef8);
    local_38 = (byte)iVar3;
    if (iVar3 != 0) {
      param_1 = param_1 * (float)(1 << (local_38 & 0x1f));
    }
    uVar4 = *(uint *)(param_2 + 0x1ed0);
    uVar6 = param_3 / uVar4;
    param_3 = param_3 - uVar6 * uVar4;
    uVar15 = param_3;
    if ((int)uVar6 < (int)param_3) {
      uVar15 = uVar6;
    }
    uVar7 = ~uVar6 + *(int *)(param_2 + 0x1ed4);
    uVar14 = (uVar4 - 1) - param_3;
    if (uVar14 <= uVar7) {
      uVar7 = uVar14;
    }
    if ((int)uVar7 < (int)uVar15) {
      uVar15 = uVar7;
    }
    if (0 < (int)uVar15) {
      uVar16 = (ulong)uVar2;
      iVar8 = 1;
      iVar10 = 0;
      do {
        iVar9 = iVar8;
        iVar8 = iVar9 * 2;
        lVar11 = 0;
        lVar13 = lVar5 + ((ulong)((uVar6 - iVar9) * uVar4) + ((long)(int)param_3 - (long)iVar9)) * 2
        ;
        uVar7 = 0;
        do {
          iVar18 = (int)lVar11;
          lVar1 = lVar11 * 2;
          lVar11 = lVar11 + 1;
          uVar7 = uVar7 + (uint)*(ushort *)(lVar13 + (ulong)(uVar4 * 2 * iVar9 + iVar18) * 2) +
                          (uint)*(ushort *)(lVar13 + lVar1);
        } while ((int)lVar11 <= iVar8);
        iVar18 = 1;
        uVar14 = uVar4;
        do {
          uVar12 = (ulong)uVar14;
          iVar18 = iVar18 + 1;
          uVar19 = uVar14 + iVar8;
          uVar14 = uVar14 + uVar4;
          uVar7 = uVar7 + (uint)*(ushort *)(lVar13 + (ulong)uVar19 * 2) +
                          (uint)*(ushort *)(lVar13 + uVar12 * 2);
        } while (iVar18 != iVar8);
        uVar12 = (ulong)uVar7 / (ulong)(uint)(iVar9 * 8);
        iVar8 = (int)uVar12;
        if (iVar8 <= (int)uVar17) {
          fVar20 = (float)iVar10 +
                   (float)(int)((iVar9 - iVar10) * (uVar17 - (int)uVar16)) /
                   (float)(iVar8 - (int)uVar16);
          if (fVar20 != _DAT_00131e24) goto LAB_0010af61;
          break;
        }
        iVar8 = iVar9 + 1;
        if ((param_1 < (float)iVar9) && (iVar10 = iVar9 * 9 >> 3, iVar8 <= iVar10)) {
          iVar8 = iVar10;
        }
        uVar16 = uVar12;
        iVar10 = iVar9;
      } while (iVar8 <= (int)uVar15);
    }
    fVar20 = (float)(int)uVar15;
    if (param_1 < fVar20) {
LAB_0010af61:
      if ((int)(DAT_00131e40 + fVar20) <= (int)uVar15) {
        uVar15 = (int)(DAT_00131e40 + fVar20);
      }
      iVar8 = uVar15 * 2;
      if (-1 < iVar8) {
        uVar14 = (uVar6 - uVar15) * uVar4;
        iVar10 = 0;
        uVar7 = 0;
        uVar6 = 0;
        do {
          lVar13 = 0;
          do {
            uVar19 = (uint)*(ushort *)
                            (lVar5 + ((ulong)uVar14 + ((long)(int)param_3 - (long)(int)uVar15)) * 2
                            + lVar13 * 2);
            if (uVar19 <= uVar17) {
              uVar6 = uVar6 + uVar19;
              uVar7 = uVar7 + 1;
            }
            lVar13 = lVar13 + 1;
          } while ((int)lVar13 <= iVar8);
          iVar10 = iVar10 + 1;
          uVar14 = uVar14 + uVar4;
        } while (iVar10 != iVar8 + 1);
        if (uVar7 != 0) {
          if (iVar3 != 0) {
            fVar20 = fVar20 / (float)(1 << (local_38 & 0x1f));
          }
          *param_4 = fVar20;
          *param_5 = uVar6 / uVar7;
          return 1;
        }
      }
    }
  }
  return 0;
}


==================================================================

### FUNC 0010b0a0 (1381 bytes) name=FUN_0010b0a0

/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

ulong FUN_0010b0a0(long param_1,ushort param_2,uint param_3,int param_4)

{
  long lVar1;
  undefined4 uVar2;
  int iVar3;
  int iVar4;
  int iVar5;
  ulong uVar6;
  byte bVar7;
  int iVar8;
  uint uVar9;
  uint uVar10;
  int *piVar11;
  int iVar12;
  float fVar13;
  float fVar14;
  float fVar15;
  float local_40;
  int local_3c [3];
  
  fVar13 = DAT_00131e20;
  if (*(int *)(param_1 + 0x1760) == 0) {
    uVar6 = FUN_0010a150(param_1,param_2);
    return uVar6;
  }
  uVar6 = (ulong)*(uint *)(param_1 + 0x78);
  uVar9 = (uint)param_2;
  if (*(uint *)(param_1 + 0x1764) <= *(uint *)(param_1 + 0x78)) {
    uVar6 = 0;
  }
  lVar1 = param_1 + 0x1768 + uVar6 * 0x21c;
  fVar15 = *(float *)(lVar1 + 0x204);
  if ((fVar15 <= _DAT_00131e44) || (DAT_00131e48 <= fVar15)) {
    if (((param_4 == 0) ||
        (((*(float *)(lVar1 + 0xac) < DAT_00131e20 || (*(float *)(lVar1 + 0xb0) < DAT_00131e20)) ||
         (*(float *)(lVar1 + 0xb4) <= 0.0)))) || (*(float *)(lVar1 + 0xbc) <= 0.0)) {
      iVar3 = *(int *)(param_1 + 0x7810);
      iVar5 = *(int *)(param_1 + 0x44);
    }
    else {
      iVar5 = FUN_0010ad90(param_1,param_3,&local_40,local_3c);
      if (iVar5 == 0) {
        iVar3 = *(int *)(param_1 + 0x7810);
      }
      else {
        if (*(float *)(lVar1 + 0xb0) < local_40) {
          fVar15 = local_40 * *(float *)(lVar1 + 0xbc) + *(float *)(lVar1 + 0xc0);
        }
        else {
          fVar15 = local_40 * *(float *)(lVar1 + 0xb4) + *(float *)(lVar1 + 0xb8);
        }
        fVar14 = *(float *)(lVar1 + 0xac);
        if (*(float *)(lVar1 + 0xb0) < fVar14) {
          fVar14 = fVar14 * *(float *)(lVar1 + 0xbc) + *(float *)(lVar1 + 0xc0);
        }
        else {
          fVar14 = fVar14 * *(float *)(lVar1 + 0xb4) + *(float *)(lVar1 + 0xb8);
        }
        iVar3 = *(int *)(param_1 + 0x7810);
        if (iVar3 == 0) {
          iVar5 = FUN_0010a190(param_1,uVar9);
          iVar3 = FUN_0010a190(param_1,local_3c[0]);
          uVar9 = FUN_0010a1e0(param_1,(int)((float)iVar5 +
                                            (float)(iVar5 - iVar3) * (fVar13 - fVar15 / fVar14)));
          iVar3 = 0;
        }
        else {
          bVar7 = 7 - (char)*(undefined4 *)(param_1 + 0x7814);
          iVar5 = (uint)param_2 << (bVar7 & 0x1f);
          uVar9 = (int)((float)iVar5 +
                       (float)(iVar5 - (local_3c[0] << (bVar7 & 0x1f))) * (fVar13 - fVar15 / fVar14)
                       ) >> (bVar7 & 0x1f);
        }
      }
      iVar5 = *(int *)(param_1 + 0x44);
    }
    if (iVar3 == 0) goto LAB_0010b1a4;
  }
  else {
    uVar2 = FUN_0010a150(param_1,uVar9);
    iVar3 = FUN_00109e70(param_1,uVar2);
    iVar5 = *(int *)(param_1 + 0x44);
    iVar4 = FUN_00109e70(param_1,iVar5);
    iVar4 = (int)(((float)iVar3 - (float)iVar4 * (DAT_00131e20 - fVar15)) / fVar15);
    iVar3 = DAT_003400fc;
    if (DAT_003400fc <= iVar4) {
      iVar3 = iVar4;
    }
    if (*(int *)(param_1 + 0x7810) == 0) {
      uVar9 = FUN_0010a1e0(param_1);
      goto LAB_0010b1a4;
    }
    uVar9 = iVar3 >> (7U - (char)*(undefined4 *)(param_1 + 0x7814) & 0x1f);
  }
  uVar9 = FUN_0010a150(param_1,uVar9);
LAB_0010b1a4:
  iVar3 = *(int *)(lVar1 + 0x3c) + -1;
  if (iVar3 == 0) {
    uVar6 = 1;
    uVar10 = 0;
  }
  else if (*(int *)(lVar1 + 0x40) < (int)uVar9) {
    iVar4 = 0;
    piVar11 = (int *)(lVar1 + 0x44);
    do {
      iVar4 = iVar4 + 1;
      if (iVar4 == iVar3) {
        uVar10 = iVar3 * 2;
        uVar6 = (ulong)(uVar10 + 1);
        goto LAB_0010b1e4;
      }
      iVar12 = *piVar11;
      piVar11 = piVar11 + 1;
    } while (iVar12 < (int)uVar9);
    uVar10 = iVar4 * 2;
    uVar6 = (ulong)(uVar10 + 1);
  }
  else {
    uVar6 = 1;
    uVar10 = 0;
  }
LAB_0010b1e4:
  iVar3 = *(int *)(param_1 + 0x40);
  iVar12 = (int)((long)(int)uVar9 * (long)*(int *)(lVar1 + 0xd4 + (ulong)uVar10 * 4) >>
                ((byte)*(undefined4 *)(lVar1 + 0x30) & 0x3f)) + *(int *)(lVar1 + 0xd4 + uVar6 * 4);
  iVar4 = (*(int *)(lVar1 + 0x38) + *(int *)(param_1 + 0x3c)) - *(int *)(lVar1 + 0x34);
  if (*(int *)(param_1 + 0x4c) == 0) {
    iVar4 = iVar3 - iVar4;
    iVar8 = -1000;
  }
  else {
    iVar4 = iVar4 - iVar3;
    iVar8 = -5000;
  }
  if (iVar8 <= iVar4) {
    iVar8 = iVar4;
  }
  iVar4 = 1000;
  if (iVar8 < 0x3e9) {
    iVar4 = iVar8;
  }
  iVar5 = FUN_0010a3c0(param_1,iVar3,
                       (iVar3 - *(int *)(param_1 + 0x48)) + (iVar5 - *(int *)(param_1 + 0x3c)) * 2 +
                       iVar4);
  if (param_4 != 0) {
    if (*(float *)(param_1 + 0x8c) != 0.0) {
      iVar3 = *(int *)(param_1 + 0x4ba0);
      if (*(int *)(lVar1 + 0x20c) - *(int *)(lVar1 + 0x208) < 0xc351) {
        if (iVar3 < 40000) {
          if (iVar3 < 0x1389) {
            iVar3 = 5000;
          }
        }
        else {
          iVar3 = 40000;
        }
      }
      else if (iVar3 < 80000) {
        if (iVar3 < -79999) {
          iVar3 = -80000;
        }
      }
      else {
        iVar3 = 80000;
      }
      iVar3 = FUN_0010a3c0(param_1,35000,
                           (int)((float)(iVar3 - *(int *)(param_1 + 0x88)) *
                                *(float *)(param_1 + 0x8c)));
      iVar5 = iVar5 + iVar3;
    }
    if (*(float *)(lVar1 + 0x214) != 0.0) {
      uVar9 = *(uint *)(param_1 + 0x1ed0);
      iVar4 = (param_3 - (param_3 / uVar9) * uVar9) - (uVar9 >> 1);
      iVar3 = param_3 / uVar9 - (*(uint *)(param_1 + 0x1ed4) >> 1);
      fVar13 = (float)(iVar3 * iVar3 + iVar4 * iVar4);
      fVar15 = SQRT(fVar13);
      if (NAN(fVar15)) {
        fVar15 = sqrtf(fVar13);
      }
      fVar15 = (float)((uint)fVar15 ^ DAT_00131e70);
      fVar13 = *(float *)(lVar1 + 0x214);
      iVar3 = FUN_00109e70(param_1,iVar12);
      iVar4 = FUN_00109e70(param_1,*(undefined4 *)(param_1 + 0x48));
      iVar5 = iVar5 + (int)((float)(iVar3 - iVar4) * fVar15 * fVar13);
    }
  }
  iVar5 = FUN_0010ac30(param_1,iVar12,iVar5);
  return (ulong)(uint)(iVar5 + iVar12);
}


==================================================================

### FUNC 0010b620 (652 bytes) name=FUN_0010b620

void FUN_0010b620(long param_1)

{
  undefined4 uVar1;
  int iVar2;
  int iVar3;
  int iVar4;
  byte bVar5;
  int iVar6;
  
  memcpy((void *)(param_1 + 0x4b80),(void *)(param_1 + 0x1f08),0x2c78);
  uVar1 = FUN_0010b0a0(param_1,*(undefined2 *)(param_1 + 0x1f28),
                       (*(uint *)(param_1 + 0x1ed0) >> 1) + (*(uint *)(param_1 + 0x77f8) >> 1),0);
  *(undefined4 *)(param_1 + 0x4ba0) = uVar1;
  uVar1 = FUN_0010b0a0(param_1,*(undefined2 *)(param_1 + 0x1f3c),
                       (*(uint *)(param_1 + 0x1ed0) >> 1) + (*(uint *)(param_1 + 0x77f8) >> 1),0);
  *(undefined4 *)(param_1 + 0x4bb4) = uVar1;
  uVar1 = FUN_0010b0a0(param_1,*(undefined2 *)(param_1 + 0x1f20),*(undefined4 *)(param_1 + 0x4ba8),1
                      );
  *(undefined4 *)(param_1 + 0x4b98) = uVar1;
  uVar1 = FUN_0010b0a0(param_1,*(undefined2 *)(param_1 + 8000),
                       (*(uint *)(param_1 + 0x1ed0) >> 1) + (*(uint *)(param_1 + 0x77f8) >> 1),0);
  *(undefined4 *)(param_1 + 0x4bb8) = uVar1;
  iVar2 = FUN_0010b0a0(param_1,*(undefined2 *)(param_1 + 0x1f24),*(undefined4 *)(param_1 + 0x4bac),1
                      );
  iVar4 = *(int *)(param_1 + 0xb0);
  *(int *)(param_1 + 0x4b9c) = iVar2;
  if (iVar4 == 2) {
    iVar6 = *(int *)(param_1 + 0x4ba0);
    *(float *)(param_1 + 0xbc) = (float)iVar6 * DAT_00131e34;
  }
  else {
    if (iVar4 == 3) {
      *(float *)(param_1 + 0xbc) = (float)*(int *)(param_1 + 0x48) * DAT_00131e34;
    }
    iVar6 = *(int *)(param_1 + 0x4ba0);
  }
  if (*(int *)(param_1 + 0x7810) == 0) {
    bVar5 = (byte)*(undefined4 *)(param_1 + 0x780c);
    *(uint *)(param_1 + 0x4bbc) = (uint)*(ushort *)(param_1 + 0x1f44) << (bVar5 & 0x1f);
    iVar3 = (uint)*(ushort *)(param_1 + 0x1f2c) << (bVar5 & 0x1f);
  }
  else {
    bVar5 = 7 - (char)*(undefined4 *)(param_1 + 0x7814);
    uVar1 = FUN_0010ac30(param_1,iVar6,(uint)*(ushort *)(param_1 + 0x1f44) << (bVar5 & 0x1f));
    *(undefined4 *)(param_1 + 0x4bbc) = uVar1;
    iVar3 = FUN_0010ac30(param_1,iVar6,(uint)*(ushort *)(param_1 + 0x1f2c) << (bVar5 & 0x1f));
  }
  *(int *)(param_1 + 0x4ba4) = iVar3;
  if (*(int *)(param_1 + 0x60) == 0) {
    iVar4 = *(int *)(param_1 + 0x4b98);
    goto LAB_0010b761;
  }
  if (iVar4 == 0) {
    *(int *)(param_1 + 0x4ba0) = iVar6;
LAB_0010b7a8:
    iVar4 = *(int *)(param_1 + 0x4b98);
    *(int *)(param_1 + 0x4b9c) = iVar2;
  }
  else {
    uVar1 = FUN_0010a230(*(undefined4 *)(param_1 + 0xb8),param_1,iVar6);
    iVar2 = *(int *)(param_1 + 0x4b9c);
    *(undefined4 *)(param_1 + 0x4ba0) = uVar1;
    if (*(int *)(param_1 + 0xb0) == 0) goto LAB_0010b7a8;
    iVar2 = FUN_0010a230(*(undefined4 *)(param_1 + 0xb8),param_1,iVar2);
    *(int *)(param_1 + 0x4b9c) = iVar2;
    iVar4 = *(int *)(param_1 + 0x4b98);
    if (*(int *)(param_1 + 0xb0) != 0) {
      iVar4 = FUN_0010a230(*(undefined4 *)(param_1 + 0xb8),param_1,iVar4);
      iVar2 = *(int *)(param_1 + 0x4b9c);
    }
  }
  *(int *)(param_1 + 0x4b98) = iVar4;
  iVar6 = *(int *)(param_1 + 0x4ba0);
LAB_0010b761:
  if (iVar4 < iVar2) {
    *(int *)(param_1 + 0x4b98) = iVar2;
    iVar4 = iVar2;
  }
  if (iVar4 < iVar6) {
    *(int *)(param_1 + 0x4ba0) = iVar4;
    iVar6 = iVar4;
  }
  if (iVar6 < iVar2) {
    *(int *)(param_1 + 0x4ba0) = iVar2;
  }
  return;
}


==================================================================

### FUNC 0010b8d0 (169 bytes) name=FUN_0010b8d0

uint FUN_0010b8d0(undefined4 param_1,long param_2,int param_3)

{
  uint uVar1;
  uint uVar2;
  int iVar3;
  uint uVar4;
  uint uVar5;
  uint uVar6;
  undefined4 extraout_XMM0_Da;
  undefined4 extraout_XMM0_Da_00;
  
  uVar6 = 0xffff;
  uVar5 = 0;
  uVar1 = *(uint *)(param_2 + 0x1ed0);
  uVar2 = *(uint *)(param_2 + 0x77f8);
  *(undefined4 *)(param_2 + 0x5c) = 1;
  do {
    uVar4 = uVar6 + uVar5 >> 1;
    iVar3 = FUN_0010b0a0(param_1,param_2,(short)uVar4,(uVar1 >> 1) + (uVar2 >> 1),0);
    if (((*(int *)(param_2 + 0x5c) != 0) ||
        (param_1 = extraout_XMM0_Da, *(int *)(param_2 + 0x60) != 0)) &&
       (param_1 = *(undefined4 *)(param_2 + 0xb8), *(int *)(param_2 + 0xb0) != 0)) {
      iVar3 = FUN_0010a230(param_2,iVar3);
      param_1 = extraout_XMM0_Da_00;
    }
    if (param_3 < iVar3) {
      uVar6 = uVar4;
      uVar4 = uVar5;
    }
    uVar5 = uVar4;
  } while (uVar5 + 1 < uVar6);
  return uVar6 + uVar5 >> 1;
}


==================================================================

### FUNC 0010b990 (80 bytes) name=FUN_0010b990

undefined1  [16] FUN_0010b990(long param_1)

{
  int iVar1;
  ulong uVar2;
  ushort uVar3;
  undefined8 uVar4;
  uint uVar5;
  undefined1 auVar6 [16];
  undefined1 auVar7 [16];
  
  uVar3 = FUN_0010b8d0();
  uVar4 = 0x100;
  if (((int)(uint)uVar3 <= *(int *)(param_1 + 0x1f3c)) &&
     (uVar5 = (uint)uVar3,
     uVar5 == *(uint *)(param_1 + 0x1f20) || (int)(uint)uVar3 < (int)*(uint *)(param_1 + 0x1f20))) {
    iVar1 = *(int *)(param_1 + 8000);
    uVar4 = 0;
    if (iVar1 <= (int)uVar5) {
      uVar2 = (ulong)(uint)(*(int *)(param_1 + 0x1f3c) - iVar1);
      auVar7._1_7_ = 0;
      auVar7[0] = *(byte *)(param_1 + 0x2760 +
                           (ulong)((uVar5 - iVar1) * (int)(0xffc00000 / uVar2) >> 0x16));
      auVar7._8_8_ = 0xffc00000 % uVar2;
      return auVar7;
    }
  }
  auVar6._8_2_ = uVar3;
  auVar6._0_8_ = uVar4;
  auVar6._10_6_ = 0;
  return auVar6;
}


==================================================================

### FUNC 0010b9f0 (786 bytes) name=FUN_0010b9f0

void FUN_0010b9f0(long param_1)

{
  undefined2 uVar1;
  uint uVar2;
  undefined4 uVar3;
  ushort uVar4;
  ushort uVar5;
  int iVar6;
  uint uVar7;
  undefined1 *puVar8;
  ulong uVar9;
  long lVar10;
  uint uVar11;
  undefined8 *puVar12;
  undefined8 *puVar13;
  undefined8 *puVar14;
  undefined8 *puVar15;
  uint uVar16;
  bool bVar17;
  byte bVar18;
  
  bVar18 = 0;
  uVar7 = *(uint *)(param_1 + 0x1f3c);
  uVar2 = *(uint *)(param_1 + 8000);
  uVar4 = FUN_0010b8d0(param_1,*(undefined4 *)(param_1 + 0x18));
  uVar5 = FUN_0010b8d0(param_1,*(undefined4 *)(param_1 + 0x14));
  uVar16 = 0x100;
  if (uVar4 <= uVar7) {
    uVar16 = 0xffffffff;
    if (uVar2 < uVar4 || uVar2 == uVar4) {
      uVar16 = (uint)*(byte *)(param_1 + 0x2760 +
                              (ulong)((uVar4 - uVar2) * 0x3ff) / (ulong)(uVar7 - uVar2));
    }
  }
  uVar11 = 0x100;
  if (uVar5 <= uVar7) {
    uVar11 = 0;
    if (uVar2 < uVar5 || uVar2 == uVar5) {
      uVar11 = (uint)*(byte *)(param_1 + 0x2760 +
                              (ulong)((uVar5 - uVar2) * 0x3ff) / (ulong)(uVar7 - uVar2));
    }
  }
  puVar12 = (undefined8 *)(param_1 + 0x6d8);
  puVar13 = (undefined8 *)(param_1 + 0x2b0);
  uVar7 = 0x400;
  iVar6 = 0x400;
  bVar17 = ((ulong)puVar12 & 1) != 0;
  puVar15 = puVar12;
  if (bVar17) {
    puVar13 = (undefined8 *)(param_1 + 0x2b1);
    *(undefined1 *)(param_1 + 0x6d8) = *(undefined1 *)(param_1 + 0x2b0);
    uVar7 = 0x3ff;
    iVar6 = 0x3ff;
    puVar15 = (undefined8 *)(param_1 + 0x6d9);
  }
  if (((ulong)puVar15 & 2) != 0) {
    uVar1 = *(undefined2 *)puVar13;
    puVar13 = (undefined8 *)((long)puVar13 + 2);
    uVar7 = iVar6 - 2;
    *(undefined2 *)puVar15 = uVar1;
    puVar15 = (undefined8 *)((long)puVar15 + 2);
  }
  puVar14 = puVar15;
  if (((ulong)puVar15 & 4) != 0) {
    uVar3 = *(undefined4 *)puVar13;
    puVar14 = (undefined8 *)((long)puVar15 + 4);
    puVar13 = (undefined8 *)((long)puVar13 + 4);
    uVar7 = uVar7 - 4;
    *(undefined4 *)puVar15 = uVar3;
  }
  for (uVar9 = (ulong)(uVar7 >> 3); uVar9 != 0; uVar9 = uVar9 - 1) {
    *puVar14 = *puVar13;
    puVar13 = puVar13 + (ulong)bVar18 * -2 + 1;
    puVar14 = puVar14 + (ulong)bVar18 * -2 + 1;
  }
  lVar10 = 0;
  if ((uVar7 & 4) != 0) {
    *(undefined4 *)puVar14 = *(undefined4 *)puVar13;
    lVar10 = 4;
  }
  if ((uVar7 & 2) != 0) {
    *(undefined2 *)((long)puVar14 + lVar10) = *(undefined2 *)((long)puVar13 + lVar10);
    lVar10 = lVar10 + 2;
  }
  if (bVar17) {
    *(undefined1 *)((long)puVar14 + lVar10) = *(undefined1 *)((long)puVar13 + lVar10);
  }
  puVar8 = (undefined1 *)((long)puVar12 + (long)(int)uVar11 * 4);
  while( true ) {
    uVar7 = 0xff;
    if ((int)uVar16 < 0xff) {
      uVar7 = uVar16;
    }
    if ((int)uVar7 < (int)uVar11) break;
    *puVar8 = 0;
    puVar8[1] = 0xff;
    uVar11 = uVar11 + 1;
    puVar8[2] = 0;
    puVar8[3] = 0;
    puVar8 = puVar8 + 4;
  }
  puVar13 = (undefined8 *)(param_1 + 0xb00);
  uVar7 = 0x400;
  iVar6 = 0x400;
  bVar17 = ((ulong)puVar13 & 1) != 0;
  puVar15 = puVar12;
  if (bVar17) {
    puVar13 = (undefined8 *)(param_1 + 0xb01);
    *(undefined1 *)(param_1 + 0xb00) = *(undefined1 *)(param_1 + 0x6d8);
    uVar7 = 0x3ff;
    iVar6 = 0x3ff;
    puVar15 = (undefined8 *)(param_1 + 0x6d9);
  }
  if (((ulong)puVar13 & 2) != 0) {
    uVar1 = *(undefined2 *)puVar15;
    puVar15 = (undefined8 *)((long)puVar15 + 2);
    uVar7 = iVar6 - 2;
    *(undefined2 *)puVar13 = uVar1;
    puVar13 = (undefined8 *)((long)puVar13 + 2);
  }
  puVar14 = puVar13;
  if (((ulong)puVar13 & 4) != 0) {
    uVar3 = *(undefined4 *)puVar15;
    puVar14 = (undefined8 *)((long)puVar13 + 4);
    puVar15 = (undefined8 *)((long)puVar15 + 4);
    uVar7 = uVar7 - 4;
    *(undefined4 *)puVar13 = uVar3;
  }
  lVar10 = 0;
  for (uVar9 = (ulong)(uVar7 >> 3); uVar9 != 0; uVar9 = uVar9 - 1) {
    *puVar14 = *puVar15;
    puVar15 = puVar15 + (ulong)bVar18 * -2 + 1;
    puVar14 = puVar14 + (ulong)bVar18 * -2 + 1;
  }
  if ((uVar7 & 4) != 0) {
    *(undefined4 *)puVar14 = *(undefined4 *)puVar15;
    lVar10 = 4;
  }
  if ((uVar7 & 2) != 0) {
    *(undefined2 *)((long)puVar14 + lVar10) = *(undefined2 *)((long)puVar15 + lVar10);
    lVar10 = lVar10 + 2;
  }
  if (bVar17) {
    *(undefined1 *)((long)puVar14 + lVar10) = *(undefined1 *)((long)puVar15 + lVar10);
  }
  puVar13 = (undefined8 *)(param_1 + 0xf28);
  uVar7 = 0x400;
  iVar6 = 0x400;
  bVar17 = ((ulong)puVar13 & 1) != 0;
  if (bVar17) {
    puVar13 = (undefined8 *)(param_1 + 0xf29);
    puVar12 = (undefined8 *)(param_1 + 0x6d9);
    *(undefined1 *)(param_1 + 0xf28) = *(undefined1 *)(param_1 + 0x6d8);
    uVar7 = 0x3ff;
    iVar6 = 0x3ff;
  }
  puVar15 = puVar13;
  if (((ulong)puVar13 & 2) != 0) {
    uVar1 = *(undefined2 *)puVar12;
    puVar15 = (undefined8 *)((long)puVar13 + 2);
    puVar12 = (undefined8 *)((long)puVar12 + 2);
    uVar7 = iVar6 - 2;
    *(undefined2 *)puVar13 = uVar1;
  }
  puVar13 = puVar15;
  if (((ulong)puVar15 & 4) != 0) {
    uVar3 = *(undefined4 *)puVar12;
    puVar13 = (undefined8 *)((long)puVar15 + 4);
    puVar12 = (undefined8 *)((long)puVar12 + 4);
    uVar7 = uVar7 - 4;
    *(undefined4 *)puVar15 = uVar3;
  }
  lVar10 = 0;
  for (uVar9 = (ulong)(uVar7 >> 3); uVar9 != 0; uVar9 = uVar9 - 1) {
    *puVar13 = *puVar12;
    puVar12 = puVar12 + (ulong)bVar18 * -2 + 1;
    puVar13 = puVar13 + (ulong)bVar18 * -2 + 1;
  }
  if ((uVar7 & 4) != 0) {
    *(undefined4 *)puVar13 = *(undefined4 *)puVar12;
    lVar10 = 4;
  }
  if ((uVar7 & 2) != 0) {
    *(undefined2 *)((long)puVar13 + lVar10) = *(undefined2 *)((long)puVar12 + lVar10);
    lVar10 = lVar10 + 2;
  }
  if (bVar17) {
    *(undefined1 *)((long)puVar13 + lVar10) = *(undefined1 *)((long)puVar12 + lVar10);
  }
  return;
}


==================================================================

### FUNC 0010bd10 (347 bytes) name=FUN_0010bd10

void FUN_0010bd10(long param_1)

{
  int iVar1;
  int iVar2;
  ulong uVar3;
  ushort uVar4;
  uint uVar5;
  int iVar6;
  long lVar7;
  uint uVar8;
  uint uVar9;
  uint uVar10;
  uint uVar11;
  uint uVar12;
  int iVar13;
  
  if ((*(uint *)(param_1 + 0x1c) < *(uint *)(param_1 + 0x20)) &&
     (*(int *)(param_1 + 0x14) < *(int *)(param_1 + 0x18))) {
    uVar5 = FUN_0010b8d0();
    uVar4 = FUN_0010b8d0(param_1,*(undefined4 *)(param_1 + 0x18));
    uVar5 = uVar5 & 0xffff;
    uVar10 = *(uint *)(param_1 + 0x1f20);
    if ((int)*(uint *)(param_1 + 0x1f20) <= (int)(uint)uVar4) {
      uVar10 = (uint)uVar4;
    }
    uVar11 = *(uint *)(param_1 + 0x1f24);
    if ((int)uVar5 <= (int)*(uint *)(param_1 + 0x1f24)) {
      uVar11 = uVar5;
    }
    *(uint *)(param_1 + 0x1f3c) = uVar10;
    iVar13 = 0;
    *(uint *)(param_1 + 8000) = uVar11;
    uVar3 = (ulong)((uVar5 - uVar11) * 0x3ff) / (ulong)(uVar10 - uVar11);
    uVar5 = ((uVar4 - uVar11) * 0x3ff) / (uVar10 - uVar11);
    uVar10 = (uint)uVar3;
    iVar1 = *(int *)(param_1 + 0x20) * 4;
    iVar2 = *(int *)(param_1 + 0x1c);
    if (uVar10 != 0) {
      iVar13 = (int)((uint)(iVar2 << 0x18) / uVar3);
    }
    uVar11 = 0;
    if (uVar10 < uVar5) {
      uVar11 = (uint)((iVar1 + iVar2 * -4) * 0x400000) / (uVar5 - uVar10);
    }
    uVar12 = 0;
    if (uVar5 < 0x3ff) {
      uVar12 = (uint)((*(int *)(param_1 + 0x20) * -4 + 0x3ff) * 0x400000) / (0x3ff - uVar5);
    }
    param_1 = param_1 + 0x2760;
    iVar6 = 0;
    uVar9 = -uVar5 * uVar12;
    lVar7 = 0;
    uVar8 = -uVar10 * uVar11;
    do {
      if (uVar10 < (uint)lVar7) {
        if ((uint)lVar7 < uVar5) {
          *(char *)(param_1 + lVar7) = (char)((uVar8 >> 0x16) + iVar2 * 4 >> 2);
        }
        else {
          *(char *)(param_1 + lVar7) = (char)((uVar9 >> 0x16) + iVar1 >> 2);
        }
      }
      else {
        *(char *)(param_1 + lVar7) = (char)((uint)iVar6 >> 0x18);
      }
      lVar7 = lVar7 + 1;
      iVar6 = iVar6 + iVar13;
      uVar9 = uVar9 + uVar12;
      uVar8 = uVar8 + uVar11;
    } while (lVar7 != 0x400);
  }
  return;
}


==================================================================

### FUNC 0010be80 (1251 bytes) name=FUN_0010be80

void FUN_0010be80(long param_1)

{
  undefined2 uVar1;
  undefined4 uVar2;
  uint uVar3;
  uint uVar4;
  ulong uVar5;
  ulong uVar6;
  uint uVar7;
  long lVar8;
  uint uVar9;
  undefined8 *puVar10;
  undefined8 *puVar11;
  undefined8 *puVar12;
  undefined8 *puVar13;
  int iVar14;
  bool bVar15;
  byte bVar16;
  
  bVar16 = 0;
  uVar4 = *(uint *)(param_1 + 0x1f24);
  uVar9 = *(uint *)(param_1 + 0x1f20);
  if (uVar4 == uVar9) {
    *(uint *)(param_1 + 8000) = uVar4;
    *(uint *)(param_1 + 0x1f3c) = uVar4;
    puVar11 = (undefined8 *)(param_1 + 0x2760);
    uVar5 = 0x400;
    bVar15 = ((ulong)puVar11 & 1) != 0;
    if (bVar15) {
      *(undefined1 *)(param_1 + 0x2760) = 0x80;
      puVar11 = (undefined8 *)(param_1 + 0x2761);
      uVar5 = 0x3ff;
    }
    puVar10 = puVar11;
    if (((ulong)puVar11 & 2) != 0) {
      puVar10 = (undefined8 *)((long)puVar11 + 2);
      uVar5 = (ulong)((int)uVar5 - 2);
      *(undefined2 *)puVar11 = 0x8080;
    }
    if (((ulong)puVar10 & 4) != 0) {
      *(undefined4 *)puVar10 = 0x80808080;
      uVar5 = (ulong)((int)uVar5 - 4);
      puVar10 = (undefined8 *)((long)puVar10 + 4);
    }
    for (uVar6 = uVar5 >> 3; uVar6 != 0; uVar6 = uVar6 - 1) {
      *puVar10 = 0x8080808080808080;
      puVar10 = puVar10 + 1;
    }
    if ((uVar5 & 4) != 0) {
      *(undefined4 *)puVar10 = 0x80808080;
      puVar10 = (undefined8 *)((long)puVar10 + 4);
    }
    puVar11 = puVar10;
    if ((uVar5 & 2) != 0) {
      puVar11 = (undefined8 *)((long)puVar10 + 2);
      *(undefined2 *)puVar10 = 0x8080;
    }
    if (bVar15) {
      *(undefined1 *)puVar11 = 0x80;
    }
    memset(*(void **)(param_1 + 0x298),0x80,(ulong)*(uint *)(param_1 + 0x77f8));
    puVar11 = (undefined8 *)(param_1 + 0x1f60);
    uVar5 = 0x400;
    bVar15 = ((ulong)puVar11 & 1) != 0;
    if (bVar15) {
      *(undefined1 *)(param_1 + 0x1f60) = 0;
      puVar11 = (undefined8 *)(param_1 + 0x1f61);
      uVar5 = 0x3ff;
    }
    puVar10 = puVar11;
    if (((ulong)puVar11 & 2) != 0) {
      puVar10 = (undefined8 *)((long)puVar11 + 2);
      uVar5 = (ulong)((int)uVar5 - 2);
      *(undefined2 *)puVar11 = 0;
    }
    if (((ulong)puVar10 & 4) != 0) {
      *(undefined4 *)puVar10 = 0;
      uVar5 = (ulong)((int)uVar5 - 4);
      puVar10 = (undefined8 *)((long)puVar10 + 4);
    }
    for (uVar6 = uVar5 >> 3; uVar6 != 0; uVar6 = uVar6 - 1) {
      *puVar10 = 0;
      puVar10 = puVar10 + (ulong)bVar16 * -2 + 1;
    }
    if ((uVar5 & 4) != 0) {
      *(undefined4 *)puVar10 = 0;
      puVar10 = (undefined8 *)((long)puVar10 + 4);
    }
    puVar11 = puVar10;
    if ((uVar5 & 2) != 0) {
      puVar11 = (undefined8 *)((long)puVar10 + 2);
      *(undefined2 *)puVar10 = 0;
    }
    if (bVar15) {
      *(undefined1 *)puVar11 = 0;
    }
    *(undefined4 *)(param_1 + 0x2160) = *(undefined4 *)(param_1 + 0x77f8);
    memset(*(void **)(param_1 + 0x2a8),0x80,(ulong)*(uint *)(param_1 + 0x7800));
    *(undefined4 *)(param_1 + 0x1f4c) = 1;
    return;
  }
  if (*(int *)(param_1 + 0x10) == 0) {
    iVar14 = *(int *)(param_1 + 0x1f28);
    if (*(int *)(param_1 + 0x6c) != 0) {
      FUN_00108e10();
      iVar14 = *(int *)(param_1 + 0x4b6c);
      uVar4 = *(uint *)(param_1 + 0x1f24);
      uVar9 = *(uint *)(param_1 + 0x1f20);
    }
    uVar3 = FUN_0010a500(param_1);
    uVar7 = iVar14 - (uVar3 >> 1);
    if (uVar7 <= uVar4) {
      uVar4 = uVar7;
    }
    uVar3 = (uVar3 >> 1) + iVar14;
    *(uint *)(param_1 + 8000) = uVar4;
    if (uVar9 <= uVar3) {
      uVar9 = uVar3;
    }
    *(uint *)(param_1 + 0x1f3c) = uVar9;
    if ((int)uVar4 < 0) {
      *(undefined4 *)(param_1 + 8000) = 0;
    }
    if (0xffff < (int)uVar9) {
      *(undefined4 *)(param_1 + 0x1f3c) = 0xffff;
    }
    FUN_0010a610(param_1);
    if (*(int *)(param_1 + 0x28) != 0) {
      FUN_0010b9f0(param_1);
      *(undefined4 *)(param_1 + 0x4b64) = 1;
      goto LAB_0010bf28;
    }
    iVar14 = *(int *)(param_1 + 0x4b64);
  }
  else {
    FUN_0010bd10();
    iVar14 = *(int *)(param_1 + 0x4b64);
  }
  if (iVar14 != 0) {
    puVar11 = (undefined8 *)(param_1 + 0x6d8);
    puVar10 = (undefined8 *)(param_1 + 0x2b0);
    uVar4 = 0x400;
    bVar15 = ((ulong)puVar11 & 1) != 0;
    puVar12 = puVar10;
    if (bVar15) {
      puVar11 = (undefined8 *)(param_1 + 0x6d9);
      puVar12 = (undefined8 *)(param_1 + 0x2b1);
      *(undefined1 *)(param_1 + 0x6d8) = *(undefined1 *)(param_1 + 0x2b0);
      uVar4 = 0x3ff;
    }
    puVar13 = puVar11;
    if (((ulong)puVar11 & 2) != 0) {
      uVar1 = *(undefined2 *)puVar12;
      puVar13 = (undefined8 *)((long)puVar11 + 2);
      puVar12 = (undefined8 *)((long)puVar12 + 2);
      uVar4 = uVar4 - 2;
      *(undefined2 *)puVar11 = uVar1;
    }
    puVar11 = puVar13;
    if (((ulong)puVar13 & 4) != 0) {
      uVar2 = *(undefined4 *)puVar12;
      puVar11 = (undefined8 *)((long)puVar13 + 4);
      puVar12 = (undefined8 *)((long)puVar12 + 4);
      uVar4 = uVar4 - 4;
      *(undefined4 *)puVar13 = uVar2;
    }
    lVar8 = 0;
    for (uVar5 = (ulong)(uVar4 >> 3); uVar5 != 0; uVar5 = uVar5 - 1) {
      *puVar11 = *puVar12;
      puVar12 = puVar12 + (ulong)bVar16 * -2 + 1;
      puVar11 = puVar11 + (ulong)bVar16 * -2 + 1;
    }
    if ((uVar4 & 4) != 0) {
      *(undefined4 *)puVar11 = *(undefined4 *)puVar12;
      lVar8 = 4;
    }
    if ((uVar4 & 2) != 0) {
      *(undefined2 *)((long)puVar11 + lVar8) = *(undefined2 *)((long)puVar12 + lVar8);
      lVar8 = lVar8 + 2;
    }
    if (bVar15) {
      *(undefined1 *)((long)puVar11 + lVar8) = *(undefined1 *)((long)puVar12 + lVar8);
    }
    puVar12 = (undefined8 *)(param_1 + 0xb00);
    uVar4 = 0x400;
    bVar15 = ((ulong)puVar12 & 1) != 0;
    puVar11 = puVar10;
    if (bVar15) {
      puVar12 = (undefined8 *)(param_1 + 0xb01);
      puVar11 = (undefined8 *)(param_1 + 0x2b1);
      *(undefined1 *)(param_1 + 0xb00) = *(undefined1 *)(param_1 + 0x2b0);
      uVar4 = 0x3ff;
    }
    puVar13 = puVar12;
    if (((ulong)puVar12 & 2) != 0) {
      uVar1 = *(undefined2 *)puVar11;
      puVar13 = (undefined8 *)((long)puVar12 + 2);
      puVar11 = (undefined8 *)((long)puVar11 + 2);
      uVar4 = uVar4 - 2;
      *(undefined2 *)puVar12 = uVar1;
    }
    puVar12 = puVar13;
    if (((ulong)puVar13 & 4) != 0) {
      uVar2 = *(undefined4 *)puVar11;
      puVar12 = (undefined8 *)((long)puVar13 + 4);
      puVar11 = (undefined8 *)((long)puVar11 + 4);
      uVar4 = uVar4 - 4;
      *(undefined4 *)puVar13 = uVar2;
    }
    lVar8 = 0;
    for (uVar5 = (ulong)(uVar4 >> 3); uVar5 != 0; uVar5 = uVar5 - 1) {
      *puVar12 = *puVar11;
      puVar11 = puVar11 + (ulong)bVar16 * -2 + 1;
      puVar12 = puVar12 + (ulong)bVar16 * -2 + 1;
    }
    if ((uVar4 & 4) != 0) {
      *(undefined4 *)puVar12 = *(undefined4 *)puVar11;
      lVar8 = 4;
    }
    if ((uVar4 & 2) != 0) {
      *(undefined2 *)((long)puVar12 + lVar8) = *(undefined2 *)((long)puVar11 + lVar8);
      lVar8 = lVar8 + 2;
    }
    if (bVar15) {
      *(undefined1 *)((long)puVar12 + lVar8) = *(undefined1 *)((long)puVar11 + lVar8);
    }
    puVar11 = (undefined8 *)(param_1 + 0xf28);
    uVar4 = 0x400;
    bVar15 = ((ulong)puVar11 & 1) != 0;
    if (bVar15) {
      puVar11 = (undefined8 *)(param_1 + 0xf29);
      puVar10 = (undefined8 *)(param_1 + 0x2b1);
      *(undefined1 *)(param_1 + 0xf28) = *(undefined1 *)(param_1 + 0x2b0);
      uVar4 = 0x3ff;
    }
    puVar12 = puVar11;
    if (((ulong)puVar11 & 2) != 0) {
      uVar1 = *(undefined2 *)puVar10;
      puVar12 = (undefined8 *)((long)puVar11 + 2);
      puVar10 = (undefined8 *)((long)puVar10 + 2);
      uVar4 = uVar4 - 2;
      *(undefined2 *)puVar11 = uVar1;
    }
    puVar11 = puVar12;
    if (((ulong)puVar12 & 4) != 0) {
      uVar2 = *(undefined4 *)puVar10;
      puVar11 = (undefined8 *)((long)puVar12 + 4);
      puVar10 = (undefined8 *)((long)puVar10 + 4);
      uVar4 = uVar4 - 4;
      *(undefined4 *)puVar12 = uVar2;
    }
    lVar8 = 0;
    for (uVar5 = (ulong)(uVar4 >> 3); uVar5 != 0; uVar5 = uVar5 - 1) {
      *puVar11 = *puVar10;
      puVar10 = puVar10 + (ulong)bVar16 * -2 + 1;
      puVar11 = puVar11 + (ulong)bVar16 * -2 + 1;
    }
    if ((uVar4 & 4) != 0) {
      *(undefined4 *)puVar11 = *(undefined4 *)puVar10;
      lVar8 = 4;
    }
    if ((uVar4 & 2) != 0) {
      *(undefined2 *)((long)puVar11 + lVar8) = *(undefined2 *)((long)puVar10 + lVar8);
      lVar8 = lVar8 + 2;
    }
    if (bVar15) {
      *(undefined1 *)((long)puVar11 + lVar8) = *(undefined1 *)((long)puVar10 + lVar8);
    }
    *(undefined4 *)(param_1 + 0x4b64) = 0;
  }
LAB_0010bf28:
  if (*(int *)(param_1 + 0x58) == 0) {
    bVar15 = false;
    if (*(int *)(param_1 + 0xc) == 0) {
      bVar15 = *(int *)(param_1 + 0x2c) == 0;
    }
  }
  else {
    bVar15 = false;
  }
  FUN_00108ae0(param_1,bVar15);
  return;
}


==================================================================

### FUNC 0010c3e0 (906 bytes) name=FUN_0010c3e0

undefined8
FUN_0010c3e0(long param_1,uint param_2,uint param_3,uint param_4,uint param_5,int *param_6,
            int param_7)

{
  undefined4 uVar1;
  uint uVar2;
  uint uVar3;
  uint uVar4;
  int iVar5;
  int *piVar6;
  int iVar7;
  ushort *puVar8;
  long lVar9;
  undefined8 uVar10;
  uint uVar11;
  uint uVar12;
  uint uVar13;
  int iVar14;
  uint local_48;
  
  if (param_7 != 0) {
    pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0x218));
  }
  if (*(int *)(param_1 + 0x214) == 0) {
    piVar6 = __errno_location();
    *piVar6 = -0x1b51fffb;
  }
  else {
    if ((((param_2 <= param_4) && (uVar2 = *(uint *)(param_1 + 0x1ed0), param_4 < uVar2)) &&
        (param_3 <= param_5)) &&
       ((param_5 < *(uint *)(param_1 + 0x1ed4) && (param_6 != (int *)0x0)))) {
      uVar13 = param_3;
      if (((param_3 == 0 && param_2 == 0) && (uVar13 = 0, uVar2 - 1 == param_4)) &&
         (uVar13 = 0, *(uint *)(param_1 + 0x1ed4) - 1 == param_5)) {
        uVar12 = *(uint *)(param_1 + 0x1f24);
        uVar11 = *(uint *)(param_1 + 0x1f20);
        iVar5 = *(int *)(param_1 + 0x1f34);
        iVar14 = *(int *)(param_1 + 0x1f30);
        lVar9 = (long)*(int *)(param_1 + 0x1f28) * (ulong)*(uint *)(param_1 + 0x77f8);
        local_48 = uVar2;
      }
      else {
        iVar14 = 0;
        iVar5 = 0;
        uVar11 = 0;
        uVar12 = 0xffffffff;
        uVar3 = uVar2 * uVar13;
        lVar9 = 0;
        local_48 = param_4 + 1;
        do {
          iVar7 = uVar3 + param_2;
          puVar8 = (ushort *)(*(long *)(param_1 + 0x268) + ((ulong)uVar3 + (ulong)param_2) * 2);
          do {
            lVar9 = lVar9 + (ulong)*puVar8;
            uVar4 = (uint)*puVar8;
            if (uVar11 < uVar4) {
              uVar11 = uVar4;
              iVar14 = iVar7;
            }
            if (uVar4 < uVar12) {
              uVar12 = uVar4;
              iVar5 = iVar7;
            }
            iVar7 = iVar7 + 1;
            puVar8 = puVar8 + 1;
          } while (iVar7 != local_48 + uVar3);
          uVar13 = uVar13 + 1;
          uVar3 = uVar3 + uVar2;
        } while (uVar13 <= param_5);
      }
      iVar7 = FUN_0010b0a0(param_1,uVar12 & 0xffff,iVar5,1);
      *param_6 = iVar7;
      iVar7 = FUN_0010b0a0(param_1,uVar11 & 0xffff,iVar14,1);
      param_6[1] = iVar7;
      iVar7 = FUN_0010b0a0(param_1,lVar9 / (long)(ulong)(((param_5 + 1) - param_3) *
                                                        (local_48 - param_2)) & 0xffff,
                           (param_4 + param_2 >> 1) + ((param_3 + param_5) * uVar2 >> 1),1);
      param_6[2] = iVar7;
      param_6[3] = iVar5;
      param_6[4] = iVar14;
      if (*(int *)(param_1 + 0x60) == 0) {
        iVar5 = param_6[1];
      }
      else {
        if (*(int *)(param_1 + 0xb0) == 0) {
          *param_6 = *param_6;
          iVar5 = param_6[1];
LAB_0010c6a7:
          iVar7 = param_6[2];
          param_6[1] = iVar5;
        }
        else {
          iVar5 = FUN_0010a230(*(undefined4 *)(param_1 + 0xb8),param_1);
          iVar14 = *(int *)(param_1 + 0xb0);
          uVar1 = *(undefined4 *)(param_1 + 0xb8);
          *param_6 = iVar5;
          iVar5 = param_6[1];
          if (iVar14 == 0) goto LAB_0010c6a7;
          iVar5 = FUN_0010a230(uVar1,param_1);
          iVar14 = *(int *)(param_1 + 0xb0);
          uVar1 = *(undefined4 *)(param_1 + 0xb8);
          param_6[1] = iVar5;
          iVar7 = param_6[2];
          if (iVar14 != 0) {
            iVar7 = FUN_0010a230(uVar1,param_1,iVar7);
            iVar5 = param_6[1];
          }
        }
        param_6[2] = iVar7;
      }
      iVar14 = *param_6;
      if (iVar5 < iVar14) {
        param_6[1] = iVar14;
        iVar5 = iVar14;
      }
      if (iVar5 < iVar7) {
        param_6[2] = iVar5;
        iVar7 = iVar5;
      }
      if (iVar7 < iVar14) {
        param_6[2] = iVar14;
      }
      uVar10 = 1;
      goto joined_r0x0010c454;
    }
    piVar6 = __errno_location();
    *piVar6 = -0x1b51ffff;
  }
  uVar10 = 0;
joined_r0x0010c454:
  if (param_7 != 0) {
    pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0x218));
  }
  return uVar10;
}


==================================================================

### FUNC 0010c780 (2167 bytes) name=FUN_0010c780

undefined8
FUN_0010c780(long param_1,uint param_2,uint param_3,uint param_4,uint param_5,int *param_6,
            int param_7)

{
  undefined4 uVar1;
  int iVar2;
  uint uVar3;
  int iVar4;
  int iVar5;
  int *piVar6;
  uint uVar7;
  uint uVar8;
  int iVar9;
  uint uVar10;
  long lVar11;
  undefined8 uVar12;
  uint uVar13;
  int iVar14;
  int iVar15;
  int iVar16;
  uint uVar17;
  uint uVar18;
  long lVar19;
  long lVar20;
  ulong uVar21;
  float fVar22;
  float fVar23;
  float fVar24;
  float fVar25;
  float fVar26;
  uint local_b0;
  int local_a8;
  int local_a4;
  long local_90;
  long local_80;
  int local_74;
  
  if (param_7 != 0) {
    pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0x218));
  }
  if (*(int *)(param_1 + 0x214) == 0) {
    piVar6 = __errno_location();
    *piVar6 = -0x1b51fffb;
  }
  else {
    if ((((param_2 < param_4) && (param_4 < *(uint *)(param_1 + 0x1ed0))) && (param_3 < param_5)) &&
       ((param_5 < *(uint *)(param_1 + 0x1ed4) && (param_6 != (int *)0x0)))) {
      uVar10 = param_4 - param_2;
      uVar18 = param_5 - param_3;
      if (uVar10 < uVar18) {
        fVar26 = (float)(int)(uVar18 * uVar18 - uVar10 * uVar10);
        fVar23 = SQRT(fVar26);
        fVar22 = fVar23;
        if (NAN(fVar23)) {
          fVar22 = sqrtf(fVar26);
        }
        if (NAN(fVar23)) {
          fVar23 = sqrtf(fVar26);
        }
        local_90 = 0;
        lVar20 = 0;
        local_a8 = 0;
        local_a4 = 0;
        uVar21 = 0;
        uVar17 = 0;
        uVar8 = 0xffffffff;
        do {
          iVar5 = (int)local_90;
          iVar16 = param_3 + iVar5;
          iVar15 = (param_3 - (int)((float)(param_5 + param_3) + fVar23) / 2) + iVar5;
          lVar11 = *(long *)(param_1 + 0x268) +
                   ((ulong)(uint)(iVar16 * *(int *)(param_1 + 0x1ed0)) + (ulong)param_2) * 2;
          iVar2 = 0;
          lVar19 = lVar11 + 2;
          iVar5 = (param_3 - (int)((float)(param_5 + param_3) - fVar22) / 2) + iVar5;
          uVar7 = param_2 - param_4;
          uVar3 = param_2;
          do {
            iVar9 = ((int)uVar7 >> 0x1f ^ uVar7) - ((int)uVar7 >> 0x1f);
            iVar4 = iVar2;
            if (iVar2 < iVar9) {
              fVar26 = (float)(iVar5 * iVar5 * 4 + uVar7 * uVar7);
              fVar24 = SQRT(fVar26);
              if (NAN(fVar24)) {
                fVar24 = sqrtf(fVar26);
              }
              fVar26 = (float)(uVar7 * uVar7 + iVar15 * iVar15 * 4);
              fVar25 = SQRT(fVar26);
              if (NAN(fVar25)) {
                fVar25 = sqrtf(fVar26);
              }
              iVar4 = iVar9;
              if ((int)(fVar24 + fVar25) <= (int)(uVar18 * 2)) goto LAB_0010cca8;
              if (!CARRY4(param_2 + param_4,uVar7)) break;
            }
            else {
LAB_0010cca8:
              uVar21 = (ulong)((int)uVar21 + 1);
              lVar20 = lVar20 + (ulong)*(ushort *)(lVar19 + -2);
              uVar13 = (uint)*(ushort *)(lVar19 + -2);
              if (uVar17 < uVar13) {
                local_a8 = uVar3 + *(int *)(param_1 + 0x1ed0) * iVar16;
                uVar17 = uVar13;
              }
              iVar2 = iVar4;
              if (uVar13 < uVar8) {
                local_a4 = *(int *)(param_1 + 0x1ed0) * iVar16 + uVar3;
                uVar8 = uVar13;
              }
            }
            lVar19 = lVar19 + 2;
            uVar3 = uVar3 + 1;
            uVar7 = uVar7 + 2;
          } while (lVar19 != lVar11 + (ulong)uVar10 * 2 + 4);
          local_90 = local_90 + 1;
        } while (local_90 != (ulong)uVar18 + 1);
      }
      else {
        uVar7 = param_4 + param_2;
        fVar26 = (float)(int)(uVar10 * uVar10 - uVar18 * uVar18);
        fVar23 = SQRT(fVar26);
        fVar22 = fVar23;
        if (NAN(fVar23)) {
          fVar22 = sqrtf(fVar26);
        }
        if (NAN(fVar23)) {
          fVar23 = sqrtf(fVar26);
        }
        local_80 = 0;
        lVar20 = 0;
        local_a8 = 0;
        local_a4 = 0;
        uVar21 = 0;
        uVar17 = 0;
        uVar8 = 0xffffffff;
        do {
          iVar16 = param_3 + (int)local_80;
          lVar11 = 0;
          iVar5 = 0;
          iVar2 = iVar16 * 2 - (param_5 + param_3);
          iVar2 = iVar2 * iVar2;
          lVar19 = *(long *)(param_1 + 0x268) + 2 +
                   ((ulong)(uint)(iVar16 * *(int *)(param_1 + 0x1ed0)) + (ulong)param_2) * 2;
          do {
            iVar15 = (int)lVar11;
            iVar9 = param_2 + iVar15;
            uVar13 = iVar9 * 2 - uVar7;
            uVar3 = (int)uVar13 >> 0x1f;
            iVar14 = (uVar13 ^ uVar3) - uVar3;
            iVar4 = iVar5;
            if (iVar5 < iVar14) {
              iVar4 = (param_2 - (int)((float)uVar7 - fVar22) / 2) + iVar15;
              fVar26 = (float)(uint)(iVar2 + iVar4 * iVar4 * 4);
              fVar24 = SQRT(fVar26);
              if (NAN(fVar24)) {
                fVar24 = sqrtf(fVar26);
              }
              iVar15 = iVar15 + (param_2 - (int)((float)uVar7 + fVar23) / 2);
              fVar26 = (float)(uint)(iVar2 + iVar15 * iVar15 * 4);
              fVar25 = SQRT(fVar26);
              if (NAN(fVar25)) {
                fVar25 = sqrtf(fVar26);
              }
              iVar4 = iVar14;
              if ((int)(fVar24 + fVar25) <= (int)(uVar10 * 2)) goto LAB_0010c980;
              if (uVar7 <= (uint)(iVar9 * 2)) break;
            }
            else {
LAB_0010c980:
              uVar21 = (ulong)((int)uVar21 + 1);
              lVar20 = lVar20 + (ulong)*(ushort *)(lVar19 + -2);
              uVar3 = (uint)*(ushort *)(lVar19 + -2);
              if (uVar17 < uVar3) {
                local_a8 = iVar16 * *(int *)(param_1 + 0x1ed0) + iVar9;
                uVar17 = uVar3;
              }
              iVar5 = iVar4;
              if (uVar3 < uVar8) {
                local_a4 = iVar16 * *(int *)(param_1 + 0x1ed0) + iVar9;
                uVar8 = uVar3;
              }
            }
            lVar11 = lVar11 + 1;
            lVar19 = lVar19 + 2;
          } while (lVar11 != (ulong)uVar10 + 1);
          local_80 = local_80 + 1;
        } while (local_80 != (ulong)uVar18 + 1);
      }
      local_b0 = param_4 + param_2;
      local_74 = param_5 + param_3;
      iVar2 = *(int *)(param_1 + 0x1ed0);
      iVar5 = FUN_0010b0a0(param_1,uVar8 & 0xffff,local_a4,1);
      *param_6 = iVar5;
      iVar5 = FUN_0010b0a0(param_1,uVar17,local_a8,1);
      param_6[1] = iVar5;
      iVar2 = FUN_0010b0a0(param_1,lVar20 / (long)uVar21 & 0xffff,
                           (local_b0 >> 1) + ((uint)(local_74 * iVar2) >> 1),1);
      param_6[2] = iVar2;
      param_6[3] = local_a4;
      param_6[4] = local_a8;
      if (*(int *)(param_1 + 0x60) == 0) {
        iVar5 = param_6[1];
      }
      else {
        if (*(int *)(param_1 + 0xb0) == 0) {
          *param_6 = *param_6;
          iVar5 = param_6[1];
LAB_0010cdac:
          param_6[1] = iVar5;
          iVar2 = param_6[2];
        }
        else {
          iVar5 = FUN_0010a230(*(undefined4 *)(param_1 + 0xb8),param_1);
          iVar2 = *(int *)(param_1 + 0xb0);
          uVar1 = *(undefined4 *)(param_1 + 0xb8);
          *param_6 = iVar5;
          iVar5 = param_6[1];
          if (iVar2 == 0) goto LAB_0010cdac;
          iVar5 = FUN_0010a230(uVar1,param_1);
          iVar16 = *(int *)(param_1 + 0xb0);
          uVar1 = *(undefined4 *)(param_1 + 0xb8);
          param_6[1] = iVar5;
          iVar2 = param_6[2];
          if (iVar16 != 0) {
            iVar2 = FUN_0010a230(uVar1,param_1,iVar2);
            iVar5 = param_6[1];
          }
        }
        param_6[2] = iVar2;
      }
      iVar16 = *param_6;
      if (iVar5 < iVar16) {
        param_6[1] = iVar16;
        iVar5 = iVar16;
      }
      if (iVar5 < iVar2) {
        param_6[2] = iVar5;
        iVar2 = iVar5;
      }
      if (iVar2 < iVar16) {
        param_6[2] = iVar16;
      }
      uVar12 = 1;
      goto joined_r0x0010c807;
    }
    piVar6 = __errno_location();
    *piVar6 = -0x1b51ffff;
  }
  uVar12 = 0;
joined_r0x0010c807:
  if (param_7 != 0) {
    pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0x218));
  }
  return uVar12;
}


==================================================================

### FUNC 0010d020 (862 bytes) name=FUN_0010d020

uint FUN_0010d020(long param_1,ushort *param_2,uint param_3,undefined4 *param_4,uint param_5,
                 uint param_6,int param_7,int param_8)

{
  ushort uVar1;
  long lVar2;
  uint uVar3;
  uint uVar4;
  uint uVar5;
  undefined4 uVar6;
  undefined4 uVar7;
  undefined4 uVar8;
  int *piVar9;
  uint uVar10;
  int iVar12;
  ulong uVar13;
  uint uVar14;
  int iVar15;
  uint uVar16;
  uint uVar17;
  uint local_3c;
  ulong uVar11;
  
  if (param_8 != 0) {
    pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0x218));
  }
  if (*(int *)(param_1 + 0x214) == 0) {
    piVar9 = __errno_location();
    *piVar9 = -0x1b51fffb;
    goto joined_r0x0010d0a9;
  }
  if (param_7 == 0) {
    if (param_5 < *(uint *)(param_1 + 0x1ed0)) {
      uVar17 = *(uint *)(param_1 + 0x1ed4);
      goto joined_r0x0010d0d0;
    }
  }
  else if (param_5 < *(uint *)(param_1 + 0x1ed4)) {
    uVar17 = *(uint *)(param_1 + 0x1ed0);
joined_r0x0010d0d0:
    if ((((param_6 < uVar17) && (param_4 != (undefined4 *)0x0)) && (param_2 != (ushort *)0x0)) &&
       (1 < param_3)) {
      if (param_7 == 0) {
        uVar3 = *(int *)(param_1 + 0x1ed4) - param_6;
        uVar17 = param_3 >> 1;
        if (uVar3 <= param_3 >> 1) {
          uVar17 = uVar3;
        }
        if (param_6 < uVar17 + param_6) {
          uVar3 = *(uint *)(param_1 + 0x1ed0);
          lVar2 = *(long *)(param_1 + 0x268);
          uVar4 = 0;
          uVar10 = param_6 * uVar3 + param_5;
          do {
            uVar11 = (ulong)uVar10;
            uVar10 = uVar10 + uVar3;
            uVar13 = (ulong)uVar4;
            uVar4 = uVar4 + 1;
            param_2[uVar13] = *(ushort *)(lVar2 + uVar11 * 2);
          } while (uVar4 != uVar17);
        }
        else {
          uVar3 = *(uint *)(param_1 + 0x1ed0);
        }
      }
      else {
        uVar3 = *(int *)(param_1 + 0x1ed0) - param_6;
        uVar17 = param_3 >> 1;
        if (uVar3 <= param_3 >> 1) {
          uVar17 = uVar3;
        }
        memcpy(param_2,(void *)(*(long *)(param_1 + 0x268) +
                               ((ulong)(*(int *)(param_1 + 0x1ed0) * param_5) + (ulong)param_6) * 2)
               ,(ulong)uVar17 * 2);
        uVar3 = *(uint *)(param_1 + 0x1ed0);
      }
      if (uVar17 == 0) {
        uVar10 = 0;
        local_3c = 0xffffffff;
        uVar4 = 0;
        uVar16 = 0;
        uVar14 = 0xffff;
      }
      else {
        uVar10 = 0;
        uVar16 = 0;
        uVar4 = 0;
        local_3c = 0xffffffff;
        uVar5 = uVar17;
        do {
          uVar1 = *param_2;
          uVar16 = uVar16 + uVar1;
          uVar14 = (uint)uVar1;
          if (uVar4 < uVar1) {
            uVar4 = uVar14;
            uVar10 = uVar5;
          }
          if (uVar14 < local_3c) {
            local_3c = uVar14;
          }
          uVar5 = uVar5 - 1;
          param_2 = param_2 + 1;
          uVar14 = local_3c;
        } while (uVar5 != 0);
      }
      if (param_7 == 0) {
        iVar15 = (uVar17 - uVar10) * uVar3 + (uVar3 >> 1);
        iVar12 = param_5 + (*(uint *)(param_1 + 0x77f8) >> 1);
      }
      else {
        iVar12 = (uVar3 >> 1) + uVar3 * param_5;
        iVar15 = ((*(uint *)(param_1 + 0x77f8) >> 1) + uVar17) - uVar10;
      }
      uVar6 = FUN_0010b0a0(param_1,uVar14,iVar12,0);
      *param_4 = uVar6;
      uVar6 = FUN_0010b0a0(param_1,uVar4,iVar12,0);
      param_4[1] = uVar6;
      uVar6 = FUN_0010b0a0(param_1,(ulong)uVar16 / (ulong)uVar17 & 0xffff,iVar12,0);
      param_4[2] = uVar6;
      param_4[4] = uVar4;
      param_4[5] = iVar15;
      param_4[3] = local_3c;
      if (*(int *)(param_1 + 0x60) == 0) goto LAB_0010d24c;
      if (*(int *)(param_1 + 0xb0) == 0) {
        *param_4 = *param_4;
        uVar8 = param_4[1];
LAB_0010d240:
        uVar7 = param_4[2];
        param_4[1] = uVar8;
      }
      else {
        uVar7 = FUN_0010a230(*(undefined4 *)(param_1 + 0xb8),param_1);
        iVar12 = *(int *)(param_1 + 0xb0);
        uVar6 = *(undefined4 *)(param_1 + 0xb8);
        uVar8 = param_4[1];
        *param_4 = uVar7;
        if (iVar12 == 0) goto LAB_0010d240;
        uVar8 = FUN_0010a230(uVar6,param_1);
        iVar12 = *(int *)(param_1 + 0xb0);
        uVar6 = *(undefined4 *)(param_1 + 0xb8);
        param_4[1] = uVar8;
        uVar7 = param_4[2];
        if (iVar12 != 0) {
          uVar7 = FUN_0010a230(uVar6,param_1,uVar7);
        }
      }
      param_4[2] = uVar7;
LAB_0010d24c:
      if (param_8 == 0) {
        return uVar17;
      }
      pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0x218));
      return uVar17;
    }
  }
  piVar9 = __errno_location();
  *piVar9 = -0x1b51ffff;
joined_r0x0010d0a9:
  if (param_8 != 0) {
    pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0x218));
  }
  return 0;
}


==================================================================

### FUNC 0010d3a0 (1056 bytes) name=FUN_0010d3a0

uint FUN_0010d3a0(long param_1,ushort *param_2,uint param_3,undefined4 *param_4,uint param_5,
                 uint param_6,uint param_7,uint param_8,int param_9)

{
  ushort uVar1;
  uint uVar2;
  long lVar3;
  int iVar4;
  uint uVar5;
  undefined4 uVar6;
  uint uVar7;
  undefined4 uVar8;
  undefined4 uVar9;
  int *piVar10;
  uint uVar11;
  int iVar12;
  uint uVar13;
  uint uVar14;
  uint uVar15;
  ushort *puVar16;
  ushort *puVar17;
  uint uVar18;
  int iVar19;
  
  if (param_9 != 0) {
    pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0x218));
  }
  if (*(int *)(param_1 + 0x214) == 0) {
    piVar10 = __errno_location();
    *piVar10 = -0x1b51fffb;
  }
  else {
    uVar2 = *(uint *)(param_1 + 0x1ed0);
    if (((((param_5 < uVar2) && (param_7 < uVar2)) && (param_6 < *(uint *)(param_1 + 0x1ed4))) &&
        (param_8 < *(uint *)(param_1 + 0x1ed4))) &&
       (((param_5 != param_7 || (param_6 != param_8)) &&
        ((param_4 != (undefined4 *)0x0 && ((param_2 != (ushort *)0x0 && (1 < param_3)))))))) {
      uVar11 = (int)(param_5 - param_7) >> 0x1f;
      iVar4 = (param_5 - param_7 ^ uVar11) - uVar11;
      uVar11 = (int)(param_6 - param_8) >> 0x1f;
      iVar12 = (param_6 - param_8 ^ uVar11) - uVar11;
      iVar19 = iVar4;
      if (iVar4 < iVar12) {
        iVar19 = iVar12;
      }
      uVar11 = param_3 >> 1;
      if ((int)(iVar19 + 1U) <= (int)(param_3 >> 1)) {
        uVar11 = iVar19 + 1U;
      }
      uVar5 = param_5;
      uVar18 = param_6;
      uVar13 = param_7;
      uVar15 = param_8;
      if (param_5 <= param_7) {
        uVar5 = param_7;
        uVar18 = param_8;
        uVar13 = param_5;
        uVar15 = param_6;
      }
      if (iVar4 < iVar12) {
        if ((int)uVar15 < (int)uVar18) {
          uVar14 = (uVar15 - 1) + uVar11;
          if ((int)uVar18 < (int)uVar14) {
            uVar14 = uVar18;
          }
          if ((int)uVar15 <= (int)uVar14) {
            iVar4 = uVar15 * uVar2;
            lVar3 = *(long *)(param_1 + 0x268);
            puVar17 = param_2;
            iVar19 = 0;
            do {
              puVar16 = puVar17 + 1;
              uVar7 = iVar19 / (int)(uVar18 - uVar15) + uVar13 + iVar4;
              iVar4 = iVar4 + uVar2;
              *puVar17 = *(ushort *)(lVar3 + (ulong)uVar7 * 2);
              puVar17 = puVar16;
              iVar19 = iVar19 + (uVar5 - uVar13);
            } while (puVar16 != param_2 + (ulong)(uVar14 - uVar15) + 1);
          }
        }
        else {
          uVar14 = (uVar15 - uVar11) + 1;
          if ((int)uVar14 < (int)uVar18) {
            uVar14 = uVar18;
          }
          if ((int)uVar14 <= (int)uVar15) {
            iVar4 = uVar15 * uVar2;
            lVar3 = *(long *)(param_1 + 0x268);
            puVar17 = param_2;
            iVar19 = 0;
            do {
              puVar16 = puVar17 + 1;
              uVar7 = iVar19 / (int)(uVar18 - uVar15) + uVar13 + iVar4;
              iVar4 = iVar4 - uVar2;
              *puVar17 = *(ushort *)(lVar3 + (ulong)uVar7 * 2);
              puVar17 = puVar16;
              iVar19 = iVar19 + (uVar13 - uVar5);
            } while (puVar16 != param_2 + (ulong)(uVar15 - uVar14) + 1);
          }
        }
      }
      else {
        uVar14 = (uVar13 - 1) + uVar11;
        if ((int)uVar5 < (int)uVar14) {
          uVar14 = uVar5;
        }
        if ((int)uVar13 <= (int)uVar14) {
          lVar3 = *(long *)(param_1 + 0x268);
          iVar4 = uVar5 - uVar13;
          puVar17 = param_2;
          iVar19 = 0;
          do {
            uVar5 = (iVar19 / iVar4 + uVar15) * uVar2 + uVar13;
            uVar13 = uVar13 + 1;
            *puVar17 = *(ushort *)(lVar3 + (ulong)uVar5 * 2);
            puVar17 = puVar17 + 1;
            iVar19 = iVar19 + (uVar18 - uVar15);
          } while (uVar13 != uVar14 + 1);
        }
      }
      uVar18 = 0;
      uVar13 = 0;
      uVar5 = 0xffffffff;
      uVar15 = uVar11;
      do {
        uVar1 = *param_2;
        uVar18 = uVar18 + uVar1;
        uVar14 = (uint)uVar1;
        if (uVar13 < uVar1) {
          uVar13 = uVar14;
        }
        if (uVar14 < uVar5) {
          uVar5 = uVar14;
        }
        uVar15 = uVar15 - 1;
        param_2 = param_2 + 1;
      } while (uVar15 != 0);
      iVar19 = (param_5 + param_7 >> 1) + ((param_6 + param_8) * uVar2 >> 1);
      uVar6 = FUN_0010b0a0(param_1,uVar5,iVar19,0);
      *param_4 = uVar6;
      uVar6 = FUN_0010b0a0(param_1,uVar13,iVar19,0);
      param_4[1] = uVar6;
      uVar6 = FUN_0010b0a0(param_1,(ulong)uVar18 / (ulong)uVar11 & 0xffff,iVar19,0);
      param_4[2] = uVar6;
      if (*(int *)(param_1 + 0x60) == 0) goto joined_r0x0010d411;
      if (*(int *)(param_1 + 0xb0) == 0) {
        *param_4 = *param_4;
        uVar9 = param_4[1];
LAB_0010d5fa:
        uVar8 = param_4[2];
        param_4[1] = uVar9;
      }
      else {
        uVar8 = FUN_0010a230(*(undefined4 *)(param_1 + 0xb8),param_1);
        iVar19 = *(int *)(param_1 + 0xb0);
        uVar6 = *(undefined4 *)(param_1 + 0xb8);
        uVar9 = param_4[1];
        *param_4 = uVar8;
        if (iVar19 == 0) goto LAB_0010d5fa;
        uVar9 = FUN_0010a230(uVar6,param_1);
        iVar19 = *(int *)(param_1 + 0xb0);
        uVar6 = *(undefined4 *)(param_1 + 0xb8);
        param_4[1] = uVar9;
        uVar8 = param_4[2];
        if (iVar19 != 0) {
          uVar8 = FUN_0010a230(uVar6,param_1,uVar8);
        }
      }
      param_4[2] = uVar8;
      goto joined_r0x0010d411;
    }
    piVar10 = __errno_location();
    *piVar10 = -0x1b51ffff;
  }
  uVar11 = 0;
joined_r0x0010d411:
  if (param_9 != 0) {
    pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0x218));
  }
  return uVar11;
}


==================================================================

### FUNC 0010d7e0 (1106 bytes) name=FUN_0010d7e0

uint FUN_0010d7e0(long param_1,uint *param_2,uint param_3,undefined4 *param_4,uint param_5,
                 uint param_6,uint param_7,uint param_8,int param_9)

{
  long lVar1;
  uint uVar2;
  undefined4 uVar3;
  undefined4 uVar4;
  undefined4 uVar5;
  int *piVar6;
  int iVar7;
  uint uVar8;
  uint *puVar9;
  uint uVar10;
  uint uVar11;
  int iVar12;
  uint uVar13;
  uint uVar14;
  uint uVar15;
  int iVar16;
  undefined4 extraout_XMM0_Da;
  undefined4 extraout_XMM0_Da_00;
  undefined4 extraout_XMM0_Da_01;
  undefined4 extraout_XMM0_Da_02;
  
  if (param_9 != 0) {
    pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0x218));
  }
  if (*(int *)(param_1 + 0x214) == 0) {
    piVar6 = __errno_location();
    *piVar6 = -0x1b51fffb;
  }
  else {
    uVar2 = *(uint *)(param_1 + 0x1ed0);
    if (((((param_5 < uVar2) && (param_7 < uVar2)) && (param_6 < *(uint *)(param_1 + 0x1ed4))) &&
        (param_8 < *(uint *)(param_1 + 0x1ed4))) &&
       (((param_5 != param_7 || (param_6 != param_8)) &&
        ((param_4 != (undefined4 *)0x0 && ((param_2 != (uint *)0x0 && (3 < param_3)))))))) {
      uVar11 = (int)(param_5 - param_7) >> 0x1f;
      iVar7 = (param_5 - param_7 ^ uVar11) - uVar11;
      uVar11 = (int)(param_6 - param_8) >> 0x1f;
      iVar12 = (param_6 - param_8 ^ uVar11) - uVar11;
      iVar16 = iVar7;
      if (iVar7 < iVar12) {
        iVar16 = iVar12;
      }
      uVar11 = param_3 >> 2;
      if ((int)(iVar16 + 1U) <= (int)(param_3 >> 2)) {
        uVar11 = iVar16 + 1U;
      }
      uVar14 = param_5;
      uVar15 = param_6;
      uVar8 = param_7;
      uVar13 = param_8;
      if (param_5 <= param_7) {
        uVar14 = param_7;
        uVar15 = param_8;
        uVar8 = param_5;
        uVar13 = param_6;
      }
      if (iVar7 < iVar12) {
        if ((int)uVar13 < (int)uVar15) {
          uVar2 = (uVar13 - 1) + uVar11;
          if ((int)uVar15 < (int)uVar2) {
            uVar2 = uVar15;
          }
          if ((int)uVar13 <= (int)uVar2) {
            lVar1 = *(long *)(param_1 + 0x268);
            iVar7 = uVar15 - uVar13;
            puVar9 = param_2;
            iVar16 = 0;
            do {
              iVar12 = *(int *)(param_1 + 0x1ed0) * uVar13;
              uVar13 = uVar13 + 1;
              *puVar9 = (uint)*(ushort *)(lVar1 + (ulong)(iVar16 / iVar7 + uVar8 + iVar12) * 2);
              puVar9 = puVar9 + 1;
              iVar16 = iVar16 + (uVar14 - uVar8);
            } while (uVar13 != uVar2 + 1);
          }
        }
        else {
          uVar2 = (uVar13 - uVar11) + 1;
          if ((int)uVar2 < (int)uVar15) {
            uVar2 = uVar15;
          }
          if ((int)uVar2 <= (int)uVar13) {
            lVar1 = *(long *)(param_1 + 0x268);
            iVar7 = uVar15 - uVar13;
            puVar9 = param_2;
            iVar16 = 0;
            do {
              iVar12 = *(int *)(param_1 + 0x1ed0) * uVar13;
              uVar13 = uVar13 - 1;
              *puVar9 = (uint)*(ushort *)(lVar1 + (ulong)(iVar16 / iVar7 + uVar8 + iVar12) * 2);
              puVar9 = puVar9 + 1;
              iVar16 = iVar16 + (uVar8 - uVar14);
            } while (uVar13 != uVar2 - 1);
          }
        }
      }
      else {
        uVar10 = (uVar8 - 1) + uVar11;
        if ((int)uVar14 < (int)uVar10) {
          uVar10 = uVar14;
        }
        if ((int)uVar8 <= (int)uVar10) {
          iVar7 = uVar14 - uVar8;
          lVar1 = *(long *)(param_1 + 0x268);
          puVar9 = param_2;
          iVar16 = 0;
          while( true ) {
            uVar2 = uVar2 * (iVar16 / iVar7 + uVar13) + uVar8;
            uVar8 = uVar8 + 1;
            *puVar9 = (uint)*(ushort *)(lVar1 + (ulong)uVar2 * 2);
            if (uVar8 == uVar10 + 1) break;
            uVar2 = *(uint *)(param_1 + 0x1ed0);
            puVar9 = puVar9 + 1;
            iVar16 = iVar16 + (uVar15 - uVar13);
          }
        }
      }
      uVar14 = 0;
      uVar8 = 0;
      uVar13 = 0xffffffff;
      puVar9 = param_2;
      uVar2 = uVar11;
      do {
        uVar15 = *puVar9;
        uVar14 = uVar14 + uVar15;
        if (uVar8 < uVar15) {
          uVar8 = uVar15;
        }
        if (uVar15 < uVar13) {
          uVar13 = uVar15;
        }
        uVar2 = uVar2 - 1;
        puVar9 = puVar9 + 1;
      } while (uVar2 != 0);
      iVar16 = (param_5 + param_7 >> 1) + ((param_6 + param_8) * *(int *)(param_1 + 0x1ed0) >> 1);
      uVar3 = FUN_0010b0a0(param_1,uVar13 & 0xffff,iVar16,0);
      *param_4 = uVar3;
      uVar3 = FUN_0010b0a0(param_1,uVar8 & 0xffff,iVar16,0);
      param_4[1] = uVar3;
      uVar3 = FUN_0010b0a0(param_1,(ulong)uVar14 / (ulong)uVar11 & 0xffff,iVar16,0);
      param_4[2] = uVar3;
      uVar3 = extraout_XMM0_Da;
      if (*(int *)(param_1 + 0x60) != 0) {
        uVar3 = *(undefined4 *)(param_1 + 0xb8);
        if (*(int *)(param_1 + 0xb0) == 0) {
          *param_4 = *param_4;
          uVar5 = param_4[1];
LAB_0010da52:
          uVar4 = param_4[2];
          param_4[1] = uVar5;
        }
        else {
          uVar4 = FUN_0010a230(uVar3,param_1);
          iVar7 = *(int *)(param_1 + 0xb0);
          uVar3 = *(undefined4 *)(param_1 + 0xb8);
          uVar5 = param_4[1];
          *param_4 = uVar4;
          if (iVar7 == 0) goto LAB_0010da52;
          uVar5 = FUN_0010a230(uVar3,param_1);
          iVar7 = *(int *)(param_1 + 0xb0);
          uVar3 = *(undefined4 *)(param_1 + 0xb8);
          param_4[1] = uVar5;
          uVar4 = param_4[2];
          if (iVar7 != 0) {
            uVar4 = FUN_0010a230(uVar3,param_1,uVar4);
            uVar3 = extraout_XMM0_Da_02;
          }
        }
        param_4[2] = uVar4;
      }
      puVar9 = param_2 + (ulong)(uVar11 - 1) + 1;
      do {
        uVar2 = FUN_0010b0a0(uVar3,param_1,(short)*param_2,iVar16,0);
        *param_2 = uVar2;
        uVar3 = extraout_XMM0_Da_00;
        if (*(int *)(param_1 + 0x60) != 0) {
          uVar3 = *(undefined4 *)(param_1 + 0xb8);
          if (*(int *)(param_1 + 0xb0) != 0) {
            uVar2 = FUN_0010a230(param_1,uVar2);
            uVar3 = extraout_XMM0_Da_01;
          }
          *param_2 = uVar2;
        }
        param_2 = param_2 + 1;
      } while (param_2 != puVar9);
      goto joined_r0x0010d851;
    }
    piVar6 = __errno_location();
    *piVar6 = -0x1b51ffff;
  }
  uVar11 = 0;
joined_r0x0010d851:
  if (param_9 != 0) {
    pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0x218));
  }
  return uVar11;
}


==================================================================

### FUNC 0010dc40 (624 bytes) name=FUN_0010dc40

undefined8 FUN_0010dc40(long param_1,uint *param_2,uint param_3,int *param_4,int param_5)

{
  undefined4 uVar1;
  ushort uVar2;
  uint uVar3;
  uint uVar4;
  int iVar5;
  int iVar6;
  int iVar7;
  int *piVar8;
  uint uVar9;
  undefined8 uVar11;
  uint uVar12;
  uint uVar13;
  uint uVar14;
  uint uVar15;
  uint uVar16;
  long lVar17;
  uint uVar18;
  ulong uVar10;
  
  if (param_5 != 0) {
    pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0x218));
  }
  if (*(int *)(param_1 + 0x214) == 0) {
    piVar8 = __errno_location();
    *piVar8 = -0x1b51fffb;
  }
  else {
    if (((param_4 != (int *)0x0) && (param_2 != (uint *)0x0)) && (param_3 != 0)) {
      uVar3 = *(uint *)(param_1 + 0x1ed0);
      uVar15 = 0;
      uVar13 = 0;
      lVar17 = 0;
      uVar14 = 0;
      uVar12 = 0xffffffff;
      uVar18 = 0;
      uVar16 = 0;
      uVar10 = (ulong)param_3;
      do {
        uVar9 = *param_2;
        param_2 = param_2 + 1;
        uVar2 = *(ushort *)(*(long *)(param_1 + 0x268) + (ulong)uVar9 * 2);
        lVar17 = lVar17 + (ulong)uVar2;
        uVar4 = (uint)uVar2;
        if (uVar14 < uVar4) {
          uVar18 = uVar9;
          uVar14 = uVar4;
        }
        if (uVar4 < uVar12) {
          uVar16 = uVar9;
          uVar12 = uVar4;
        }
        uVar15 = uVar15 + uVar9 / uVar3;
        uVar13 = uVar13 + (uVar9 - (uVar9 / uVar3) * uVar3);
        uVar9 = (int)uVar10 - 1;
        uVar10 = (ulong)uVar9;
      } while (uVar9 != 0);
      iVar5 = FUN_0010b0a0(param_1,uVar12 & 0xffff,uVar16,1);
      *param_4 = iVar5;
      iVar5 = FUN_0010b0a0(param_1,uVar14,uVar18,1);
      param_4[1] = iVar5;
      iVar5 = FUN_0010b0a0(param_1,lVar17 / (long)(ulong)param_3 & 0xffff,
                           (uVar15 / param_3) * uVar3 + uVar13 / param_3,1);
      param_4[2] = iVar5;
      param_4[3] = uVar16;
      param_4[4] = uVar18;
      if (*(int *)(param_1 + 0x60) == 0) {
        iVar7 = param_4[1];
      }
      else {
        if (*(int *)(param_1 + 0xb0) == 0) {
          *param_4 = *param_4;
          iVar7 = param_4[1];
LAB_0010de64:
          iVar5 = param_4[2];
          param_4[1] = iVar7;
        }
        else {
          iVar6 = FUN_0010a230(*(undefined4 *)(param_1 + 0xb8),param_1);
          iVar5 = *(int *)(param_1 + 0xb0);
          uVar1 = *(undefined4 *)(param_1 + 0xb8);
          iVar7 = param_4[1];
          *param_4 = iVar6;
          if (iVar5 == 0) goto LAB_0010de64;
          iVar7 = FUN_0010a230(uVar1,param_1);
          iVar6 = *(int *)(param_1 + 0xb0);
          uVar1 = *(undefined4 *)(param_1 + 0xb8);
          param_4[1] = iVar7;
          iVar5 = param_4[2];
          if (iVar6 != 0) {
            iVar5 = FUN_0010a230(uVar1,param_1,iVar5);
            iVar7 = param_4[1];
          }
        }
        param_4[2] = iVar5;
      }
      iVar6 = *param_4;
      if (iVar7 < iVar6) {
        param_4[1] = iVar6;
        iVar7 = iVar6;
      }
      if (iVar7 < iVar5) {
        param_4[2] = iVar7;
        iVar5 = iVar7;
      }
      if (iVar5 < iVar6) {
        param_4[2] = iVar6;
      }
      uVar11 = 1;
      goto joined_r0x0010dcb1;
    }
    piVar8 = __errno_location();
    *piVar8 = -0x1b51ffff;
  }
  uVar11 = 0;
joined_r0x0010dcb1:
  if (param_5 != 0) {
    pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0x218));
  }
  return uVar11;
}


==================================================================

### FUNC 0010ded0 (460 bytes) name=FUN_0010ded0

undefined4 FUN_0010ded0(long param_1,uint param_2,int param_3,int param_4)

{
  uint uVar1;
  undefined4 uVar2;
  int *piVar3;
  ulong uVar4;
  int iVar5;
  uint uVar6;
  int iVar7;
  int iVar8;
  int iVar9;
  int iVar10;
  uint uVar11;
  uint uVar12;
  uint uVar13;
  
  if (param_4 != 0) {
    pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0x218));
  }
  if (*(int *)(param_1 + 0x214) == 0) {
    piVar3 = __errno_location();
    *piVar3 = -0x1b51fffb;
  }
  else {
    if (param_2 < *(uint *)(param_1 + 0x77f8)) {
      if (param_3 == 1) {
        uVar12 = *(uint *)(param_1 + 0x1ed0);
        iVar9 = 0;
        uVar1 = param_2 / uVar12;
        iVar8 = param_2 - uVar1 * uVar12;
        iVar7 = iVar8;
LAB_0010dfae:
        iVar5 = uVar1 - iVar9;
        uVar13 = 0;
        uVar6 = 0;
        do {
          if (((-1 < iVar8) && (iVar8 < (int)uVar12)) && (iVar5 <= (int)(uVar1 + iVar9))) {
            uVar11 = uVar12 * iVar5 + iVar8;
            iVar10 = iVar5;
            do {
              if ((-1 < iVar10) && (iVar10 < *(int *)(param_1 + 0x1ed4))) {
                uVar6 = uVar6 + 1;
                uVar13 = uVar13 + *(ushort *)(*(long *)(param_1 + 0x268) + (ulong)uVar11 * 2);
              }
              iVar10 = iVar10 + 1;
              uVar11 = uVar11 + uVar12;
            } while (iVar10 != uVar1 + iVar9 + 1);
          }
          iVar8 = iVar8 + 1;
        } while (iVar8 <= iVar7);
        uVar4 = (ulong)uVar13;
      }
      else {
        iVar9 = 1;
        if (param_3 != 3) {
          iVar9 = (param_3 != 5) + 2;
        }
        uVar12 = *(uint *)(param_1 + 0x1ed0);
        uVar1 = param_2 / uVar12;
        iVar7 = param_2 - uVar1 * uVar12;
        iVar8 = iVar7 - iVar9;
        iVar7 = iVar7 + iVar9;
        if (iVar8 <= iVar7) goto LAB_0010dfae;
        uVar4 = 0;
        uVar6 = 0;
      }
      uVar2 = FUN_0010b0a0(param_1,uVar4 / uVar6 & 0xffff,param_2,1);
      if ((*(int *)(param_1 + 0x60) != 0) && (*(int *)(param_1 + 0xb0) != 0)) {
        uVar2 = FUN_0010a230(*(undefined4 *)(param_1 + 0xb8),param_1,uVar2);
      }
      goto joined_r0x0010df44;
    }
    piVar3 = __errno_location();
    *piVar3 = -0x1b51ffff;
  }
  uVar2 = 0x80000001;
joined_r0x0010df44:
  if (param_4 != 0) {
    pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0x218));
  }
  return uVar2;
}


==================================================================

### FUNC 0010e0c0 (303 bytes) name=FUN_0010e0c0

void FUN_0010e0c0(long param_1,long param_2,long param_3,long param_4,int param_5)

{
  uint uVar1;
  int iVar2;
  int iVar3;
  undefined2 uVar4;
  int iVar5;
  long lVar6;
  
  iVar5 = *(int *)(param_1 + 0x3c);
  uVar1 = *(uint *)(param_1 + 0x1720);
  iVar2 = *(int *)(param_1 + 0x1444 + (ulong)uVar1 * 4);
  if (iVar5 < *(int *)(param_1 + 0x1444)) {
    iVar2 = ((iVar5 - iVar2) * 0x1000) /
            (*(int *)(param_1 + 0x1444 + (ulong)(uVar1 + 1) * 4) - iVar2);
    iVar5 = -0x3fff;
    if (-0x4000 < iVar2) {
      iVar5 = iVar2;
    }
    iVar2 = 0x3fff;
    if (iVar5 < 0x4000) {
      iVar2 = iVar5;
    }
  }
  else {
    iVar2 = ((iVar5 - iVar2) * 0x1000) /
            (*(int *)(param_1 + 0x1444 + (ulong)(uVar1 + 1) * 4) - iVar2);
    iVar3 = -0x3fff;
    if (-0x4000 < iVar2) {
      iVar3 = iVar2;
    }
    iVar2 = 0x3fff;
    if (iVar3 < 0x4000) {
      iVar2 = iVar3;
    }
    if (iVar5 <= *(int *)(param_1 + 0x1444 + (ulong)(*(int *)(param_1 + 0x1438) - 1) * 4)) {
      if (param_5 == 0) {
        return;
      }
      lVar6 = 0;
      do {
        *(short *)(param_4 + lVar6) =
             (short)(((int)*(short *)(param_3 + lVar6) - (int)*(short *)(param_2 + lVar6)) * iVar2
                    >> 0xc) + *(short *)(param_2 + lVar6);
        lVar6 = lVar6 + 2;
      } while (lVar6 != (ulong)(param_5 - 1) * 2 + 2);
      return;
    }
  }
  if (param_5 == 0) {
    return;
  }
  lVar6 = 0;
  do {
    iVar5 = (((int)*(short *)(param_3 + lVar6) - (int)*(short *)(param_2 + lVar6)) * iVar2 >> 0xc) +
            (int)*(short *)(param_2 + lVar6);
    if (iVar5 < -0x8000) {
      iVar5 = -0x8000;
    }
    uVar4 = (undefined2)iVar5;
    if (0x7fff < iVar5) {
      uVar4 = 0x7fff;
    }
    *(undefined2 *)(param_4 + lVar6) = uVar4;
    lVar6 = lVar6 + 2;
  } while (lVar6 != (ulong)(param_5 - 1) * 2 + 2);
  return;
}


==================================================================

### FUNC 0010e200 (297 bytes) name=FUN_0010e200

void FUN_0010e200(long param_1,long param_2,long param_3,long param_4,int param_5)

{
  uint uVar1;
  int iVar2;
  int iVar3;
  undefined2 uVar4;
  int iVar5;
  long lVar6;
  
  iVar5 = *(int *)(param_1 + 0x3c);
  uVar1 = *(uint *)(param_1 + 0x1720);
  iVar2 = *(int *)(param_1 + 0x1444 + (ulong)uVar1 * 4);
  if (iVar5 < *(int *)(param_1 + 0x1444)) {
    iVar2 = ((iVar5 - iVar2) * 0x1000) /
            (*(int *)(param_1 + 0x1444 + (ulong)(uVar1 + 1) * 4) - iVar2);
    iVar5 = -0x3fff;
    if (-0x4000 < iVar2) {
      iVar5 = iVar2;
    }
    iVar2 = 0x3fff;
    if (iVar5 < 0x4000) {
      iVar2 = iVar5;
    }
  }
  else {
    iVar2 = ((iVar5 - iVar2) * 0x1000) /
            (*(int *)(param_1 + 0x1444 + (ulong)(uVar1 + 1) * 4) - iVar2);
    iVar3 = -0x3fff;
    if (-0x4000 < iVar2) {
      iVar3 = iVar2;
    }
    iVar2 = 0x3fff;
    if (iVar3 < 0x4000) {
      iVar2 = iVar3;
    }
    if (iVar5 <= *(int *)(param_1 + 0x1444 + (ulong)(*(int *)(param_1 + 0x1438) - 1) * 4)) {
      if (param_5 == 0) {
        return;
      }
      lVar6 = 0;
      do {
        *(ushort *)(param_4 + lVar6) =
             (short)((int)(((uint)*(ushort *)(param_3 + lVar6) - (uint)*(ushort *)(param_2 + lVar6))
                          * iVar2) >> 0xc) + *(ushort *)(param_2 + lVar6);
        lVar6 = lVar6 + 2;
      } while (lVar6 != (ulong)(param_5 - 1) * 2 + 2);
      return;
    }
  }
  if (param_5 == 0) {
    return;
  }
  lVar6 = 0;
  do {
    iVar5 = ((int)(((uint)*(ushort *)(param_3 + lVar6) - (uint)*(ushort *)(param_2 + lVar6)) * iVar2
                  ) >> 0xc) + (uint)*(ushort *)(param_2 + lVar6);
    if (iVar5 < 0) {
      iVar5 = 0;
    }
    uVar4 = (undefined2)iVar5;
    if (0xffff < iVar5) {
      uVar4 = 0xffff;
    }
    *(undefined2 *)(param_4 + lVar6) = uVar4;
    lVar6 = lVar6 + 2;
  } while (lVar6 != (ulong)(param_5 - 1) * 2 + 2);
  return;
}


==================================================================

### FUNC 0010e340 (453 bytes) name=FUN_0010e340

void FUN_0010e340(long param_1,int param_2,uint param_3)

{
  long lVar1;
  int iVar2;
  uint uVar3;
  int iVar4;
  int iVar5;
  
  pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0x218));
  if ((*(int *)(param_1 + 0x208) != 0) && (*(int *)(param_1 + 0x1328) != 0)) {
    if (param_2 == 0) {
      FUN_00107760(param_1);
      if ((*(int *)(param_1 + 0x1328) != 0) && (*(int *)(param_1 + 0x132c) != 0)) {
        FUN_00109f20(param_1);
      }
    }
    else {
      if ((param_2 == 1) && (1 < param_3)) {
        DAT_0033f644 = 0;
        DAT_0033f640 = 0;
        DAT_0033f650 = (*(int *)(param_1 + 0x1434) + -1) * *(int *)(param_1 + 0x77f8);
        DAT_0033f64c = (*(int *)(param_1 + 0x77f8) + DAT_0033f650) * 2;
        DAT_0033f648 = ((param_3 - 2) + DAT_0033f650 + DAT_0033f64c) / (param_3 - 1) + 7 &
                       0xfffffff8;
      }
      else if (param_2 < 1) goto LAB_0010e4b8;
      uVar3 = 0;
      if (DAT_0033f644 < DAT_0033f650) {
        uVar3 = DAT_0033f648;
        if (DAT_0033f650 - DAT_0033f644 <= (int)DAT_0033f648) {
          uVar3 = DAT_0033f650 - DAT_0033f644;
        }
        lVar1 = (long)DAT_0033f644 * 2;
        iVar4 = DAT_0033f644 + uVar3;
        FUN_0010e0c0(param_1,lVar1 + *(long *)(param_1 + 0x1728),lVar1 + *(long *)(param_1 + 0x1730)
                     ,lVar1 + *(long *)(param_1 + 0x1738),uVar3);
        DAT_0033f644 = iVar4;
      }
      iVar4 = DAT_0033f64c;
      if (((int)uVar3 < (int)DAT_0033f648) && (DAT_0033f640 < DAT_0033f64c)) {
        iVar2 = DAT_0033f64c - DAT_0033f640;
        if ((int)(DAT_0033f648 - uVar3) <= DAT_0033f64c - DAT_0033f640) {
          iVar2 = DAT_0033f648 - uVar3;
        }
        lVar1 = (long)DAT_0033f640 * 2;
        iVar5 = DAT_0033f640 + iVar2;
        FUN_0010e200(param_1,lVar1 + *(long *)(param_1 + 0x1740),lVar1 + *(long *)(param_1 + 0x1748)
                     ,lVar1 + *(long *)(param_1 + 0x1750),iVar2);
        DAT_0033f640 = iVar5;
        if (iVar4 == iVar5) {
          *(undefined4 *)(param_1 + 0x1330) = 1;
        }
      }
    }
  }
LAB_0010e4b8:
  pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0x218));
  return;
}


==================================================================

### FUNC 0010e520 (485 bytes) name=FUN_0010e520

void FUN_0010e520(long param_1,long param_2)

{
  undefined1 *puVar1;
  long lVar2;
  undefined1 uVar3;
  long lVar4;
  uint uVar5;
  int iVar6;
  int iVar7;
  ulong uVar8;
  undefined1 *puVar9;
  undefined2 uVar10;
  undefined1 *puVar12;
  undefined1 *puVar13;
  undefined1 uVar14;
  long lVar15;
  long lVar16;
  uint uVar17;
  int iVar18;
  long in_FS_OFFSET;
  undefined1 auStack_68 [16];
  undefined1 *local_58;
  undefined8 local_48;
  undefined8 local_40;
  undefined4 local_38;
  long local_30;
  int iVar11;
  
  local_30 = *(long *)(in_FS_OFFSET + 0x28);
  lVar4 = *(long *)(param_1 + 600);
  lVar16 = *(long *)(param_1 + 0x1dd0);
  if (*(int *)(param_1 + 0x1dec) == 0) {
    lVar16 = 0;
  }
  iVar7 = FUN_00109ed0(param_1,100000);
  iVar6 = DAT_0033f590;
  if (*(int *)(param_1 + 0x77f8) != 0) {
    iVar18 = 0;
    lVar2 = (ulong)(*(int *)(param_1 + 0x77f8) - 1) * 2 + 2;
    lVar15 = 0;
    do {
      while( true ) {
        iVar11 = ((uint)*(ushort *)(param_2 + lVar15) - (uint)*(ushort *)(lVar16 + lVar15)) * iVar6
                 + iVar7;
        uVar10 = (undefined2)iVar11;
        if (iVar11 < 0x10000) break;
        iVar18 = iVar18 + 1;
        uVar10 = 0xffff;
LAB_0010e599:
        *(undefined2 *)(lVar4 + lVar15) = uVar10;
        lVar15 = lVar15 + 2;
        if (lVar15 == lVar2) goto LAB_0010e5e0;
      }
      if (-1 < iVar11) goto LAB_0010e599;
      iVar18 = iVar18 + 1;
      *(undefined2 *)(lVar4 + lVar15) = 0;
      lVar15 = lVar15 + 2;
    } while (lVar15 != lVar2);
LAB_0010e5e0:
    if ((0x100 < iVar18) && (1 < iVar6)) {
      iVar7 = *(int *)(param_1 + 0x7804);
      DAT_0033f590 = iVar6 + -1;
      FUN_00113aa0(auStack_68,2);
      FUN_00116630(auStack_68,"Conversation ratio adjusted to ");
      uVar8 = FUN_00116480(auStack_68);
      if (0x18 < uVar8) {
        local_48 = 0x3233343536373839;
        local_38 = 0x393837;
        local_40 = 0x3635343332313031;
        puVar1 = local_58;
        uVar17 = (iVar6 + -1) * iVar7;
        do {
          puVar12 = puVar1;
          puVar1 = puVar12 + 1;
          uVar5 = uVar17 / 10;
          uVar14 = *(undefined1 *)((long)&local_40 + (ulong)(uVar17 % 10) + 1);
          *puVar12 = uVar14;
          uVar17 = uVar5;
        } while (uVar5 != 0);
        if ((local_58 != puVar1) && (puVar9 = local_58, local_58 < puVar12)) {
          while( true ) {
            uVar3 = *puVar9;
            puVar13 = puVar12 + -1;
            *puVar9 = uVar14;
            *puVar12 = uVar3;
            if (puVar13 <= puVar9 + 1) break;
            uVar14 = *puVar13;
            puVar9 = puVar9 + 1;
            puVar12 = puVar13;
          }
        }
        local_58 = local_58 + ((int)puVar1 - (int)local_58);
        *local_58 = 0;
      }
      FUN_00116630(auStack_68,"mK/LSB");
      FUN_00113b30(auStack_68);
    }
  }
  if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
                    /* WARNING: Subroutine does not return */
    __stack_chk_fail();
  }
  return;
}


==================================================================

### FUNC 0010e730 (281 bytes) name=FUN_0010e730

void FUN_0010e730(long param_1,long param_2)

{
  uint uVar1;
  short sVar2;
  undefined4 uVar3;
  int iVar4;
  long lVar5;
  uint uVar6;
  int iVar7;
  short *psVar8;
  ushort *puVar9;
  long lVar11;
  long lVar12;
  int iVar13;
  long lVar14;
  short *psVar15;
  long lVar10;
  
  lVar12 = *(long *)(param_1 + 0x1dd0);
  lVar11 = *(long *)(param_1 + 0x1750);
  uVar3 = *(undefined4 *)(param_1 + 0xfc);
  lVar5 = *(long *)(param_1 + 600);
  if (*(int *)(param_1 + 0x1dec) == 0) {
    lVar12 = 0;
  }
  uVar1 = *(int *)(param_1 + 0x1434) - 1;
  iVar4 = *(int *)(param_1 + 0x77f8);
  if (iVar4 != 0) {
    psVar15 = (short *)(*(long *)(param_1 + 0x1738) + 2);
    lVar14 = 0;
    do {
      iVar13 = (int)((uint)*(ushort *)(param_2 + lVar14) - (uint)*(ushort *)(lVar12 + lVar14)) >> 1;
      if ((uVar1 == 0) || (iVar13 <= psVar15[-1])) {
        lVar10 = 0;
      }
      else {
        uVar6 = 0;
        psVar8 = psVar15;
        do {
          uVar6 = uVar6 + 1;
          lVar10 = (ulong)(iVar4 * 2 * uVar1) * 2;
          if (uVar1 == uVar6) goto LAB_0010e7f9;
          sVar2 = *psVar8;
          psVar8 = psVar8 + 1;
        } while (sVar2 < iVar13);
        lVar10 = (ulong)(uVar6 * iVar4 * 2) * 2;
      }
LAB_0010e7f9:
      puVar9 = (ushort *)(lVar10 + lVar11);
      lVar11 = lVar11 + 4;
      iVar7 = ((int)((uint)*puVar9 * iVar13) >> ((byte)uVar3 & 0x1f)) + (uint)puVar9[1];
      iVar13 = 0;
      if (-1 < iVar7) {
        iVar13 = iVar7;
      }
      if (0xffff < iVar13) {
        iVar13 = 0xffff;
      }
      psVar15 = psVar15 + uVar1;
      *(short *)(lVar5 + lVar14) = (short)iVar13;
      lVar14 = lVar14 + 2;
    } while (lVar14 != (ulong)(iVar4 - 1) * 2 + 2);
  }
  return;
}


==================================================================

### FUNC 0010e850 (501 bytes) name=FUN_0010e850

ulong FUN_0010e850(long param_1,long param_2)

{
  uint *puVar1;
  ulong uVar2;
  uint uVar3;
  ulong uVar4;
  uint *puVar5;
  
  puVar5 = *(uint **)(param_1 + 0x1758);
  uVar3 = *(uint *)(param_1 + 0x1534 + (ulong)*(uint *)(param_1 + 0x1720) * 4);
  uVar4 = (ulong)uVar3;
  if (uVar3 != 0) {
    puVar1 = puVar5 + ((ulong)(uVar3 - 1) * 5 + 5) * 2;
    do {
      uVar4 = (ulong)(puVar5[1] - 3);
      switch(uVar4) {
      case 0:
        uVar2 = (long)(int)((uint)*(ushort *)(param_2 + (ulong)puVar5[3] * 2) +
                            (uint)*(ushort *)(param_2 + (ulong)puVar5[2] * 2) +
                           (uint)*(ushort *)(param_2 + (ulong)puVar5[4] * 2)) * 0x55555556;
        uVar4 = uVar2 & 0xffffffff;
        *(short *)(param_2 + (ulong)*puVar5 * 2) = (short)(uVar2 >> 0x20);
        break;
      case 1:
        uVar3 = (int)((uint)*(ushort *)(param_2 + (ulong)puVar5[2] * 2) +
                      (uint)*(ushort *)(param_2 + (ulong)puVar5[3] * 2) +
                      (uint)*(ushort *)(param_2 + (ulong)puVar5[4] * 2) +
                     (uint)*(ushort *)(param_2 + (ulong)puVar5[5] * 2)) >> 2;
        uVar4 = (ulong)uVar3;
        *(short *)(param_2 + (ulong)*puVar5 * 2) = (short)uVar3;
        break;
      case 2:
        uVar2 = (long)(int)((uint)*(ushort *)(param_2 + (ulong)puVar5[3] * 2) +
                            (uint)*(ushort *)(param_2 + (ulong)puVar5[2] * 2) +
                            (uint)*(ushort *)(param_2 + (ulong)puVar5[4] * 2) +
                            (uint)*(ushort *)(param_2 + (ulong)puVar5[5] * 2) +
                           (uint)*(ushort *)(param_2 + (ulong)puVar5[6] * 2)) * 0x66666667;
        uVar4 = uVar2 & 0xffffffff;
        *(short *)(param_2 + (ulong)*puVar5 * 2) = (short)(uVar2 >> 0x21);
        break;
      case 3:
        uVar2 = (long)(int)((uint)*(ushort *)(param_2 + (ulong)puVar5[3] * 2) +
                            (uint)*(ushort *)(param_2 + (ulong)puVar5[2] * 2) +
                            (uint)*(ushort *)(param_2 + (ulong)puVar5[4] * 2) +
                            (uint)*(ushort *)(param_2 + (ulong)puVar5[5] * 2) +
                            (uint)*(ushort *)(param_2 + (ulong)puVar5[6] * 2) +
                           (uint)*(ushort *)(param_2 + (ulong)puVar5[7] * 2)) * 0x2aaaaaab;
        uVar4 = uVar2 & 0xffffffff;
        *(short *)(param_2 + (ulong)*puVar5 * 2) = (short)(uVar2 >> 0x20);
        break;
      case 4:
        uVar3 = (uint)*(ushort *)(param_2 + (ulong)puVar5[3] * 2) +
                (uint)*(ushort *)(param_2 + (ulong)puVar5[2] * 2) +
                (uint)*(ushort *)(param_2 + (ulong)puVar5[4] * 2) +
                (uint)*(ushort *)(param_2 + (ulong)puVar5[5] * 2) +
                (uint)*(ushort *)(param_2 + (ulong)puVar5[6] * 2) +
                (uint)*(ushort *)(param_2 + (ulong)puVar5[7] * 2) +
                (uint)*(ushort *)(param_2 + (ulong)puVar5[8] * 2);
        uVar4 = (long)(int)uVar3 * -0x6db6db6d & 0xffffffff;
        *(short *)(param_2 + (ulong)*puVar5 * 2) = (short)(uVar3 / 7);
        break;
      case 5:
        uVar3 = (int)((uint)*(ushort *)(param_2 + (ulong)puVar5[2] * 2) +
                      (uint)*(ushort *)(param_2 + (ulong)puVar5[3] * 2) +
                      (uint)*(ushort *)(param_2 + (ulong)puVar5[4] * 2) +
                      (uint)*(ushort *)(param_2 + (ulong)puVar5[5] * 2) +
                      (uint)*(ushort *)(param_2 + (ulong)puVar5[6] * 2) +
                      (uint)*(ushort *)(param_2 + (ulong)puVar5[7] * 2) +
                      (uint)*(ushort *)(param_2 + (ulong)puVar5[8] * 2) +
                     (uint)*(ushort *)(param_2 + (ulong)puVar5[9] * 2)) >> 3;
        uVar4 = (ulong)uVar3;
        *(short *)(param_2 + (ulong)*puVar5 * 2) = (short)uVar3;
        break;
      default:
        goto switchD_0010e8b2_default;
      }
      puVar5 = puVar5 + 10;
    } while (puVar5 != puVar1);
  }
switchD_0010e8b2_default:
  return uVar4;
}


==================================================================

### FUNC 0010ea70 (51 bytes) name=FUN_0010ea70

void FUN_0010ea70(long param_1)

{
  if ((*(int *)(param_1 + 0x1328) != 0) && (*(int *)(param_1 + 0x1330) != 0)) {
    FUN_0010e730();
    FUN_0010e850(param_1,*(undefined8 *)(param_1 + 600));
    return;
  }
  FUN_0010e520();
  return;
}


==================================================================

### FUNC 0010eab0 (127 bytes) name=FUN_0010eab0

void FUN_0010eab0(long param_1)

{
  int iVar1;
  undefined8 uVar2;
  
  if (*(int *)(param_1 + 0x1eec) != 1) {
    iVar1 = FUN_00106b40(param_1 + 0x1df0);
    *(undefined4 *)(param_1 + 0x1f0c) = 0;
    if (iVar1 != 0) {
      uVar2 = 0;
      if (*(int *)(param_1 + 0x1e1c) != 0) {
        uVar2 = *(undefined8 *)(param_1 + 0x1e00);
      }
      FUN_0010ea70(param_1,uVar2);
      *(undefined4 *)(param_1 + 0x1f14) = 1;
    }
    return;
  }
  FUN_00106b40(param_1 + 0x1df0);
  uVar2 = 0;
  if (*(int *)(param_1 + 0x1e1c) != 0) {
    uVar2 = *(undefined8 *)(param_1 + 0x1e00);
  }
  *(undefined8 *)(param_1 + 0x4b78) = uVar2;
  FUN_0010ea70(param_1);
  *(undefined4 *)(param_1 + 0x1f14) = 1;
  return;
}


==================================================================

### FUNC 0010eb40 (149 bytes) name=FUN_0010eb40

void FUN_0010eb40(long param_1)

{
  long lVar1;
  long lVar2;
  long lVar3;
  uint uVar4;
  uint uVar5;
  
  lVar2 = FUN_0011a270(param_1 + 0x1e90);
  if (lVar2 != 0) {
    uVar5 = *(uint *)(param_1 + 0x77f8);
    if (*(int *)(param_1 + 0x1328) == 0) {
      lVar3 = 0;
      uVar4 = 0;
      if (uVar5 != 0) {
        do {
          lVar1 = lVar3 * 2;
          lVar3 = lVar3 + 1;
          uVar4 = uVar4 + *(ushort *)(lVar2 + lVar1);
        } while ((uint)lVar3 < uVar5);
        *(uint *)(param_1 + 0x1f44) = uVar4 / uVar5;
        return;
      }
      uVar5 = 0;
      uVar4 = 0;
    }
    else {
      if (uVar5 == 0) {
        uVar4 = 0;
      }
      else {
        lVar3 = 0;
        uVar4 = 0;
        do {
          lVar1 = lVar3 * 2;
          lVar3 = lVar3 + 1;
          uVar4 = uVar4 + *(ushort *)(lVar2 + lVar1);
        } while ((uint)lVar3 < uVar5);
      }
      uVar5 = uVar5 - *(int *)(param_1 + 0x1534 + (ulong)*(uint *)(param_1 + 0x1720) * 4);
      if (uVar5 == 0) {
        return;
      }
    }
    *(uint *)(param_1 + 0x1f44) = uVar4 / uVar5;
  }
  return;
}


==================================================================

### FUNC 0010ebe0 (394 bytes) name=FUN_0010ebe0

undefined4 FUN_0010ebe0(long param_1,int param_2)

{
  pthread_mutex_t *__mutex;
  void *pvVar1;
  int *piVar2;
  char *pcVar3;
  undefined1 auStack_48 [40];
  
  __mutex = (pthread_mutex_t *)(param_1 + 0x218);
  pthread_mutex_lock(__mutex);
  if ((*(int *)(param_1 + 0x208) == 0) || (*(int *)(param_1 + 0x214) == 0)) {
    pthread_mutex_unlock(__mutex);
    piVar2 = __errno_location();
    *piVar2 = -0x1b51fffa;
    return 0;
  }
  if (param_2 == 0) {
    *(undefined4 *)(param_1 + 0x210) = 0;
    if (*(void **)(param_1 + 0x278) != (void *)0x0) {
      operator_delete__(*(void **)(param_1 + 0x278));
      *(undefined8 *)(param_1 + 0x278) = 0;
LAB_0010ec51:
      if (*(int *)(param_1 + 0x210) != 0) {
        pcVar3 = "Add Temperature Mask";
        goto LAB_0010ec66;
      }
    }
    pcVar3 = "Delete Temperature Mask";
  }
  else {
    if (*(long *)(param_1 + 0x278) == 0) {
      pvVar1 = operator_new__((ulong)*(uint *)(param_1 + 0x77f8) * 2);
      *(void **)(param_1 + 0x278) = pvVar1;
      *(void **)(param_1 + 0x280) = pvVar1;
      if (pvVar1 == (void *)0x0) {
        FUN_00113aa0(auStack_48,4);
        FUN_00116630(auStack_48,"Failed to create mask frame");
        FUN_00113b30(auStack_48);
        piVar2 = __errno_location();
        *piVar2 = -0x1b51fffe;
        goto LAB_0010ec51;
      }
    }
    pcVar3 = "Add Temperature Mask";
    memcpy(*(void **)(param_1 + 0x280),*(void **)(param_1 + 0x268),
           (ulong)*(uint *)(param_1 + 0x77f8) * 2);
    *(undefined4 *)(param_1 + 0x210) = 1;
  }
LAB_0010ec66:
  FUN_00113aa0(auStack_48,2);
  FUN_00116630(auStack_48,pcVar3);
  FUN_00113b30(auStack_48);
  pthread_mutex_unlock(__mutex);
  return *(undefined4 *)(param_1 + 0x210);
}


==================================================================

### FUNC 0010eda0 (95 bytes) name=FUN_0010eda0

void FUN_0010eda0(long param_1)

{
  ushort *puVar1;
  ushort *puVar2;
  ushort uVar3;
  int iVar4;
  int iVar5;
  int iVar6;
  
  uVar3 = FUN_00109ed0(param_1,0);
  puVar1 = *(ushort **)(param_1 + 0x280);
  puVar2 = *(ushort **)(param_1 + 0x268);
  for (iVar5 = *(int *)(param_1 + 0x77f8); iVar5 != 0; iVar5 = iVar5 + -1) {
    iVar4 = ((uint)*puVar2 - (uint)*puVar1) + (uint)uVar3;
    iVar6 = 0;
    if ((-1 < iVar4) && (iVar6 = iVar4, 0xfffe < iVar4)) {
      iVar6 = -1;
    }
    *puVar2 = (ushort)iVar6;
    puVar1 = puVar1 + 1;
    puVar2 = puVar2 + 1;
  }
  return;
}


==================================================================

### FUNC 0010ee00 (316 bytes) name=FUN_0010ee00

undefined8 FUN_0010ee00(long param_1,long param_2,uint param_3,int param_4,int param_5)

{
  undefined4 uVar1;
  long lVar2;
  uint uVar3;
  undefined4 uVar4;
  int *piVar5;
  int iVar6;
  ulong uVar7;
  
  if (param_5 != 0) {
    pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0x218));
  }
  if (*(int *)(param_1 + 0x214) == 0) {
    piVar5 = __errno_location();
    iVar6 = -0x1b51fffb;
  }
  else {
    if (param_2 != 0) {
      lVar2 = *(long *)(param_1 + 0x268);
      uVar3 = param_3 >> 2;
      if (*(uint *)(param_1 + 0x77f8) <= param_3 >> 2) {
        uVar3 = *(uint *)(param_1 + 0x77f8);
      }
      uVar1 = *(undefined4 *)(param_1 + 0xb8);
      uVar7 = 0;
      if (uVar3 != 0) {
        do {
          while (((uVar4 = FUN_0010b0a0(param_1,*(undefined2 *)(lVar2 + uVar7 * 2),
                                        uVar7 & 0xffffffff,1), param_4 == 0 &&
                  (*(int *)(param_1 + 0x60) == 0)) || (*(int *)(param_1 + 0xb0) == 0))) {
            *(undefined4 *)(param_2 + uVar7 * 4) = uVar4;
            uVar7 = uVar7 + 1;
            if (uVar3 <= (uint)uVar7) goto LAB_0010eed0;
          }
          uVar4 = FUN_0010a230(uVar1,param_1,uVar4);
          *(undefined4 *)(param_2 + uVar7 * 4) = uVar4;
          uVar7 = uVar7 + 1;
        } while ((uint)uVar7 < uVar3);
      }
LAB_0010eed0:
      if (param_5 != 0) {
        pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0x218));
      }
      return 1;
    }
    piVar5 = __errno_location();
    iVar6 = -0x1b51ffff;
  }
  *piVar5 = iVar6;
  if (param_5 != 0) {
    pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0x218));
  }
  return 0;
}


==================================================================

### FUNC 0010ef60 (405 bytes) name=FUN_0010ef60

ulong FUN_0010ef60(long param_1,uint param_2,uint param_3)

{
  pthread_mutex_t *__mutex;
  ushort uVar1;
  uint uVar2;
  int iVar3;
  ushort *puVar4;
  uint uVar5;
  ulong uVar6;
  int iVar7;
  uint uVar8;
  uint uVar9;
  uint uVar10;
  uint uVar11;
  uint uVar12;
  uint uVar13;
  uint uVar14;
  uint uVar15;
  uint uVar16;
  uint uVar17;
  
  uVar2 = *(uint *)(param_1 + 0x1ed0);
  uVar10 = 0x10;
  if ((0xf < param_2) && (uVar10 = uVar2 >> 1, param_2 <= uVar2 >> 1)) {
    uVar10 = param_2;
  }
  uVar15 = *(uint *)(param_1 + 0x1ed4);
  uVar11 = 9;
  if ((8 < param_3) && (uVar11 = uVar15 >> 1, param_3 <= uVar15 >> 1)) {
    uVar11 = param_3;
  }
  __mutex = (pthread_mutex_t *)(param_1 + 0x218);
  uVar16 = uVar15 + uVar11 >> 1;
  uVar15 = uVar15 - uVar11 >> 1;
  pthread_mutex_lock(__mutex);
  if ((*(int *)(param_1 + 0x214) != 0) && (uVar15 < uVar16)) {
    uVar11 = 0;
    uVar5 = uVar2 - uVar10 >> 1;
    iVar3 = *(int *)(param_1 + 0x1ed0);
    uVar9 = 0;
    uVar17 = (uVar15 - 1) * iVar3;
    do {
      puVar4 = (ushort *)(*(long *)(param_1 + 0x268) + ((ulong)uVar17 + (ulong)(uVar5 - 1)) * 2);
      for (iVar7 = (uVar2 + uVar10 >> 1) - uVar5; iVar7 != 0; iVar7 = iVar7 + -1) {
        uVar1 = *puVar4;
        uVar11 = uVar11 + ((int)((uint)uVar1 + (uint)puVar4[2] + (uint)puVar4[(uint)(iVar3 * 2)] +
                                (uint)puVar4[(ulong)(uint)(iVar3 * 2) + 2]) >> 2);
        uVar8 = (uint)uVar1 - (uint)puVar4[(uint)(iVar3 * 2)];
        uVar12 = (uint)uVar1 - (uint)puVar4[2];
        uVar13 = (int)uVar8 >> 0x1f;
        uVar14 = (int)uVar12 >> 0x1f;
        uVar9 = uVar9 + (((uVar8 ^ uVar13) - uVar13) + ((uVar12 ^ uVar14) - uVar14) >> 1);
        puVar4 = puVar4 + 1;
      }
      uVar15 = uVar15 + 1;
      uVar17 = uVar17 + iVar3;
    } while (uVar15 != uVar16);
    pthread_mutex_unlock(__mutex);
    uVar6 = (ulong)uVar11;
    if (0xffff < uVar11) {
      uVar6 = (ulong)uVar9 / (ulong)(uVar11 >> 0x10);
    }
    return uVar6;
  }
  pthread_mutex_unlock(__mutex);
  return 0;
}


==================================================================

### FUNC 0010f100 (417 bytes) name=FUN_0010f100

int FUN_0010f100(long param_1,uint param_2,uint param_3)

{
  pthread_mutex_t *__mutex;
  ushort *puVar1;
  ushort *puVar2;
  long lVar3;
  ulong uVar4;
  long lVar5;
  uint uVar6;
  uint uVar7;
  uint uVar8;
  uint uVar9;
  uint uVar10;
  uint uVar11;
  int iVar12;
  double dVar13;
  double __x;
  
  if ((int)param_2 < 0x10) {
    uVar10 = *(uint *)(param_1 + 0x1ed0);
    uVar7 = 0x10;
  }
  else {
    uVar10 = *(uint *)(param_1 + 0x1ed0);
    uVar7 = uVar10;
    if (param_2 <= uVar10) {
      uVar7 = param_2;
    }
  }
  if ((int)param_3 < 9) {
    uVar9 = *(uint *)(param_1 + 0x1ed4);
    uVar8 = 9;
  }
  else {
    uVar9 = *(uint *)(param_1 + 0x1ed4);
    uVar8 = uVar9;
    if (param_3 <= uVar9) {
      uVar8 = param_3;
    }
  }
  __mutex = (pthread_mutex_t *)(param_1 + 0x218);
  uVar11 = uVar9 - uVar8 >> 1;
  uVar6 = uVar10 - uVar7 >> 1;
  uVar9 = uVar9 + uVar8 >> 1;
  pthread_mutex_lock(__mutex);
  uVar10 = uVar10 + uVar7 >> 1;
  if (*(int *)(param_1 + 0x214) == 0) {
    pthread_mutex_unlock(__mutex);
    iVar12 = 0;
  }
  else {
    if (uVar11 < uVar9) {
      lVar5 = 0;
      lVar3 = 0;
      uVar8 = uVar11 * *(int *)(param_1 + 0x1ed0);
      uVar7 = uVar11;
      do {
        puVar2 = (ushort *)(*(long *)(param_1 + 0x268) + ((ulong)uVar8 + (ulong)uVar6) * 2);
        if (uVar6 < uVar10) {
          puVar1 = puVar2 + (ulong)((uVar10 - 1) - uVar6) + 1;
          do {
            uVar4 = (ulong)*puVar2;
            puVar2 = puVar2 + 1;
            lVar3 = lVar3 + uVar4;
            lVar5 = lVar5 + uVar4 * uVar4;
          } while (puVar2 != puVar1);
        }
        uVar7 = uVar7 + 1;
        uVar8 = uVar8 + *(int *)(param_1 + 0x1ed0);
      } while (uVar9 != uVar7);
      dVar13 = (double)lVar3 * (double)lVar3;
    }
    else {
      dVar13 = 0.0;
      lVar5 = 0;
    }
    uVar10 = (uVar10 - uVar6) * (uVar9 - uVar11);
    pthread_mutex_unlock(__mutex);
    __x = ((double)lVar5 - dVar13 / (double)uVar10) / (double)(uVar10 - 1);
    dVar13 = SQRT(__x);
    if (NAN(dVar13)) {
      dVar13 = sqrt(__x);
    }
    iVar12 = (int)dVar13;
  }
  return iVar12;
}


==================================================================

### FUNC 0010f2b0 (321 bytes) name=FUN_0010f2b0

void FUN_0010f2b0(long param_1,int *param_2,ushort *param_3,uint param_4)

{
  ushort uVar1;
  uint uVar2;
  uint uVar3;
  int iVar4;
  ulong uVar5;
  uint uVar6;
  uint uVar7;
  int iVar8;
  uint uVar9;
  uint uVar10;
  uint uVar11;
  ushort *puVar12;
  uint uVar13;
  uint uVar14;
  uint uVar15;
  
  uVar15 = 0;
  iVar8 = 4;
  uVar14 = (uint)*param_3;
  uVar2 = (uint)param_3[1];
  uVar9 = (uint)*param_3;
  puVar12 = param_3;
  uVar6 = uVar14;
  uVar11 = uVar9;
  if (param_3[1] < uVar14) goto LAB_0010f34c;
LAB_0010f2ec:
  uVar3 = (uint)puVar12[2];
  if (uVar6 < uVar9) {
    uVar9 = uVar6;
  }
  uVar7 = uVar3;
  uVar11 = uVar9;
  if (uVar2 < puVar12[2]) goto LAB_0010f303;
  do {
    uVar3 = uVar2;
    uVar11 = uVar9;
    if (uVar7 < uVar9) {
      uVar9 = uVar7;
      uVar11 = uVar7;
    }
LAB_0010f303:
    do {
      uVar1 = puVar12[4];
      uVar2 = (uint)uVar1;
      uVar10 = uVar9;
      uVar13 = (uint)uVar1;
      if ((uVar1 <= uVar3) && (uVar13 = uVar3, uVar11 = uVar9, uVar2 < uVar9)) {
        uVar10 = uVar2;
        uVar11 = uVar2;
      }
      uVar3 = (uint)puVar12[6];
      uVar15 = uVar15 + uVar6 + uVar2 + uVar7 + uVar3;
      uVar9 = uVar10;
      uVar2 = uVar3;
      if ((uVar3 <= uVar13) && (uVar9 = uVar11, uVar2 = uVar13, uVar3 < uVar10)) {
        uVar9 = uVar3;
        uVar11 = uVar3;
      }
      puVar12 = puVar12 + (ulong)(*(int *)(param_1 + 0x1ed0) * 2 - 8) + 8;
      iVar8 = iVar8 + -1;
      if (iVar8 == 0) {
        if (param_4 <= (uVar2 - uVar9) * 0x20) {
          uVar15 = uVar15 >> 4;
          uVar6 = uVar2 - uVar15;
          if (uVar2 - uVar15 < uVar15 - uVar9) {
            uVar6 = uVar15 - uVar9;
          }
          if (param_4 <= uVar6) {
            param_4 = uVar6;
          }
          iVar8 = 4;
          while( true ) {
            iVar4 = (int)(0x8000 / (ulong)param_4);
            param_2[2] = param_2[2] + (param_3[2] - uVar15) * iVar4;
            uVar1 = param_3[4];
            *param_2 = *param_2 + (uVar14 - uVar15) * iVar4;
            param_2[4] = param_2[4] + (uVar1 - uVar15) * iVar4;
            param_2[6] = param_2[6] + (param_3[6] - uVar15) * iVar4;
            iVar8 = iVar8 + -1;
            uVar5 = (ulong)(*(int *)(param_1 + 0x1ed0) * 2 - 8);
            param_3 = param_3 + uVar5 + 8;
            param_2 = param_2 + uVar5 + 8;
            if (iVar8 == 0) break;
            uVar14 = (uint)*param_3;
          }
        }
        return;
      }
      uVar6 = (uint)*puVar12;
      if (uVar6 <= uVar2) goto LAB_0010f2ec;
LAB_0010f34c:
      uVar3 = (uint)puVar12[2];
      uVar2 = uVar6;
      uVar7 = uVar3;
    } while (uVar6 < uVar3);
  } while( true );
}


==================================================================

### FUNC 0010f400 (507 bytes) name=FUN_0010f400

void FUN_0010f400(long param_1,int param_2)

{
  byte bVar1;
  int iVar2;
  int iVar3;
  uint uVar4;
  uint uVar5;
  long lVar6;
  ulong uVar7;
  uint uVar8;
  long lVar9;
  long lVar10;
  long lVar11;
  int *piVar12;
  int *piVar13;
  byte *pbVar14;
  byte *pbVar15;
  uint uVar16;
  uint uVar17;
  long lVar18;
  uint local_3c;
  
  memset(*(void **)(param_1 + 0x2a0),0,(ulong)*(uint *)(param_1 + 0x77f8) << 2);
  FUN_0010a4b0(param_1,30000,*(int *)(param_1 + 0x24) * 1000);
  if (*(int *)(param_1 + 0x1ed4) == 6) {
    pbVar14 = *(byte **)(param_1 + 0x298);
    piVar13 = *(int **)(param_1 + 0x2a0);
    uVar5 = 6;
  }
  else {
    local_3c = 0;
    do {
      iVar2 = *(int *)(param_1 + 0x1ed0);
      if (iVar2 != 6) {
        lVar6 = (long)(int)(local_3c * iVar2);
        lVar10 = lVar6 * 2;
        lVar18 = lVar6 * 4;
        do {
          lVar9 = lVar10 + *(long *)(param_1 + 0x268);
          lVar11 = lVar18 + *(long *)(param_1 + 0x2a0);
          lVar10 = lVar10 + 2;
          lVar18 = lVar18 + 4;
          FUN_0010f2b0(param_1,lVar11,lVar9);
        } while (lVar10 != (lVar6 + 1 + (ulong)(iVar2 - 7)) * 2);
      }
      uVar5 = *(uint *)(param_1 + 0x1ed4);
      local_3c = local_3c + 1;
    } while (local_3c < uVar5 - 6);
    pbVar14 = *(byte **)(param_1 + 0x298);
    piVar13 = *(int **)(param_1 + 0x2a0);
    if (uVar5 == 0) {
      return;
    }
  }
  uVar8 = *(uint *)(param_1 + 0x1ed0);
  uVar17 = 0;
  do {
    if (uVar17 < 6) {
      uVar16 = (uVar17 >> 1) + 1;
    }
    else {
      uVar16 = 4;
      if (uVar5 < uVar17 + 7) {
        uVar16 = (uVar5 + 1) - uVar17 >> 1;
      }
    }
    if (uVar8 != 0) {
      uVar7 = 0;
      piVar12 = piVar13;
      pbVar15 = pbVar14;
      do {
        uVar5 = (uint)uVar7;
        if (uVar5 < 6) {
          uVar4 = (int)(uVar7 >> 1) + 1;
        }
        else {
          uVar4 = 4;
          if (uVar8 < uVar5 + 7) {
            uVar4 = (uVar8 + 1) - uVar5 >> 1;
          }
        }
        piVar13 = piVar12 + 1;
        iVar2 = *piVar12 * param_2;
        if (uVar4 * uVar16 == 0x10) {
          if (iVar2 < 0) {
            iVar2 = iVar2 + 0x7ffff;
          }
          iVar2 = iVar2 >> 0x13;
        }
        else {
          iVar2 = iVar2 / (int)(uVar4 * uVar16 * 0x8000);
        }
        iVar3 = iVar2 + (uint)*pbVar15;
        if ((int)(iVar2 + (uint)*pbVar15) < 0) {
          iVar3 = 0;
        }
        pbVar14 = pbVar15 + 1;
        bVar1 = (byte)iVar3;
        if (0xff < iVar3) {
          bVar1 = 0xff;
        }
        uVar7 = (ulong)(uVar5 + 1);
        *pbVar15 = bVar1;
        uVar8 = *(uint *)(param_1 + 0x1ed0);
        piVar12 = piVar13;
        pbVar15 = pbVar14;
      } while (uVar5 + 1 < uVar8);
    }
    uVar5 = *(uint *)(param_1 + 0x1ed4);
    uVar17 = uVar17 + 1;
  } while (uVar17 < uVar5);
  return;
}


==================================================================

### FUNC 0010f620 (256 bytes) name=FUN_0010f620

void FUN_0010f620(long param_1,int *param_2,ushort *param_3,uint param_4)

{
  ushort uVar1;
  uint uVar2;
  uint uVar3;
  int iVar4;
  uint uVar5;
  ushort *puVar6;
  uint uVar7;
  uint uVar8;
  uint uVar9;
  uint uVar10;
  uint uVar11;
  uint uVar12;
  
  uVar12 = 0;
  uVar9 = (uint)*param_3;
  iVar4 = 4;
  uVar2 = (uint)param_3[1];
  puVar6 = param_3;
  uVar10 = uVar9;
  uVar8 = uVar9;
  if (param_3[1] < *param_3) goto LAB_0010f6b8;
LAB_0010f658:
  uVar3 = (uint)puVar6[2];
  if (uVar10 < uVar9) {
    uVar9 = uVar10;
  }
  uVar11 = uVar3;
  uVar8 = uVar9;
  if (uVar2 < puVar6[2]) goto LAB_0010f670;
  do {
    uVar3 = uVar2;
    uVar8 = uVar9;
    if (uVar11 < uVar9) {
      uVar9 = uVar11;
      uVar8 = uVar11;
    }
LAB_0010f670:
    do {
      uVar1 = puVar6[4];
      uVar2 = (uint)uVar1;
      uVar7 = uVar9;
      uVar5 = (uint)uVar1;
      if ((uVar1 <= uVar3) && (uVar5 = uVar3, uVar8 = uVar9, uVar2 < uVar9)) {
        uVar7 = uVar2;
        uVar8 = uVar2;
      }
      uVar3 = (uint)puVar6[6];
      uVar12 = uVar12 + uVar10 + uVar2 + uVar11 + uVar3;
      uVar9 = uVar7;
      uVar2 = uVar3;
      if ((uVar3 <= uVar5) && (uVar9 = uVar8, uVar2 = uVar5, uVar3 < uVar7)) {
        uVar9 = uVar3;
        uVar8 = uVar3;
      }
      puVar6 = puVar6 + (ulong)(*(int *)(param_1 + 0x1ed0) * 2 - 8) + 8;
      iVar4 = iVar4 + -1;
      if (iVar4 == 0) {
        if ((uVar2 - uVar9) * 0x20 < param_4) {
          *param_2 = 0;
          return;
        }
        uVar12 = uVar12 >> 4;
        uVar10 = uVar2 - uVar12;
        if (uVar2 - uVar12 < uVar12 - uVar9) {
          uVar10 = uVar12 - uVar9;
        }
        if (param_4 <= uVar10) {
          param_4 = uVar10;
        }
        *param_2 = (int)(0x8000 / (ulong)param_4) *
                   (param_3[(ulong)(uint)(*(int *)(param_1 + 0x1ed0) * 3) + 3] - uVar12);
        return;
      }
      uVar10 = (uint)*puVar6;
      if (uVar10 <= uVar2) goto LAB_0010f658;
LAB_0010f6b8:
      uVar3 = (uint)puVar6[2];
      uVar2 = uVar10;
      uVar11 = uVar3;
    } while (uVar10 < uVar3);
  } while( true );
}


==================================================================

### FUNC 0010f730 (529 bytes) name=FUN_0010f730

void FUN_0010f730(long param_1,int param_2)

{
  ushort uVar1;
  long lVar2;
  byte *pbVar3;
  byte *pbVar4;
  byte *pbVar5;
  long lVar6;
  int *piVar7;
  byte bVar8;
  int iVar9;
  long lVar10;
  uint uVar11;
  long lVar12;
  int iVar13;
  uint local_34;
  
  uVar1 = FUN_0010a4b0(param_1,30000,*(int *)(param_1 + 0x24) * 1000);
  iVar13 = *(int *)(param_1 + 0x1ed0);
  lVar6 = *(long *)(param_1 + 0x2a0);
  local_34 = 0;
  uVar11 = param_2 * 2 * (uint)uVar1 >> 8;
  do {
    lVar2 = *(long *)(param_1 + 0x268) + (ulong)(local_34 * iVar13) * 2;
    lVar10 = lVar2;
    lVar12 = lVar6 + 0xc + (ulong)((local_34 + 3) * iVar13) * 4;
    if (iVar13 != 6) {
      do {
        lVar6 = lVar10 + 2;
        FUN_0010f620(param_1,lVar12,lVar10,uVar11);
        lVar10 = lVar6;
        lVar12 = lVar12 + 4;
      } while (lVar6 != lVar2 + 2 + (ulong)(iVar13 - 7) * 2);
      iVar13 = *(int *)(param_1 + 0x1ed0);
      lVar6 = *(long *)(param_1 + 0x2a0);
    }
    iVar9 = *(int *)(param_1 + 0x1ed4);
    local_34 = local_34 + 2;
  } while (local_34 <= iVar9 - 7U);
  if (iVar9 != 7) {
    local_34 = 1;
    while( true ) {
      lVar2 = *(long *)(param_1 + 0x268) + (ulong)(local_34 * iVar13) * 2;
      lVar10 = lVar2;
      lVar6 = lVar6 + 0xc + (ulong)((local_34 + 3) * iVar13) * 4;
      if (iVar13 != 6) {
        do {
          lVar12 = lVar10 + 2;
          FUN_0010f620(param_1,lVar6,lVar10,uVar11);
          lVar10 = lVar12;
          lVar6 = lVar6 + 4;
        } while (lVar12 != lVar2 + 2 + (ulong)(iVar13 - 7) * 2);
        iVar9 = *(int *)(param_1 + 0x1ed4);
      }
      local_34 = local_34 + 2;
      if (iVar9 - 7U < local_34) break;
      iVar13 = *(int *)(param_1 + 0x1ed0);
      lVar6 = *(long *)(param_1 + 0x2a0);
    }
    if (iVar9 - 3U < 4) {
      return;
    }
    iVar13 = *(int *)(param_1 + 0x1ed0);
    lVar6 = *(long *)(param_1 + 0x2a0);
  }
  uVar11 = 3;
  while( true ) {
    lVar2 = (ulong)(uVar11 * iVar13) + 3;
    pbVar3 = (byte *)(lVar2 + *(long *)(param_1 + 0x298));
    pbVar4 = pbVar3;
    piVar7 = (int *)(lVar6 + lVar2 * 4);
    if (iVar13 != 6) {
      do {
        iVar9 = *piVar7 * param_2;
        if (iVar9 < 0) {
          iVar9 = iVar9 + 0x7fff;
        }
        iVar9 = (iVar9 >> 0xf) + (uint)*pbVar4;
        if (iVar9 < 0) {
          iVar9 = 0;
        }
        pbVar5 = pbVar4 + 1;
        bVar8 = (byte)iVar9;
        if (0xff < iVar9) {
          bVar8 = 0xff;
        }
        *pbVar4 = bVar8;
        pbVar4 = pbVar5;
        piVar7 = piVar7 + 1;
      } while (pbVar5 != pbVar3 + (ulong)(iVar13 - 7) + 1);
      iVar9 = *(int *)(param_1 + 0x1ed4);
    }
    uVar11 = uVar11 + 1;
    if (iVar9 - 3U <= uVar11) break;
    iVar13 = *(int *)(param_1 + 0x1ed0);
    lVar6 = *(long *)(param_1 + 0x2a0);
  }
  return;
}


==================================================================

### FUNC 0010f950 (11 bytes) name=FUN_0010f950

void FUN_0010f950(undefined8 param_1,int param_2)

{
  if (param_2 == 0) {
    return;
  }
  FUN_0010f400();
  return;
}


==================================================================

### FUNC 0010f970 (11 bytes) name=FUN_0010f970

void FUN_0010f970(undefined8 param_1,int param_2)

{
  if (param_2 != 0) {
    FUN_0010f730();
    return;
  }
  return;
}


==================================================================

### FUNC 0010f990 (234 bytes) name=FUN_0010f990

void FUN_0010f990(long param_1,int param_2,int param_3,int param_4)

{
  pthread_mutex_t *__mutex;
  uint uVar1;
  uint uVar2;
  uint uVar3;
  uint uVar4;
  
  __mutex = (pthread_mutex_t *)(param_1 + 0x218);
  pthread_mutex_lock(__mutex);
  if (param_2 - 1U < 4) {
    uVar2 = *(uint *)(param_1 + 0x1ed0);
    uVar3 = 1 << ((byte)param_2 & 0x1f);
    uVar1 = *(uint *)(param_1 + 0x1ed4);
    *(int *)(param_1 + 0x1ef8) = param_2;
    uVar4 = param_3 - uVar2 / (uVar3 * 2);
    if ((int)uVar4 < 0) {
      uVar4 = 0;
    }
    uVar2 = (uVar2 - 2) - uVar2 / uVar3;
    if (uVar4 <= uVar2) {
      uVar2 = uVar4;
    }
    uVar4 = param_4 - uVar1 / (uVar3 * 2);
    if ((int)uVar4 < 0) {
      uVar4 = 0;
    }
    *(uint *)(param_1 + 0x1efc) = uVar2 & 0xfffffffe;
    uVar2 = (uVar1 - 1) - uVar1 / uVar3;
    if (uVar4 <= uVar2) {
      uVar2 = uVar4;
    }
    *(uint *)(param_1 + 0x1f00) = uVar2;
    pthread_mutex_unlock(__mutex);
    return;
  }
  *(undefined4 *)(param_1 + 0x1ef8) = 0;
  *(undefined4 *)(param_1 + 0x1efc) = 0;
  *(undefined4 *)(param_1 + 0x1f00) = 0;
  pthread_mutex_unlock(__mutex);
  return;
}


==================================================================

### FUNC 0010fa80 (7 bytes) name=FUN_0010fa80

undefined4 FUN_0010fa80(long param_1)

{
  return *(undefined4 *)(param_1 + 0x1ef8);
}


==================================================================

### FUNC 0010fa90 (416 bytes) name=FUN_0010fa90

void FUN_0010fa90(long param_1)

{
  ushort uVar1;
  ushort uVar2;
  uint uVar3;
  void *pvVar4;
  long lVar5;
  uint uVar6;
  ushort *puVar7;
  ushort *puVar8;
  ulong uVar9;
  int iVar10;
  uint uVar11;
  uint *puVar12;
  uint uVar13;
  ushort *puVar14;
  ushort *puVar15;
  uint *puVar16;
  void *__src;
  ushort uVar17;
  ushort uVar18;
  
  uVar3 = *(uint *)(param_1 + 0x1ed0);
  iVar10 = (*(uint *)(param_1 + 0x1ed4) >> 1) + 1;
  __src = (void *)(*(long *)(param_1 + 0x268) +
                  ((ulong)(uVar3 * *(int *)(param_1 + 0x1f00)) + (ulong)*(uint *)(param_1 + 0x1efc))
                  * 2);
  pvVar4 = *(void **)(param_1 + 0x290);
  do {
    pvVar4 = memcpy(pvVar4,__src,(ulong)((uVar3 >> 1) + 2) * 2);
    uVar3 = *(uint *)(param_1 + 0x1ed0);
    __src = (void *)((long)__src + (ulong)uVar3 * 2);
    iVar10 = iVar10 + -1;
    pvVar4 = (void *)((long)pvVar4 + (ulong)((uVar3 >> 1) + 2) * 2);
  } while (iVar10 != 0);
  puVar15 = *(ushort **)(param_1 + 0x290);
  puVar16 = *(uint **)(param_1 + 0x268);
  uVar11 = *(uint *)(param_1 + 0x1ed4) >> 1;
  if (uVar11 != 0) {
    while( true ) {
      uVar3 = uVar3 >> 1;
      puVar8 = puVar15;
      if (uVar3 != 0) {
        puVar12 = puVar16;
        uVar6 = uVar3;
        uVar13 = (uint)*puVar15;
        do {
          uVar17 = puVar8[1];
          puVar8 = puVar8 + 1;
          uVar6 = uVar6 - 1;
          *puVar12 = ((int)(uVar17 + uVar13) >> 1) << 0x10 | uVar13;
          puVar12 = puVar12 + 1;
          uVar13 = (uint)uVar17;
        } while (uVar6 != 0);
        uVar9 = (ulong)(uVar3 - 1);
        uVar3 = *(uint *)(param_1 + 0x1ed0) >> 1;
        puVar16 = puVar16 + uVar9 + 1;
        puVar14 = puVar15 + uVar9 + 3;
        puVar8 = puVar15 + ((uVar9 + 1) - (ulong)uVar3);
        if (*(uint *)(param_1 + 0x1ed0) >> 1 != 0) {
          puVar7 = puVar8;
          puVar12 = puVar16;
          uVar17 = *puVar8;
          uVar18 = puVar15[uVar9 + 3];
          uVar6 = uVar3;
          do {
            uVar1 = puVar7[1];
            uVar2 = puVar14[1];
            puVar7 = puVar7 + 1;
            puVar14 = puVar14 + 1;
            uVar6 = uVar6 - 1;
            *puVar12 = ((int)((uint)uVar1 + (uint)uVar17 + (uint)uVar18 + (uint)uVar2) >> 2) << 0x10
                       | (int)((uint)uVar17 + (uint)uVar18) >> 1;
            puVar12 = puVar12 + 1;
            uVar17 = uVar1;
            uVar18 = uVar2;
          } while (uVar6 != 0);
          lVar5 = (ulong)(uVar3 - 1) + 1;
          puVar16 = puVar16 + lVar5;
          puVar8 = puVar8 + lVar5;
        }
      }
      puVar15 = puVar8 + 2;
      uVar11 = uVar11 - 1;
      if (uVar11 == 0) break;
      uVar3 = *(uint *)(param_1 + 0x1ed0);
    }
  }
  return;
}


==================================================================

### FUNC 0010fc40 (1006 bytes) name=FUN_0010fc40

void FUN_0010fc40(long param_1)

{
  ushort uVar1;
  ushort uVar2;
  void *pvVar3;
  ulong uVar4;
  long lVar5;
  uint *puVar6;
  int iVar7;
  ushort *puVar8;
  ushort *puVar9;
  void *__src;
  uint uVar10;
  ushort uVar11;
  ushort *puVar12;
  ushort uVar13;
  ushort *puVar14;
  uint uVar15;
  uint *puVar16;
  ushort *local_48;
  uint local_3c;
  
  uVar15 = *(uint *)(param_1 + 0x1ed0);
  pvVar3 = *(void **)(param_1 + 0x290);
  iVar7 = (*(uint *)(param_1 + 0x1ed4) >> 2) + 1;
  __src = (void *)(*(long *)(param_1 + 0x268) +
                  ((ulong)(uVar15 * *(int *)(param_1 + 0x1f00)) + (ulong)*(uint *)(param_1 + 0x1efc)
                  ) * 2);
  do {
    pvVar3 = memcpy(pvVar3,__src,(ulong)((uVar15 >> 2) + 2) * 2);
    uVar15 = *(uint *)(param_1 + 0x1ed0);
    __src = (void *)((long)__src + (ulong)uVar15 * 2);
    iVar7 = iVar7 + -1;
    pvVar3 = (void *)((long)pvVar3 + (ulong)((uVar15 >> 2) + 2) * 2);
  } while (iVar7 != 0);
  puVar14 = *(ushort **)(param_1 + 0x290);
  puVar16 = *(uint **)(param_1 + 0x268);
  local_3c = *(uint *)(param_1 + 0x1ed4) >> 2;
  if (local_3c == 0) {
    return;
  }
  puVar9 = puVar14;
  if (uVar15 >> 2 == 0) goto LAB_00110000;
  do {
    puVar6 = puVar16;
    puVar9 = puVar14;
    uVar11 = *puVar14;
    uVar10 = uVar15 >> 2;
    do {
      uVar13 = puVar9[1];
      puVar9 = puVar9 + 1;
      iVar7 = (uint)uVar11 + (uint)uVar13;
      *puVar6 = ((int)((uint)uVar11 + (uint)uVar11 * 2 + (uint)uVar13) >> 2) << 0x10 | (uint)uVar11;
      uVar10 = uVar10 - 1;
      puVar6[1] = ((int)(iVar7 + (uint)uVar13 * 2) >> 2) << 0x10 | iVar7 >> 1;
      puVar6 = puVar6 + 2;
      uVar11 = uVar13;
    } while (uVar10 != 0);
    uVar4 = (ulong)((uVar15 >> 2) - 1);
    puVar16 = puVar16 + (uVar4 + 1) * 2;
    puVar8 = puVar14 + uVar4 + 3;
    uVar15 = *(uint *)(param_1 + 0x1ed0) >> 2;
    lVar5 = (ulong)uVar15 * -2;
    puVar9 = puVar14 + ((uVar4 + 1) - (ulong)uVar15);
    if (*(uint *)(param_1 + 0x1ed0) >> 2 == 0) goto LAB_00110002;
    puVar6 = puVar16;
    puVar12 = puVar9;
    uVar11 = *puVar9;
    uVar13 = puVar14[uVar4 + 3];
    uVar10 = uVar15;
    do {
      uVar1 = puVar12[1];
      uVar2 = puVar8[1];
      puVar12 = puVar12 + 1;
      puVar8 = puVar8 + 1;
      *puVar6 = ((int)((uint)uVar11 + (uint)uVar11 * 8 + ((uint)uVar13 + (uint)uVar1) * 3 +
                      (uint)uVar2) >> 4) << 0x10 |
                (int)((uint)uVar11 + (uint)uVar11 * 2 + (uint)uVar13) >> 2;
      uVar10 = uVar10 - 1;
      puVar6[1] = ((int)((uint)uVar1 + (uint)uVar1 * 8 + ((uint)uVar11 + (uint)uVar2) * 3 +
                        (uint)uVar13) >> 4) << 0x10 |
                  (int)((uint)uVar2 + (uint)uVar13 + ((uint)uVar11 + (uint)uVar1) * 3) >> 3;
      puVar6 = puVar6 + 2;
      uVar11 = uVar1;
      uVar13 = uVar2;
    } while (uVar10 != 0);
    uVar4 = (ulong)(uVar15 - 1);
    puVar16 = puVar16 + (uVar4 + 1) * 2;
    puVar14 = puVar9 + uVar4 + 3;
    uVar15 = *(uint *)(param_1 + 0x1ed0) >> 2;
    lVar5 = (ulong)uVar15 * -2;
    local_48 = puVar9 + ((uVar4 + 1) - (ulong)uVar15);
    if (*(uint *)(param_1 + 0x1ed0) >> 2 == 0) goto LAB_0011000c;
    puVar6 = puVar16;
    puVar8 = local_48;
    uVar11 = *local_48;
    uVar13 = puVar9[uVar4 + 3];
    uVar10 = uVar15;
    do {
      uVar1 = puVar8[1];
      uVar2 = puVar14[1];
      iVar7 = (uint)uVar11 + (uint)uVar13;
      puVar8 = puVar8 + 1;
      puVar14 = puVar14 + 1;
      *puVar6 = ((int)(iVar7 * 3 + (uint)uVar1 + (uint)uVar2) >> 3) << 0x10 | iVar7 >> 1;
      uVar10 = uVar10 - 1;
      puVar6[1] = ((int)(iVar7 + ((uint)uVar1 + (uint)uVar2) * 3) >> 3) << 0x10 |
                  (int)((uint)uVar11 + (uint)uVar1 + (uint)uVar13 + (uint)uVar2) >> 2;
      puVar6 = puVar6 + 2;
      uVar11 = uVar1;
      uVar13 = uVar2;
    } while (uVar10 != 0);
    uVar4 = (ulong)(uVar15 - 1);
    puVar16 = puVar16 + (uVar4 + 1) * 2;
    uVar15 = *(uint *)(param_1 + 0x1ed0) >> 2;
    puVar9 = local_48 + uVar4 + 3;
    puVar14 = local_48 + ((uVar4 + 1) - (ulong)uVar15);
    if (*(uint *)(param_1 + 0x1ed0) >> 2 != 0) {
      puVar6 = puVar16;
      puVar8 = puVar14;
      uVar11 = *puVar14;
      uVar13 = local_48[uVar4 + 3];
      uVar10 = uVar15;
      do {
        uVar1 = puVar9[1];
        uVar2 = puVar8[1];
        puVar8 = puVar8 + 1;
        puVar9 = puVar9 + 1;
        *puVar6 = ((int)(((uint)uVar11 + (uint)uVar1) * 3 + (uint)uVar2 +
                        (uint)uVar13 + (uint)uVar13 * 8) >> 4) << 0x10 |
                  (int)((uint)uVar13 + (uint)uVar13 * 2 + (uint)uVar11) >> 2;
        uVar10 = uVar10 - 1;
        puVar6[1] = ((int)(((uint)uVar13 + (uint)uVar2) * 3 + (uint)uVar11 +
                          (uint)uVar1 + (uint)uVar1 * 8) >> 4) << 0x10 |
                    (int)((uint)uVar11 + (uint)uVar2 + ((uint)uVar13 + (uint)uVar1) * 3) >> 3;
        puVar6 = puVar6 + 2;
        uVar11 = uVar2;
        uVar13 = uVar1;
      } while (uVar10 != 0);
      lVar5 = (ulong)(uVar15 - 1) + 1;
      puVar16 = puVar16 + lVar5 * 2;
      puVar14 = puVar14 + lVar5;
    }
    while( true ) {
      local_3c = local_3c - 1;
      if (local_3c == 0) {
        return;
      }
      puVar14 = puVar14 + 2;
      uVar15 = *(uint *)(param_1 + 0x1ed0);
      puVar9 = puVar14;
      if (uVar15 >> 2 != 0) break;
LAB_00110000:
      lVar5 = 0;
LAB_00110002:
      local_48 = (ushort *)((long)puVar9 + lVar5);
LAB_0011000c:
      puVar14 = (ushort *)((long)local_48 + lVar5);
    }
  } while( true );
}


==================================================================

### FUNC 00110030 (343 bytes) name=FUN_00110030

undefined4 FUN_00110030(long param_1,undefined8 *param_2,int param_3)

{
  undefined1 uVar1;
  undefined2 uVar2;
  undefined4 uVar3;
  uint uVar4;
  ulong uVar5;
  long lVar6;
  undefined8 *puVar7;
  undefined8 *puVar8;
  bool bVar9;
  byte bVar10;
  
  bVar10 = 0;
  if (param_3 != 0x21c) {
    return 0;
  }
  pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0x218));
  if (*(int *)((long)param_2 + 0x3c) - 1U < 0x19) {
    puVar7 = (undefined8 *)(param_1 + 0x1768);
    uVar4 = 0x21c;
    bVar9 = ((ulong)puVar7 & 1) != 0;
    if (bVar9) {
      uVar1 = *(undefined1 *)param_2;
      puVar7 = (undefined8 *)(param_1 + 0x1769);
      param_2 = (undefined8 *)((long)param_2 + 1);
      *(undefined1 *)(param_1 + 0x1768) = uVar1;
      uVar4 = 0x21b;
    }
    puVar8 = puVar7;
    if (((ulong)puVar7 & 2) != 0) {
      uVar2 = *(undefined2 *)param_2;
      puVar8 = (undefined8 *)((long)puVar7 + 2);
      param_2 = (undefined8 *)((long)param_2 + 2);
      uVar4 = uVar4 - 2;
      *(undefined2 *)puVar7 = uVar2;
    }
    puVar7 = puVar8;
    if (((ulong)puVar8 & 4) != 0) {
      uVar3 = *(undefined4 *)param_2;
      puVar7 = (undefined8 *)((long)puVar8 + 4);
      param_2 = (undefined8 *)((long)param_2 + 4);
      uVar4 = uVar4 - 4;
      *(undefined4 *)puVar8 = uVar3;
    }
    lVar6 = 0;
    for (uVar5 = (ulong)(uVar4 >> 3); uVar5 != 0; uVar5 = uVar5 - 1) {
      *puVar7 = *param_2;
      param_2 = param_2 + (ulong)bVar10 * -2 + 1;
      puVar7 = puVar7 + (ulong)bVar10 * -2 + 1;
    }
    if ((uVar4 & 4) != 0) {
      *(undefined4 *)puVar7 = *(undefined4 *)param_2;
      lVar6 = 4;
    }
    if ((uVar4 & 2) != 0) {
      *(undefined2 *)((long)puVar7 + lVar6) = *(undefined2 *)((long)param_2 + lVar6);
      lVar6 = lVar6 + 2;
    }
    if (bVar9) {
      *(undefined1 *)((long)puVar7 + lVar6) = *(undefined1 *)((long)param_2 + lVar6);
    }
    *(undefined4 *)(param_1 + 0x1764) = 1;
    *(undefined4 *)(param_1 + 0x1760) = 1;
    *(undefined4 *)(param_1 + 0x78) = 0;
  }
  pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0x218));
  uVar3 = 0;
  if (*(int *)(param_1 + 0x1760) != 0) {
    *(undefined4 *)(param_1 + 0x7810) = *(undefined4 *)(param_1 + 0x182c);
    *(undefined4 *)(param_1 + 0x7814) = *(undefined4 *)(param_1 + 0x1834);
    FUN_00109d40(param_1,*(undefined4 *)(param_1 + 0x1830));
    uVar3 = *(undefined4 *)(param_1 + 0x1760);
  }
  return uVar3;
}


==================================================================

### FUNC 001101b0 (39 bytes) name=FUN_001101b0

void FUN_001101b0(long param_1,undefined4 *param_2,undefined4 *param_3,undefined4 *param_4)

{
  undefined4 uVar1;
  
  uVar1 = 0;
  if (*(int *)(param_1 + 0x7810) != 0) {
    uVar1 = *(undefined4 *)(param_1 + 0x7814);
  }
  *param_2 = uVar1;
  *param_3 = *(undefined4 *)(param_1 + 0x7804);
  *param_4 = *(undefined4 *)(param_1 + 0x7808);
  return;
}


==================================================================

### FUNC 001101e0 (296 bytes) name=FUN_001101e0

undefined8 FUN_001101e0(long param_1,int param_2,uint param_3,undefined4 param_4)

{
  int iVar1;
  long lVar2;
  char *pcVar3;
  char *pcVar4;
  undefined4 uVar5;
  bool bVar6;
  
  bVar6 = *(int *)(param_1 + 0x1760) == 0;
  if (bVar6) {
    if (6 < param_2 - 1U) {
LAB_00110259:
      if (param_3 == 0) {
        return 0;
      }
      uVar5 = 0;
      if ((param_3 - 1 & param_3) != 0) {
        return 0;
      }
      goto LAB_00110269;
    }
  }
  else {
    lVar2 = 0x14;
    pcVar3 = (char *)(param_1 + 0x1768);
    pcVar4 = "Shutterless Default";
    do {
      if (lVar2 == 0) break;
      lVar2 = lVar2 + -1;
      bVar6 = *pcVar3 == *pcVar4;
      pcVar3 = pcVar3 + 1;
      pcVar4 = pcVar4 + 1;
    } while (bVar6);
    if (bVar6) {
      pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0x218));
      *(uint *)(param_1 + 0x183c) = param_3;
      *(undefined4 *)(param_1 + 0x1840) = param_4;
      *(undefined4 *)(param_1 + 0x7810) = 0;
      pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0x218));
      return 1;
    }
    if ((6 < param_2 - 1U) ||
       (*(int *)(param_1 + 0x182c + (ulong)*(uint *)(param_1 + 0x78) * 0x21c) == 0))
    goto LAB_00110259;
  }
  uVar5 = 1;
LAB_00110269:
  pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0x218));
  *(undefined4 *)(param_1 + 0x7810) = uVar5;
  *(int *)(param_1 + 0x7814) = param_2;
  iVar1 = 0;
  *(uint *)(param_1 + 0x7804) = param_3;
  *(undefined4 *)(param_1 + 0x7808) = param_4;
  do {
    if (param_3 == 1 << ((byte)iVar1 & 0x1f)) {
      *(int *)(param_1 + 0x780c) = iVar1;
      break;
    }
    iVar1 = iVar1 + 1;
  } while (iVar1 != 0x20);
  pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0x218));
  return 1;
}


==================================================================

### FUNC 00110320 (671 bytes) name=FUN_00110320

void FUN_00110320(long param_1)

{
  byte bVar1;
  byte bVar2;
  byte bVar3;
  byte bVar4;
  byte bVar5;
  byte bVar6;
  undefined1 uVar7;
  ulong uVar8;
  void *pvVar9;
  long lVar10;
  byte *pbVar11;
  int iVar12;
  size_t __n;
  byte *pbVar13;
  void *pvVar14;
  int iVar15;
  byte *pbVar16;
  byte *pbVar17;
  uint uVar18;
  void *__src;
  uint uVar19;
  
  uVar19 = 0;
  __src = *(void **)(param_1 + 0x298);
  uVar18 = *(uint *)(param_1 + 0x1ed0) + 8;
  uVar8 = (ulong)uVar18;
  pvVar14 = (void *)(((ulong)(uint)((*(int *)(param_1 + 0x1edc) + 3) * *(int *)(param_1 + 0x1ed8)) -
                     (ulong)((*(int *)(param_1 + 0x1ed4) + 1) * uVar18)) +
                    *(long *)(param_1 + 0x200));
  __n = (size_t)*(uint *)(param_1 + 0x1ed0);
  pvVar9 = pvVar14;
  if (*(int *)(param_1 + 0x1ed4) != 0) {
    do {
      pvVar9 = memcpy(pvVar9,__src,__n);
      uVar18 = *(uint *)(param_1 + 0x1ed0);
      iVar12 = (uint)*(byte *)((long)__src + (ulong)(uVar18 - 1)) * 2 -
               (uint)*(byte *)((long)__src + (ulong)(uVar18 - 2));
      if (iVar12 < 0) {
        iVar12 = 0;
      }
      uVar7 = 0xff;
      if (iVar12 < 0x100) {
        uVar7 = (undefined1)iVar12;
      }
      uVar19 = uVar19 + 1;
      *(undefined1 *)((long)pvVar9 + (ulong)uVar18) = uVar7;
      __n = (size_t)*(uint *)(param_1 + 0x1ed0);
      __src = (void *)((long)__src + __n);
      uVar8 = (ulong)(*(uint *)(param_1 + 0x1ed0) + 8);
      pvVar9 = (void *)((long)pvVar9 + uVar8);
    } while (uVar19 < *(uint *)(param_1 + 0x1ed4));
  }
  lVar10 = 0;
  if ((int)__n != -1) {
    do {
      iVar12 = (uint)*(byte *)((long)pvVar9 + (lVar10 - uVar8)) * 2 -
               (uint)*(byte *)((long)pvVar9 + lVar10 + uVar8 * -2);
      if (iVar12 < 0) {
        iVar12 = 0;
      }
      uVar7 = (undefined1)iVar12;
      if (0xff < iVar12) {
        uVar7 = 0xff;
      }
      *(undefined1 *)((long)pvVar9 + lVar10) = uVar7;
      lVar10 = lVar10 + 1;
    } while (lVar10 != __n + 1);
  }
  uVar18 = 0;
  if (*(int *)(param_1 + 0x1ed4) != 0) {
    do {
      uVar19 = *(uint *)(param_1 + 0x1ed0);
      pbVar11 = (byte *)((ulong)((uVar18 * 3 >> 1) * *(int *)(param_1 + 0x1ed8)) +
                        *(long *)(param_1 + 0x200));
      pbVar13 = (byte *)((ulong)((uVar19 + 8) * uVar18) + (long)pvVar14);
      if (uVar19 >> 1 != 0) {
        pbVar17 = pbVar11 + (ulong)((uVar19 >> 1) - 1) * 3 + 3;
        while( true ) {
          bVar1 = pbVar13[1];
          bVar2 = *pbVar13;
          pbVar16 = pbVar13 + (ulong)uVar19 + 8;
          bVar3 = pbVar13[2];
          bVar4 = *pbVar16;
          bVar5 = pbVar16[2];
          bVar6 = pbVar16[1];
          *pbVar11 = bVar2;
          iVar15 = (uint)bVar1 * 0x156;
          iVar12 = (uint)bVar6 * 2;
          pbVar11[1] = (byte)(iVar15 + (uint)bVar2 * 0xab >> 9);
          pbVar11[2] = (byte)(iVar15 + (uint)bVar3 * 0xab >> 9);
          iVar15 = (uint)bVar4 * 0x156;
          pbVar16 = pbVar11 + *(uint *)(param_1 + 0x1ed8);
          *pbVar16 = (byte)((uint)bVar2 * 0xab + iVar15 >> 9);
          pbVar16[1] = (byte)(((uint)bVar2 + ((uint)bVar4 + (uint)bVar1 + iVar12) * 2) * 0x39 >> 9);
          pbVar16[2] = (byte)(((uint)bVar3 + ((uint)bVar1 + (uint)bVar5 + iVar12) * 2) * 0x39 >> 9);
          pbVar16 = pbVar13 + (*(int *)(param_1 + 0x1ed0) * 2 + 0x10);
          pbVar13 = pbVar13 + 2;
          bVar1 = *pbVar16;
          bVar2 = pbVar16[1];
          bVar3 = pbVar16[2];
          pbVar16 = pbVar11 + (uint)(*(int *)(param_1 + 0x1ed8) * 2);
          *pbVar16 = (byte)(iVar15 + (uint)bVar1 * 0xab >> 9);
          pbVar16[1] = (byte)(((uint)bVar1 + ((uint)bVar4 + (uint)bVar2 + iVar12) * 2) * 0x39 >> 9);
          pbVar11 = pbVar11 + 3;
          pbVar16[2] = (byte)(((uint)bVar3 + (iVar12 + (uint)bVar5 + (uint)bVar2) * 2) * 0x39 >> 9);
          if (pbVar11 == pbVar17) break;
          uVar19 = *(uint *)(param_1 + 0x1ed0);
        }
      }
      uVar18 = uVar18 + 2;
    } while (uVar18 < *(uint *)(param_1 + 0x1ed4));
  }
  return;
}


==================================================================

### FUNC 001105d0 (1436 bytes) name=FUN_001105d0

void FUN_001105d0(long param_1)

{
  void *pvVar1;
  byte bVar2;
  byte bVar3;
  byte bVar4;
  byte bVar5;
  byte bVar6;
  byte bVar7;
  byte bVar8;
  byte bVar9;
  undefined1 uVar10;
  uint uVar11;
  ulong uVar12;
  void *pvVar13;
  long lVar14;
  byte *pbVar15;
  byte *pbVar16;
  int iVar17;
  size_t __n;
  uint uVar18;
  void *__src;
  uint uVar19;
  uint uVar20;
  byte *pbVar21;
  uint uVar22;
  int iVar23;
  int iVar24;
  uint uVar25;
  int iVar26;
  byte *pbVar27;
  uint local_44;
  
  uVar25 = 0;
  __src = *(void **)(param_1 + 0x298);
  uVar11 = *(uint *)(param_1 + 0x1ed0) + 8;
  uVar12 = (ulong)uVar11;
  pvVar1 = (void *)(((ulong)(uint)((*(int *)(param_1 + 0x1edc) + 3) * *(int *)(param_1 + 0x1ed8)) -
                    (ulong)((*(int *)(param_1 + 0x1ed4) + 1) * uVar11)) + *(long *)(param_1 + 0x200)
                   );
  __n = (size_t)*(uint *)(param_1 + 0x1ed0);
  pvVar13 = pvVar1;
  if (*(int *)(param_1 + 0x1ed4) != 0) {
    do {
      pvVar13 = memcpy(pvVar13,__src,__n);
      uVar11 = *(uint *)(param_1 + 0x1ed0);
      iVar17 = (uint)*(byte *)((long)__src + (ulong)(uVar11 - 1)) * 2 -
               (uint)*(byte *)((long)__src + (ulong)(uVar11 - 2));
      if (iVar17 < 0) {
        iVar17 = 0;
      }
      uVar10 = 0xff;
      if (iVar17 < 0x100) {
        uVar10 = (undefined1)iVar17;
      }
      uVar25 = uVar25 + 1;
      *(undefined1 *)((long)pvVar13 + (ulong)uVar11) = uVar10;
      __n = (size_t)*(uint *)(param_1 + 0x1ed0);
      __src = (void *)((long)__src + __n);
      uVar12 = (ulong)(*(uint *)(param_1 + 0x1ed0) + 8);
      pvVar13 = (void *)((long)pvVar13 + uVar12);
    } while (uVar25 < *(uint *)(param_1 + 0x1ed4));
  }
  lVar14 = 0;
  if ((int)__n != -1) {
    do {
      iVar17 = (uint)*(byte *)((long)pvVar13 + (lVar14 - uVar12)) * 2 -
               (uint)*(byte *)((long)pvVar13 + lVar14 + uVar12 * -2);
      if (iVar17 < 0) {
        iVar17 = 0;
      }
      uVar10 = (undefined1)iVar17;
      if (0xff < iVar17) {
        uVar10 = 0xff;
      }
      *(undefined1 *)((long)pvVar13 + lVar14) = uVar10;
      lVar14 = lVar14 + 1;
    } while (lVar14 != __n + 1);
  }
  local_44 = 0;
  if (*(int *)(param_1 + 0x1ed4) != 0) {
    do {
      uVar11 = *(uint *)(param_1 + 0x1ed0);
      pbVar15 = (byte *)((ulong)((uVar11 + 8) * local_44) + (long)pvVar1);
      pbVar27 = (byte *)((ulong)(((local_44 * 5) / 3) * *(int *)(param_1 + 0x1ed8)) +
                        *(long *)(param_1 + 0x200));
      if (uVar11 / 3 != 0) {
        pbVar16 = pbVar15 + (ulong)(uVar11 / 3 - 1) * 3 + 3;
        while( true ) {
          pbVar21 = pbVar15 + (ulong)uVar11 + 8;
          bVar2 = pbVar15[1];
          bVar3 = *pbVar15;
          bVar4 = pbVar15[2];
          bVar5 = pbVar15[3];
          bVar6 = pbVar21[1];
          uVar11 = (uint)bVar6;
          bVar7 = *pbVar21;
          bVar8 = pbVar21[2];
          bVar9 = pbVar21[3];
          iVar17 = (uint)bVar3 * 0x19a;
          *pbVar27 = bVar3;
          uVar20 = (uint)bVar9;
          pbVar27[1] = (byte)((uint)bVar2 * 0x267 + iVar17 >> 10);
          pbVar27[2] = (byte)((uint)bVar2 * 0x334 + (uint)bVar4 * 0xcd >> 10);
          pbVar27[3] = (byte)((uint)bVar2 * 0xcd + (uint)bVar4 * 0x334 >> 10);
          pbVar27[4] = (byte)((uint)bVar4 * 0x267 + (uint)bVar5 * 0x19a >> 10);
          pbVar21 = pbVar27 + *(uint *)(param_1 + 0x1ed8);
          *pbVar21 = (byte)(iVar17 + (uint)bVar7 * 0x267 >> 10);
          iVar23 = (uint)bVar8 * 0x7b;
          iVar17 = (uint)bVar6 * 0x7b;
          iVar26 = (uint)bVar8 * 0x1ec;
          pbVar21[1] = (byte)((uint)bVar3 * 0xa4 + (uint)bVar6 * 0x171 +
                              ((uint)bVar7 + (uint)bVar2) * 0xf6 >> 10);
          pbVar21[2] = (byte)(((uint)bVar4 + (uint)bVar2 * 4 + ((uint)bVar6 + (uint)bVar6 * 2) * 2)
                              * 0x52 + iVar23 >> 10);
          pbVar21[3] = (byte)(iVar26 + iVar17 + ((uint)bVar2 + (uint)bVar4 * 4) * 0x52 >> 10);
          pbVar21[4] = (byte)((bVar4 + uVar20) * 0xf6 + (uint)bVar5 * 0xa4 + (uint)bVar8 * 0x171 >>
                             10);
          pbVar21 = pbVar15 + (*(int *)(param_1 + 0x1ed0) * 2 + 0x10);
          bVar2 = pbVar21[1];
          bVar3 = *pbVar21;
          uVar25 = (uint)pbVar21[2];
          iVar24 = (uint)bVar2 * 0x7b;
          uVar18 = (uint)pbVar21[3];
          pbVar21 = pbVar27 + (uint)(*(int *)(param_1 + 0x1ed8) * 2);
          *pbVar21 = (byte)((uint)bVar7 * 0x334 + (uint)bVar3 * 0xcd >> 10);
          uVar22 = (uint)bVar7;
          pbVar21[1] = (byte)((uint)bVar3 * 0x52 + (uint)bVar6 * 0x1ec + uVar22 * 0x148 + iVar24 >>
                             10);
          pbVar21[2] = (byte)((uVar25 + ((uint)bVar2 + (uint)bVar8 + uVar11 * 4) * 4) * 0x29 >> 10);
          pbVar21[3] = (byte)(((uint)bVar2 + (uVar25 + uVar11 + (uint)bVar8 * 4) * 4) * 0x29 >> 10);
          pbVar21[4] = (byte)(iVar26 + uVar20 * 0x148 + uVar18 * 0x52 + uVar25 * 0x7b >> 10);
          pbVar21 = pbVar27 + (uint)(*(int *)(param_1 + 0x1ed8) * 3);
          uVar19 = (uint)bVar3;
          *pbVar21 = (byte)(uVar22 * 0xcd + uVar19 * 0x334 >> 10);
          iVar26 = (uint)bVar2 * 0x1ec;
          pbVar21[1] = (byte)(uVar19 * 0x148 + uVar22 * 0x52 + iVar17 + iVar26 >> 10);
          pbVar21[2] = (byte)(((uint)bVar8 + (uVar25 + uVar11 + (uint)bVar2 * 4) * 4) * 0x29 >> 10);
          pbVar21[3] = (byte)((uVar11 + ((uint)bVar2 + (uint)bVar8 + uVar25 * 4) * 4) * 0x29 >> 10);
          pbVar21[4] = (byte)(uVar20 * 0x52 + iVar23 + uVar18 * 0x148 + uVar25 * 0x1ec >> 10);
          pbVar21 = pbVar15 + (*(int *)(param_1 + 0x1ed0) * 3 + 0x18);
          bVar3 = pbVar21[1];
          bVar4 = *pbVar21;
          bVar5 = pbVar21[2];
          bVar6 = pbVar21[3];
          pbVar21 = pbVar27 + (uint)(*(int *)(param_1 + 0x1ed8) << 2);
          *pbVar21 = (byte)(uVar19 * 0x267 + (uint)bVar4 * 0x19a >> 10);
          pbVar15 = pbVar15 + 3;
          pbVar21[1] = (byte)((uint)bVar4 * 0xa4 + (uint)bVar2 * 0x171 + (uVar19 + bVar3) * 0xf6 >>
                             10);
          pbVar27 = pbVar27 + 5;
          pbVar21[2] = (byte)(iVar26 + uVar25 * 0x7b + ((uint)bVar5 + (uint)bVar3 * 4) * 0x52 >> 10)
          ;
          pbVar21[3] = (byte)(uVar25 * 0x1ec + iVar24 + ((uint)bVar3 + (uint)bVar5 * 4) * 0x52 >> 10
                             );
          pbVar21[4] = (byte)(uVar25 * 0x171 + (uint)bVar6 * 0xa4 + (bVar5 + uVar18) * 0xf6 >> 10);
          if (pbVar15 == pbVar16) break;
          uVar11 = *(uint *)(param_1 + 0x1ed0);
        }
      }
      local_44 = local_44 + 3;
    } while (local_44 < *(uint *)(param_1 + 0x1ed4));
  }
  return;
}


==================================================================

### FUNC 00110b70 (1030 bytes) name=FUN_00110b70

ulong FUN_00110b70(long param_1)

{
  int iVar1;
  byte *pbVar2;
  byte *pbVar3;
  byte *pbVar4;
  byte bVar5;
  byte bVar6;
  byte bVar7;
  int iVar8;
  int iVar9;
  ulong uVar10;
  int iVar11;
  long lVar12;
  uint uVar13;
  long lVar14;
  long lVar15;
  long lVar16;
  int iVar17;
  int iVar18;
  int iVar19;
  int iVar20;
  int iVar21;
  int local_4c;
  int local_48;
  
  iVar8 = *(int *)(param_1 + 0x1ed0);
  iVar9 = *(int *)(param_1 + 0x1ed4);
  iVar11 = iVar8 * 2;
  lVar14 = *(long *)(param_1 + 0x298);
  lVar12 = *(long *)(param_1 + 0x200);
  if (iVar9 < 2) {
    iVar19 = (iVar8 + -1) * 2;
  }
  else {
    local_48 = 1;
    local_4c = 0;
    do {
      iVar18 = local_4c * iVar8;
      iVar19 = 0;
      iVar21 = 2;
      if (2 < iVar8) {
        do {
          iVar17 = (iVar19 >> 1) + iVar18;
          lVar15 = (long)(iVar19 + iVar18);
          pbVar2 = (byte *)(lVar14 + 1 + lVar15);
          pbVar3 = (byte *)(lVar14 + 2 + lVar15);
          lVar16 = (long)(iVar19 + iVar18 + iVar8);
          bVar6 = *pbVar2;
          uVar13 = (uint)*(byte *)(lVar14 + lVar15);
          *(uint *)(lVar12 + (long)iVar17 * 4) =
               ((int)((uint)*pbVar3 + (uint)bVar6) >> 1) * 0x1000000 +
               ((int)(uVar13 + bVar6) >> 1) * 0x100 + (uint)bVar6 * 0x10000 + uVar13;
          bVar6 = *(byte *)(lVar14 + lVar15);
          bVar7 = *pbVar2;
          bVar5 = *(byte *)(lVar14 + 1 + lVar16);
          *(int *)(lVar12 + (long)(iVar17 + (iVar8 >> 1)) * 4) =
               ((int)((uint)*pbVar3 + (uint)bVar7 + (uint)bVar5 +
                     (uint)*(byte *)(lVar14 + 2 + lVar16)) >> 2) * 0x1000000 +
               ((int)((uint)bVar6 + (uint)bVar7 + (uint)*(byte *)(lVar14 + lVar16) + (uint)bVar5) >>
               2) * 0x100 +
               ((int)((uint)bVar6 + (uint)*(byte *)(lVar14 + lVar16)) >> 1) +
               ((int)((uint)bVar7 + (uint)bVar5) >> 1) * 0x10000;
          iVar17 = iVar21 + 2;
          iVar19 = iVar21;
          iVar21 = iVar17;
        } while (iVar17 < iVar8);
      }
      iVar18 = iVar18 + iVar8 + -2;
      iVar19 = local_4c * 2 * iVar8 + iVar8 + -2;
      pbVar2 = (byte *)(lVar14 + iVar18);
      pbVar3 = (byte *)(lVar14 + 1 + (long)iVar18);
      bVar6 = *pbVar2;
      *(ushort *)(lVar12 + (long)iVar19 * 2) =
           (ushort)bVar6 + (short)(((int)((uint)*pbVar3 + (uint)bVar6) >> 1) << 8);
      bVar6 = *pbVar2;
      bVar7 = *(byte *)(lVar14 + (iVar18 + iVar8));
      local_4c = local_48;
      *(short *)(lVar12 + (long)(iVar19 + iVar8) * 2) =
           (short)((int)((uint)bVar6 + (uint)bVar7) >> 1) +
           (short)(((int)((uint)*pbVar3 + (uint)bVar6 + (uint)bVar7 +
                         (uint)*(byte *)(lVar14 + 1 + (long)(iVar18 + iVar8))) >> 2) << 8);
      local_48 = local_48 + 1;
    } while (iVar9 != local_48);
    iVar19 = (iVar8 + -1) * 2;
    iVar21 = 0;
    iVar18 = 1;
    do {
      iVar20 = iVar21 * iVar8 + iVar8 + -1;
      iVar21 = iVar21 * 2 * iVar11 + iVar19;
      pbVar2 = (byte *)(lVar14 + iVar20);
      pbVar4 = (byte *)(lVar14 + -1 + (long)iVar20);
      *(byte *)(lVar12 + iVar21) = *pbVar2;
      pbVar3 = (byte *)(lVar14 + (iVar20 + iVar8));
      *(char *)(lVar12 + 1 + (long)iVar21) =
           (char)((int)(uint)*pbVar4 >> 2) + (char)((int)((uint)*pbVar2 + (uint)*pbVar2 * 2) >> 2);
      *(char *)(lVar12 + (iVar21 + iVar11)) = (char)((int)((uint)*pbVar3 + (uint)*pbVar2) >> 1);
      bVar6 = *pbVar3;
      iVar17 = iVar18 + 1;
      *(char *)(lVar12 + 1 + (long)(iVar21 + iVar11)) =
           (char)((int)((uint)*pbVar2 + (uint)*pbVar2 * 2 + (uint)*pbVar4 +
                        (uint)*(byte *)(lVar14 + -1 + (long)(iVar20 + iVar8)) +
                       (uint)bVar6 + (uint)bVar6 * 2) >> 3);
      iVar21 = iVar18;
      iVar18 = iVar17;
    } while (iVar9 != iVar17);
  }
  iVar21 = iVar8 * (iVar9 + -1);
  iVar9 = (iVar9 + -1) * 2;
  if (1 < iVar8) {
    iVar18 = 0;
    iVar17 = 1;
    do {
      iVar1 = iVar18 + iVar21;
      iVar18 = iVar9 * iVar11 + iVar18 * 2;
      pbVar2 = (byte *)(lVar14 + iVar1);
      *(byte *)(lVar12 + iVar18) = *pbVar2;
      pbVar4 = (byte *)(lVar14 + 1 + (long)iVar1);
      pbVar3 = (byte *)(lVar14 + (iVar1 - iVar8));
      *(char *)(lVar12 + 1 + (long)iVar18) = (char)((int)((uint)*pbVar4 + (uint)*pbVar2) >> 1);
      *(char *)(lVar12 + (iVar18 + iVar11)) =
           (char)((int)(uint)*pbVar3 >> 2) + (char)((int)((uint)*pbVar2 + (uint)*pbVar2 * 2) >> 2);
      bVar6 = *pbVar4;
      iVar20 = iVar17 + 1;
      *(char *)(lVar12 + 1 + (long)(iVar18 + iVar11)) =
           (char)((int)((uint)*pbVar2 + (uint)*pbVar2 * 2 + (uint)*pbVar3 +
                        (uint)*(byte *)(lVar14 + 1 + (long)(iVar1 - iVar8)) +
                       (uint)bVar6 + (uint)bVar6 * 2) >> 3);
      iVar18 = iVar17;
      iVar17 = iVar20;
    } while (iVar8 != iVar20);
  }
  iVar21 = iVar8 + -1 + iVar21;
  iVar19 = iVar19 + iVar9 * iVar11;
  lVar14 = (long)iVar21;
  lVar12 = (long)iVar19;
  *(undefined1 *)(*(long *)(param_1 + 0x200) + lVar12) =
       *(undefined1 *)(*(long *)(param_1 + 0x298) + lVar14);
  bVar6 = *(byte *)(*(long *)(param_1 + 0x298) + lVar14);
  *(char *)(*(long *)(param_1 + 0x200) + 1 + lVar12) =
       (char)((int)((uint)bVar6 + (uint)bVar6 * 2 +
                   (uint)*(byte *)(*(long *)(param_1 + 0x298) + -1 + lVar14)) >> 2);
  lVar15 = (long)(iVar11 + iVar19);
  bVar6 = *(byte *)(*(long *)(param_1 + 0x298) + lVar14);
  *(char *)(*(long *)(param_1 + 0x200) + lVar15) =
       (char)((int)((uint)bVar6 + (uint)bVar6 * 2 +
                   (uint)*(byte *)(*(long *)(param_1 + 0x298) + (long)(iVar21 - iVar8))) >> 2);
  lVar14 = *(long *)(param_1 + 0x200);
  uVar10 = (long)(int)((uint)*(byte *)(lVar14 + lVar15) +
                      (uint)*(byte *)(lVar14 + lVar12) + (uint)*(byte *)(lVar14 + 1 + lVar12)) *
           0x55555556;
  *(char *)(lVar14 + 1 + lVar15) = (char)(uVar10 >> 0x20);
  return uVar10 & 0xffffffff;
}


==================================================================

### FUNC 00110f90 (668 bytes) name=FUN_00110f90

void FUN_00110f90(long param_1)

{
  uint uVar1;
  uint uVar2;
  uint uVar3;
  uint uVar4;
  long lVar5;
  int iVar6;
  float fVar7;
  float fVar8;
  uint uVar9;
  undefined1 uVar10;
  ulong uVar11;
  ulong uVar12;
  int iVar13;
  ulong uVar14;
  uint uVar15;
  uint uVar16;
  int iVar17;
  float fVar18;
  float fVar19;
  float fVar20;
  float fVar21;
  float fVar22;
  
  fVar8 = DAT_00131e4c;
  fVar7 = DAT_00131e20;
  uVar1 = *(uint *)(param_1 + 0x1ed0);
  uVar2 = *(uint *)(param_1 + 0x1ed4);
  uVar3 = *(uint *)(param_1 + 0x1ed8);
  uVar4 = *(uint *)(param_1 + 0x1edc);
  if (uVar3 != 0) {
    uVar12 = 0;
    fVar22 = (float)uVar1 - DAT_00131e20;
    do {
      iVar17 = (int)uVar12;
      fVar21 = (float)uVar12 * ((float)uVar1 / (float)uVar3);
      fVar20 = fVar22;
      if (fVar21 <= fVar22) {
        fVar20 = fVar21;
      }
      iVar13 = (int)(long)fVar20;
      uVar14 = (long)fVar20 & 0xffffffff;
      if (uVar4 != 0) {
        uVar9 = 0;
        fVar21 = (float)uVar2 - fVar7;
        do {
          fVar18 = (float)uVar9 * ((float)uVar2 / (float)uVar4);
          fVar19 = fVar21;
          if (fVar18 <= fVar21) {
            fVar19 = fVar18;
          }
          uVar11 = (ulong)fVar19;
          iVar6 = (int)uVar11;
          uVar15 = iVar6 + 1;
          if (iVar13 + 1U < uVar1) {
            if (uVar15 < uVar2) {
              lVar5 = *(long *)(param_1 + 0x298);
              uVar15 = uVar1 * iVar6 + iVar13;
              fVar18 = fVar20 - (float)uVar14;
              fVar19 = fVar19 - (float)(uVar11 & 0xffffffff);
              uVar15 = (uint)(long)(((float)*(byte *)(lVar5 + (ulong)uVar15) * (fVar7 - fVar18) +
                                    (float)*(byte *)(lVar5 + (ulong)(uVar15 + 1)) * fVar18) *
                                    (fVar7 - fVar19) +
                                    ((float)*(byte *)(lVar5 + (ulong)(uVar15 + uVar1)) *
                                     (fVar7 - fVar18) +
                                    (float)*(byte *)(lVar5 + (ulong)(uVar15 + uVar1 + 1)) * fVar18)
                                    * fVar19 + fVar8);
            }
            else {
              if (uVar2 != uVar15) goto LAB_00111080;
              uVar15 = iVar6 * uVar1 + iVar13;
              uVar16 = (uint)*(byte *)(*(long *)(param_1 + 0x298) + (ulong)uVar15);
              uVar15 = (uint)(long)((float)uVar16 +
                                    (float)(int)(*(byte *)(*(long *)(param_1 + 0x298) +
                                                          (ulong)(uVar15 + 1)) - uVar16) *
                                    (fVar20 - (float)uVar14) + fVar8);
            }
LAB_001111bd:
            uVar10 = (undefined1)uVar15;
            if (0xff < uVar15) {
              uVar10 = 0xff;
            }
            *(undefined1 *)(*(long *)(param_1 + 0x200) + uVar12) = uVar10;
          }
          else {
            if ((uVar1 == iVar13 + 1U) && (uVar15 < uVar2)) {
              uVar16 = (uint)*(byte *)(*(long *)(param_1 + 0x298) + (ulong)(uVar1 * iVar6 + iVar13))
              ;
              uVar15 = (uint)(long)((float)uVar16 +
                                    (float)(int)(*(byte *)(*(long *)(param_1 + 0x298) +
                                                          (ulong)(uVar15 * uVar1 + iVar13)) - uVar16
                                                ) * (fVar19 - (float)(uVar11 & 0xffffffff)) + fVar8)
              ;
              goto LAB_001111bd;
            }
LAB_00111080:
            *(undefined1 *)(*(long *)(param_1 + 0x200) + uVar12) =
                 *(undefined1 *)(*(long *)(param_1 + 0x298) + (ulong)(iVar6 * uVar1 + iVar13));
          }
          uVar9 = uVar9 + 1;
          uVar12 = (ulong)((int)uVar12 + uVar3);
        } while (uVar9 != uVar4);
      }
      uVar9 = iVar17 + 1;
      uVar12 = (ulong)uVar9;
    } while (uVar9 != uVar3);
  }
  return;
}


==================================================================

### FUNC 00111240 (464 bytes) name=FUN_00111240

void FUN_00111240(long param_1,int param_2)

{
  int iVar1;
  uint uVar2;
  uint uVar3;
  
  if (param_2 == 0) {
    if (*(int *)(param_1 + 0x214) == 0) {
      return;
    }
  }
  else {
    pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0x218));
    if (*(int *)(param_1 + 0x214) == 0) {
      pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0x218));
      return;
    }
  }
  FUN_0010be80(param_1);
  if (((*(int *)(param_1 + 0x1f4c) != 0) && (*(int *)(param_1 + 0x2c) != 0)) &&
     ((*(int *)(param_1 + 0x28) == 0 || (*(int *)(param_1 + 0x10) != 0)))) {
    iVar1 = *(int *)(param_1 + 0x2c) * 8;
    if (*(int *)(param_1 + 0x68) == 0) {
      if (iVar1 != 0) {
        FUN_0010f400(param_1);
      }
    }
    else if (iVar1 != 0) {
      FUN_0010f730(param_1);
    }
  }
  if (*(long *)(param_1 + 0x1ed8) == *(long *)(param_1 + 0x1ed0)) {
    memcpy(*(void **)(param_1 + 0x200),*(void **)(param_1 + 0x298),
           (ulong)*(uint *)(param_1 + 0x77f8));
  }
  else {
    uVar2 = *(uint *)(param_1 + 0x1ed0);
    uVar3 = *(uint *)(param_1 + 0x1ed8);
    if ((uVar3 == uVar2 * 2) && (*(int *)(param_1 + 0x1edc) == *(int *)(param_1 + 0x1ed4) * 2)) {
      FUN_00110b70(param_1);
    }
    else if ((uVar3 * 2 == uVar2 * 3) &&
            (*(int *)(param_1 + 0x1edc) * 2 == *(int *)(param_1 + 0x1ed4) * 3)) {
      FUN_00110320(param_1);
    }
    else if ((uVar3 * 3 == uVar2 * 5) &&
            (*(int *)(param_1 + 0x1edc) * 3 == *(int *)(param_1 + 0x1ed4) * 5)) {
      FUN_001105d0(param_1);
    }
    else if ((uVar2 < uVar3) && (*(uint *)(param_1 + 0x1ed4) < *(uint *)(param_1 + 0x1edc))) {
      FUN_00110f90(param_1);
    }
  }
  if (param_2 == 0) {
    return;
  }
  pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0x218));
  return;
}


==================================================================

### FUNC 00111440 (266 bytes) name=FUN_00111440

void FUN_00111440(long param_1,int param_2)

{
  int iVar1;
  long lVar2;
  undefined2 *puVar3;
  int iVar4;
  long lVar5;
  undefined2 *puVar6;
  undefined2 *puVar7;
  int iVar8;
  undefined2 *puVar9;
  int iVar10;
  
  if (param_2 == 1) {
    memcpy(*(void **)(param_1 + 0x290),*(void **)(param_1 + 0x268),
           (ulong)*(uint *)(param_1 + 0x77f8) * 2);
    iVar4 = *(int *)(param_1 + 0x1ed4);
    iVar10 = *(int *)(param_1 + 0x1ed0);
    puVar7 = *(undefined2 **)(param_1 + 0x290);
    iVar1 = (iVar4 + -1) * iVar10;
    puVar9 = (undefined2 *)(*(long *)(param_1 + 0x268) + (long)iVar1 * 2);
    if (iVar10 != 0) {
      iVar8 = iVar4 + 3;
      if (-1 < iVar4) {
        iVar8 = iVar4;
      }
      iVar1 = iVar1 + iVar10;
      iVar8 = iVar8 >> 2;
      lVar2 = (long)iVar10;
      lVar5 = (ulong)(iVar8 - 1) + 1;
      do {
        puVar3 = puVar7;
        puVar6 = puVar9;
        iVar4 = iVar8;
        if (iVar8 != 0) {
          do {
            *puVar6 = *puVar3;
            puVar6[-lVar2] = puVar3[1];
            puVar6[lVar2 * -2] = puVar3[2];
            puVar6[lVar2 * -3] = puVar3[3];
            iVar4 = iVar4 + -1;
            puVar3 = puVar3 + 4;
            puVar6 = puVar6 + lVar2 * -4;
          } while (iVar4 != 0);
          puVar7 = puVar7 + lVar5 * 4;
          puVar9 = (undefined2 *)((long)puVar9 + lVar2 * -8 * lVar5);
        }
        puVar9 = puVar9 + (long)iVar1 + 1;
        iVar10 = iVar10 + -1;
      } while (iVar10 != 0);
    }
    return;
  }
  return;
}


==================================================================

### FUNC 00111560 (444 bytes) name=FUN_00111560

void FUN_00111560(long param_1,uint param_2)

{
  void *__dest;
  int iVar1;
  uint uVar2;
  size_t __n;
  uint *puVar3;
  uint *puVar4;
  int iVar5;
  uint *puVar6;
  int iVar7;
  void *__src;
  long lVar8;
  int iVar9;
  long lVar10;
  undefined1 local_838 [2056];
  
  iVar1 = *(int *)(param_1 + 0x1ed0);
  iVar7 = *(int *)(param_1 + 0x1ed4);
  if (((param_2 & 2) != 0) && (0 < iVar7 / 2)) {
    lVar10 = 0;
    __n = (long)iVar1 * 2;
    lVar8 = (long)((iVar7 + -1) * iVar1) * 2;
    iVar9 = 0;
    do {
      iVar9 = iVar9 + 1;
      __dest = (void *)(*(long *)(param_1 + 0x268) + lVar10);
      __src = (void *)(*(long *)(param_1 + 0x268) + lVar8);
      lVar10 = lVar10 + __n;
      __memcpy_chk(local_838,__dest,__n,0x800);
      memcpy(__dest,__src,__n);
      memcpy(__src,local_838,__n);
      lVar8 = lVar8 + (long)-iVar1 * 2;
    } while (iVar9 != iVar7 / 2);
  }
  if (((param_2 & 1) != 0) && (iVar7 = iVar7 + -1, -1 < iVar7)) {
    iVar9 = iVar1 + 3;
    if (-1 < iVar1) {
      iVar9 = iVar1;
    }
    lVar8 = (long)((iVar9 >> 2) * 2);
    puVar6 = (uint *)(*(long *)(param_1 + 0x268) + -4 + ((long)(iVar1 * iVar7) + lVar8 * 2) * 2);
    do {
      puVar3 = puVar6 + (1 - lVar8);
      puVar4 = puVar6;
      for (iVar5 = iVar9 >> 2; iVar5 != 0; iVar5 = iVar5 + -1) {
        uVar2 = *puVar4;
        *puVar4 = *puVar3 >> 0x10 | *puVar3 << 0x10;
        *puVar3 = uVar2 >> 0x10 | uVar2 << 0x10;
        puVar3 = puVar3 + 1;
        puVar4 = puVar4 + -1;
      }
      iVar7 = iVar7 + -1;
      puVar6 = (uint *)((long)puVar6 + (long)-iVar1 * 2);
    } while (iVar7 != -1);
  }
  return;
}


==================================================================

### FUNC 00111720 (1221 bytes) name=FUN_00111720

undefined8 FUN_00111720(long param_1,void *param_2,int param_3,int param_4,int param_5,int param_6)

{
  pthread_mutex_t *__mutex;
  ushort uVar1;
  uint uVar2;
  undefined2 uVar3;
  uint uVar4;
  long lVar5;
  long lVar6;
  int iVar7;
  ushort *puVar8;
  
  __mutex = (pthread_mutex_t *)(param_1 + 0x218);
  pthread_mutex_lock(__mutex);
  lVar5 = FUN_00113bc0();
  if ((*(int *)(param_1 + 0x208) == 0) || (param_2 == (void *)0x0)) {
LAB_00111824:
    pthread_mutex_unlock(__mutex);
    return 0;
  }
  if (param_3 == 0) {
    if (*(int *)(param_1 + 0x20c) == 0) goto LAB_00111824;
    *(undefined4 *)(param_1 + 0x1f4c) = 0;
    *(undefined4 *)(param_1 + 0x1f50) = 0;
    *(undefined4 *)(param_1 + 0x1f54) = 0;
    FUN_0010eab0(param_1);
    if (*(int *)(param_1 + 0x1f14) != 0) goto LAB_00111855;
    if ((*(int *)(param_1 + 0x1f18) == 0) || (*(int *)(param_1 + 0x1f0c) == 0)) {
      FUN_0010b620(param_1);
      pthread_mutex_unlock(__mutex);
      return 0;
    }
    *(undefined4 *)(param_1 + 0x1f18) = 0;
    *(undefined8 *)(param_1 + 0x268) = *(undefined8 *)(param_1 + 0x260);
  }
  else {
    *(undefined4 *)(param_1 + 0x1f4c) = 0;
    *(undefined4 *)(param_1 + 0x1f50) = 0;
    *(undefined4 *)(param_1 + 0x1f54) = 0;
    if (param_3 != 1) goto LAB_00111824;
    memcpy(*(void **)(param_1 + 600),param_2,(ulong)*(uint *)(param_1 + 0x77f8) * 2);
LAB_00111855:
    *(undefined4 *)(param_1 + 0x1f14) = 0;
    *(undefined8 *)(param_1 + 0x268) = *(undefined8 *)(param_1 + 600);
  }
  *(undefined4 *)(param_1 + 0x4b60) = 0;
  if (*(int *)(param_1 + 0x84) != 0) {
    FUN_00111440(param_1);
  }
  if (*(int *)(param_1 + 0x80) != 0) {
    FUN_00111560(param_1);
  }
  if ((*(int *)(param_1 + 0x58) == 0) && (param_4 == 0)) {
    if (*(int *)(param_1 + 100) != 0) {
      iVar7 = *(int *)(param_1 + 0x77f8);
      puVar8 = *(ushort **)(param_1 + 0x268);
      uVar1 = *puVar8;
      uVar4 = (uint)uVar1;
      if (iVar7 != 0) {
        while( true ) {
          if ((ushort)uVar4 < uVar1) {
            uVar4 = (uint)uVar1;
          }
          iVar7 = iVar7 + -1;
          if (iVar7 == 0) break;
          uVar1 = puVar8[1];
          puVar8 = puVar8 + 1;
        }
      }
      *(uint *)(param_1 + 0x1f20) = uVar4;
    }
    *(undefined4 *)(param_1 + 0x1f48) = 0;
    goto LAB_001118f3;
  }
  if ((param_5 == 0) && (1 < *(uint *)(param_1 + 0x1ef0))) {
    uVar3 = FUN_0010a4b0(param_1,30000,*(undefined4 *)(param_1 + 0x38));
    FUN_0011a140(param_1 + 0x1e50,*(undefined8 *)(param_1 + 0x268),uVar3);
    *(undefined4 *)(param_1 + 0x1f48) = 1;
  }
  else {
    *(undefined4 *)(param_1 + 0x1f48) = 0;
  }
  if (*(int *)(param_1 + 0x210) != 0) {
    FUN_0010eda0(param_1);
  }
  if (param_6 != 0) {
    iVar7 = *(int *)(param_1 + 0x1ef8);
    if (iVar7 == 1) {
      FUN_0010fa90(param_1);
    }
    else if (iVar7 == 2) {
LAB_00111bbf:
      FUN_0010fc40(param_1);
    }
    else if (iVar7 == 3) {
      FUN_0010fa90(param_1);
      FUN_0010fc40(param_1);
    }
    else if (iVar7 == 4) {
      FUN_0010fc40(param_1);
      goto LAB_00111bbf;
    }
  }
  FUN_001089d0(param_1,*(undefined8 *)(param_1 + 0x268));
  FUN_0010be80(param_1);
  if (((*(int *)(param_1 + 0x1f4c) != 0) && (*(int *)(param_1 + 0x2c) != 0)) &&
     ((*(int *)(param_1 + 0x28) == 0 || (*(int *)(param_1 + 0x10) != 0)))) {
    iVar7 = *(int *)(param_1 + 0x2c) * 8;
    if (*(int *)(param_1 + 0x68) == 0) {
      if (iVar7 != 0) {
        FUN_0010f400(param_1);
      }
    }
    else if (iVar7 != 0) {
      FUN_0010f730(param_1);
    }
  }
  if (param_4 != 0) {
    if (*(long *)(param_1 + 0x1ed8) == *(long *)(param_1 + 0x1ed0)) {
      memcpy(*(void **)(param_1 + 0x200),*(void **)(param_1 + 0x298),
             (ulong)*(uint *)(param_1 + 0x77f8));
    }
    else {
      uVar4 = *(uint *)(param_1 + 0x1ed0);
      uVar2 = *(uint *)(param_1 + 0x1ed8);
      if ((uVar2 == uVar4 * 2) && (*(int *)(param_1 + 0x1edc) == *(int *)(param_1 + 0x1ed4) * 2)) {
        FUN_00110b70(param_1);
      }
      else if ((uVar2 * 2 == uVar4 * 3) &&
              (*(int *)(param_1 + 0x1edc) * 2 == *(int *)(param_1 + 0x1ed4) * 3)) {
        FUN_00110320(param_1);
      }
      else if ((uVar2 * 3 == uVar4 * 5) &&
              (*(int *)(param_1 + 0x1edc) * 3 == *(int *)(param_1 + 0x1ed4) * 5)) {
        FUN_001105d0(param_1);
      }
      else if ((uVar4 < uVar2) && (*(uint *)(param_1 + 0x1ed4) < *(uint *)(param_1 + 0x1edc))) {
        FUN_00110f90(param_1);
      }
    }
    lVar6 = FUN_00113bc0();
    *(long *)(param_1 + 0x1f58) = lVar6 - lVar5;
    FUN_0010b620(param_1);
    *(undefined4 *)(param_1 + 0x214) = 1;
    pthread_mutex_unlock(__mutex);
    return 3;
  }
LAB_001118f3:
  lVar6 = FUN_00113bc0();
  *(long *)(param_1 + 0x1f58) = lVar6 - lVar5;
  FUN_0010b620(param_1);
  *(undefined4 *)(param_1 + 0x214) = 1;
  pthread_mutex_unlock(__mutex);
  return 1;
}


==================================================================

### FUNC 00111c30 (1646 bytes) name=FUN_00111c30

/* WARNING: Type propagation algorithm not settling */

void FUN_00111c30(undefined8 *param_1)

{
  int iVar1;
  ulong uVar2;
  uint uVar3;
  ulong uVar4;
  char *pcVar5;
  undefined8 *puVar6;
  undefined8 *puVar7;
  long in_FS_OFFSET;
  bool bVar8;
  byte bVar9;
  pthread_mutexattr_t apStack_38 [2];
  long local_30;
  
  bVar9 = 0;
  local_30 = *(long *)(in_FS_OFFSET + 0x28);
  *param_1 = &PTR_FUN_0033ecf0;
  iVar1 = pthread_mutexattr_init(apStack_38);
  if (iVar1 == 0) {
    iVar1 = pthread_mutexattr_settype(apStack_38,1);
    if (iVar1 == 0) {
      iVar1 = pthread_mutex_init((pthread_mutex_t *)(param_1 + 0x43),apStack_38);
      if (iVar1 == 0) {
        iVar1 = pthread_mutexattr_destroy(apStack_38);
        if (iVar1 == 0) {
          FUN_00106a00(param_1 + 0x3b8);
          FUN_00106a00(param_1 + 0x3be);
          FUN_00106a00(param_1 + 0x3c4);
          FUN_00119e90(param_1 + 0x3ca);
          FUN_00119e90(param_1 + 0x3d2);
          puVar7 = param_1 + 1;
          param_1[0x3da] = 0;
          param_1[0x3db] = 0;
          param_1[0x3dc] = 0;
          param_1[0x3dd] = 0;
          uVar4 = 0xac;
          iVar1 = 0xac;
          bVar8 = ((ulong)puVar7 & 1) != 0;
          param_1[0x3de] = 0;
          if (bVar8) {
            puVar7 = (undefined8 *)((long)param_1 + 9);
            *(undefined1 *)(param_1 + 1) = 0;
            uVar4 = 0xab;
            iVar1 = 0xab;
          }
          if (((ulong)puVar7 & 2) == 0) {
            uVar3 = (uint)uVar4;
          }
          else {
            uVar3 = iVar1 - 2;
            uVar4 = (ulong)uVar3;
            *(undefined2 *)puVar7 = 0;
            puVar7 = (undefined8 *)((long)puVar7 + 2);
          }
          if (((ulong)puVar7 & 4) != 0) {
            *(undefined4 *)puVar7 = 0;
            uVar4 = (ulong)(uVar3 - 4);
            puVar7 = (undefined8 *)((long)puVar7 + 4);
          }
          for (uVar2 = uVar4 >> 3; uVar2 != 0; uVar2 = uVar2 - 1) {
            *puVar7 = 0;
            puVar7 = puVar7 + (ulong)bVar9 * -2 + 1;
          }
          if ((uVar4 & 4) != 0) {
            *(undefined4 *)puVar7 = 0;
            puVar7 = (undefined8 *)((long)puVar7 + 4);
          }
          if ((uVar4 & 2) != 0) {
            *(undefined2 *)puVar7 = 0;
            puVar7 = (undefined8 *)((long)puVar7 + 2);
          }
          if (bVar8) {
            *(undefined1 *)puVar7 = 0;
          }
          param_1[0xeff] = 0;
          *(undefined4 *)(param_1 + 0xf00) = 0;
          memset(param_1 + 0x3e1,0,0x2c78);
          memset(param_1 + 0x970,0,0x2c78);
          puVar7 = param_1 + 0x265;
          uVar4 = 0x438;
          iVar1 = 0x438;
          bVar8 = ((ulong)puVar7 & 1) != 0;
          if (bVar8) {
            puVar7 = (undefined8 *)((long)param_1 + 0x1329);
            *(undefined1 *)(param_1 + 0x265) = 0;
            uVar4 = 0x437;
            iVar1 = 0x437;
          }
          puVar6 = puVar7;
          if (((ulong)puVar7 & 2) != 0) {
            puVar6 = (undefined8 *)((long)puVar7 + 2);
            uVar4 = (ulong)(iVar1 - 2);
            *(undefined2 *)puVar7 = 0;
          }
          if (((ulong)puVar6 & 4) != 0) {
            *(undefined4 *)puVar6 = 0;
            uVar4 = (ulong)((int)uVar4 - 4);
            puVar6 = (undefined8 *)((long)puVar6 + 4);
          }
          for (uVar2 = uVar4 >> 3; uVar2 != 0; uVar2 = uVar2 - 1) {
            *puVar6 = 0;
            puVar6 = puVar6 + (ulong)bVar9 * -2 + 1;
          }
          if ((uVar4 & 4) != 0) {
            *(undefined4 *)puVar6 = 0;
            puVar6 = (undefined8 *)((long)puVar6 + 4);
          }
          if ((uVar4 & 2) != 0) {
            *(undefined2 *)puVar6 = 0;
            puVar6 = (undefined8 *)((long)puVar6 + 2);
          }
          if (bVar8) {
            *(undefined1 *)puVar6 = 0;
          }
          puVar7 = param_1 + 0x2ec;
          uVar4 = 0x65c;
          iVar1 = 0x65c;
          bVar8 = ((ulong)puVar7 & 1) != 0;
          if (bVar8) {
            puVar7 = (undefined8 *)((long)param_1 + 0x1761);
            *(undefined1 *)(param_1 + 0x2ec) = 0;
            uVar4 = 0x65b;
            iVar1 = 0x65b;
          }
          puVar6 = puVar7;
          if (((ulong)puVar7 & 2) != 0) {
            puVar6 = (undefined8 *)((long)puVar7 + 2);
            uVar4 = (ulong)(iVar1 - 2);
            *(undefined2 *)puVar7 = 0;
          }
          if (((ulong)puVar6 & 4) != 0) {
            *(undefined4 *)puVar6 = 0;
            uVar4 = (ulong)((int)uVar4 - 4);
            puVar6 = (undefined8 *)((long)puVar6 + 4);
          }
          for (uVar2 = uVar4 >> 3; uVar2 != 0; uVar2 = uVar2 - 1) {
            *puVar6 = 0;
            puVar6 = puVar6 + (ulong)bVar9 * -2 + 1;
          }
          if ((uVar4 & 4) != 0) {
            *(undefined4 *)puVar6 = 0;
            puVar6 = (undefined8 *)((long)puVar6 + 4);
          }
          if ((uVar4 & 2) != 0) {
            *(undefined2 *)puVar6 = 0;
            puVar6 = (undefined8 *)((long)puVar6 + 2);
          }
          if (bVar8) {
            *(undefined1 *)puVar6 = 0;
          }
          puVar7 = (undefined8 *)((long)param_1 + 0xb4);
          param_1[0x3df] = 0;
          *(undefined4 *)(param_1 + 0x3e0) = 0;
          uVar4 = 0x2c;
          iVar1 = 0x2c;
          bVar8 = ((ulong)puVar7 & 1) != 0;
          if (bVar8) {
            puVar7 = (undefined8 *)((long)param_1 + 0xb5);
            *(undefined1 *)((long)param_1 + 0xb4) = 0;
            uVar4 = 0x2b;
            iVar1 = 0x2b;
          }
          if (((ulong)puVar7 & 2) == 0) {
            uVar3 = (uint)uVar4;
            puVar6 = puVar7;
          }
          else {
            puVar6 = (undefined8 *)((long)puVar7 + 2);
            uVar3 = iVar1 - 2;
            uVar4 = (ulong)uVar3;
            *(undefined2 *)puVar7 = 0;
          }
          if (((ulong)puVar6 & 4) != 0) {
            *(undefined4 *)puVar6 = 0;
            uVar4 = (ulong)(uVar3 - 4);
            puVar6 = (undefined8 *)((long)puVar6 + 4);
          }
          for (uVar2 = uVar4 >> 3; uVar2 != 0; uVar2 = uVar2 - 1) {
            *puVar6 = 0;
            puVar6 = puVar6 + (ulong)bVar9 * -2 + 1;
          }
          if ((uVar4 & 4) != 0) {
            *(undefined4 *)puVar6 = 0;
            puVar6 = (undefined8 *)((long)puVar6 + 4);
          }
          if ((uVar4 & 2) != 0) {
            *(undefined2 *)puVar6 = 0;
            puVar6 = (undefined8 *)((long)puVar6 + 2);
          }
          if (bVar8) {
            *(undefined1 *)puVar6 = 0;
          }
          *(undefined4 *)((long)param_1 + 0xb4) = 0x41200000;
          *(undefined4 *)(param_1 + 0x17) = 0x3f800000;
          *(undefined4 *)((long)param_1 + 0xbc) = 0x41a00000;
          *(undefined4 *)(param_1 + 0x18) = 0x3ecccccd;
          *(undefined4 *)((long)param_1 + 0xc4) = 0x41a00000;
          *(undefined4 *)(param_1 + 0x19) = 0;
          *(undefined4 *)((long)param_1 + 0xcc) = 0;
          *(undefined4 *)(param_1 + 0x1a) = 0;
          *(undefined4 *)((long)param_1 + 0xd4) = 0;
          *(undefined4 *)(param_1 + 0x1b) = 0x3f7fa57f;
          *(undefined4 *)((long)param_1 + 0xdc) = 0x3f800000;
          *(undefined4 *)(param_1 + 0x41) = 0;
          *(undefined4 *)((long)param_1 + 0x20c) = 0;
          *(undefined4 *)((long)param_1 + 0x214) = 0;
          *(undefined4 *)(param_1 + 0x42) = 0;
          param_1[0x48] = 0;
          param_1[0x49] = 0;
          param_1[0x4a] = 0;
          param_1[0x4b] = 0;
          param_1[0x4c] = 0;
          param_1[0x4d] = 0;
          param_1[0x4e] = 0;
          param_1[0x4f] = 0;
          param_1[0x50] = 0;
          param_1[0x53] = 0;
          param_1[0x54] = 0;
          param_1[0x55] = 0;
          param_1[0x51] = 0;
          param_1[0x52] = 0;
          *(undefined4 *)((long)param_1 + 0x7804) = 8;
          *(undefined4 *)(param_1 + 0xf01) = 0xffff3cb0;
          *(undefined4 *)((long)param_1 + 0x780c) = 3;
          *(undefined4 *)(param_1 + 0xf02) = 0;
          *(undefined4 *)((long)param_1 + 0x7814) = 0;
          param_1[0x40] = 0;
          FUN_001079d0(param_1,0);
          FUN_00109d40(param_1,0);
          if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
            return;
          }
                    /* WARNING: Subroutine does not return */
          __stack_chk_fail();
        }
        puVar7 = (undefined8 *)__cxa_allocate_exception(8);
        pcVar5 = "pthread_mutexattr_destroy failed\n";
      }
      else {
        puVar7 = (undefined8 *)__cxa_allocate_exception(8);
        pcVar5 = "pthread_mutex_init failed\n";
      }
    }
    else {
      puVar7 = (undefined8 *)__cxa_allocate_exception(8);
      pcVar5 = "pthread_mutexattr_settype failed\n";
    }
  }
  else {
    puVar7 = (undefined8 *)__cxa_allocate_exception(8);
    pcVar5 = "pthread_mutexattr_init failed\n";
  }
  *puVar7 = pcVar5;
                    /* WARNING: Subroutine does not return */
  __cxa_throw(puVar7,&PTR_vtable_0033ec10,0);
}


==================================================================

### FUNC 00112370 (125 bytes) name=FUN_00112370

void FUN_00112370(undefined8 *param_1)

{
  undefined8 *puVar1;
  
  *param_1 = &PTR_FUN_0033ecf0;
  FUN_001071e0();
  FUN_00119e10(param_1 + 0x3d2);
  puVar1 = param_1 + 0x3ca;
  FUN_00119e10(puVar1);
  do {
    puVar1 = puVar1 + -6;
    (**(code **)*puVar1)(puVar1);
  } while (param_1 + 0x3be != puVar1);
  FUN_00106990(param_1 + 0x3b8);
  pthread_mutex_destroy((pthread_mutex_t *)(param_1 + 0x43));
  return;
}


==================================================================

### FUNC 00112460 (18 bytes) name=FUN_00112460

void FUN_00112460(void *param_1)

{
  FUN_00112370();
  operator_delete(param_1);
  return;
}


==================================================================

### FUNC 00112480 (637 bytes) name=FUN_00112480

undefined8 FUN_00112480(long param_1,int param_2,long param_3)

{
  pthread_mutex_t *__mutex;
  int *piVar1;
  void *__src;
  void *__dest;
  undefined8 uVar2;
  ulong __n;
  uint local_84;
  long local_80;
  undefined2 local_78;
  int local_76;
  undefined2 local_72;
  undefined2 local_70;
  undefined4 local_6e;
  undefined2 local_68;
  undefined2 local_66;
  undefined2 local_62;
  undefined2 local_60;
  undefined2 local_5e;
  undefined2 local_5c;
  undefined1 local_58 [40];
  
  __mutex = (pthread_mutex_t *)(param_1 + 0x218);
  FUN_001161f0(local_58,0x100);
  pthread_mutex_lock(__mutex);
  if ((*(int *)(param_1 + 0x208) == 0) || (*(int *)(param_1 + 0x214) == 0)) {
    uVar2 = 0;
    pthread_mutex_unlock(__mutex);
    piVar1 = __errno_location();
    *piVar1 = -0x1b51fffa;
  }
  else {
    if (param_2 == 1) {
      local_84 = *(uint *)(param_1 + 0x77fc);
      __src = *(void **)(param_1 + 0x200);
      local_80 = param_1 + 0xad8;
    }
    else if (param_2 == 2) {
      local_84 = *(uint *)(param_1 + 0x7800);
      __src = *(void **)(param_1 + 0x2a8);
      local_80 = param_1 + 0xf00;
    }
    else {
      if (param_2 != 0) {
        uVar2 = 0;
        pthread_mutex_unlock(__mutex);
        piVar1 = __errno_location();
        *piVar1 = -0x1b51ffff;
        goto LAB_00112515;
      }
      local_84 = *(uint *)(param_1 + 0x77f8);
      local_80 = param_1 + 0x6b0;
      __src = (void *)FUN_00108dc0(param_1);
    }
    if (__src == (void *)0x0) {
      uVar2 = 0;
      pthread_mutex_unlock(__mutex);
      piVar1 = __errno_location();
      *piVar1 = -0x1b51fffd;
    }
    else {
      __n = (ulong)local_84;
      __dest = operator_new__(__n);
      if (__dest == (void *)0x0) {
        uVar2 = 0;
        pthread_mutex_unlock(__mutex);
        piVar1 = __errno_location();
        *piVar1 = -0x1b51fffe;
      }
      else {
        memcpy(__dest,__src,__n);
        pthread_mutex_unlock(__mutex);
        if (param_3 == 0) {
          FUN_00113c20(&local_68);
          FUN_00116490(local_58,"%d-%d-%d %d-%d-%d.bmp",local_68,local_66,local_62,local_60,local_5e
                       ,local_5c);
        }
        else {
          FUN_00116630(local_58,param_3);
        }
        local_78 = 0x4d42;
        local_72 = 0;
        local_70 = 0;
        local_6e = 0x436;
        local_76 = local_84 + 0x436;
        uVar2 = FUN_00116550(local_58);
        FUN_00106fb0(&local_68,uVar2,0);
        FUN_001070c0(&local_68,&local_78,0xe,1);
        FUN_001070c0(&local_68,local_80,0x428,1);
        FUN_001070c0(&local_68,__dest,__n,1);
        FUN_00106d80(&local_68);
        uVar2 = 1;
        operator_delete__(__dest);
      }
    }
  }
LAB_00112515:
  FUN_00116360(local_58);
  return uVar2;
}


==================================================================

### FUNC 00112770 (963 bytes) name=FUN_00112770

undefined8 FUN_00112770(long param_1,undefined4 param_2,long param_3)

{
  pthread_mutex_t *__mutex;
  void *__dest;
  undefined8 uVar1;
  void *__src;
  int *piVar2;
  ulong __n;
  undefined4 local_80;
  undefined4 local_7c;
  undefined4 local_78;
  undefined4 local_74 [3];
  undefined2 local_68;
  undefined2 local_66;
  undefined2 local_62;
  undefined2 local_60;
  undefined2 local_5e;
  undefined2 local_5c;
  undefined1 local_58 [40];
  
  __mutex = (pthread_mutex_t *)(param_1 + 0x218);
  FUN_001161f0(local_58,0x100);
  local_78 = 0;
  local_74[0] = 0;
  pthread_mutex_lock(__mutex);
  if ((*(int *)(param_1 + 0x208) == 0) || (*(int *)(param_1 + 0x214) == 0)) {
    uVar1 = 0;
    pthread_mutex_unlock(__mutex);
    piVar2 = __errno_location();
    *piVar2 = -0x1b51fffa;
    goto LAB_00112805;
  }
  switch(param_2) {
  case 3:
    local_80 = *(undefined4 *)(param_1 + 0x1ed0);
    __src = *(void **)(param_1 + 0x1dd0);
    local_7c = *(undefined4 *)(param_1 + 0x1ed4);
    local_78 = *(undefined4 *)(param_1 + 0x40);
    local_74[0] = *(undefined4 *)(param_1 + 0x3c);
    if (*(int *)(param_1 + 0x1dec) != 0) {
      __n = (ulong)(uint)(*(int *)(param_1 + 0x77f8) * 2);
      break;
    }
    goto LAB_00112981;
  case 4:
    __src = *(void **)(param_1 + 0x270);
    __n = (ulong)(uint)(*(int *)(param_1 + 0x77f8) * 2);
    local_80 = *(undefined4 *)(param_1 + 0x1ed0);
    local_7c = *(undefined4 *)(param_1 + 0x1ed4);
    local_78 = *(undefined4 *)(param_1 + 0x40);
    local_74[0] = *(undefined4 *)(param_1 + 0x3c);
    break;
  case 5:
    __src = *(void **)(param_1 + 0x240);
    __n = (ulong)(uint)(*(int *)(param_1 + 0x77f8) * 2);
    local_80 = *(undefined4 *)(param_1 + 0x1ed0);
    local_7c = *(undefined4 *)(param_1 + 0x1ed4);
    local_78 = *(undefined4 *)(param_1 + 0x48);
    local_74[0] = *(undefined4 *)(param_1 + 0x44);
    break;
  case 6:
    __src = *(void **)(param_1 + 0x248);
    __n = (ulong)(uint)(*(int *)(param_1 + 0x77f8) * 4);
    local_80 = *(undefined4 *)(param_1 + 0x1ed0);
    local_7c = *(undefined4 *)(param_1 + 0x1ed4);
    local_78 = *(undefined4 *)(param_1 + 0x48);
    local_74[0] = *(undefined4 *)(param_1 + 0x44);
    break;
  case 7:
    __src = *(void **)(param_1 + 0x268);
    __n = (ulong)(uint)(*(int *)(param_1 + 0x77f8) * 2);
    local_80 = *(undefined4 *)(param_1 + 0x1ed0);
    local_7c = *(undefined4 *)(param_1 + 0x1ed4);
    local_78 = *(undefined4 *)(param_1 + 0x48);
    local_74[0] = *(undefined4 *)(param_1 + 0x44);
    break;
  case 8:
    __src = (void *)(param_1 + 0x2360);
    goto LAB_00112837;
  case 9:
    __src = (void *)(param_1 + 0x1f60);
LAB_00112837:
    local_7c = 1;
    local_80 = 0x100;
    __n = 0x400;
    goto LAB_0011283d;
  case 10:
    __n = (ulong)(uint)(*(int *)(param_1 + 0x77f8) * 2);
    local_80 = *(undefined4 *)(param_1 + 0x1ed0);
    local_7c = *(undefined4 *)(param_1 + 0x1ed4);
    local_78 = *(undefined4 *)(param_1 + 0x48);
    local_74[0] = *(undefined4 *)(param_1 + 0x44);
    __src = (void *)FUN_0011a270(param_1 + 0x1e90);
    break;
  default:
    uVar1 = 0;
    pthread_mutex_unlock(__mutex);
    piVar2 = __errno_location();
    *piVar2 = -0x1b51ffff;
    goto LAB_00112805;
  }
  if (__src == (void *)0x0) {
LAB_00112981:
    uVar1 = 0;
    pthread_mutex_unlock(__mutex);
    piVar2 = __errno_location();
    *piVar2 = -0x1b51fffd;
  }
  else {
LAB_0011283d:
    __dest = operator_new__(__n);
    if (__dest == (void *)0x0) {
      pthread_mutex_unlock(__mutex);
      piVar2 = __errno_location();
      *piVar2 = -0x1b51fffe;
      uVar1 = 0;
    }
    else {
      memcpy(__dest,__src,__n);
      pthread_mutex_unlock(__mutex);
      if (param_3 == 0) {
        FUN_00113c20(&local_68);
        FUN_00116490(local_58,"%d-%02d-%02d %02d-%02d-%02d.raw",local_68,local_66,local_62,local_60,
                     local_5e,local_5c);
      }
      else {
        FUN_00116630(local_58,param_3);
      }
      uVar1 = FUN_00116550(local_58);
      FUN_00106fb0(&local_68,uVar1,0);
      FUN_001070c0(&local_68,&local_80,4,1);
      FUN_001070c0(&local_68,&local_7c,4,1);
      FUN_001070c0(&local_68,&local_78,4,1);
      FUN_001070c0(&local_68,local_74,4,1);
      FUN_001070c0(&local_68,__dest,__n,1);
      FUN_00106d80(&local_68);
      uVar1 = 1;
      operator_delete__(__dest);
    }
  }
LAB_00112805:
  FUN_00116360(local_58);
  return uVar1;
}


==================================================================

### FUNC 00112bc0 (3732 bytes) name=FUN_00112bc0

/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

undefined4 FUN_00112bc0(long param_1,char *param_2)

{
  pthread_mutex_t *__mutex;
  int iVar1;
  undefined *puVar2;
  bool bVar3;
  int iVar4;
  undefined4 uVar5;
  int iVar6;
  uint uVar7;
  int *piVar8;
  int *piVar9;
  long lVar10;
  long lVar11;
  ulong uVar12;
  void *pvVar13;
  int *piVar14;
  ostream *poVar15;
  long lVar16;
  uint uVar17;
  ulong uVar18;
  long lVar19;
  long lVar20;
  ulong uVar21;
  undefined4 *puVar22;
  char *pcVar23;
  undefined8 *puVar24;
  undefined8 *puVar25;
  undefined8 *puVar26;
  undefined8 *puVar27;
  char *pcVar28;
  undefined8 *puVar29;
  bool bVar30;
  byte bVar31;
  int local_1c8;
  uint local_1c0;
  int local_194;
  int local_190;
  uint local_18c;
  undefined4 local_188;
  undefined4 local_184;
  undefined4 local_180;
  int local_17c;
  undefined1 local_178 [32];
  undefined1 local_158 [28];
  undefined4 local_13c;
  
  bVar31 = 0;
  __mutex = (pthread_mutex_t *)(param_1 + 0x218);
  local_18c = 8;
  local_188 = 0xffff3cb0;
  local_184 = 0;
  local_180 = 0;
  pthread_mutex_lock(__mutex);
  if (*(void **)(param_1 + 0x1580) != (void *)0x0) {
    operator_delete__(*(void **)(param_1 + 0x1580));
    *(undefined8 *)(param_1 + 0x1580) = 0;
  }
  if (*(void **)(param_1 + 0x1588) != (void *)0x0) {
    operator_delete__(*(void **)(param_1 + 0x1588));
    *(undefined8 *)(param_1 + 0x1588) = 0;
  }
  if (*(void **)(param_1 + 0x1590) != (void *)0x0) {
    operator_delete__(*(void **)(param_1 + 0x1590));
    *(undefined8 *)(param_1 + 0x1590) = 0;
  }
  puVar24 = (undefined8 *)(param_1 + 0x1328);
  uVar21 = 0x438;
  bVar30 = false;
  iVar4 = 0x438;
  if (((ulong)puVar24 & 1) == 0) {
    bVar3 = false;
    if (((ulong)puVar24 & 2) == 0) goto LAB_00112c7a;
LAB_00112f88:
    bVar30 = bVar3;
    uVar7 = iVar4 - 2;
    uVar21 = (ulong)uVar7;
    *(undefined2 *)puVar24 = 0;
    puVar24 = (undefined8 *)((long)puVar24 + 2);
  }
  else {
    puVar24 = (undefined8 *)(param_1 + 0x1329);
    *(undefined1 *)(param_1 + 0x1328) = 0;
    uVar21 = 0x437;
    bVar30 = true;
    iVar4 = 0x437;
    bVar3 = true;
    if (((ulong)puVar24 & 2) != 0) goto LAB_00112f88;
LAB_00112c7a:
    uVar7 = (uint)uVar21;
  }
  if (((ulong)puVar24 & 4) != 0) {
    *(undefined4 *)puVar24 = 0;
    uVar21 = (ulong)(uVar7 - 4);
    puVar24 = (undefined8 *)((long)puVar24 + 4);
  }
  for (uVar18 = uVar21 >> 3; uVar18 != 0; uVar18 = uVar18 - 1) {
    *puVar24 = 0;
    puVar24 = puVar24 + (ulong)bVar31 * -2 + 1;
  }
  if ((uVar21 & 4) != 0) {
    *(undefined4 *)puVar24 = 0;
    puVar24 = (undefined8 *)((long)puVar24 + 4);
  }
  puVar25 = puVar24;
  if ((uVar21 & 2) != 0) {
    puVar25 = (undefined8 *)((long)puVar24 + 2);
    *(undefined2 *)puVar24 = 0;
  }
  if (bVar30) {
    *(undefined1 *)puVar25 = 0;
  }
  puVar24 = (undefined8 *)(param_1 + 0xe0);
  uVar21 = 0x120;
  bVar3 = false;
  iVar4 = 0x120;
  bVar30 = false;
  if (((ulong)puVar24 & 1) == 0) {
    puVar25 = puVar24;
    if (((ulong)puVar24 & 2) == 0) goto LAB_00112cd7;
LAB_00112fe0:
    puVar26 = (undefined8 *)((long)puVar25 + 2);
    uVar7 = iVar4 - 2;
    uVar21 = (ulong)uVar7;
    *(undefined2 *)puVar25 = 0;
  }
  else {
    puVar25 = (undefined8 *)(param_1 + 0xe1);
    *(undefined1 *)(param_1 + 0xe0) = 0;
    uVar21 = 0x11f;
    bVar3 = true;
    iVar4 = 0x11f;
    bVar30 = true;
    if (((ulong)puVar25 & 2) != 0) goto LAB_00112fe0;
LAB_00112cd7:
    uVar7 = (uint)uVar21;
    puVar26 = puVar25;
    bVar30 = bVar3;
  }
  if (((ulong)puVar26 & 4) != 0) {
    *(undefined4 *)puVar26 = 0;
    uVar21 = (ulong)(uVar7 - 4);
    puVar26 = (undefined8 *)((long)puVar26 + 4);
  }
  for (uVar18 = uVar21 >> 3; uVar18 != 0; uVar18 = uVar18 - 1) {
    *puVar26 = 0;
    puVar26 = puVar26 + (ulong)bVar31 * -2 + 1;
  }
  if ((uVar21 & 4) != 0) {
    *(undefined4 *)puVar26 = 0;
    puVar26 = (undefined8 *)((long)puVar26 + 4);
  }
  puVar25 = puVar26;
  if ((uVar21 & 2) != 0) {
    puVar25 = (undefined8 *)((long)puVar26 + 2);
    *(undefined2 *)puVar26 = 0;
  }
  if (bVar30) {
    *(undefined1 *)puVar25 = 0;
  }
  puVar25 = (undefined8 *)(param_1 + 0x1760);
  uVar21 = 0x65c;
  bVar3 = false;
  iVar4 = 0x65c;
  bVar30 = false;
  if (((ulong)puVar25 & 1) == 0) {
    puVar26 = puVar25;
    if (((ulong)puVar25 & 2) == 0) goto LAB_00112d36;
LAB_00113038:
    puVar27 = (undefined8 *)((long)puVar26 + 2);
    uVar7 = iVar4 - 2;
    uVar21 = (ulong)uVar7;
    *(undefined2 *)puVar26 = 0;
  }
  else {
    puVar26 = (undefined8 *)(param_1 + 0x1761);
    *(undefined1 *)(param_1 + 0x1760) = 0;
    uVar21 = 0x65b;
    bVar3 = true;
    iVar4 = 0x65b;
    bVar30 = true;
    if (((ulong)puVar26 & 2) != 0) goto LAB_00113038;
LAB_00112d36:
    uVar7 = (uint)uVar21;
    puVar27 = puVar26;
    bVar30 = bVar3;
  }
  if (((ulong)puVar27 & 4) != 0) {
    *(undefined4 *)puVar27 = 0;
    uVar21 = (ulong)(uVar7 - 4);
    puVar27 = (undefined8 *)((long)puVar27 + 4);
  }
  for (uVar18 = uVar21 >> 3; uVar18 != 0; uVar18 = uVar18 - 1) {
    *puVar27 = 0;
    puVar27 = puVar27 + (ulong)bVar31 * -2 + 1;
  }
  if ((uVar21 & 4) != 0) {
    *(undefined4 *)puVar27 = 0;
    puVar27 = (undefined8 *)((long)puVar27 + 4);
  }
  puVar26 = puVar27;
  if ((uVar21 & 2) != 0) {
    puVar26 = (undefined8 *)((long)puVar27 + 2);
    *(undefined2 *)puVar27 = 0;
  }
  if (bVar30) {
    *(undefined1 *)puVar26 = 0;
  }
  if (((*(int *)(param_1 + 0x208) == 0) || (*param_2 == '\0')) ||
     (iVar4 = access(param_2,0), iVar4 != 0)) {
    pthread_mutex_unlock(__mutex);
    return 0;
  }
  FUN_00107130(local_178,param_2);
  strncpy((char *)(param_1 + 0x1334),param_2,0x100);
  *(undefined1 *)(param_1 + 0x1433) = 0;
  local_17c = 0;
  FUN_00106f60(local_178,&local_17c,4,1);
  FUN_00106f60(local_178,&local_194,4,1);
  FUN_00106f60(local_178,&local_190,4,1);
  FUN_00106f60(local_178,param_1 + 0x1438,4,1);
  FUN_00106f60(local_178,param_1 + 0x1434,4,1);
  if (local_17c == 0x5aa50003) {
    FUN_00106f60(local_178,&local_18c,4,1);
    FUN_00106f60(local_178,&local_188,4,1);
    *(undefined4 *)(param_1 + 0x7810) = 0;
    iVar4 = 0x24;
  }
  else {
    iVar4 = 0;
    if (local_17c == 0x5aa50004) {
      FUN_00106f60(local_178,&local_184,4,1);
      FUN_00106f60(local_178,&local_180,4,1);
      *(undefined4 *)(param_1 + 0x7810) = 1;
      iVar4 = 0x144;
    }
  }
  FUN_00106f60(local_178,param_1 + 0x143c,4,1);
  FUN_00106f60(local_178,param_1 + 0x1440,4,1);
  if (*(int *)(param_1 + 0x7810) != 0) {
    FUN_00106f60(local_178,puVar24,0x120,1);
  }
  if ((((1 < local_17c + 0xa55afffdU) || (0x11 < *(uint *)(param_1 + 0x1438) - 2)) ||
      ((*(int *)(param_1 + 0x1434) == 0 || ((local_18c == 0 || ((local_18c - 1 & local_18c) != 0))))
      )) || (7 < *(uint *)(param_1 + 0x7814))) {
    std::__ostream_insert<char,std::char_traits<char>>
              ((ostream *)PTR_cout_0033efc8,"The calibration table data is not correct1.\n",0x2c);
    goto LAB_00112f48;
  }
  if (*(int *)(param_1 + 0x84) == 0) {
    if (*(int *)(param_1 + 0x1ed0) == local_194) {
      iVar6 = *(int *)(param_1 + 0x1ed4);
joined_r0x00113139:
      if (iVar6 == local_190) goto LAB_0011313f;
    }
  }
  else {
    if (*(int *)(param_1 + 0x84) != 1) {
LAB_0011313f:
      FUN_00106f60(local_178,(int *)(param_1 + 0x1444),(ulong)*(uint *)(param_1 + 0x1438) * 4,1);
      FUN_00106f60(local_178,param_1 + 0x1494,(ulong)*(uint *)(param_1 + 0x1438) << 2,1);
      FUN_00106f60(local_178,param_1 + 0x14e4,(ulong)*(uint *)(param_1 + 0x1438) << 2,1);
      piVar14 = (int *)(param_1 + 0x1534);
      FUN_00106f60(local_178,piVar14,(ulong)(*(int *)(param_1 + 0x1438) - 1) << 2,1);
      uVar7 = *(uint *)(param_1 + 0x1438);
      iVar6 = 0;
      piVar9 = (int *)(param_1 + 0x1444);
LAB_00113202:
      if (iVar6 != uVar7 - 1) {
        if ((uint)piVar9[0x3c] < *(uint *)(param_1 + 0x77f8)) goto code_r0x001131ef;
        goto LAB_001132b0;
      }
      lVar19 = (ulong)*(uint *)(param_1 + 0x143c) + (ulong)*(uint *)(param_1 + 0x1440) +
               (ulong)(*(uint *)(param_1 + 0x77f8) * (*(int *)(param_1 + 0x1434) * 3 + -1)) * 2;
      if (iVar6 == 0) {
        local_1c0 = 0;
      }
      else {
        local_1c0 = 0;
        do {
          iVar6 = *piVar14;
          piVar14 = piVar14 + 1;
          local_1c0 = local_1c0 + iVar6 * 0x28;
        } while (piVar14 != (int *)(param_1 + 0x1538 + (ulong)(uVar7 - 2) * 4));
      }
      uVar21 = (ulong)local_1c0;
      lVar10 = (ulong)uVar7 * lVar19 + (ulong)(uVar7 * 4 - 1) * 4 + (long)iVar4 + uVar21;
      lVar11 = FUN_00106d40(local_178);
      if (lVar10 <= lVar11) {
        lVar11 = FUN_00106d40();
        if ((*(int *)(param_1 + 0x7810) == 0) && (0x11f < *(uint *)(param_1 + 0x143c))) {
          lVar16 = FUN_00106f80(local_178);
          FUN_00106f90(local_178,
                       lVar16 + (ulong)(uint)((*(int *)(param_1 + 0x1434) + -1) *
                                             *(int *)(param_1 + 0x77f8)) * 2,0);
          puVar26 = (undefined8 *)local_158;
          puVar27 = (undefined8 *)local_158;
          for (lVar20 = 0x24; lVar20 != 0; lVar20 = lVar20 + -1) {
            *puVar27 = 0;
            puVar27 = puVar27 + (ulong)bVar31 * -2 + 1;
          }
          FUN_00106f60(local_178,puVar26,0x120,1);
          FUN_00106f90(local_178,lVar16,0);
          if (local_158._0_4_ == 0x1000000) {
            bVar30 = ((ulong)puVar24 & 1) != 0;
            local_13c = 0xc;
            uVar7 = 0x120;
            puVar27 = puVar24;
            if (bVar30) {
              puVar27 = (undefined8 *)(param_1 + 0xe1 + (ulong)bVar31 * -2);
              puVar26 = (undefined8 *)(local_158 + (ulong)bVar31 * -2 + 1);
              *(undefined1 *)puVar24 = 0;
              uVar7 = 0x11f;
            }
            puVar24 = puVar26;
            puVar29 = puVar27;
            if (((ulong)puVar27 & 2) != 0) {
              uVar7 = uVar7 - 2;
              puVar29 = (undefined8 *)((long)puVar27 + (ulong)bVar31 * -4 + 2);
              puVar24 = (undefined8 *)((long)puVar26 + (ulong)bVar31 * -4 + 2);
              *(undefined2 *)puVar27 = *(undefined2 *)puVar26;
            }
            puVar26 = puVar24;
            puVar27 = puVar29;
            if (((ulong)puVar29 & 4) != 0) {
              uVar7 = uVar7 - 4;
              puVar27 = (undefined8 *)((long)puVar29 + (ulong)bVar31 * -8 + 4);
              puVar26 = (undefined8 *)((long)puVar24 + (ulong)bVar31 * -8 + 4);
              *(undefined4 *)puVar29 = *(undefined4 *)puVar24;
            }
            lVar16 = 0;
            for (uVar18 = (ulong)(uVar7 >> 3); uVar18 != 0; uVar18 = uVar18 - 1) {
              *puVar27 = *puVar26;
              puVar26 = puVar26 + (ulong)bVar31 * -2 + 1;
              puVar27 = puVar27 + (ulong)bVar31 * -2 + 1;
            }
            if ((uVar7 & 4) != 0) {
              *(undefined4 *)puVar27 = *(undefined4 *)puVar26;
              lVar16 = 4;
            }
            if ((uVar7 & 2) != 0) {
              *(undefined2 *)((long)puVar27 + lVar16) = *(undefined2 *)((long)puVar26 + lVar16);
              lVar16 = lVar16 + 2;
            }
            if (bVar30) {
              *(undefined1 *)((long)puVar27 + lVar16) = *(undefined1 *)((long)puVar26 + lVar16);
            }
          }
        }
        if (*(int *)(param_1 + 0xfc) == 0) {
          *(undefined4 *)(param_1 + 0xfc) = 0xc;
        }
        uVar12 = (ulong)*(uint *)(param_1 + 0x1438) * lVar19 + 3 >> 2;
        uVar18 = 0xffffffffffffffff;
        if (uVar12 < 0x1fc0000000000001) {
          uVar18 = uVar12 * 4;
        }
        pvVar13 = operator_new__(uVar18);
        *(void **)(param_1 + 0x1580) = pvVar13;
        pvVar13 = operator_new__(lVar19 + 3U & 0xfffffffffffffffc);
        *(void **)(param_1 + 0x1588) = pvVar13;
        if (local_1c0 != 0) {
          pvVar13 = operator_new__(uVar21);
          *(void **)(param_1 + 0x1590) = pvVar13;
        }
        if (((*(long *)(param_1 + 0x1580) == 0) ||
            (lVar16 = *(long *)(param_1 + 0x1588), lVar16 == 0)) ||
           ((local_1c0 != 0 && (*(long *)(param_1 + 0x1590) == 0)))) {
          FUN_00113aa0(local_158,4);
          FUN_00116630(local_158,"Failed to allocate memory for calibration data.\n");
          FUN_00113b30(local_158);
          goto LAB_00112f48;
        }
        *(long *)(param_1 + 0x1738) = lVar16;
        *(ulong *)(param_1 + 0x1750) =
             lVar16 + ((ulong)(*(uint *)(param_1 + 0x143c) >> 1) +
                      (ulong)(uint)((*(int *)(param_1 + 0x1434) + -1) * *(int *)(param_1 + 0x77f8)))
                      * 2;
        uVar5 = FUN_00106f80(local_178);
        uVar7 = *(uint *)(param_1 + 0x1438);
        *(undefined4 *)(param_1 + 0x15e8) = uVar5;
        *(undefined4 *)(param_1 + 0x1638) = 0;
        local_1c8 = (int)lVar19;
        if (1 < uVar7) {
          piVar14 = (int *)(param_1 + 0x15e8);
          do {
            piVar9 = piVar14 + 1;
            *piVar9 = *piVar14 + local_1c8;
            piVar14[0x15] = piVar14[0x14] + local_1c8;
            piVar14 = piVar9;
          } while (piVar9 != (int *)(param_1 + 0x15ec + (ulong)(uVar7 - 2) * 4));
        }
        *(undefined4 *)(param_1 + 0x16d4) = 0;
        uVar17 = 1;
        *(uint *)(param_1 + 0x1688) = local_1c8 * uVar7 + *(int *)(param_1 + 0x15e8);
        piVar14 = (int *)(param_1 + 0x1688);
        if (1 < uVar7 - 1) {
          do {
            uVar17 = uVar17 + 1;
            piVar14[1] = *piVar14 + piVar14[-0x55] * 0x28;
            piVar14[0x14] = piVar14[-0x55] * 0x28 + piVar14[0x13];
            piVar14 = piVar14 + 1;
          } while (uVar7 - 1 != uVar17);
        }
        FUN_00106f60(local_178,*(undefined8 *)(param_1 + 0x1580),(ulong)uVar7 * lVar19);
        if (local_1c0 != 0) {
          FUN_00106f60(local_178,*(undefined8 *)(param_1 + 0x1590),uVar21);
        }
        iVar4 = *(int *)(param_1 + 0x1438);
        if (iVar4 == 0) {
          if (lVar10 < lVar11) goto LAB_0011355b;
        }
        else {
          puVar22 = (undefined4 *)(param_1 + 0x1598);
          do {
            *puVar22 = 1;
            puVar22 = puVar22 + 1;
          } while (puVar22 != (undefined4 *)(param_1 + 0x159c + (ulong)(iVar4 - 1) * 4));
          if (lVar10 < lVar11) {
LAB_0011355b:
            iVar4 = FUN_00106d40(local_178);
            iVar6 = FUN_00106f80(local_178);
            iVar4 = iVar4 - iVar6;
            *(undefined4 *)(param_1 + 0x1764) = 0;
            while ((0x43 < iVar4 && (*(uint *)(param_1 + 0x1764) < 3))) {
              local_158._0_4_ = 0;
              FUN_00106f60(local_178,local_158,4);
              if (local_158._0_4_ != 0x6bb60001) break;
              pcVar23 = (char *)(param_1 + 0x1768 + (ulong)*(uint *)(param_1 + 0x1764) * 0x21c);
              FUN_00106f60(local_178,pcVar23,0x20,1);
              pcVar23[0x1e] = '\0';
              pcVar23[0x1f] = '\0';
              FUN_00106f60(local_178,pcVar23 + 0x20,4,1);
              FUN_00106f60(local_178,pcVar23 + 0x24,4,1);
              FUN_00106f60(local_178,pcVar23 + 0x28,4,1);
              FUN_00106f60(local_178,pcVar23 + 0x2c,4,1);
              FUN_00106f60(local_178,pcVar23 + 0x30,4,1);
              FUN_00106f60(local_178,pcVar23 + 0x38,4,1);
              FUN_00106f60(local_178,pcVar23 + 0x34,4,1);
              FUN_00106f60(local_178,pcVar23 + 0x3c,4);
              if (0xf < *(uint *)(pcVar23 + 0x30)) break;
              uVar7 = *(int *)(pcVar23 + 0x3c) - 1;
              if (0x18 < uVar7) break;
              if (iVar4 < 0x21c) {
                iVar6 = 1;
                if (*(int *)(pcVar23 + 0x3c) != 1) {
                  FUN_00106f60(local_178,pcVar23 + 0x40,(ulong)uVar7 << 2,1);
                  iVar6 = *(int *)(pcVar23 + 0x3c);
                }
                FUN_00106f60(local_178,pcVar23 + 0xd4,(ulong)(uint)(iVar6 * 2) << 2);
                pcVar23[0x204] = '\0';
                pcVar23[0x205] = '\0';
                pcVar23[0x206] = -0x80;
                pcVar23[0x207] = '?';
                iVar4 = (iVar4 - (*(int *)(pcVar23 + 0x3c) * 0xc + -4)) + -0x44;
              }
              else {
                FUN_00106f60(local_178,pcVar23 + 0x40,0x1dc);
                iVar4 = iVar4 + -0x220;
                if ((*(float *)(pcVar23 + 0x204) <= 0.0) ||
                   (DAT_00131e20 < *(float *)(pcVar23 + 0x204))) {
                  pcVar23[0x204] = '\0';
                  pcVar23[0x205] = '\0';
                  pcVar23[0x206] = -0x80;
                  pcVar23[0x207] = '?';
                }
              }
              if ((*(float *)(pcVar23 + 0x214) < DAT_00131e50) ||
                 (_DAT_00131e54 < *(float *)(pcVar23 + 0x214))) {
                pcVar23[0x214] = '\0';
                pcVar23[0x215] = '\0';
                pcVar23[0x216] = '\0';
                pcVar23[0x217] = '\0';
              }
              puVar2 = PTR_cout_0033efc8;
              *(undefined4 *)(pcVar23 + 0xc4) = *(undefined4 *)(param_1 + 0x7810);
              *(undefined4 *)(pcVar23 + 200) = local_184;
              *(undefined4 *)(pcVar23 + 0xcc) = local_180;
              *(int *)(param_1 + 0x1764) = *(int *)(param_1 + 0x1764) + 1;
              *(undefined4 *)(param_1 + 0x1760) = 1;
              poVar15 = std::operator<<((ostream *)puVar2,"Found Lens: ");
              poVar15 = std::operator<<(poVar15,pcVar23);
              std::endl<char,std::char_traits<char>>(poVar15);
            }
          }
          else if ((iVar4 == 1) ||
                  ((iVar4 == 2 && (*(int *)(param_1 + 0x1448) - *(int *)(param_1 + 0x1444) == 50000)
                   ))) {
            bVar30 = ((ulong)puVar25 & 1) != 0;
            *(undefined4 *)(param_1 + 0x132c) = 1;
            uVar21 = 0x65c;
            puVar24 = puVar25;
            if (bVar30) {
              puVar24 = (undefined8 *)(param_1 + 0x1761 + (ulong)bVar31 * -2);
              *(undefined1 *)puVar25 = 0;
              uVar21 = 0x65b;
            }
            puVar25 = puVar24;
            if (((ulong)puVar24 & 2) != 0) {
              uVar21 = (ulong)((int)uVar21 - 2);
              puVar25 = (undefined8 *)((long)puVar24 + (ulong)bVar31 * -4 + 2);
              *(undefined2 *)puVar24 = 0;
            }
            puVar24 = puVar25;
            if (((ulong)puVar25 & 4) != 0) {
              uVar21 = (ulong)((int)uVar21 - 4);
              puVar24 = (undefined8 *)((long)puVar25 + (ulong)bVar31 * -8 + 4);
              *(undefined4 *)puVar25 = 0;
            }
            for (uVar18 = uVar21 >> 3; uVar18 != 0; uVar18 = uVar18 - 1) {
              *puVar24 = 0;
              puVar24 = puVar24 + (ulong)bVar31 * -2 + 1;
            }
            puVar25 = puVar24;
            if ((uVar21 & 4) != 0) {
              puVar25 = (undefined8 *)((long)puVar24 + (ulong)bVar31 * -8 + 4);
              *(undefined4 *)puVar24 = 0;
            }
            puVar24 = puVar25;
            if ((uVar21 & 2) != 0) {
              puVar24 = (undefined8 *)((long)puVar25 + (ulong)bVar31 * -4 + 2);
              *(undefined2 *)puVar25 = 0;
            }
            if (bVar30) {
              *(undefined1 *)puVar24 = 0;
            }
            *(undefined4 *)(param_1 + 0x1760) = 1;
            *(undefined4 *)(param_1 + 0x1764) = 1;
            pcVar23 = "Default Lens";
            pcVar28 = (char *)(param_1 + 0x1768);
            for (lVar19 = 0xd; lVar19 != 0; lVar19 = lVar19 + -1) {
              *pcVar28 = *pcVar23;
              pcVar23 = pcVar23 + (ulong)bVar31 * -2 + 1;
              pcVar28 = pcVar28 + (ulong)bVar31 * -2 + 1;
            }
            *(undefined4 *)(param_1 + 0x1788) = 0x3e99999a;
            *(undefined4 *)(param_1 + 0x178c) = 0x3f800000;
            *(undefined4 *)(param_1 + 0x1790) = 0x40000000;
            *(undefined4 *)(param_1 + 0x1794) = 0x3fc00000;
            *(undefined4 *)(param_1 + 0x17a4) = 1;
            *(undefined4 *)(param_1 + 0x196c) = 0x3f800000;
            *(undefined4 *)(param_1 + 0x1970) = 0;
            *(undefined4 *)(param_1 + 0x1974) = 100000;
            iVar4 = (*(int *)(param_1 + 0x1448) + *(int *)(param_1 + 0x1444)) / 2;
            *(int *)(param_1 + 0x179c) = iVar4;
            *(int *)(param_1 + 0x17a0) = iVar4 + -500;
            *(undefined4 *)(param_1 + 0x183c) = *(undefined4 *)(param_1 + 0x7804);
            *(undefined4 *)(param_1 + 0x1840) = *(undefined4 *)(param_1 + 0x7808);
          }
        }
        if (*(int *)(param_1 + 0x7810) == 0) {
          iVar4 = 0;
          *(undefined4 *)(param_1 + 0x7808) = local_188;
          *(uint *)(param_1 + 0x7804) = local_18c;
          do {
            if (local_18c == 1 << ((byte)iVar4 & 0x1f)) {
              *(int *)(param_1 + 0x780c) = iVar4;
              break;
            }
            iVar4 = iVar4 + 1;
          } while (iVar4 != 0x20);
        }
        else {
          *(undefined4 *)(param_1 + 0x7814) = local_180;
        }
        *(undefined4 *)(param_1 + 0x1328) = 1;
        pthread_mutex_unlock(__mutex);
        FUN_00109d40(param_1,local_184);
        uVar5 = *(undefined4 *)(param_1 + 0x1328);
        goto LAB_00112f52;
      }
      std::operator<<((ostream *)PTR_cout_0033efc8,"The calibration table length is not correct.\n")
      ;
      goto LAB_00112f48;
    }
    if (*(int *)(param_1 + 0x1ed4) == local_194) {
      iVar6 = *(int *)(param_1 + 0x1ed0);
      goto joined_r0x00113139;
    }
  }
  std::operator<<((ostream *)PTR_cout_0033efc8,"The calibration table size mismatch FPA.\n");
LAB_00112f48:
  pthread_mutex_unlock(__mutex);
  uVar5 = 0;
LAB_00112f52:
  FUN_00106db0(local_178);
  return uVar5;
code_r0x001131ef:
  piVar8 = piVar9 + 1;
  iVar6 = iVar6 + 1;
  iVar1 = *piVar9;
  piVar9 = piVar8;
  if (*piVar8 <= iVar1) goto LAB_001132b0;
  goto LAB_00113202;
LAB_001132b0:
  std::operator<<((ostream *)PTR_cout_0033efc8,"The calibration table data is not correct2.\n");
  goto LAB_00112f48;
}


==================================================================

### FUNC 00113aa0 (122 bytes) name=FUN_00113aa0

void FUN_00113aa0(undefined8 param_1,int param_2)

{
  tm *ptVar1;
  time_t local_20;
  
  FUN_001161f0(param_1,0x400);
  time(&local_20);
  ptVar1 = localtime(&local_20);
  FUN_00116490(param_1,"%d.%02d.%02d %02d:%02d:%02d  %s",ptVar1->tm_year + 0x76c,ptVar1->tm_mon + 1,
               ptVar1->tm_mday,ptVar1->tm_hour,ptVar1->tm_min,ptVar1->tm_sec,
               (&PTR_s_TRACE___0033ea00)[param_2]);
  return;
}


==================================================================

### FUNC 00113b30 (62 bytes) name=FUN_00113b30

void FUN_00113b30(undefined8 param_1)

{
  FUN_00116630(param_1,&DAT_00131fd0);
  FUN_00116580(param_1,DAT_00340aa0);
  fflush(DAT_00340aa0);
  FUN_00116360(param_1);
  return;
}


==================================================================

### FUNC 00113b90 (8 bytes) name=FUN_00113b90

void FUN_00113b90(undefined8 param_1)

{
  DAT_00340aa0 = param_1;
  return;
}


==================================================================

### FUNC 00113ba0 (21 bytes) name=FUN_00113ba0

void FUN_00113ba0(void)

{
  DAT_00340aa0 = FUN_00106ef0();
  return;
}


==================================================================

### FUNC 00113bc0 (69 bytes) name=FUN_00113bc0

long FUN_00113bc0(void)

{
  timespec local_18;
  
  clock_gettime(1,&local_18);
  return local_18.tv_sec * 1000 + local_18.tv_nsec / 1000000;
}


==================================================================

### FUNC 00113c10 (11 bytes) name=FUN_00113c10

void FUN_00113c10(int param_1)

{
  usleep(param_1 * 1000);
  return;
}


==================================================================

### FUNC 00113c20 (104 bytes) name=FUN_00113c20

void FUN_00113c20(short *param_1)

{
  int iVar1;
  tm *ptVar2;
  time_t local_20 [2];
  
  time(local_20);
  ptVar2 = localtime(local_20);
  iVar1 = ptVar2->tm_mon;
  *param_1 = (short)ptVar2->tm_year + 0x76c;
  param_1[1] = (short)iVar1 + 1;
  param_1[2] = (short)ptVar2->tm_wday;
  param_1[3] = (short)ptVar2->tm_mday;
  param_1[4] = (short)ptVar2->tm_hour;
  iVar1 = ptVar2->tm_sec;
  param_1[5] = (short)ptVar2->tm_min;
  param_1[6] = (short)iVar1;
  param_1[7] = 400;
  return;
}


==================================================================

### FUNC 00113c90 (327 bytes) name=FUN_00113c90

undefined8 FUN_00113c90(uint *param_1,int *param_2,int *param_3,int param_4)

{
  int iVar1;
  long lVar2;
  long lVar3;
  undefined8 uVar4;
  int iVar5;
  long lVar6;
  long lVar7;
  int *piVar8;
  int *piVar9;
  int iVar10;
  uint uVar11;
  long lVar12;
  uint uVar13;
  uint uVar14;
  
  iVar1 = param_4 >> 0x1f;
  iVar5 = param_4 / 3 + iVar1;
  uVar11 = iVar1 - iVar5;
  uVar13 = iVar5 - iVar1;
  uVar14 = uVar11 - 1;
  if ((int)uVar11 < (int)uVar13) {
    lVar7 = 0;
    lVar12 = 0x7fffffffffffffff;
    iVar1 = -uVar11;
    lVar2 = (long)(int)uVar11;
    lVar6 = 0;
    do {
      piVar8 = param_2;
      piVar9 = (int *)((long)param_3 + (lVar2 * 4 - lVar6));
      if ((int)uVar11 < 0) {
        piVar8 = (int *)((long)param_2 + lVar6 + (long)iVar1 * 4);
        piVar9 = param_3;
      }
      iVar5 = param_4 - (((int)uVar11 >> 0x1f ^ uVar11) - ((int)uVar11 >> 0x1f));
      if (iVar5 == 0) {
        lVar3 = 0;
      }
      else {
        lVar3 = 0;
        iVar10 = iVar5;
        do {
          lVar3 = lVar3 + (long)(*piVar8 - *piVar9) * (long)(*piVar8 - *piVar9);
          iVar10 = iVar10 + -1;
          piVar8 = piVar8 + 1;
          piVar9 = piVar9 + 1;
        } while (iVar10 != 0);
      }
      lVar3 = lVar3 / (long)iVar5;
      if (lVar3 < lVar12) {
        lVar12 = lVar3;
        uVar14 = uVar11;
      }
      if (lVar7 < lVar3) {
        lVar7 = lVar3;
      }
      uVar11 = uVar11 + 1;
      lVar6 = lVar6 + -4;
    } while (uVar11 != uVar13);
  }
  else {
    lVar7 = 0;
    lVar12 = 0x7fffffffffffffff;
  }
  if (param_4 < 0) {
    param_4 = param_4 + 3;
  }
  uVar4 = 0;
  if (((-(param_4 >> 2) <= (int)uVar14) && ((int)uVar14 <= param_4 >> 2)) && (lVar12 * 2 <= lVar7))
  {
    *param_1 = uVar14;
    uVar4 = 1;
  }
  return uVar4;
}


==================================================================

### FUNC 00113de0 (330 bytes) name=FUN_00113de0

void FUN_00113de0(void *param_1,ushort *param_2)

{
  ushort uVar1;
  size_t __n;
  int iVar2;
  int iVar3;
  int iVar4;
  long lVar5;
  long lVar6;
  int iVar7;
  int iVar8;
  int iVar9;
  ushort *puVar10;
  
  iVar4 = DAT_00340ab4;
  iVar2 = DAT_00340ab0;
  lVar5 = (long)DAT_00340ab4;
  __n = lVar5 * 2;
  iVar7 = (DAT_00340ab0 + -2) * DAT_00340ab4;
  if (iVar7 != 2) {
    lVar6 = 0;
    iVar3 = (uint)param_2[lVar5] + (uint)*param_2 + (uint)param_2[lVar5 * 2];
    iVar8 = (uint)param_2[1] + (uint)param_2[lVar5 + 1] + (uint)param_2[lVar5 * 2 + 1];
    do {
      iVar9 = (uint)*(ushort *)((long)param_2 + lVar6 + 4) +
              (uint)*(ushort *)((long)param_2 + lVar6 + __n + 4) +
              (uint)*(ushort *)((long)param_2 + lVar6 + __n + __n + 4);
      *(short *)((long)param_1 + lVar6 + __n + 2) =
           (short)((ulong)(uint)(iVar9 + iVar8 + iVar3) / 9);
      lVar6 = lVar6 + 2;
      iVar3 = iVar8;
      iVar8 = iVar9;
    } while (lVar6 != (ulong)(iVar7 - 3) * 2 + 2);
  }
  memcpy(param_1,param_2,__n);
  lVar6 = (long)(iVar7 + iVar4);
  memcpy((void *)((long)param_1 + lVar6 * 2),param_2 + lVar6,__n);
  if (2 < iVar2) {
    lVar6 = (long)(iVar4 * 2);
    param_2 = param_2 + lVar6 + -1;
    puVar10 = (ushort *)((long)param_1 + lVar6 * 2 + -2);
    iVar4 = 1;
    do {
      iVar4 = iVar4 + 1;
      puVar10[(lVar5 - lVar6) + 1] = param_2[(lVar5 - lVar6) + 1];
      uVar1 = *param_2;
      param_2 = param_2 + lVar5;
      *puVar10 = uVar1;
      puVar10 = (ushort *)((long)puVar10 + lVar6);
    } while (iVar4 != iVar2 + -1);
  }
  return;
}


==================================================================

### FUNC 00113f30 (294 bytes) name=FUN_00113f30

void FUN_00113f30(void *param_1,long param_2)

{
  ushort *puVar1;
  ushort uVar2;
  size_t __n;
  int iVar3;
  long lVar4;
  long lVar5;
  undefined2 *puVar6;
  undefined2 uVar7;
  uint uVar8;
  int iVar9;
  int iVar10;
  long lVar11;
  ushort *puVar12;
  uint uVar13;
  uint uVar14;
  int iVar15;
  
  iVar10 = DAT_00340ab4;
  iVar3 = DAT_00340ab0;
  lVar4 = (long)DAT_00340ab4;
  __n = lVar4 * 2;
  iVar15 = (DAT_00340ab0 + -2) * DAT_00340ab4;
  lVar11 = (long)(DAT_00340ab4 * 2);
  puVar12 = (ushort *)(param_2 + __n);
  if (iVar15 != 2) {
    lVar5 = 0;
    do {
      puVar1 = puVar12 + 2;
      uVar2 = *puVar12;
      puVar12 = puVar12 + 1;
      uVar8 = (uint)*(ushort *)(param_2 + 2 + lVar5) -
              (uint)*(ushort *)(param_2 + 2 + lVar11 * 2 + lVar5);
      uVar13 = (int)uVar8 >> 0x1f;
      uVar14 = (int)((uint)uVar2 - (uint)*puVar1) >> 0x1f;
      iVar9 = ((uVar8 ^ uVar13) - uVar13) + (((uint)uVar2 - (uint)*puVar1 ^ uVar14) - uVar14);
      uVar7 = (undefined2)iVar9;
      if (0xffff < iVar9) {
        uVar7 = 0xffff;
      }
      *(undefined2 *)((long)param_1 + lVar5 + __n + 2) = uVar7;
      lVar5 = lVar5 + 2;
    } while (lVar5 != (ulong)(iVar15 - 3) * 2 + 2);
  }
  memset(param_1,0,__n);
  memset((void *)((long)param_1 + (long)(iVar10 + iVar15) * 2),0,__n);
  if (2 < iVar3) {
    puVar6 = (undefined2 *)((long)param_1 + lVar11 * 2 + -2);
    iVar10 = 1;
    do {
      iVar10 = iVar10 + 1;
      puVar6[(lVar4 - lVar11) + 1] = 0;
      *puVar6 = 0;
      puVar6 = (undefined2 *)((long)puVar6 + lVar11);
    } while (iVar10 != iVar3 + -1);
  }
  return;
}


==================================================================

### FUNC 00114060 (373 bytes) name=FUN_00114060

/* WARNING: Type propagation algorithm not settling */

undefined8 FUN_00114060(undefined8 param_1,undefined8 param_2,long param_3,long param_4)

{
  int *piVar1;
  ushort uVar2;
  int iVar3;
  long lVar4;
  undefined8 uVar5;
  long lVar6;
  int *piVar7;
  int *piVar8;
  int iVar9;
  int local_2338;
  int local_2334 [479];
  int local_1bb8;
  int local_1bb4 [479];
  int local_1438;
  undefined1 local_1434 [2556];
  int local_a38;
  undefined1 local_a34 [2564];
  
  iVar3 = DAT_00340ab0;
  piVar7 = &local_2338;
  piVar8 = &local_1438;
  for (lVar6 = 0x140; lVar6 != 0; lVar6 = lVar6 + -1) {
    piVar8[0] = 0;
    piVar8[1] = 0;
    piVar8 = piVar8 + 2;
  }
  piVar8 = piVar7;
  for (lVar6 = 0xf0; lVar6 != 0; lVar6 = lVar6 + -1) {
    piVar8[0] = 0;
    piVar8[1] = 0;
    piVar8 = piVar8 + 2;
  }
  piVar8 = &local_a38;
  for (lVar6 = 0x140; lVar6 != 0; lVar6 = lVar6 + -1) {
    piVar8[0] = 0;
    piVar8[1] = 0;
    piVar8 = piVar8 + 2;
  }
  piVar8 = &local_1bb8;
  for (lVar6 = 0xf0; lVar6 != 0; lVar6 = lVar6 + -1) {
    piVar8[0] = 0;
    piVar8[1] = 0;
    piVar8 = piVar8 + 2;
  }
  if (0 < DAT_00340ab0) {
    lVar6 = (ulong)(DAT_00340ab4 - 1) * 2 + 2;
    do {
      if (DAT_00340ab4 < 1) {
        iVar9 = 0;
      }
      else {
        lVar4 = 0;
        iVar9 = 0;
        do {
          uVar2 = *(ushort *)(param_3 + lVar4);
          piVar8 = (int *)((long)&local_1438 + lVar4 * 2);
          *piVar8 = *piVar8 + (uint)uVar2;
          lVar4 = lVar4 + 2;
          iVar9 = iVar9 + (uint)uVar2;
        } while (lVar4 != lVar6);
        param_3 = param_3 + lVar6;
      }
      *piVar7 = iVar9;
      piVar7 = piVar7 + 1;
    } while (piVar7 != local_2334 + (DAT_00340ab0 - 1U));
    piVar7 = &local_1bb8;
    piVar8 = local_1bb4;
    while( true ) {
      if (DAT_00340ab4 < 1) {
        *piVar7 = 0;
      }
      else {
        lVar4 = 0;
        iVar9 = 0;
        do {
          uVar2 = *(ushort *)(param_4 + lVar4);
          piVar1 = (int *)((long)&local_a38 + lVar4 * 2);
          *piVar1 = *piVar1 + (uint)uVar2;
          lVar4 = lVar4 + 2;
          iVar9 = iVar9 + (uint)uVar2;
        } while (lVar4 != lVar6);
        param_4 = param_4 + lVar6;
        *piVar7 = iVar9;
      }
      if (piVar8 == local_1bb4 + (DAT_00340ab0 - 1U)) break;
      piVar7 = piVar8;
      piVar8 = piVar8 + 1;
    }
  }
  iVar9 = FUN_00113c90(param_1,local_1434,local_a34,DAT_00340ab4 + -2);
  uVar5 = 0;
  if (iVar9 != 0) {
    uVar5 = FUN_00113c90(param_2,local_2334,local_1bb4,iVar3 + -2);
  }
  return uVar5;
}


==================================================================

### FUNC 001141e0 (229 bytes) name=FUN_001141e0

bool FUN_001141e0(undefined8 param_1,undefined8 param_2)

{
  uint uVar1;
  long lVar2;
  ulong uVar3;
  int *piVar4;
  long in_FS_OFFSET;
  undefined1 auStack_3b8 [32];
  int local_398 [222];
  long local_20;
  
  local_20 = *(long *)(in_FS_OFFSET + 0x28);
  piVar4 = local_398;
  for (lVar2 = 0x6e; lVar2 != 0; lVar2 = lVar2 + -1) {
    piVar4[0] = 0;
    piVar4[1] = 0;
    piVar4 = piVar4 + 2;
  }
  *piVar4 = 0;
  FUN_00107130(auStack_3b8,param_1);
  FUN_00106f60(auStack_3b8,local_398,0x374,1);
  uVar3 = 0;
  if ((local_398[0] == 0x374) && (local_398[2] == DAT_00340ab4)) {
    if (local_398[3] == DAT_00340ab0) {
      uVar1 = FUN_00106f60(auStack_3b8,param_2,(long)(DAT_00340ab0 * DAT_00340ab4) * 2,1);
      uVar3 = (ulong)uVar1;
    }
  }
  FUN_00106db0(auStack_3b8);
  if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
    return uVar3 == (long)(DAT_00340ab4 * DAT_00340ab0) * 2;
  }
                    /* WARNING: Subroutine does not return */
  __stack_chk_fail();
}


==================================================================

### FUNC 001142f0 (647 bytes) name=FUN_001142f0

undefined8
FUN_001142f0(undefined8 param_1,undefined8 param_2,int param_3,int param_4,undefined4 *param_5,
            undefined4 *param_6)

{
  void *pvVar1;
  void *pvVar2;
  int iVar3;
  int *piVar4;
  undefined8 uVar5;
  ulong uVar6;
  void *pvVar7;
  
  DAT_00340ab0 = param_4;
  DAT_00340ab4 = param_3;
  if ((ulong)((long)(param_3 * param_4) * 2) < 0x3f80000000000001) {
    uVar6 = (long)(param_3 * param_4) * 4;
    DAT_00340ac8 = operator_new__(uVar6);
    DAT_00340ac0 = operator_new__(uVar6);
  }
  else {
    DAT_00340ac8 = operator_new__(0xffffffffffffffff);
    DAT_00340ac0 = operator_new__(0xffffffffffffffff);
    uVar6 = 0xffffffffffffffff;
  }
  DAT_00340ab8 = operator_new__(uVar6);
  if (DAT_00340ac8 != (void *)0x0) {
    if ((DAT_00340ac0 != (void *)0x0) && (DAT_00340ab8 != (void *)0x0)) {
      iVar3 = FUN_001141e0(param_1);
      pvVar2 = DAT_00340ac8;
      pvVar7 = DAT_00340ac0;
      if (iVar3 == 0) {
        if (DAT_00340ac8 != (void *)0x0) {
          operator_delete__(DAT_00340ac8);
          DAT_00340ac8 = (void *)0x0;
        }
        if (DAT_00340ac0 != (void *)0x0) {
          operator_delete__(DAT_00340ac0);
          DAT_00340ac0 = (void *)0x0;
        }
        if (DAT_00340ab8 != (void *)0x0) {
          operator_delete__(DAT_00340ab8);
          DAT_00340ab8 = (void *)0x0;
        }
        piVar4 = __errno_location();
        *piVar4 = -0x1b51fff7;
        uVar5 = 0;
      }
      else {
        FUN_00113de0(DAT_00340ac0,DAT_00340ac8);
        pvVar1 = DAT_00340ab8;
        FUN_00113de0(DAT_00340ab8,param_2);
        FUN_00113f30(pvVar2,pvVar7);
        FUN_00113f30(param_2,pvVar1);
        iVar3 = FUN_00114060(param_5,param_6,pvVar2,param_2);
        if (iVar3 == 0) {
          *param_5 = 0;
          *param_6 = 0;
        }
        if (pvVar2 != (void *)0x0) {
          operator_delete__(pvVar2);
          DAT_00340ac8 = (void *)0x0;
          pvVar7 = DAT_00340ac0;
        }
        if (pvVar7 != (void *)0x0) {
          operator_delete__(pvVar7);
          DAT_00340ac0 = (void *)0x0;
        }
        if (DAT_00340ab8 == (void *)0x0) {
          uVar5 = 1;
        }
        else {
          operator_delete__(DAT_00340ab8);
          DAT_00340ab8 = (void *)0x0;
          uVar5 = 1;
        }
      }
      return uVar5;
    }
    operator_delete__(DAT_00340ac8);
    DAT_00340ac8 = (void *)0x0;
  }
  if (DAT_00340ac0 != (void *)0x0) {
    operator_delete__(DAT_00340ac0);
    DAT_00340ac0 = (void *)0x0;
  }
  if (DAT_00340ab8 != (void *)0x0) {
    operator_delete__(DAT_00340ab8);
    DAT_00340ab8 = (void *)0x0;
  }
  piVar4 = __errno_location();
  *piVar4 = -0x1b51fffe;
  return 0;
}


==================================================================

### FUNC 00114580 (42 bytes) name=FUN_00114580

void FUN_00114580(undefined4 *param_1)

{
  *param_1 = 0;
  param_1[1] = 0;
  param_1[2] = 0x67452301;
  param_1[3] = 0xefcdab89;
  param_1[4] = 0x98badcfe;
  param_1[5] = 0x10325476;
  return;
}


==================================================================

### FUNC 001145b0 (89 bytes) name=FUN_001145b0

void FUN_001145b0(long param_1,long param_2,uint param_3)

{
  uint uVar1;
  undefined4 *puVar2;
  uint uVar3;
  ulong uVar4;
  
  uVar3 = 0;
  uVar4 = 0;
  if (param_3 != 0) {
    do {
      puVar2 = (undefined4 *)(param_2 + uVar4 * 4);
      *(char *)(param_1 + (ulong)uVar3) = (char)*puVar2;
      *(char *)(param_1 + (ulong)(uVar3 + 1)) = (char)((uint)*puVar2 >> 8);
      *(char *)(param_1 + (ulong)(uVar3 + 2)) = (char)((uint)*puVar2 >> 0x10);
      uVar1 = uVar3 + 3;
      uVar3 = uVar3 + 4;
      *(char *)(param_1 + (ulong)uVar1) = (char)((uint)*puVar2 >> 0x18);
      uVar4 = (ulong)((int)uVar4 + 1);
    } while (uVar3 < param_3);
  }
  return;
}


==================================================================

### FUNC 00114610 (89 bytes) name=FUN_00114610

void FUN_00114610(long param_1,long param_2,uint param_3)

{
  uint uVar1;
  uint uVar2;
  uint uVar3;
  uint uVar4;
  ulong uVar5;
  uint uVar6;
  ulong uVar7;
  
  uVar4 = 0;
  uVar6 = 0;
  if (param_3 != 0) {
    do {
      uVar3 = uVar4 + 1;
      uVar1 = uVar4 + 2;
      uVar7 = (ulong)uVar6;
      uVar6 = uVar6 + 1;
      uVar5 = (ulong)uVar4;
      uVar2 = uVar4 + 3;
      uVar4 = uVar4 + 4;
      *(uint *)(param_1 + uVar7 * 4) =
           (uint)*(byte *)(param_2 + (ulong)uVar3) << 8 |
           (uint)*(byte *)(param_2 + (ulong)uVar1) << 0x10 | (uint)*(byte *)(param_2 + uVar5) |
           (uint)*(byte *)(param_2 + (ulong)uVar2) << 0x18;
    } while (uVar4 < param_3);
  }
  return;
}


==================================================================

### FUNC 00114670 (1997 bytes) name=FUN_00114670

void FUN_00114670(int *param_1,undefined8 param_2)

{
  int iVar1;
  uint uVar2;
  uint uVar3;
  uint uVar4;
  uint uVar5;
  uint uVar6;
  uint uVar7;
  int local_138;
  int local_134;
  int local_130;
  int local_12c;
  int local_128;
  int local_124;
  int local_120;
  int local_11c;
  int local_118;
  int local_114;
  int local_110;
  int local_10c;
  int local_108;
  int local_104;
  int local_100;
  int local_fc;
  
  uVar6 = param_1[1];
  uVar2 = param_1[2];
  uVar4 = param_1[3];
  iVar1 = *param_1;
  FUN_00114610(&local_138,param_2,0x40);
  uVar3 = iVar1 + -0x28955b88 + local_138 + (~uVar6 & uVar4 | uVar2 & uVar6);
  uVar3 = (uVar3 >> 0x19 | uVar3 * 0x80) + uVar6;
  uVar4 = uVar4 + 0xe8c7b756 + local_134 + (~uVar3 & uVar2 | uVar3 & uVar6);
  uVar5 = (uVar4 >> 0x14 | uVar4 * 0x1000) + uVar3;
  uVar2 = (~uVar5 & uVar6 | uVar5 & uVar3) + uVar2 + 0x242070db + local_130;
  uVar2 = (uVar2 >> 0xf | uVar2 * 0x20000) + uVar5;
  uVar6 = (~uVar2 & uVar3 | uVar2 & uVar5) + uVar6 + 0xc1bdceee + local_12c;
  uVar7 = (uVar6 >> 10 | uVar6 * 0x400000) + uVar2;
  uVar6 = (~uVar7 & uVar5 | uVar7 & uVar2) + uVar3 + 0xf57c0faf + local_128;
  uVar4 = (uVar6 >> 0x19 | uVar6 * 0x80) + uVar7;
  uVar6 = (~uVar4 & uVar2 | uVar4 & uVar7) + uVar5 + 0x4787c62a + local_124;
  uVar3 = (uVar6 >> 0x14 | uVar6 * 0x1000) + uVar4;
  uVar6 = (~uVar3 & uVar7 | uVar3 & uVar4) + uVar2 + 0xa8304613 + local_120;
  uVar6 = (uVar6 >> 0xf | uVar6 * 0x20000) + uVar3;
  uVar2 = (~uVar6 & uVar4 | uVar6 & uVar3) + uVar7 + 0xfd469501 + local_11c;
  uVar5 = (uVar2 >> 10 | uVar2 * 0x400000) + uVar6;
  uVar2 = (~uVar5 & uVar3 | uVar5 & uVar6) + uVar4 + 0x698098d8 + local_118;
  uVar2 = (uVar2 >> 0x19 | uVar2 * 0x80) + uVar5;
  uVar4 = (~uVar2 & uVar6 | uVar2 & uVar5) + uVar3 + 0x8b44f7af + local_114;
  uVar4 = (uVar4 >> 0x14 | uVar4 * 0x1000) + uVar2;
  uVar6 = (~uVar4 & uVar5 | uVar4 & uVar2) + (uVar6 - 0xa44f) + local_110;
  uVar6 = (uVar6 >> 0xf | uVar6 * 0x20000) + uVar4;
  uVar3 = uVar5 + 0x895cd7be + local_10c + (~uVar6 & uVar2 | uVar6 & uVar4);
  uVar3 = (uVar3 >> 10 | uVar3 * 0x400000) + uVar6;
  uVar2 = (~uVar3 & uVar4 | uVar3 & uVar6) + uVar2 + 0x6b901122 + local_108;
  uVar2 = (uVar2 >> 0x19 | uVar2 * 0x80) + uVar3;
  uVar4 = (~uVar2 & uVar6 | uVar2 & uVar3) + uVar4 + 0xfd987193 + local_104;
  uVar4 = (uVar4 >> 0x14 | uVar4 * 0x1000) + uVar2;
  uVar6 = (~uVar4 & uVar3 | uVar4 & uVar2) + uVar6 + 0xa679438e + local_100;
  uVar6 = (uVar6 >> 0xf | uVar6 * 0x20000) + uVar4;
  uVar3 = (~uVar6 & uVar2 | uVar6 & uVar4) + uVar3 + 0x49b40821 + local_fc;
  uVar3 = (uVar3 >> 10 | uVar3 * 0x400000) + uVar6;
  uVar2 = (uVar3 & uVar4 | ~uVar4 & uVar6) + local_134 + -0x9e1da9e + uVar2;
  uVar2 = (uVar2 >> 0x1b | uVar2 * 0x20) + uVar3;
  uVar4 = local_120 + -0x3fbf4cc0 + uVar4 + (uVar2 & uVar6 | ~uVar6 & uVar3);
  uVar5 = (uVar4 >> 0x17 | uVar4 * 0x200) + uVar2;
  uVar6 = local_10c + 0x265e5a51 + uVar6 + (uVar5 & uVar3 | ~uVar3 & uVar2);
  uVar4 = (uVar6 >> 0x12 | uVar6 * 0x4000) + uVar5;
  uVar6 = (uVar4 & uVar2 | ~uVar2 & uVar5) + local_138 + -0x16493856 + uVar3;
  uVar6 = (uVar6 >> 0xc | uVar6 * 0x100000) + uVar4;
  uVar2 = local_124 + -0x29d0efa3 + uVar2 + (uVar6 & uVar5 | ~uVar5 & uVar4);
  uVar3 = (uVar2 >> 0x1b | uVar2 * 0x20) + uVar6;
  uVar2 = (uVar3 & uVar4 | ~uVar4 & uVar6) + local_110 + 0x2441453 + uVar5;
  uVar2 = (uVar2 >> 0x17 | uVar2 * 0x200) + uVar3;
  uVar4 = (uVar2 & uVar6 | ~uVar6 & uVar3) + local_fc + -0x275e197f + uVar4;
  uVar4 = (uVar4 >> 0x12 | uVar4 * 0x4000) + uVar2;
  uVar6 = local_128 + -0x182c0438 + uVar6 + (uVar4 & uVar3 | ~uVar3 & uVar2);
  uVar5 = (uVar6 >> 0xc | uVar6 * 0x100000) + uVar4;
  uVar6 = (uVar5 & uVar2 | ~uVar2 & uVar4) + local_114 + 0x21e1cde6 + uVar3;
  uVar6 = (uVar6 >> 0x1b | uVar6 * 0x20) + uVar5;
  uVar2 = (uVar6 & uVar4 | ~uVar4 & uVar5) + local_100 + -0x3cc8f82a + uVar2;
  uVar2 = (uVar2 >> 0x17 | uVar2 * 0x200) + uVar6;
  uVar4 = local_12c + -0xb2af279 + uVar4 + (uVar2 & uVar5 | ~uVar5 & uVar6);
  uVar3 = (uVar4 >> 0x12 | uVar4 * 0x4000) + uVar2;
  uVar4 = (uVar3 & uVar6 | ~uVar6 & uVar2) + local_118 + 0x455a14ed + uVar5;
  uVar4 = (uVar4 >> 0xc | uVar4 * 0x100000) + uVar3;
  uVar6 = (uVar4 & uVar2 | ~uVar2 & uVar3) + local_104 + -0x561c16fb + uVar6;
  uVar6 = (uVar6 >> 0x1b | uVar6 * 0x20) + uVar4;
  uVar2 = local_130 + -0x3105c08 + uVar2 + (uVar6 & uVar3 | ~uVar3 & uVar4);
  uVar5 = (uVar2 >> 0x17 | uVar2 * 0x200) + uVar6;
  uVar2 = (uVar5 & uVar4 | ~uVar4 & uVar6) + local_11c + 0x676f02d9 + uVar3;
  uVar2 = (uVar2 >> 0x12 | uVar2 * 0x4000) + uVar5;
  uVar4 = (uVar2 & uVar6 | ~uVar6 & uVar5) + local_108 + -0x72d5b376 + uVar4;
  uVar4 = (uVar4 >> 0xc | uVar4 * 0x100000) + uVar2;
  uVar6 = local_124 + -0x5c6be + uVar6 + (uVar2 ^ uVar5 ^ uVar4);
  uVar3 = (uVar6 >> 0x1c | uVar6 * 0x10) + uVar4;
  uVar6 = local_118 + -0x788e097f + uVar5 + (uVar4 ^ uVar2 ^ uVar3);
  uVar5 = (uVar6 >> 0x15 | uVar6 * 0x800) + uVar3;
  uVar6 = (uVar3 ^ uVar4 ^ uVar5) + local_10c + 0x6d9d6122 + uVar2;
  uVar6 = (uVar6 >> 0x10 | uVar6 * 0x10000) + uVar5;
  uVar2 = local_100 + -0x21ac7f4 + uVar4 + (uVar5 ^ uVar3 ^ uVar6);
  uVar2 = (uVar2 >> 9 | uVar2 * 0x800000) + uVar6;
  uVar4 = local_134 + -0x5b4115bc + uVar3 + (uVar6 ^ uVar5 ^ uVar2);
  uVar3 = (uVar4 >> 0x1c | uVar4 * 0x10) + uVar2;
  uVar4 = (uVar2 ^ uVar6 ^ uVar3) + local_128 + 0x4bdecfa9 + uVar5;
  uVar4 = (uVar4 >> 0x15 | uVar4 * 0x800) + uVar3;
  uVar6 = local_11c + -0x944b4a0 + uVar6 + (uVar3 ^ uVar2 ^ uVar4);
  uVar5 = (uVar6 >> 0x10 | uVar6 * 0x10000) + uVar4;
  uVar6 = local_110 + -0x41404390 + uVar2 + (uVar4 ^ uVar3 ^ uVar5);
  uVar2 = (uVar6 >> 9 | uVar6 * 0x800000) + uVar5;
  uVar6 = (uVar5 ^ uVar4 ^ uVar2) + local_104 + 0x289b7ec6 + uVar3;
  uVar6 = (uVar6 >> 0x1c | uVar6 * 0x10) + uVar2;
  uVar4 = local_138 + -0x155ed806 + uVar4 + (uVar2 ^ uVar5 ^ uVar6);
  uVar3 = (uVar4 >> 0x15 | uVar4 * 0x800) + uVar6;
  uVar4 = local_12c + -0x2b10cf7b + uVar5 + (uVar6 ^ uVar2 ^ uVar3);
  uVar5 = (uVar4 >> 0x10 | uVar4 * 0x10000) + uVar3;
  uVar2 = (uVar3 ^ uVar6 ^ uVar5) + local_120 + 0x4881d05 + uVar2;
  uVar4 = (uVar2 >> 9 | uVar2 * 0x800000) + uVar5;
  uVar6 = local_114 + -0x262b2fc7 + uVar6 + (uVar5 ^ uVar3 ^ uVar4);
  uVar2 = (uVar6 >> 0x1c | uVar6 * 0x10) + uVar4;
  uVar6 = local_108 + -0x1924661b + uVar3 + (uVar4 ^ uVar5 ^ uVar2);
  uVar3 = (uVar6 >> 0x15 | uVar6 * 0x800) + uVar2;
  uVar6 = (uVar2 ^ uVar4 ^ uVar3) + local_fc + 0x1fa27cf8 + uVar5;
  uVar6 = (uVar6 >> 0x10 | uVar6 * 0x10000) + uVar3;
  uVar4 = (uVar3 ^ uVar2 ^ uVar6) + local_130 + -0x3b53a99b + uVar4;
  uVar4 = (uVar4 >> 9 | uVar4 * 0x800000) + uVar6;
  uVar2 = ((~uVar3 | uVar4) ^ uVar6) + local_138 + -0xbd6ddbc + uVar2;
  uVar2 = (uVar2 >> 0x1a | uVar2 * 0x40) + uVar4;
  uVar3 = ((~uVar6 | uVar2) ^ uVar4) + local_11c + 0x432aff97 + uVar3;
  uVar3 = (uVar3 >> 0x16 | uVar3 * 0x400) + uVar2;
  uVar6 = ((~uVar4 | uVar3) ^ uVar2) + local_100 + -0x546bdc59 + uVar6;
  uVar6 = (uVar6 >> 0x11 | uVar6 * 0x8000) + uVar3;
  uVar4 = ((~uVar2 | uVar6) ^ uVar3) + local_124 + -0x36c5fc7 + uVar4;
  uVar4 = (uVar4 >> 0xb | uVar4 * 0x200000) + uVar6;
  uVar2 = ((~uVar3 | uVar4) ^ uVar6) + local_108 + 0x655b59c3 + uVar2;
  uVar2 = (uVar2 >> 0x1a | uVar2 * 0x40) + uVar4;
  uVar3 = ((~uVar6 | uVar2) ^ uVar4) + local_12c + -0x70f3336e + uVar3;
  uVar3 = (uVar3 >> 0x16 | uVar3 * 0x400) + uVar2;
  uVar6 = ((~uVar4 | uVar3) ^ uVar2) + local_110 + -0x100b83 + uVar6;
  uVar6 = (uVar6 >> 0x11 | uVar6 * 0x8000) + uVar3;
  uVar4 = ((~uVar2 | uVar6) ^ uVar3) + local_134 + -0x7a7ba22f + uVar4;
  uVar4 = (uVar4 >> 0xb | uVar4 * 0x200000) + uVar6;
  uVar2 = local_118 + 0x6fa87e4f + uVar2 + ((~uVar3 | uVar4) ^ uVar6);
  uVar5 = (uVar2 >> 0x1a | uVar2 * 0x40) + uVar4;
  uVar2 = local_fc + -0x1d31920 + uVar3 + ((~uVar6 | uVar5) ^ uVar4);
  uVar3 = (uVar2 >> 0x16 | uVar2 * 0x400) + uVar5;
  uVar6 = local_120 + -0x5cfebcec + uVar6 + ((~uVar4 | uVar3) ^ uVar5);
  uVar2 = (uVar6 >> 0x11 | uVar6 * 0x8000) + uVar3;
  uVar6 = local_104 + 0x4e0811a1 + uVar4 + ((~uVar5 | uVar2) ^ uVar3);
  uVar4 = (uVar6 >> 0xb | uVar6 * 0x200000) + uVar2;
  uVar6 = ((~uVar3 | uVar4) ^ uVar2) + local_128 + -0x8ac817e + uVar5;
  uVar6 = (uVar6 >> 0x1a | uVar6 * 0x40) + uVar4;
  *param_1 = *param_1 + uVar6;
  uVar3 = ((~uVar2 | uVar6) ^ uVar4) + local_10c + -0x42c50dcb + uVar3;
  uVar3 = (uVar3 >> 0x16 | uVar3 * 0x400) + uVar6;
  param_1[3] = param_1[3] + uVar3;
  uVar2 = ((~uVar4 | uVar3) ^ uVar6) + local_130 + 0x2ad7d2bb + uVar2;
  uVar2 = (uVar2 >> 0x11 | uVar2 * 0x8000) + uVar3;
  param_1[2] = param_1[2] + uVar2;
  uVar6 = ((~uVar6 | uVar2) ^ uVar3) + local_114 + -0x14792c6f + uVar4;
  param_1[1] = (uVar6 >> 0xb | uVar6 * 0x200000) + param_1[1] + uVar2;
  return;
}


==================================================================

### FUNC 00114e40 (246 bytes) name=FUN_00114e40

void FUN_00114e40(uint *param_1,void *param_2,uint param_3)

{
  uint uVar1;
  ulong __n;
  uint uVar2;
  uint uVar3;
  uint *__dest;
  uint uVar4;
  
  uVar2 = param_3 * 8;
  uVar3 = *param_1;
  uVar1 = uVar3 + uVar2;
  *param_1 = uVar1;
  uVar4 = uVar3 >> 3 & 0x3f;
  uVar3 = 0x40 - uVar4;
  if (uVar2 < uVar1 || uVar2 - uVar1 == 0) {
    uVar2 = param_1[1];
  }
  else {
    uVar2 = param_1[1] + 1;
  }
  param_1[1] = (param_3 >> 0x1d) + uVar2;
  if (param_3 < uVar3) {
    __dest = (uint *)((long)param_1 + (ulong)uVar4 + 0x18);
    __n = 0;
    uVar3 = 0;
  }
  else {
    __n = (ulong)uVar3;
    __dest = param_1 + 6;
    memcpy((void *)((long)param_1 + (ulong)uVar4 + 0x18),param_2,__n);
    FUN_00114670(param_1 + 2,__dest);
    uVar2 = 0x80 - uVar4;
    if (0x80 - uVar4 <= param_3) {
      while( true ) {
        uVar3 = uVar2;
        FUN_00114670(param_1 + 2,(long)param_2 + __n);
        if (param_3 < uVar3 + 0x40) break;
        __n = (ulong)uVar3;
        uVar2 = uVar3 + 0x40;
      }
      __n = (ulong)uVar3;
    }
  }
  memcpy(__dest,(void *)(__n + (long)param_2),(ulong)(param_3 - uVar3));
  return;
}


==================================================================

### FUNC 00114f50 (151 bytes) name=FUN_00114f50

void FUN_00114f50(uint *param_1)

{
  uint uVar1;
  int iVar2;
  long in_FS_OFFSET;
  undefined1 auStack_28 [8];
  long local_20;
  
  local_20 = *(long *)(in_FS_OFFSET + 0x28);
  uVar1 = *param_1 >> 3 & 0x3f;
  iVar2 = 0x78 - uVar1;
  if (uVar1 < 0x38) {
    iVar2 = 0x38 - uVar1;
  }
  FUN_001145b0(auStack_28,param_1,8);
  FUN_00114e40(param_1,&DAT_0033f5a0,iVar2);
  FUN_00114e40(param_1,auStack_28,8);
  FUN_001145b0(param_1 + 0x16,param_1 + 2,0x10);
  if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
    return;
  }
                    /* WARNING: Subroutine does not return */
  __stack_chk_fail();
}


==================================================================

### FUNC 00114ff0 (112 bytes) name=FUN_00114ff0

bool FUN_00114ff0(long param_1,int param_2)

{
  if ((((((0x373 < param_2) && (0.0 < *(float *)(param_1 + 0x2c4))) &&
        (*(float *)(param_1 + 0x2c4) <= DAT_00131e20)) &&
       ((0.0 < *(float *)(param_1 + 0x2cc) && (*(float *)(param_1 + 0x2cc) <= DAT_00131e20)))) &&
      ((0.0 < *(float *)(param_1 + 0x2d0) &&
       ((*(float *)(param_1 + 0x2d0) <= DAT_00131e20 && (*(int *)(param_1 + 0x2f0) + 100U < 0xc9))))
      )) && (-0x65 < *(int *)(param_1 + 0x2f4))) {
    return *(int *)(param_1 + 0x2f4) < 0x65;
  }
  return false;
}


==================================================================

### FUNC 00115070 (114 bytes) name=FUN_00115070

void FUN_00115070(undefined8 *param_1)

{
  *param_1 = 0;
  *(undefined4 *)(param_1 + 1) = 0;
  *(undefined1 *)((long)param_1 + 0xc) = 0;
  param_1[2] = 0;
  *(undefined4 *)(param_1 + 3) = 0;
  *(undefined1 *)((long)param_1 + 0x1c) = 0;
  param_1[4] = 0;
  *(undefined4 *)(param_1 + 5) = 0;
  *(undefined1 *)((long)param_1 + 0x2c) = 0;
  param_1[6] = 0;
  *(undefined4 *)(param_1 + 7) = 0;
  *(undefined1 *)((long)param_1 + 0x3c) = 0;
  param_1[8] = 0;
  *(undefined4 *)(param_1 + 9) = 0;
  *(undefined1 *)((long)param_1 + 0x4c) = 0;
  param_1[10] = 0;
  *(undefined4 *)(param_1 + 0xb) = 0;
  *(undefined1 *)((long)param_1 + 0x5c) = 0;
  return;
}


==================================================================

### FUNC 001150f0 (1116 bytes) name=FUN_001150f0

undefined8 FUN_001150f0(long *param_1,char *param_2)

{
  FILE *__s;
  undefined8 uVar1;
  long lVar2;
  uint uVar3;
  undefined8 *puVar4;
  int iVar5;
  int iVar6;
  byte bVar7;
  undefined4 local_16c;
  undefined4 local_168;
  uint local_164;
  undefined4 local_160;
  int local_15c;
  undefined4 local_d8;
  undefined4 local_d4;
  undefined4 local_d0;
  undefined4 local_cc;
  undefined4 local_c8;
  undefined4 local_c4;
  
  bVar7 = 0;
  if ((((param_1[2] == 0) ||
       ((((*param_1 != 0 && (9999999 < (int)param_1[1] - 1U)) || (9999999 < (int)param_1[3] - 1U))
        || ((param_1[4] != 0 && (9999999 < (int)param_1[5] - 1U)))))) ||
      ((param_1[6] != 0 && (9999999 < (int)param_1[7] - 1U)))) ||
     ((((param_1[8] != 0 && (9999999 < (int)param_1[9] - 1U)) ||
       ((param_1[10] != 0 && (9999999 < (int)param_1[0xb] - 1U)))) ||
      (__s = fopen(param_2,"wb"), __s == (FILE *)0x0)))) {
    uVar1 = 0;
  }
  else {
    local_16c = 0;
    puVar4 = (undefined8 *)&local_d8;
    for (lVar2 = 0x13; lVar2 != 0; lVar2 = lVar2 + -1) {
      *puVar4 = 0;
      puVar4 = puVar4 + (ulong)bVar7 * -2 + 1;
    }
    local_d8 = 0x5bb5b57b;
    if ((void *)*param_1 != (void *)0x0) {
      iVar5 = (int)param_1[1];
      iVar6 = (iVar5 + 3U & 0xfffffffc) - iVar5;
      fwrite((void *)*param_1,1,(long)iVar5,__s);
      if (0 < iVar6) {
        iVar5 = 0;
        do {
          fwrite(&local_16c,1,1,__s);
          iVar5 = iVar5 + 1;
        } while (iVar5 != iVar6);
      }
    }
    if (param_1[2] != 0) {
      uVar3 = (int)param_1[3] + 3U & 0xfffffffc;
      iVar5 = uVar3 - (int)param_1[3];
      puVar4 = (undefined8 *)&local_168;
      for (lVar2 = 0x11; lVar2 != 0; lVar2 = lVar2 + -1) {
        *puVar4 = 0;
        puVar4 = puVar4 + (ulong)bVar7 * -2 + 1;
      }
      local_168 = 0x5bb5b55b;
      local_164 = uVar3;
      lVar2 = ftell(__s);
      local_d4 = (undefined4)lVar2;
      fwrite(&local_168,0x88,1,__s);
      fwrite((void *)param_1[2],1,(long)(int)param_1[3],__s);
      iVar6 = 0;
      if (0 < iVar5) {
        do {
          fwrite(&local_16c,1,1,__s);
          iVar6 = iVar6 + 1;
        } while (iVar6 != iVar5);
      }
    }
    if (param_1[4] != 0) {
      uVar3 = (int)param_1[5] + 3U & 0xfffffffc;
      iVar5 = uVar3 - (int)param_1[5];
      puVar4 = (undefined8 *)&local_168;
      for (lVar2 = 0x11; lVar2 != 0; lVar2 = lVar2 + -1) {
        *puVar4 = 0;
        puVar4 = puVar4 + (ulong)bVar7 * -2 + 1;
      }
      local_168 = 0x5bb5b55c;
      local_164 = uVar3;
      lVar2 = ftell(__s);
      local_d0 = (undefined4)lVar2;
      fwrite(&local_168,0x88,1,__s);
      fwrite((void *)param_1[4],1,(long)(int)param_1[5],__s);
      iVar6 = 0;
      if (0 < iVar5) {
        do {
          fwrite(&local_16c,1,1,__s);
          iVar6 = iVar6 + 1;
        } while (iVar6 != iVar5);
      }
    }
    if (param_1[6] != 0) {
      puVar4 = (undefined8 *)&local_168;
      for (lVar2 = 0x12; lVar2 != 0; lVar2 = lVar2 + -1) {
        *puVar4 = 0;
        puVar4 = puVar4 + (ulong)bVar7 * -2 + 1;
      }
      local_168 = 0x5bb5b55d;
      local_15c = (int)(int3)((uint)(int)param_1[7] >> 8);
      local_164 = local_15c << 8;
      lVar2 = ftell(__s);
      local_cc = (undefined4)lVar2;
      fwrite(&local_168,0x90,1,__s);
      fwrite((void *)param_1[6],1,(long)(int)local_164,__s);
    }
    if (param_1[8] != 0) {
      uVar3 = (int)param_1[9] + 3U & 0xfffffffc;
      iVar5 = uVar3 - (int)param_1[9];
      puVar4 = (undefined8 *)&local_168;
      for (lVar2 = 0x11; lVar2 != 0; lVar2 = lVar2 + -1) {
        *puVar4 = 0;
        puVar4 = puVar4 + (ulong)bVar7 * -2 + 1;
      }
      local_168 = 0x5bb5b55e;
      local_160 = 2;
      local_164 = uVar3;
      lVar2 = ftell(__s);
      local_c8 = (undefined4)lVar2;
      fwrite(&local_168,0x88,1,__s);
      fwrite((void *)param_1[8],1,(long)(int)param_1[9],__s);
      iVar6 = 0;
      if (0 < iVar5) {
        do {
          fwrite(&local_16c,1,1,__s);
          iVar6 = iVar6 + 1;
        } while (iVar6 != iVar5);
      }
    }
    if (param_1[10] != 0) {
      uVar3 = (int)param_1[0xb] + 3U & 0xfffffffc;
      iVar5 = uVar3 - (int)param_1[0xb];
      puVar4 = (undefined8 *)&local_168;
      for (lVar2 = 0x11; lVar2 != 0; lVar2 = lVar2 + -1) {
        *puVar4 = 0;
        puVar4 = puVar4 + (ulong)bVar7 * -2 + 1;
      }
      local_168 = 0x5bb5b55f;
      local_164 = uVar3;
      lVar2 = ftell(__s);
      local_c4 = (undefined4)lVar2;
      fwrite(&local_168,0x88,1,__s);
      fwrite((void *)param_1[10],1,(long)(int)param_1[0xb],__s);
      iVar6 = 0;
      if (0 < iVar5) {
        do {
          fwrite(&local_16c,1,1,__s);
          iVar6 = iVar6 + 1;
        } while (iVar6 != iVar5);
      }
    }
    fwrite(&local_d8,0x98,1,__s);
    fclose(__s);
    uVar1 = 1;
  }
  return uVar1;
}


==================================================================

### FUNC 00115580 (89 bytes) name=FUN_00115580

void FUN_00115580(undefined8 *param_1,undefined8 *param_2)

{
  if (param_2 != (undefined8 *)0x0) {
    *param_2 = *param_1;
    *(undefined4 *)(param_2 + 1) = *(undefined4 *)(param_1 + 1);
    param_2[2] = param_1[2];
    *(undefined4 *)(param_2 + 3) = *(undefined4 *)(param_1 + 3);
    param_2[4] = param_1[4];
    *(undefined4 *)(param_2 + 5) = *(undefined4 *)(param_1 + 5);
    param_2[6] = param_1[6];
    *(undefined4 *)(param_2 + 7) = *(undefined4 *)(param_1 + 7);
    param_2[8] = param_1[8];
    *(undefined4 *)(param_2 + 9) = *(undefined4 *)(param_1 + 9);
    param_2[10] = param_1[10];
    *(undefined4 *)(param_2 + 0xb) = *(undefined4 *)(param_1 + 0xb);
  }
  return;
}


==================================================================

### FUNC 001155e0 (269 bytes) name=FUN_001155e0

void FUN_001155e0(undefined8 *param_1)

{
  if ((void *)*param_1 != (void *)0x0) {
    if (*(char *)((long)param_1 + 0xc) != '\0') {
      operator_delete__((void *)*param_1);
      *(undefined1 *)((long)param_1 + 0xc) = 0;
    }
    *param_1 = 0;
    *(undefined4 *)(param_1 + 1) = 0;
  }
  if ((void *)param_1[2] != (void *)0x0) {
    if (*(char *)((long)param_1 + 0x1c) != '\0') {
      operator_delete__((void *)param_1[2]);
      *(undefined1 *)((long)param_1 + 0x1c) = 0;
    }
    param_1[2] = 0;
    *(undefined4 *)(param_1 + 3) = 0;
  }
  if ((void *)param_1[4] != (void *)0x0) {
    if (*(char *)((long)param_1 + 0x2c) != '\0') {
      operator_delete__((void *)param_1[4]);
      *(undefined1 *)((long)param_1 + 0x2c) = 0;
    }
    param_1[4] = 0;
    *(undefined4 *)(param_1 + 5) = 0;
  }
  if ((void *)param_1[6] != (void *)0x0) {
    if (*(char *)((long)param_1 + 0x3c) != '\0') {
      operator_delete__((void *)param_1[6]);
      *(undefined1 *)((long)param_1 + 0x3c) = 0;
    }
    param_1[6] = 0;
    *(undefined4 *)(param_1 + 7) = 0;
  }
  if ((void *)param_1[8] != (void *)0x0) {
    if (*(char *)((long)param_1 + 0x4c) != '\0') {
      operator_delete__((void *)param_1[8]);
      *(undefined1 *)((long)param_1 + 0x4c) = 0;
    }
    param_1[8] = 0;
    *(undefined4 *)(param_1 + 9) = 0;
  }
  if ((void *)param_1[10] != (void *)0x0) {
    if (*(char *)((long)param_1 + 0x5c) != '\0') {
      operator_delete__((void *)param_1[10]);
      *(undefined1 *)((long)param_1 + 0x5c) = 0;
    }
    param_1[10] = 0;
    *(undefined4 *)(param_1 + 0xb) = 0;
  }
  return;
}


==================================================================

### FUNC 00115700 (5 bytes) name=thunk_FUN_001155e0

void thunk_FUN_001155e0(undefined8 *param_1)

{
  if ((void *)*param_1 != (void *)0x0) {
    if (*(char *)((long)param_1 + 0xc) != '\0') {
      operator_delete__((void *)*param_1);
      *(undefined1 *)((long)param_1 + 0xc) = 0;
    }
    *param_1 = 0;
    *(undefined4 *)(param_1 + 1) = 0;
  }
  if ((void *)param_1[2] != (void *)0x0) {
    if (*(char *)((long)param_1 + 0x1c) != '\0') {
      operator_delete__((void *)param_1[2]);
      *(undefined1 *)((long)param_1 + 0x1c) = 0;
    }
    param_1[2] = 0;
    *(undefined4 *)(param_1 + 3) = 0;
  }
  if ((void *)param_1[4] != (void *)0x0) {
    if (*(char *)((long)param_1 + 0x2c) != '\0') {
      operator_delete__((void *)param_1[4]);
      *(undefined1 *)((long)param_1 + 0x2c) = 0;
    }
    param_1[4] = 0;
    *(undefined4 *)(param_1 + 5) = 0;
  }
  if ((void *)param_1[6] != (void *)0x0) {
    if (*(char *)((long)param_1 + 0x3c) != '\0') {
      operator_delete__((void *)param_1[6]);
      *(undefined1 *)((long)param_1 + 0x3c) = 0;
    }
    param_1[6] = 0;
    *(undefined4 *)(param_1 + 7) = 0;
  }
  if ((void *)param_1[8] != (void *)0x0) {
    if (*(char *)((long)param_1 + 0x4c) != '\0') {
      operator_delete__((void *)param_1[8]);
      *(undefined1 *)((long)param_1 + 0x4c) = 0;
    }
    param_1[8] = 0;
    *(undefined4 *)(param_1 + 9) = 0;
  }
  if ((void *)param_1[10] != (void *)0x0) {
    if (*(char *)((long)param_1 + 0x5c) != '\0') {
      operator_delete__((void *)param_1[10]);
      *(undefined1 *)((long)param_1 + 0x5c) = 0;
    }
    param_1[10] = 0;
    *(undefined4 *)(param_1 + 0xb) = 0;
  }
  return;
}


==================================================================

### FUNC 00115710 (5 bytes) name=thunk_FUN_001155e0

void thunk_FUN_001155e0(undefined8 *param_1)

{
  if ((void *)*param_1 != (void *)0x0) {
    if (*(char *)((long)param_1 + 0xc) != '\0') {
      operator_delete__((void *)*param_1);
      *(undefined1 *)((long)param_1 + 0xc) = 0;
    }
    *param_1 = 0;
    *(undefined4 *)(param_1 + 1) = 0;
  }
  if ((void *)param_1[2] != (void *)0x0) {
    if (*(char *)((long)param_1 + 0x1c) != '\0') {
      operator_delete__((void *)param_1[2]);
      *(undefined1 *)((long)param_1 + 0x1c) = 0;
    }
    param_1[2] = 0;
    *(undefined4 *)(param_1 + 3) = 0;
  }
  if ((void *)param_1[4] != (void *)0x0) {
    if (*(char *)((long)param_1 + 0x2c) != '\0') {
      operator_delete__((void *)param_1[4]);
      *(undefined1 *)((long)param_1 + 0x2c) = 0;
    }
    param_1[4] = 0;
    *(undefined4 *)(param_1 + 5) = 0;
  }
  if ((void *)param_1[6] != (void *)0x0) {
    if (*(char *)((long)param_1 + 0x3c) != '\0') {
      operator_delete__((void *)param_1[6]);
      *(undefined1 *)((long)param_1 + 0x3c) = 0;
    }
    param_1[6] = 0;
    *(undefined4 *)(param_1 + 7) = 0;
  }
  if ((void *)param_1[8] != (void *)0x0) {
    if (*(char *)((long)param_1 + 0x4c) != '\0') {
      operator_delete__((void *)param_1[8]);
      *(undefined1 *)((long)param_1 + 0x4c) = 0;
    }
    param_1[8] = 0;
    *(undefined4 *)(param_1 + 9) = 0;
  }
  if ((void *)param_1[10] != (void *)0x0) {
    if (*(char *)((long)param_1 + 0x5c) != '\0') {
      operator_delete__((void *)param_1[10]);
      *(undefined1 *)((long)param_1 + 0x5c) = 0;
    }
    param_1[10] = 0;
    *(undefined4 *)(param_1 + 0xb) = 0;
  }
  return;
}


==================================================================

### FUNC 00115720 (112 bytes) name=FUN_00115720

void FUN_00115720(undefined8 *param_1,undefined8 *param_2)

{
  if (param_2 != (undefined8 *)0x0) {
    FUN_001155e0();
    *param_1 = *param_2;
    *(undefined4 *)(param_1 + 1) = *(undefined4 *)(param_2 + 1);
    param_1[2] = param_2[2];
    *(undefined4 *)(param_1 + 3) = *(undefined4 *)(param_2 + 3);
    param_1[4] = param_2[4];
    *(undefined4 *)(param_1 + 5) = *(undefined4 *)(param_2 + 5);
    param_1[6] = param_2[6];
    *(undefined4 *)(param_1 + 7) = *(undefined4 *)(param_2 + 7);
    param_1[8] = param_2[8];
    *(undefined4 *)(param_1 + 9) = *(undefined4 *)(param_2 + 9);
    param_1[10] = param_2[10];
    *(undefined4 *)(param_1 + 0xb) = *(undefined4 *)(param_2 + 0xb);
  }
  return;
}


==================================================================

### FUNC 00115790 (1547 bytes) name=FUN_00115790

undefined4 FUN_00115790(undefined8 *param_1,char *param_2)

{
  int iVar1;
  undefined4 uVar2;
  FILE *__stream;
  long lVar3;
  size_t sVar4;
  void *pvVar5;
  int *piVar6;
  byte bVar7;
  int local_3a8;
  int local_3a4;
  int local_318;
  int local_314;
  int local_288;
  int local_284;
  int local_1f8;
  int local_1f4;
  int local_168;
  int local_164;
  int local_d8;
  int local_d4;
  int local_d0;
  int local_cc;
  int local_c8;
  int local_c4;
  
  bVar7 = 0;
  uVar2 = 0;
  FUN_001155e0();
  __stream = fopen(param_2,"rb");
  if (__stream == (FILE *)0x0) {
    return 0;
  }
  fseek(__stream,0,2);
  lVar3 = ftell(__stream);
  iVar1 = (int)lVar3;
  if (iVar1 < 0x400) goto LAB_00115950;
  piVar6 = &local_3a8;
  for (lVar3 = 0x11; lVar3 != 0; lVar3 = lVar3 + -1) {
    piVar6[0] = 0;
    piVar6[1] = 0;
    piVar6 = piVar6 + ((ulong)bVar7 * -2 + 1) * 2;
  }
  piVar6 = &local_318;
  for (lVar3 = 0x11; lVar3 != 0; lVar3 = lVar3 + -1) {
    piVar6[0] = 0;
    piVar6[1] = 0;
    piVar6 = piVar6 + ((ulong)bVar7 * -2 + 1) * 2;
  }
  piVar6 = &local_168;
  for (lVar3 = 0x12; lVar3 != 0; lVar3 = lVar3 + -1) {
    piVar6[0] = 0;
    piVar6[1] = 0;
    piVar6 = piVar6 + ((ulong)bVar7 * -2 + 1) * 2;
  }
  piVar6 = &local_288;
  for (lVar3 = 0x11; lVar3 != 0; lVar3 = lVar3 + -1) {
    piVar6[0] = 0;
    piVar6[1] = 0;
    piVar6 = piVar6 + ((ulong)bVar7 * -2 + 1) * 2;
  }
  piVar6 = &local_1f8;
  for (lVar3 = 0x11; lVar3 != 0; lVar3 = lVar3 + -1) {
    piVar6[0] = 0;
    piVar6[1] = 0;
    piVar6 = piVar6 + ((ulong)bVar7 * -2 + 1) * 2;
  }
  piVar6 = &local_d8;
  for (lVar3 = 0x13; lVar3 != 0; lVar3 = lVar3 + -1) {
    piVar6[0] = 0;
    piVar6[1] = 0;
    piVar6 = piVar6 + ((ulong)bVar7 * -2 + 1) * 2;
  }
  fseek(__stream,(long)(iVar1 + -0x98),0);
  sVar4 = fread(&local_d8,1,0x98,__stream);
  if (sVar4 != 0x98) goto LAB_00115950;
  if (local_d8 != 0x5bb5b57b) {
    fseek(__stream,0,0);
    sVar4 = fread(&local_3a8,1,0x88,__stream);
    if (sVar4 == 0x88) {
      if (local_3a8 == 0x5bb5b55b) {
        *(int *)(param_1 + 3) = local_3a4;
        if (9999999 < local_3a4 - 1U) goto LAB_00115c20;
        pvVar5 = operator_new__((long)local_3a4);
        *(undefined1 *)((long)param_1 + 0x1c) = 1;
        param_1[2] = pvVar5;
        iVar1 = *(int *)(param_1 + 3);
      }
      else {
        *(int *)(param_1 + 3) = iVar1;
        if (9999999 < iVar1 - 1U) goto LAB_00115c20;
        pvVar5 = operator_new__((long)iVar1);
        param_1[2] = pvVar5;
        *(undefined1 *)((long)param_1 + 0x1c) = 1;
        fseek(__stream,0,0);
        iVar1 = *(int *)(param_1 + 3);
        pvVar5 = (void *)param_1[2];
      }
      sVar4 = fread(pvVar5,1,(long)iVar1,__stream);
      if (((long)*(int *)(param_1 + 3) != sVar4) ||
         (uVar2 = FUN_00114ff0(param_1[2]), (char)uVar2 == '\0')) goto LAB_00115c20;
    }
    goto LAB_00115950;
  }
  if ((((local_d4 < 0) || (local_d0 < 0)) || (local_cc < 0)) || ((local_c8 < 0 || (local_c4 < 0))))
  goto LAB_00115c20;
  if (local_d4 != 0) {
    *(int *)(param_1 + 1) = local_d4;
    if (9999999 < local_d4 - 1U) goto LAB_00115c20;
    pvVar5 = operator_new__((long)local_d4);
    *param_1 = pvVar5;
    *(undefined1 *)((long)param_1 + 0xc) = 1;
    fseek(__stream,0,0);
    sVar4 = fread((void *)*param_1,1,(long)*(int *)(param_1 + 1),__stream);
    if ((long)*(int *)(param_1 + 1) != sVar4) goto LAB_00115c20;
  }
  fseek(__stream,(long)local_d4,0);
  local_3a8 = 0;
  sVar4 = fread(&local_3a8,1,0x88,__stream);
  if (((sVar4 == 0x88) && (local_3a8 == 0x5bb5b55b)) &&
     (*(int *)(param_1 + 3) = local_3a4, local_3a4 - 1U < 10000000)) {
    pvVar5 = operator_new__((long)local_3a4);
    param_1[2] = pvVar5;
    *(undefined1 *)((long)param_1 + 0x1c) = 1;
    sVar4 = fread(pvVar5,1,(long)*(int *)(param_1 + 3),__stream);
    if (((long)*(int *)(param_1 + 3) == sVar4) &&
       (uVar2 = FUN_00114ff0(param_1[2]), (char)uVar2 != '\0')) {
      if (0 < local_d0) {
        fseek(__stream,(long)local_d0,0);
        sVar4 = fread(&local_318,1,0x88,__stream);
        if (((sVar4 != 0x88) || (local_318 != 0x5bb5b55c)) ||
           (*(int *)(param_1 + 5) = local_314, 9999999 < local_314 - 1U)) goto LAB_00115c20;
        pvVar5 = operator_new__((long)local_314);
        param_1[4] = pvVar5;
        *(undefined1 *)((long)param_1 + 0x2c) = 1;
        sVar4 = fread(pvVar5,1,(long)*(int *)(param_1 + 5),__stream);
        if ((long)*(int *)(param_1 + 5) != sVar4) goto LAB_00115c20;
      }
      if (0 < local_cc) {
        fseek(__stream,(long)local_cc,0);
        sVar4 = fread(&local_168,1,0x90,__stream);
        if (((sVar4 != 0x90) || (local_168 != 0x5bb5b55d)) ||
           (*(int *)(param_1 + 7) = local_164, 9999999 < local_164 - 1U)) goto LAB_00115c20;
        pvVar5 = operator_new__((long)local_164);
        param_1[6] = pvVar5;
        *(undefined1 *)((long)param_1 + 0x3c) = 1;
        sVar4 = fread(pvVar5,1,(long)*(int *)(param_1 + 7),__stream);
        if ((long)*(int *)(param_1 + 7) != sVar4) goto LAB_00115c20;
      }
      if (0 < local_c8) {
        fseek(__stream,(long)local_c8,0);
        sVar4 = fread(&local_288,1,0x88,__stream);
        if (((sVar4 != 0x88) || (local_288 != 0x5bb5b55e)) ||
           (*(int *)(param_1 + 9) = local_284, 9999999 < local_284 - 1U)) goto LAB_00115c20;
        pvVar5 = operator_new__((long)local_284);
        param_1[8] = pvVar5;
        *(undefined1 *)((long)param_1 + 0x4c) = 1;
        sVar4 = fread(pvVar5,1,(long)*(int *)(param_1 + 9),__stream);
        if ((long)*(int *)(param_1 + 9) != sVar4) goto LAB_00115c20;
      }
      if (local_c4 < 1) {
LAB_00115950:
        fclose(__stream);
        return uVar2;
      }
      fseek(__stream,(long)local_c4,0);
      sVar4 = fread(&local_1f8,1,0x88,__stream);
      if (((sVar4 == 0x88) && (local_1f8 == 0x5bb5b55f)) &&
         (*(int *)(param_1 + 0xb) = local_1f4, local_1f4 - 1U < 10000000)) {
        pvVar5 = operator_new__((long)local_1f4);
        param_1[10] = pvVar5;
        *(undefined1 *)((long)param_1 + 0x5c) = 1;
        sVar4 = fread(pvVar5,1,(long)*(int *)(param_1 + 0xb),__stream);
        if ((long)*(int *)(param_1 + 0xb) == sVar4) goto LAB_00115950;
      }
    }
  }
LAB_00115c20:
  fclose(__stream);
  FUN_001155e0(param_1);
  return 0;
}


==================================================================

### FUNC 00115db0 (13 bytes) name=FUN_00115db0

bool FUN_00115db0(undefined8 param_1,int param_2)

{
  return param_2 - 1U < 10000000;
}


==================================================================

### FUNC 00115dc0 (131 bytes) name=FUN_00115dc0

undefined8 FUN_00115dc0(undefined8 *param_1,void *param_2,int param_3,char param_4)

{
  undefined8 uVar1;
  void *__dest;
  
  uVar1 = 0;
  if (param_3 - 1U < 10000000) {
    if (((void *)*param_1 != (void *)0x0) && (*(char *)((long)param_1 + 0xc) != '\0')) {
      operator_delete__((void *)*param_1);
    }
    if (param_4 == '\0') {
      *param_1 = param_2;
    }
    else {
      __dest = operator_new__((long)param_3);
      *param_1 = __dest;
      memcpy(__dest,param_2,(long)param_3);
    }
    *(char *)((long)param_1 + 0xc) = param_4;
    *(int *)(param_1 + 1) = param_3;
    uVar1 = 1;
  }
  return uVar1;
}


==================================================================

### FUNC 00115e50 (134 bytes) name=FUN_00115e50

undefined8 FUN_00115e50(long param_1,void *param_2,int param_3,char param_4)

{
  undefined8 uVar1;
  void *__dest;
  
  uVar1 = 0;
  if (param_3 - 1U < 10000000) {
    if ((*(void **)(param_1 + 0x10) != (void *)0x0) && (*(char *)(param_1 + 0x1c) != '\0')) {
      operator_delete__(*(void **)(param_1 + 0x10));
    }
    if (param_4 == '\0') {
      *(void **)(param_1 + 0x10) = param_2;
    }
    else {
      __dest = operator_new__((long)param_3);
      *(void **)(param_1 + 0x10) = __dest;
      memcpy(__dest,param_2,(long)param_3);
    }
    *(char *)(param_1 + 0x1c) = param_4;
    *(int *)(param_1 + 0x18) = param_3;
    uVar1 = 1;
  }
  return uVar1;
}


==================================================================

### FUNC 00115ee0 (134 bytes) name=FUN_00115ee0

undefined8 FUN_00115ee0(long param_1,void *param_2,int param_3,char param_4)

{
  undefined8 uVar1;
  void *__dest;
  
  uVar1 = 0;
  if (param_3 - 1U < 10000000) {
    if ((*(void **)(param_1 + 0x20) != (void *)0x0) && (*(char *)(param_1 + 0x2c) != '\0')) {
      operator_delete__(*(void **)(param_1 + 0x20));
    }
    if (param_4 == '\0') {
      *(void **)(param_1 + 0x20) = param_2;
    }
    else {
      __dest = operator_new__((long)param_3);
      *(void **)(param_1 + 0x20) = __dest;
      memcpy(__dest,param_2,(long)param_3);
    }
    *(char *)(param_1 + 0x2c) = param_4;
    *(int *)(param_1 + 0x28) = param_3;
    uVar1 = 1;
  }
  return uVar1;
}


==================================================================

### FUNC 00115f70 (145 bytes) name=FUN_00115f70

undefined8 FUN_00115f70(long param_1,void *param_2,uint param_3,char param_4)

{
  uint uVar1;
  undefined8 uVar2;
  void *__dest;
  
  uVar1 = param_3 + 0xff;
  if (-1 < (int)param_3) {
    uVar1 = param_3;
  }
  uVar2 = 0;
  uVar1 = uVar1 & 0xffffff00;
  if (uVar1 - 1 < 10000000) {
    if ((*(void **)(param_1 + 0x30) != (void *)0x0) && (*(char *)(param_1 + 0x3c) != '\0')) {
      operator_delete__(*(void **)(param_1 + 0x30));
    }
    if (param_4 == '\0') {
      *(void **)(param_1 + 0x30) = param_2;
    }
    else {
      __dest = operator_new__((long)(int)uVar1);
      *(void **)(param_1 + 0x30) = __dest;
      memcpy(__dest,param_2,(long)(int)uVar1);
    }
    *(char *)(param_1 + 0x3c) = param_4;
    *(uint *)(param_1 + 0x38) = uVar1;
    uVar2 = 1;
  }
  return uVar2;
}


==================================================================

### FUNC 00116010 (134 bytes) name=FUN_00116010

undefined8 FUN_00116010(long param_1,void *param_2,int param_3,char param_4)

{
  undefined8 uVar1;
  void *__dest;
  
  uVar1 = 0;
  if (param_3 - 1U < 10000000) {
    if ((*(void **)(param_1 + 0x40) != (void *)0x0) && (*(char *)(param_1 + 0x4c) != '\0')) {
      operator_delete__(*(void **)(param_1 + 0x40));
    }
    if (param_4 == '\0') {
      *(void **)(param_1 + 0x40) = param_2;
    }
    else {
      __dest = operator_new__((long)param_3);
      *(void **)(param_1 + 0x40) = __dest;
      memcpy(__dest,param_2,(long)param_3);
    }
    *(char *)(param_1 + 0x4c) = param_4;
    *(int *)(param_1 + 0x48) = param_3;
    uVar1 = 1;
  }
  return uVar1;
}


==================================================================

### FUNC 001160a0 (134 bytes) name=FUN_001160a0

undefined8 FUN_001160a0(long param_1,void *param_2,int param_3,char param_4)

{
  undefined8 uVar1;
  void *__dest;
  
  uVar1 = 0;
  if (param_3 - 1U < 10000000) {
    if ((*(void **)(param_1 + 0x50) != (void *)0x0) && (*(char *)(param_1 + 0x5c) != '\0')) {
      operator_delete__(*(void **)(param_1 + 0x50));
    }
    if (param_4 == '\0') {
      *(void **)(param_1 + 0x50) = param_2;
    }
    else {
      __dest = operator_new__((long)param_3);
      *(void **)(param_1 + 0x50) = __dest;
      memcpy(__dest,param_2,(long)param_3);
    }
    *(char *)(param_1 + 0x5c) = param_4;
    *(int *)(param_1 + 0x58) = param_3;
    uVar1 = 1;
  }
  return uVar1;
}


==================================================================

### FUNC 00116130 (21 bytes) name=FUN_00116130

undefined4 FUN_00116130(undefined8 *param_1,undefined8 *param_2)

{
  if (param_2 != (undefined8 *)0x0) {
    *param_2 = *param_1;
    return *(undefined4 *)(param_1 + 1);
  }
  return 0xffffffff;
}


==================================================================

### FUNC 00116150 (22 bytes) name=FUN_00116150

undefined4 FUN_00116150(long param_1,undefined8 *param_2)

{
  if (param_2 != (undefined8 *)0x0) {
    *param_2 = *(undefined8 *)(param_1 + 0x10);
    return *(undefined4 *)(param_1 + 0x18);
  }
  return 0xffffffff;
}


==================================================================

### FUNC 00116170 (22 bytes) name=FUN_00116170

undefined4 FUN_00116170(long param_1,undefined8 *param_2)

{
  if (param_2 != (undefined8 *)0x0) {
    *param_2 = *(undefined8 *)(param_1 + 0x20);
    return *(undefined4 *)(param_1 + 0x28);
  }
  return 0xffffffff;
}


==================================================================

### FUNC 00116190 (22 bytes) name=FUN_00116190

undefined4 FUN_00116190(long param_1,undefined8 *param_2)

{
  if (param_2 != (undefined8 *)0x0) {
    *param_2 = *(undefined8 *)(param_1 + 0x30);
    return *(undefined4 *)(param_1 + 0x38);
  }
  return 0xffffffff;
}


==================================================================

### FUNC 001161b0 (22 bytes) name=FUN_001161b0

undefined4 FUN_001161b0(long param_1,undefined8 *param_2)

{
  if (param_2 != (undefined8 *)0x0) {
    *param_2 = *(undefined8 *)(param_1 + 0x40);
    return *(undefined4 *)(param_1 + 0x48);
  }
  return 0xffffffff;
}


==================================================================

### FUNC 001161d0 (22 bytes) name=FUN_001161d0

undefined4 FUN_001161d0(long param_1,undefined8 *param_2)

{
  if (param_2 != (undefined8 *)0x0) {
    *param_2 = *(undefined8 *)(param_1 + 0x50);
    return *(undefined4 *)(param_1 + 0x58);
  }
  return 0xffffffff;
}


==================================================================

### FUNC 001161f0 (83 bytes) name=FUN_001161f0

void FUN_001161f0(ulong *param_1,ulong param_2)

{
  void *pvVar1;
  undefined8 *puVar2;
  
  *param_1 = param_2;
  param_1[1] = 0;
  param_1[2] = 0;
  if (param_2 != 0) {
    pvVar1 = operator_new__(param_2);
    param_1[1] = (ulong)pvVar1;
    param_1[2] = (ulong)pvVar1;
    return;
  }
  puVar2 = (undefined8 *)__cxa_allocate_exception(8);
  *puVar2 = "ParamError: Invalid array size.[MStream::MStream]";
                    /* WARNING: Subroutine does not return */
  __cxa_throw(puVar2,&PTR_vtable_0033ec10,0);
}


==================================================================

### FUNC 00116250 (84 bytes) name=FUN_00116250

void FUN_00116250(ulong *param_1,char *param_2,size_t param_3)

{
  void *__dest;
  
  if (param_3 == 0) {
    param_3 = strlen(param_2);
    param_3 = param_3 + 1;
  }
  *param_1 = param_3 + 1;
  __dest = operator_new__(param_3 + 1);
  param_1[1] = (ulong)__dest;
  memcpy(__dest,param_2,param_3);
  *(undefined1 *)(param_1[1] + param_3) = 0;
  param_1[2] = param_1[1] + *param_1;
  return;
}


==================================================================

### FUNC 001162b0 (84 bytes) name=FUN_001162b0

void FUN_001162b0(ulong *param_1,long *param_2)

{
  void *__src;
  void *__dest;
  ulong uVar1;
  
  uVar1 = *(long *)(*param_2 + -0x18) + 1;
  *param_1 = uVar1;
  __dest = operator_new__(uVar1);
  __src = (void *)*param_2;
  param_1[1] = (ulong)__dest;
  memcpy(__dest,__src,*param_1 - 1);
  *(undefined1 *)((param_1[1] - 1) + *param_1) = 0;
  param_1[2] = param_1[1] + *param_1;
  return;
}


==================================================================

### FUNC 00116310 (23 bytes) name=FUN_00116310

void FUN_00116310(undefined8 *param_1,undefined8 *param_2)

{
  *param_1 = *param_2;
  param_1[1] = param_2[1];
  param_1[2] = param_2[2];
  return;
}


==================================================================

### FUNC 00116330 (45 bytes) name=FUN_00116330

void FUN_00116330(ulong *param_1,ulong *param_2)

{
  void *pvVar1;
  
  *param_1 = *param_2;
  pvVar1 = (void *)0x0;
  if ((void *)param_1[1] != (void *)0x0) {
    operator_delete__((void *)param_1[1]);
    pvVar1 = operator_new__(*param_1);
    param_1[1] = (ulong)pvVar1;
  }
  param_1[2] = (ulong)pvVar1;
  return;
}


==================================================================

### FUNC 00116360 (16 bytes) name=FUN_00116360

void FUN_00116360(long param_1)

{
  if (*(void **)(param_1 + 8) != (void *)0x0) {
    operator_delete__(*(void **)(param_1 + 8));
    return;
  }
  return;
}


==================================================================

### FUNC 00116380 (253 bytes) name=FUN_00116380

long FUN_00116380(ulong param_1,undefined1 *param_2)

{
  undefined1 uVar1;
  undefined1 *puVar2;
  undefined1 *puVar3;
  undefined1 *puVar4;
  undefined1 *puVar5;
  undefined1 uVar6;
  ulong uVar7;
  long in_FS_OFFSET;
  undefined8 local_30;
  undefined8 local_28;
  undefined8 local_20;
  long local_10;
  
  local_10 = *(long *)(in_FS_OFFSET + 0x28);
  local_30 = 0x3031323334353637;
  local_28 = 0x3837363534333231;
  local_20 = 0x46454443424139;
  puVar4 = param_2;
  do {
    puVar2 = puVar4 + 1;
    uVar7 = param_1 >> 4;
    *puVar4 = *(undefined1 *)((long)&local_30 + (long)(int)((uint)param_1 & 0xf) + 7);
    puVar4 = puVar2;
    param_1 = uVar7;
  } while (uVar7 != 0);
  if ((ulong)((long)puVar2 - (long)param_2) < 0x10) {
    puVar5 = puVar2 + (0x10 - ((long)puVar2 - (long)param_2));
    do {
      puVar3 = puVar4 + 1;
      *puVar4 = 0x30;
      puVar4 = puVar3;
      puVar2 = puVar5;
    } while (puVar3 != puVar5);
  }
  *puVar2 = 0x78;
  puVar2[1] = 0x30;
  if ((param_2 != puVar2 + 2) && (param_2 < puVar2 + 1)) {
    uVar6 = 0x30;
    puVar4 = param_2;
    puVar5 = puVar2 + 1;
    while( true ) {
      uVar1 = *puVar4;
      puVar3 = puVar5 + -1;
      *puVar4 = uVar6;
      puVar4 = puVar4 + 1;
      *puVar5 = uVar1;
      if (puVar3 <= puVar4) break;
      uVar6 = *puVar3;
      puVar5 = puVar3;
    }
  }
  if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
                    /* WARNING: Subroutine does not return */
    __stack_chk_fail();
  }
  return (long)(puVar2 + 2) - (long)param_2;
}


==================================================================

### FUNC 00116480 (12 bytes) name=FUN_00116480

long FUN_00116480(long *param_1)

{
  return (param_1[1] - param_1[2]) + *param_1;
}


==================================================================

### FUNC 00116490 (184 bytes) name=FUN_00116490

void FUN_00116490(undefined8 param_1,undefined8 param_2,undefined8 param_3,undefined8 param_4,
                 undefined8 param_5,undefined8 param_6,undefined8 param_7,undefined8 param_8,
                 long *param_9,undefined8 param_10,undefined8 param_11,undefined8 param_12,
                 undefined8 param_13,undefined8 param_14)

{
  char in_AL;
  int iVar1;
  undefined4 local_d0;
  undefined4 local_cc;
  undefined1 *local_c8;
  undefined1 *local_c0;
  undefined1 local_b8 [16];
  undefined8 local_a8;
  undefined8 local_a0;
  undefined8 local_98;
  undefined8 local_90;
  undefined8 local_88;
  undefined8 local_78;
  undefined8 local_68;
  undefined8 local_58;
  undefined8 local_48;
  undefined8 local_38;
  undefined8 local_28;
  undefined8 local_18;
  
  if (in_AL != '\0') {
    local_88 = param_1;
    local_78 = param_2;
    local_68 = param_3;
    local_58 = param_4;
    local_48 = param_5;
    local_38 = param_6;
    local_28 = param_7;
    local_18 = param_8;
  }
  local_c8 = &stack0x00000008;
  local_c0 = local_b8;
  local_d0 = 0x10;
  local_cc = 0x30;
  local_a8 = param_11;
  local_a0 = param_12;
  local_98 = param_13;
  local_90 = param_14;
  iVar1 = __vsnprintf_chk(param_9[2],(param_9[1] - param_9[2]) + *param_9,1,0xffffffffffffffff,
                          param_10,&local_d0);
  param_9[2] = param_9[2] + (long)iVar1;
  return;
}


==================================================================

### FUNC 00116550 (5 bytes) name=FUN_00116550

undefined8 FUN_00116550(long param_1)

{
  return *(undefined8 *)(param_1 + 8);
}


==================================================================

### FUNC 00116560 (5 bytes) name=FUN_00116560

undefined8 FUN_00116560(long param_1)

{
  return *(undefined8 *)(param_1 + 8);
}


==================================================================

### FUNC 00116570 (15 bytes) name=FUN_00116570

void FUN_00116570(long param_1,undefined8 param_2)

{
  FUN_001070a0(param_2,*(undefined8 *)(param_1 + 8));
  return;
}


==================================================================

### FUNC 00116580 (23 bytes) name=FUN_00116580

bool FUN_00116580(long param_1,FILE *param_2)

{
  int iVar1;
  
  iVar1 = fputs(*(char **)(param_1 + 8),param_2);
  return iVar1 == 0;
}


==================================================================

### FUNC 001165a0 (62 bytes) name=FUN_001165a0

void FUN_001165a0(long *param_1,void *param_2,size_t param_3)

{
  long lVar1;
  
  if (param_3 + 1 < (ulong)((param_1[1] - param_1[2]) + *param_1)) {
    memcpy((void *)param_1[2],param_2,param_3);
    lVar1 = param_1[2];
    param_1[2] = (long)(param_3 + lVar1);
    *(undefined1 *)(param_3 + lVar1) = 0;
  }
  return;
}


==================================================================

### FUNC 001165e0 (40 bytes) name=FUN_001165e0

void FUN_001165e0(undefined8 param_1,char *param_2)

{
  size_t sVar1;
  
  sVar1 = strlen(param_2);
  FUN_001165a0(param_1,param_2,(long)(int)sVar1);
  return;
}


==================================================================

### FUNC 00116610 (9 bytes) name=FUN_00116610

void FUN_00116610(long param_1)

{
  *(undefined8 *)(param_1 + 0x10) = *(undefined8 *)(param_1 + 8);
  return;
}


==================================================================

### FUNC 00116620 (12 bytes) name=FUN_00116620

undefined8 FUN_00116620(long param_1)

{
  return CONCAT71((int7)((ulong)*(long *)(param_1 + 8) >> 8),
                  *(long *)(param_1 + 0x10) == *(long *)(param_1 + 8));
}


==================================================================

### FUNC 00116630 (14 bytes) name=FUN_00116630

undefined8 FUN_00116630(undefined8 param_1)

{
  FUN_001165e0();
  return param_1;
}


==================================================================

### FUNC 00116640 (44 bytes) name=FUN_00116640

long * FUN_00116640(long *param_1,undefined1 param_2)

{
  long lVar1;
  
  if (2 < (ulong)((param_1[1] - param_1[2]) + *param_1)) {
    *(undefined1 *)param_1[2] = param_2;
    lVar1 = param_1[2];
    param_1[2] = lVar1 + 1;
    *(undefined1 *)(lVar1 + 1) = 0;
  }
  return param_1;
}


==================================================================

### FUNC 00116670 (320 bytes) name=FUN_00116670

undefined8 * FUN_00116670(undefined8 *param_1,long param_2,char param_3)

{
  ulong uVar1;
  undefined8 *puVar2;
  ulong uVar3;
  ulong uVar4;
  undefined8 local_58;
  void *local_50;
  undefined8 local_48;
  
  uVar4 = *(ulong *)(param_2 + 8);
  uVar1 = *(ulong *)(param_2 + 0x10);
  *param_1 = 0;
  param_1[1] = 0;
  param_1[2] = 0;
  if (uVar4 < uVar1) {
    uVar1 = uVar4 + 1;
    do {
      while (uVar3 = uVar1, *(char *)(uVar3 - 1) == param_3) {
        FUN_00116250(&local_58,uVar4,(uVar3 - 1) - uVar4);
        puVar2 = (undefined8 *)param_1[1];
        if (puVar2 == (undefined8 *)param_1[2]) {
          FUN_00116b80(param_1,puVar2,&local_58);
        }
        else {
          if (puVar2 != (undefined8 *)0x0) {
            *puVar2 = local_58;
            puVar2[1] = local_50;
            puVar2[2] = local_48;
          }
          param_1[1] = puVar2 + 3;
        }
        if (local_50 != (void *)0x0) {
          operator_delete__(local_50);
        }
        uVar1 = uVar3 + 1;
        uVar4 = uVar3;
        if (*(ulong *)(param_2 + 0x10) <= uVar3) goto LAB_00116738;
      }
      uVar1 = uVar3 + 1;
    } while (uVar3 < *(ulong *)(param_2 + 0x10));
LAB_00116738:
    if (1 < (long)(uVar3 - uVar4)) {
      FUN_00116250(&local_58);
      puVar2 = (undefined8 *)param_1[1];
      if (puVar2 == (undefined8 *)param_1[2]) {
        FUN_00116b80(param_1,puVar2,&local_58);
      }
      else {
        if (puVar2 != (undefined8 *)0x0) {
          *puVar2 = local_58;
          puVar2[1] = local_50;
          puVar2[2] = local_48;
        }
        param_1[1] = puVar2 + 3;
      }
      if (local_50 != (void *)0x0) {
        operator_delete__(local_50);
      }
    }
  }
  return param_1;
}


==================================================================

### FUNC 001167f0 (755 bytes) name=FUN_001167f0

undefined8 * FUN_001167f0(undefined8 *param_1,long param_2,char *param_3)

{
  char *pcVar1;
  undefined8 *puVar2;
  size_t sVar3;
  long lVar4;
  undefined8 *puVar5;
  undefined8 uVar6;
  undefined8 *puVar7;
  ulong uVar8;
  undefined8 *puVar9;
  char *pcVar10;
  char *pcVar11;
  undefined8 *puVar12;
  undefined8 *local_78;
  undefined8 *local_70;
  undefined8 *local_68;
  undefined8 local_58;
  void *local_50;
  undefined8 local_48;
  
  sVar3 = strlen(param_3);
  if ((int)sVar3 == 1) {
    FUN_00116670(param_1,param_2,(int)*param_3);
  }
  else if ((int)sVar3 == 2) {
    lVar4 = *(long *)(param_2 + 0x10);
    pcVar10 = *(char **)(param_2 + 8);
    local_78 = (undefined8 *)0x0;
    local_70 = (undefined8 *)0x0;
    local_68 = (undefined8 *)0x0;
    pcVar1 = (char *)(lVar4 - 1);
    pcVar11 = pcVar10;
    if (pcVar10 < pcVar1) {
      do {
        while ((*param_3 != *pcVar10 || (param_3[1] != pcVar10[1]))) {
          pcVar10 = pcVar10 + 1;
          if (pcVar1 <= pcVar10) goto LAB_001168e8;
        }
        FUN_00116250(&local_58,pcVar11,(long)pcVar10 - (long)pcVar11);
        if (local_70 == local_68) {
          FUN_00116b80(&local_78,local_70,&local_58);
        }
        else {
          if (local_70 != (undefined8 *)0x0) {
            *local_70 = local_58;
            local_70[1] = local_50;
            local_70[2] = local_48;
          }
          local_70 = local_70 + 3;
        }
        pcVar10 = pcVar10 + 2;
        if (local_50 != (void *)0x0) {
          operator_delete__(local_50);
        }
        pcVar11 = pcVar10;
      } while (pcVar10 < pcVar1);
LAB_001168e8:
      lVar4 = *(long *)(param_2 + 0x10);
    }
    if (1 < lVar4 - (long)pcVar11) {
      FUN_00116250(&local_58);
      if (local_70 == local_68) {
        FUN_00116b80(&local_78,local_70,&local_58);
      }
      else {
        if (local_70 != (undefined8 *)0x0) {
          *local_70 = local_58;
          local_70[1] = local_50;
          local_70[2] = local_48;
        }
        local_70 = local_70 + 3;
      }
      if (local_50 != (void *)0x0) {
        operator_delete__(local_50);
      }
    }
    *param_1 = 0;
    param_1[1] = 0;
    param_1[2] = 0;
    lVar4 = (long)local_70 - (long)local_78 >> 3;
    uVar8 = lVar4 * -0x5555555555555555;
    if (uVar8 == 0) {
      uVar8 = 0;
      puVar5 = (undefined8 *)0x0;
    }
    else {
      if (0xaaaaaaaaaaaaaaa < uVar8) {
        uVar6 = std::__throw_bad_alloc();
        FUN_00116b20(&local_78);
                    /* WARNING: Subroutine does not return */
        _Unwind_Resume(uVar6);
      }
      uVar8 = lVar4 * 8;
      puVar5 = operator_new(uVar8);
    }
    puVar2 = local_70;
    *param_1 = puVar5;
    param_1[1] = puVar5;
    param_1[2] = uVar8 + (long)puVar5;
    puVar7 = local_78;
    puVar9 = puVar5;
    puVar12 = local_70;
    if (local_70 != local_78) {
      do {
        if (puVar9 != (undefined8 *)0x0) {
          *puVar9 = *puVar7;
          puVar9[1] = puVar7[1];
          puVar9[2] = puVar7[2];
        }
        puVar7 = puVar7 + 3;
        puVar9 = puVar9 + 3;
      } while (puVar7 != local_70);
      param_1[1] = (long)puVar5 +
                   ((long)local_70 - (long)(local_78 + 3) & 0xfffffffffffffff8U) + 0x18;
      puVar5 = local_78 + 3;
      puVar7 = local_78;
      while( true ) {
        puVar9 = puVar5;
        if ((void *)puVar7[1] != (void *)0x0) {
          operator_delete__((void *)puVar7[1]);
        }
        puVar12 = local_78;
        if (puVar9 == puVar2) break;
        puVar5 = puVar9 + 3;
        puVar7 = puVar9;
      }
    }
    if (puVar12 != (undefined8 *)0x0) {
      operator_delete(puVar12);
    }
  }
  else {
    *param_1 = 0;
    param_1[1] = 0;
    param_1[2] = 0;
  }
  return param_1;
}


==================================================================

### FUNC 00116b20 (75 bytes) name=FUN_00116b20

void FUN_00116b20(long *param_1)

{
  void *pvVar1;
  void *pvVar2;
  
  pvVar2 = (void *)param_1[1];
  pvVar1 = (void *)*param_1;
  if (pvVar2 != pvVar1) {
    do {
      if (*(void **)((long)pvVar1 + 8) != (void *)0x0) {
        operator_delete__(*(void **)((long)pvVar1 + 8));
      }
      pvVar1 = (void *)((long)pvVar1 + 0x18);
    } while (pvVar2 != pvVar1);
    pvVar2 = (void *)*param_1;
  }
  if (pvVar2 == (void *)0x0) {
    return;
  }
  operator_delete(pvVar2);
  return;
}


==================================================================

### FUNC 00116b80 (685 bytes) name=FUN_00116b80

void FUN_00116b80(undefined8 *param_1,undefined8 *param_2,undefined8 *param_3)

{
  undefined8 uVar1;
  ulong uVar2;
  undefined8 *puVar3;
  undefined8 *puVar4;
  undefined8 *puVar5;
  long lVar6;
  undefined8 *puVar7;
  undefined8 *puVar8;
  undefined8 *puVar9;
  ulong local_68;
  undefined8 local_58;
  void *local_50;
  undefined8 local_48;
  
  puVar9 = (undefined8 *)param_1[1];
  if (puVar9 != (undefined8 *)param_1[2]) {
    if (puVar9 != (undefined8 *)0x0) {
      *puVar9 = puVar9[-3];
      puVar9[1] = puVar9[-2];
      puVar9[2] = puVar9[-1];
    }
    puVar7 = puVar9 + -3;
    param_1[1] = puVar9 + 3;
    local_58 = *param_3;
    local_50 = (void *)param_3[1];
    local_48 = param_3[2];
    lVar6 = ((long)puVar7 - (long)param_2 >> 3) * -0x5555555555555555;
    puVar9 = puVar7;
    if (0 < lVar6) {
      while( true ) {
        puVar9 = puVar9 + -3;
        FUN_00116330(puVar7,puVar9);
        lVar6 = lVar6 + -1;
        if (lVar6 == 0) break;
        puVar7 = puVar7 + -3;
      }
    }
    FUN_00116330(param_2,&local_58);
    if (local_50 == (void *)0x0) {
      return;
    }
    operator_delete__(local_50);
    return;
  }
  puVar7 = (undefined8 *)*param_1;
  lVar6 = (long)puVar9 - (long)puVar7 >> 3;
  if (lVar6 * -0x5555555555555555 == 0) {
    local_68 = 0x18;
    lVar6 = ((long)param_2 - (long)puVar7 >> 3) * -0x5555555555555555;
  }
  else {
    uVar2 = lVar6 * 0x5555555555555556;
    if (((ulong)(lVar6 * -0x5555555555555555) < uVar2 || lVar6 * 0x5555555555555555 == 0) &&
       (uVar2 < 0xaaaaaaaaaaaaaab)) {
      local_68 = lVar6 << 4;
      lVar6 = ((long)param_2 - (long)puVar7 >> 3) * -0x5555555555555555;
      if (uVar2 == 0) {
        puVar8 = (undefined8 *)0x18;
        puVar3 = (undefined8 *)0x0;
        goto LAB_00116caf;
      }
    }
    else {
      local_68 = 0xfffffffffffffff0;
      lVar6 = ((long)param_2 - (long)puVar7 >> 3) * -0x5555555555555555;
    }
  }
  puVar3 = operator_new(local_68);
  puVar9 = (undefined8 *)param_1[1];
  puVar7 = (undefined8 *)*param_1;
  puVar8 = puVar3 + 3;
LAB_00116caf:
  puVar4 = puVar3 + lVar6 * 3;
  if (puVar4 != (undefined8 *)0x0) {
    *puVar4 = *param_3;
    uVar1 = param_3[2];
    puVar4[1] = param_3[1];
    puVar4[2] = uVar1;
  }
  puVar4 = puVar3;
  puVar5 = puVar7;
  if (param_2 != puVar7) {
    do {
      if (puVar4 != (undefined8 *)0x0) {
        *puVar4 = *puVar5;
        puVar4[1] = puVar5[1];
        puVar4[2] = puVar5[2];
      }
      puVar5 = puVar5 + 3;
      puVar4 = puVar4 + 3;
    } while (param_2 != puVar5);
    puVar8 = (undefined8 *)
             ((long)puVar3 + ((long)param_2 - (long)(puVar7 + 3) & 0xfffffffffffffff8U) + 0x30);
  }
  puVar4 = param_2;
  puVar5 = puVar8;
  if (param_2 != puVar9) {
    do {
      if (puVar5 != (undefined8 *)0x0) {
        *puVar5 = *puVar4;
        puVar5[1] = puVar4[1];
        puVar5[2] = puVar4[2];
      }
      puVar4 = puVar4 + 3;
      puVar5 = puVar5 + 3;
    } while (puVar4 != puVar9);
    puVar8 = (undefined8 *)
             ((long)puVar8 + ((long)puVar9 - (long)(param_2 + 3) & 0xfffffffffffffff8U) + 0x18);
  }
  if (puVar9 != puVar7) {
    do {
      if ((void *)puVar7[1] != (void *)0x0) {
        operator_delete__((void *)puVar7[1]);
      }
      puVar7 = puVar7 + 3;
    } while (puVar7 != puVar9);
    puVar9 = (undefined8 *)*param_1;
  }
  if (puVar9 != (undefined8 *)0x0) {
    operator_delete(puVar9);
  }
  *param_1 = puVar3;
  param_1[1] = puVar8;
  param_1[2] = (long)puVar3 + local_68;
  return;
}


==================================================================

### FUNC 00116e50 (55 bytes) name=FUN_00116e50

void FUN_00116e50(pthread_mutex_t *param_1)

{
  pthread_mutex_lock(param_1);
  while (*(char *)((long)param_1 + 0x58) == '\0') {
    pthread_cond_wait((pthread_cond_t *)(param_1 + 1),param_1);
  }
  *(undefined1 *)((long)param_1 + 0x58) = 0;
  pthread_mutex_unlock(param_1);
  return;
}


==================================================================

### FUNC 00116ea0 (229 bytes) name=FUN_00116ea0

undefined8 FUN_00116ea0(pthread_mutex_t *param_1,int param_2)

{
  int iVar1;
  undefined8 uVar2;
  timeval local_38;
  timespec local_28;
  
  gettimeofday(&local_38,(__timezone_ptr_t)0x0);
  local_28.tv_sec = param_2 / 1000 + local_38.tv_sec;
  local_28.tv_nsec = local_38.tv_usec * 1000 + (long)((param_2 % 1000) * 1000000);
  if (1000000000 < local_28.tv_nsec) {
    local_28.tv_sec = local_28.tv_sec + 1;
    local_28.tv_nsec = local_28.tv_nsec % 1000000000;
  }
  pthread_mutex_lock(param_1);
  do {
    if (*(char *)((long)param_1 + 0x58) != '\0') {
      *(undefined1 *)((long)param_1 + 0x58) = 0;
      uVar2 = 0;
      goto LAB_00116f6f;
    }
    iVar1 = pthread_cond_timedwait((pthread_cond_t *)(param_1 + 1),param_1,&local_28);
  } while (iVar1 != 0x6e);
  uVar2 = 1;
LAB_00116f6f:
  pthread_mutex_unlock(param_1);
  return uVar2;
}


==================================================================

### FUNC 00116fb0 (154 bytes) name=FUN_00116fb0

undefined8 FUN_00116fb0(long param_1)

{
  undefined8 uVar1;
  
  if (param_1 == 0) {
    return 1;
  }
  if (*(long *)(param_1 + 0x48) == 0) {
    uVar1 = 2;
  }
  else {
    while (*(int *)(param_1 + 0x30) != 0) {
      FUN_00116e50(param_1 + 0x100);
      if (*(int *)(param_1 + 0x30) == 0) break;
      pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0x88));
      memcpy(*(void **)(param_1 + 0x50),*(void **)(param_1 + 0x330),
             (ulong)*(uint *)(param_1 + 0x338) + 0x4c);
      pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0x88));
      if (*(code **)(param_1 + 0x48) != (code *)0x0) {
        (**(code **)(param_1 + 0x48))
                  (*(undefined4 *)(param_1 + 0x33c),*(undefined8 *)(param_1 + 0x50));
      }
    }
    uVar1 = 0;
  }
  return uVar1;
}


==================================================================

### FUNC 00117050 (59 bytes) name=FUN_00117050

undefined8 FUN_00117050(long param_1)

{
  if (param_1 != 0) {
    do {
      if (*(int *)(param_1 + 0x2c) == 0) {
        return 0;
      }
      FUN_00116ea0(param_1 + 0x160,2000);
    } while (*(int *)(param_1 + 0x2c) != 0);
  }
  return 0;
}


==================================================================

### FUNC 001170a0 (941 bytes) name=FUN_001170a0

undefined8 FUN_001170a0(long param_1)

{
  int iVar1;
  undefined4 uVar2;
  uint uVar3;
  bool bVar4;
  int iVar5;
  int *piVar6;
  long lVar7;
  int iVar8;
  int *__src;
  undefined8 *puVar9;
  int *__dest;
  uint uVar10;
  ulong __n;
  int iVar11;
  size_t __n_00;
  int local_8c;
  undefined8 local_88;
  uint local_80;
  undefined4 uStack_7c;
  undefined4 local_78;
  int iStack_74;
  undefined4 local_70;
  undefined4 uStack_6c;
  undefined4 local_68;
  undefined4 uStack_64;
  int local_60;
  int iStack_5c;
  undefined8 local_58;
  undefined8 local_50;
  undefined8 local_48;
  undefined4 local_40;
  
  if (param_1 == 0) {
    return 0xffffffffffffffff;
  }
  local_8c = 0;
  bVar4 = false;
  puVar9 = &local_88;
  for (lVar7 = 9; lVar7 != 0; lVar7 = lVar7 + -1) {
    *puVar9 = 0;
    puVar9 = puVar9 + 1;
  }
  iVar1 = *(int *)(param_1 + 0xb10);
  uVar2 = *(undefined4 *)(param_1 + 0xb14);
  *(undefined4 *)puVar9 = 0;
  __dest = *(int **)(param_1 + 0x328);
  piVar6 = __dest;
LAB_00117140:
  iVar5 = *(int *)(param_1 + 0x28);
  do {
    if ((iVar5 == 0) ||
       (iVar5 = libusb_bulk_transfer
                          (*(undefined8 *)(param_1 + 0x68),0x81,piVar6,
                           ((int)__dest - (int)piVar6) + *(int *)(param_1 + 0x338) * 2,&local_8c,500
                          ), *(int *)(param_1 + 0x28) == 0)) {
      *(undefined4 *)(param_1 + 0x1ec) = 1;
      return 0;
    }
    if (iVar5 < 0) {
      FUN_00113c10(10);
      __dest = *(int **)(param_1 + 0x328);
      piVar6 = __dest;
      goto LAB_00117140;
    }
    __dest = *(int **)(param_1 + 0x328);
    piVar6 = (int *)((long)local_8c + (long)piVar6);
    iVar5 = (int)piVar6;
    uVar10 = iVar5 - (int)__dest;
    __n = (ulong)(int)uVar10;
    if (!bVar4) {
      __src = __dest;
      if (__dest < piVar6) {
        if (*__dest != 0x1bb1b11b) {
          do {
            __src = __src + 1;
            if (piVar6 <= __src) goto LAB_001171d9;
          } while (*__src != 0x1bb1b11b);
          uVar10 = iVar5 - (int)__src;
        }
      }
      else {
LAB_001171d9:
        piVar6 = __dest;
        if (*__src != 0x1bb1b11b) goto LAB_00117140;
        uVar10 = iVar5 - (int)__src;
      }
      __n = (ulong)(int)uVar10;
      if (__dest != __src) {
        memmove(__dest,__src,__n);
        __dest = *(int **)(param_1 + 0x328);
      }
      bVar4 = true;
    }
    uVar3 = *(uint *)(param_1 + 0x338);
    piVar6 = (int *)((long)__dest + __n);
    if (__n < (ulong)uVar3 + 0x38) goto LAB_00117140;
    if ((*__dest == 0x1bb1b11b) && (uVar3 == __dest[2])) {
      piVar6 = (int *)((long)__dest + (ulong)uVar3 + 0x1c);
      if (*piVar6 == 0x1bb1b11c) {
        if ((uint)piVar6[3] < 2) {
          iVar5 = __dest[1];
          if (iVar1 == 0xa0) {
            iVar8 = piVar6[2];
            iVar11 = iVar8 + -500;
          }
          else {
            iVar11 = piVar6[4];
            iVar8 = iVar11 + 500;
            if (iVar1 != 0x180) {
              iVar8 = piVar6[2];
            }
          }
          pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0x88));
          puVar9 = *(undefined8 **)(param_1 + 0x330);
          uStack_7c = 1;
          uStack_6c = 8;
          local_68 = 0xffff3cb0;
          *puVar9 = CONCAT44(iVar5,(undefined4)local_88);
          puVar9[1] = CONCAT44(1,uVar3);
          puVar9[2] = CONCAT44(iVar1,local_78);
          puVar9[3] = CONCAT44(8,uVar2);
          puVar9[4] = CONCAT44(uStack_64,0xffff3cb0);
          puVar9[5] = CONCAT44(iVar8,iVar11);
          puVar9[6] = local_58;
          puVar9[7] = local_50;
          puVar9[8] = local_48;
          *(undefined4 *)(puVar9 + 9) = local_40;
          local_88._4_4_ = iVar5;
          local_80 = uVar3;
          iStack_74 = iVar1;
          local_70 = uVar2;
          local_60 = iVar11;
          iStack_5c = iVar8;
          memcpy((void *)(*(long *)(param_1 + 0x330) + 0x4c),
                 (void *)(*(long *)(param_1 + 0x328) + 0x1c),(ulong)*(uint *)(param_1 + 0x338));
          pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0x88));
          pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0x100));
          pthread_cond_signal((pthread_cond_t *)(param_1 + 0x128));
          *(undefined1 *)(param_1 + 0x158) = 1;
          pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0x100));
          __dest = *(int **)(param_1 + 0x328);
          *(int *)(param_1 + 8) = *(int *)(param_1 + 8) + 1;
        }
      }
      else {
        for (piVar6 = (int *)((long)(int)(uVar10 & 0xfffffffc) + (long)__dest); __dest < piVar6;
            piVar6 = piVar6 + -1) {
          if (*piVar6 == 0x1bb1b11b) goto LAB_001172a9;
        }
        if (*piVar6 == 0x1bb1b11b) break;
      }
    }
    bVar4 = false;
    iVar5 = *(int *)(param_1 + 0x28);
    piVar6 = __dest;
  } while( true );
LAB_001172a9:
  __n_00 = (size_t)(int)(uVar10 + ((int)__dest - (int)piVar6));
  memmove(__dest,piVar6,__n_00);
  __dest = *(int **)(param_1 + 0x328);
  piVar6 = (int *)(__n_00 + (long)__dest);
  goto LAB_00117140;
}


==================================================================

### FUNC 00117470 (2646 bytes) name=FUN_00117470

/* WARNING: Type propagation algorithm not settling */

void FUN_00117470(undefined8 *param_1)

{
  long lVar1;
  int iVar2;
  undefined8 *puVar3;
  ulong uVar4;
  ulong uVar5;
  char *pcVar6;
  undefined8 *puVar7;
  long in_FS_OFFSET;
  bool bVar8;
  byte bVar9;
  pthread_mutexattr_t local_98 [4];
  pthread_mutexattr_t local_88 [4];
  pthread_mutexattr_t local_78 [4];
  pthread_mutexattr_t local_68 [4];
  pthread_mutexattr_t local_58 [4];
  pthread_mutexattr_t local_48 [2];
  long local_40;
  
  bVar9 = 0;
  local_40 = *(long *)(in_FS_OFFSET + 0x28);
  *param_1 = &PTR_FUN_0033ed30;
  iVar2 = pthread_mutexattr_init(local_48);
  if (iVar2 == 0) {
    iVar2 = pthread_mutexattr_settype(local_48,1);
    if (iVar2 == 0) {
      iVar2 = pthread_mutex_init((pthread_mutex_t *)(param_1 + 0x11),local_48);
      if (iVar2 == 0) {
        iVar2 = pthread_mutexattr_destroy(local_48);
        if (iVar2 == 0) {
          iVar2 = pthread_mutexattr_init(local_98);
          if (iVar2 != 0) {
            puVar3 = (undefined8 *)__cxa_allocate_exception(8);
            *puVar3 = "pthread_mutexattr_init failed\n";
                    /* WARNING: Subroutine does not return */
            __cxa_throw(puVar3,&PTR_vtable_0033ec10,0);
          }
          iVar2 = pthread_mutexattr_settype(local_98,1);
          if (iVar2 != 0) {
            puVar3 = (undefined8 *)__cxa_allocate_exception(8);
            *puVar3 = "pthread_mutexattr_settype failed\n";
                    /* WARNING: Subroutine does not return */
            __cxa_throw(puVar3,&PTR_vtable_0033ec10,0);
          }
          iVar2 = pthread_mutex_init((pthread_mutex_t *)(param_1 + 0x16),local_98);
          if (iVar2 != 0) {
            puVar3 = (undefined8 *)__cxa_allocate_exception(8);
            *puVar3 = "pthread_mutex_init failed\n";
                    /* WARNING: Subroutine does not return */
            __cxa_throw(puVar3,&PTR_vtable_0033ec10,0);
          }
          iVar2 = pthread_mutexattr_destroy(local_98);
          if (iVar2 != 0) {
            puVar3 = (undefined8 *)__cxa_allocate_exception(8);
            *puVar3 = "pthread_mutexattr_destroy failed\n";
                    /* WARNING: Subroutine does not return */
            __cxa_throw(puVar3,&PTR_vtable_0033ec10,0);
          }
          iVar2 = pthread_mutexattr_init(local_88);
          if (iVar2 != 0) {
            puVar3 = (undefined8 *)__cxa_allocate_exception(8);
            *puVar3 = "pthread_mutexattr_init failed\n";
                    /* WARNING: Subroutine does not return */
            __cxa_throw(puVar3,&PTR_vtable_0033ec10,0);
          }
          iVar2 = pthread_mutexattr_settype(local_88,1);
          if (iVar2 != 0) {
            puVar3 = (undefined8 *)__cxa_allocate_exception(8);
            *puVar3 = "pthread_mutexattr_settype failed\n";
                    /* WARNING: Subroutine does not return */
            __cxa_throw(puVar3,&PTR_vtable_0033ec10,0);
          }
          iVar2 = pthread_mutex_init((pthread_mutex_t *)(param_1 + 0x1b),local_88);
          if (iVar2 != 0) {
            puVar3 = (undefined8 *)__cxa_allocate_exception(8);
            *puVar3 = "pthread_mutex_init failed\n";
                    /* WARNING: Subroutine does not return */
            __cxa_throw(puVar3,&PTR_vtable_0033ec10,0);
          }
          iVar2 = pthread_mutexattr_destroy(local_88);
          if (iVar2 != 0) {
            puVar3 = (undefined8 *)__cxa_allocate_exception(8);
            *puVar3 = "pthread_mutexattr_destroy failed\n";
                    /* WARNING: Subroutine does not return */
            __cxa_throw(puVar3,&PTR_vtable_0033ec10,0);
          }
          iVar2 = pthread_mutexattr_init(local_78);
          if (iVar2 != 0) {
            puVar3 = (undefined8 *)__cxa_allocate_exception(8);
            *puVar3 = "pthread_mutexattr_init failed\n";
                    /* WARNING: Subroutine does not return */
            __cxa_throw(puVar3,&PTR_vtable_0033ec10,0);
          }
          iVar2 = pthread_mutexattr_settype(local_78,1);
          if (iVar2 != 0) {
            puVar3 = (undefined8 *)__cxa_allocate_exception(8);
            *puVar3 = "pthread_mutexattr_settype failed\n";
                    /* WARNING: Subroutine does not return */
            __cxa_throw(puVar3,&PTR_vtable_0033ec10,0);
          }
          iVar2 = pthread_mutex_init((pthread_mutex_t *)(param_1 + 0x20),local_78);
          if (iVar2 != 0) {
            puVar3 = (undefined8 *)__cxa_allocate_exception(8);
            *puVar3 = "pthread_mutex_init failed\n";
                    /* WARNING: Subroutine does not return */
            __cxa_throw(puVar3,&PTR_vtable_0033ec10,0);
          }
          iVar2 = pthread_mutexattr_destroy(local_78);
          if (iVar2 != 0) {
            puVar3 = (undefined8 *)__cxa_allocate_exception(8);
            *puVar3 = "pthread_mutexattr_destroy failed\n";
                    /* WARNING: Subroutine does not return */
            __cxa_throw(puVar3,&PTR_vtable_0033ec10,0);
          }
          *(undefined1 *)(param_1 + 0x2b) = 0;
          iVar2 = pthread_cond_init((pthread_cond_t *)(param_1 + 0x25),(pthread_condattr_t *)0x0);
          if (iVar2 != 0) {
            puVar3 = (undefined8 *)__cxa_allocate_exception(8);
            *puVar3 = "pthread_cond_init failed\n";
                    /* WARNING: Subroutine does not return */
            __cxa_throw(puVar3,&PTR_vtable_0033ec10,0);
          }
          iVar2 = pthread_mutexattr_init(local_68);
          if (iVar2 != 0) {
            puVar3 = (undefined8 *)__cxa_allocate_exception(8);
            *puVar3 = "pthread_mutexattr_init failed\n";
                    /* WARNING: Subroutine does not return */
            __cxa_throw(puVar3,&PTR_vtable_0033ec10,0);
          }
          iVar2 = pthread_mutexattr_settype(local_68,1);
          if (iVar2 != 0) {
            puVar3 = (undefined8 *)__cxa_allocate_exception(8);
            *puVar3 = "pthread_mutexattr_settype failed\n";
                    /* WARNING: Subroutine does not return */
            __cxa_throw(puVar3,&PTR_vtable_0033ec10,0);
          }
          iVar2 = pthread_mutex_init((pthread_mutex_t *)(param_1 + 0x2c),local_68);
          if (iVar2 != 0) {
            puVar3 = (undefined8 *)__cxa_allocate_exception(8);
            *puVar3 = "pthread_mutex_init failed\n";
                    /* WARNING: Subroutine does not return */
            __cxa_throw(puVar3,&PTR_vtable_0033ec10,0);
          }
          iVar2 = pthread_mutexattr_destroy(local_68);
          if (iVar2 != 0) {
            puVar3 = (undefined8 *)__cxa_allocate_exception(8);
            *puVar3 = "pthread_mutexattr_destroy failed\n";
                    /* WARNING: Subroutine does not return */
            __cxa_throw(puVar3,&PTR_vtable_0033ec10,0);
          }
          *(undefined1 *)(param_1 + 0x37) = 0;
          iVar2 = pthread_cond_init((pthread_cond_t *)(param_1 + 0x31),(pthread_condattr_t *)0x0);
          if (iVar2 != 0) {
            puVar3 = (undefined8 *)__cxa_allocate_exception(8);
            *puVar3 = "pthread_cond_init failed\n";
                    /* WARNING: Subroutine does not return */
            __cxa_throw(puVar3,&PTR_vtable_0033ec10,0);
          }
          iVar2 = pthread_mutexattr_init(local_58);
          if (iVar2 != 0) {
            puVar3 = (undefined8 *)__cxa_allocate_exception(8);
            *puVar3 = "pthread_mutexattr_init failed\n";
                    /* WARNING: Subroutine does not return */
            __cxa_throw(puVar3,&PTR_vtable_0033ec10,0);
          }
          iVar2 = pthread_mutexattr_settype(local_58,1);
          if (iVar2 != 0) {
            puVar3 = (undefined8 *)__cxa_allocate_exception(8);
            *puVar3 = "pthread_mutexattr_settype failed\n";
                    /* WARNING: Subroutine does not return */
            __cxa_throw(puVar3,&PTR_vtable_0033ec10,0);
          }
          iVar2 = pthread_mutex_init((pthread_mutex_t *)(param_1 + 0x38),local_58);
          if (iVar2 != 0) {
            puVar3 = (undefined8 *)__cxa_allocate_exception(8);
            *puVar3 = "pthread_mutex_init failed\n";
                    /* WARNING: Subroutine does not return */
            __cxa_throw(puVar3,&PTR_vtable_0033ec10,0);
          }
          iVar2 = pthread_mutexattr_destroy(local_58);
          if (iVar2 != 0) {
            puVar3 = (undefined8 *)__cxa_allocate_exception(8);
            *puVar3 = "pthread_mutexattr_destroy failed\n";
                    /* WARNING: Subroutine does not return */
            __cxa_throw(puVar3,&PTR_vtable_0033ec10,0);
          }
          iVar2 = pthread_mutexattr_init(local_48);
          if (iVar2 != 0) {
            puVar3 = (undefined8 *)__cxa_allocate_exception(8);
            *puVar3 = "pthread_mutexattr_init failed\n";
                    /* WARNING: Subroutine does not return */
            __cxa_throw(puVar3,&PTR_vtable_0033ec10,0);
          }
          iVar2 = pthread_mutexattr_settype(local_48,1);
          if (iVar2 != 0) {
            puVar3 = (undefined8 *)__cxa_allocate_exception(8);
            *puVar3 = "pthread_mutexattr_settype failed\n";
                    /* WARNING: Subroutine does not return */
            __cxa_throw(puVar3,&PTR_vtable_0033ec10,0);
          }
          iVar2 = pthread_mutex_init((pthread_mutex_t *)(param_1 + 0x159),local_48);
          if (iVar2 != 0) {
            puVar3 = (undefined8 *)__cxa_allocate_exception(8);
            *puVar3 = "pthread_mutex_init failed\n";
                    /* WARNING: Subroutine does not return */
            __cxa_throw(puVar3,&PTR_vtable_0033ec10,0);
          }
          iVar2 = pthread_mutexattr_destroy(local_48);
          if (iVar2 != 0) {
            puVar3 = (undefined8 *)__cxa_allocate_exception(8);
            *puVar3 = "pthread_mutexattr_destroy failed\n";
                    /* WARNING: Subroutine does not return */
            __cxa_throw(puVar3,&PTR_vtable_0033ec10,0);
          }
          puVar3 = param_1 + 0x68;
          *(undefined4 *)(param_1 + 0x10) = 0;
          *(undefined4 *)(param_1 + 1) = 0;
          *(undefined4 *)((long)param_1 + 0x84) = 0;
          *(undefined4 *)((long)param_1 + 0xc) = 0;
          uVar5 = 0x780;
          bVar8 = ((ulong)puVar3 & 1) != 0;
          *(undefined4 *)(param_1 + 0xf) = 0;
          *(undefined4 *)((long)param_1 + 0x7c) = 0;
          *(undefined4 *)(param_1 + 5) = 0;
          param_1[0xd] = 0;
          *(undefined4 *)((long)param_1 + 0x2c) = 0;
          param_1[0xe] = 0;
          *(undefined4 *)(param_1 + 6) = 0;
          param_1[2] = 0;
          param_1[3] = 0;
          param_1[4] = 0;
          *(undefined4 *)(param_1 + 0x3d) = 0;
          *(undefined4 *)(param_1 + 0x3e) = 0;
          *(undefined4 *)(param_1 + 0x60) = 0;
          param_1[0x65] = 0;
          param_1[0x66] = 0;
          *(undefined4 *)(param_1 + 0x67) = 0;
          *(undefined4 *)((long)param_1 + 0x33c) = 0;
          param_1[7] = 0;
          param_1[8] = 0;
          param_1[9] = 0;
          param_1[10] = 0;
          param_1[0xb] = 0;
          param_1[0xc] = 0;
          if (bVar8) {
            *(undefined1 *)(param_1 + 0x68) = 0;
            puVar3 = (undefined8 *)((long)param_1 + 0x341);
            uVar5 = 0x77f;
          }
          puVar7 = puVar3;
          if (((ulong)puVar3 & 2) != 0) {
            puVar7 = (undefined8 *)((long)puVar3 + 2);
            uVar5 = (ulong)((int)uVar5 - 2);
            *(undefined2 *)puVar3 = 0;
          }
          if (((ulong)puVar7 & 4) != 0) {
            *(undefined4 *)puVar7 = 0;
            uVar5 = (ulong)((int)uVar5 - 4);
            puVar7 = (undefined8 *)((long)puVar7 + 4);
          }
          for (uVar4 = uVar5 >> 3; uVar4 != 0; uVar4 = uVar4 - 1) {
            *puVar7 = 0;
            puVar7 = puVar7 + (ulong)bVar9 * -2 + 1;
          }
          if ((uVar5 & 4) != 0) {
            *(undefined4 *)puVar7 = 0;
            puVar7 = (undefined8 *)((long)puVar7 + 4);
          }
          if ((uVar5 & 2) != 0) {
            *(undefined2 *)puVar7 = 0;
            puVar7 = (undefined8 *)((long)puVar7 + 2);
          }
          if (bVar8) {
            *(undefined1 *)puVar7 = 0;
          }
          puVar3 = param_1 + 0x160;
          *(undefined4 *)(param_1 + 0x158) = 0;
          uVar5 = 0x38;
          *(undefined4 *)(param_1 + 0x15e) = 0;
          param_1[0x15f] = 0;
          bVar8 = ((ulong)puVar3 & 1) != 0;
          if (bVar8) {
            *(undefined1 *)(param_1 + 0x160) = 0;
            puVar3 = (undefined8 *)((long)param_1 + 0xb01);
            uVar5 = 0x37;
          }
          puVar7 = puVar3;
          if (((ulong)puVar3 & 2) != 0) {
            puVar7 = (undefined8 *)((long)puVar3 + 2);
            uVar5 = (ulong)((int)uVar5 - 2);
            *(undefined2 *)puVar3 = 0;
          }
          if (((ulong)puVar7 & 4) != 0) {
            *(undefined4 *)puVar7 = 0;
            uVar5 = (ulong)((int)uVar5 - 4);
            puVar7 = (undefined8 *)((long)puVar7 + 4);
          }
          for (uVar4 = uVar5 >> 3; uVar4 != 0; uVar4 = uVar4 - 1) {
            *puVar7 = 0;
            puVar7 = puVar7 + (ulong)bVar9 * -2 + 1;
          }
          if ((uVar5 & 4) != 0) {
            *(undefined4 *)puVar7 = 0;
            puVar7 = (undefined8 *)((long)puVar7 + 4);
          }
          if ((uVar5 & 2) != 0) {
            *(undefined2 *)puVar7 = 0;
            puVar7 = (undefined8 *)((long)puVar7 + 2);
          }
          if (bVar8) {
            *(undefined1 *)puVar7 = 0;
          }
          puVar3 = param_1 + 0x167;
          uVar5 = 0x38;
          bVar8 = ((ulong)puVar3 & 1) != 0;
          if (bVar8) {
            *(undefined1 *)(param_1 + 0x167) = 0;
            puVar3 = (undefined8 *)((long)param_1 + 0xb39);
            uVar5 = 0x37;
          }
          puVar7 = puVar3;
          if (((ulong)puVar3 & 2) != 0) {
            puVar7 = (undefined8 *)((long)puVar3 + 2);
            uVar5 = (ulong)((int)uVar5 - 2);
            *(undefined2 *)puVar3 = 0;
          }
          if (((ulong)puVar7 & 4) != 0) {
            *(undefined4 *)puVar7 = 0;
            uVar5 = (ulong)((int)uVar5 - 4);
            puVar7 = (undefined8 *)((long)puVar7 + 4);
          }
          for (uVar4 = uVar5 >> 3; uVar4 != 0; uVar4 = uVar4 - 1) {
            *puVar7 = 0;
            puVar7 = puVar7 + (ulong)bVar9 * -2 + 1;
          }
          if ((uVar5 & 4) != 0) {
            *(undefined4 *)puVar7 = 0;
            puVar7 = (undefined8 *)((long)puVar7 + 4);
          }
          if ((uVar5 & 2) != 0) {
            *(undefined2 *)puVar7 = 0;
            puVar7 = (undefined8 *)((long)puVar7 + 2);
          }
          if (bVar8) {
            *(undefined1 *)puVar7 = 0;
          }
          lVar1 = *(long *)(in_FS_OFFSET + 0x28);
          param_1[0x16e] = 0;
          param_1[0x16f] = 0;
          if (local_40 == lVar1) {
            return;
          }
                    /* WARNING: Subroutine does not return */
          __stack_chk_fail();
        }
        puVar3 = (undefined8 *)__cxa_allocate_exception(8);
        pcVar6 = "pthread_mutexattr_destroy failed\n";
      }
      else {
        puVar3 = (undefined8 *)__cxa_allocate_exception(8);
        pcVar6 = "pthread_mutex_init failed\n";
      }
    }
    else {
      puVar3 = (undefined8 *)__cxa_allocate_exception(8);
      pcVar6 = "pthread_mutexattr_settype failed\n";
    }
  }
  else {
    puVar3 = (undefined8 *)__cxa_allocate_exception(8);
    pcVar6 = "pthread_mutexattr_init failed\n";
  }
  *puVar3 = pcVar6;
                    /* WARNING: Subroutine does not return */
  __cxa_throw(puVar3,&PTR_vtable_0033ec10,0);
}


==================================================================

### FUNC 00117fc0 (403 bytes) name=FUN_00117fc0

undefined8 FUN_00117fc0(void *param_1)

{
  undefined1 uVar1;
  int iVar2;
  int iVar3;
  int *piVar4;
  undefined8 uVar5;
  ulong uVar6;
  undefined1 *puVar7;
  undefined1 *puVar8;
  undefined1 uVar9;
  undefined1 *puVar10;
  undefined1 *puVar11;
  long in_FS_OFFSET;
  undefined1 auStack_58 [16];
  undefined1 *local_48;
  undefined8 local_38;
  undefined8 local_30;
  undefined4 local_28;
  long local_20;
  
  local_20 = *(long *)(in_FS_OFFSET + 0x28);
  if (*(int *)((long)param_1 + 0x7c) == 0) {
    iVar3 = libusb_init((long)param_1 + 0x70);
    if (iVar3 < 0) {
      FUN_00113aa0(auStack_58,4);
      FUN_00116630(auStack_58);
      uVar6 = FUN_00116480(auStack_58);
      if (0x18 < uVar6) {
        local_28 = 0x393837;
        local_38 = 0x3233343536373839;
        local_30 = 0x3635343332313031;
        puVar7 = local_48;
        do {
          puVar10 = puVar7;
          iVar2 = iVar3 / 10;
          puVar7 = puVar10 + 1;
          *puVar10 = *(undefined1 *)((long)&local_30 + (long)(iVar3 % 10) + 1);
          iVar3 = iVar2;
        } while (iVar2 != 0);
        puVar10[1] = 0x2d;
        if ((local_48 != puVar10 + 2) && (local_48 < puVar7)) {
          uVar9 = 0x2d;
          puVar11 = local_48;
          while( true ) {
            uVar1 = *puVar11;
            puVar8 = puVar7 + -1;
            *puVar11 = uVar9;
            puVar11 = puVar11 + 1;
            *puVar7 = uVar1;
            if (puVar8 <= puVar11) break;
            uVar9 = *puVar8;
            puVar7 = puVar8;
          }
        }
        local_48 = local_48 + ((int)(puVar10 + 2) - (int)local_48);
        *local_48 = 0;
      }
      FUN_00113b30(auStack_58);
    }
    *(undefined4 *)((long)param_1 + 0x1e8) = 0;
    *(undefined4 *)((long)param_1 + 0x1f0) = 0;
    *(undefined4 *)((long)param_1 + 0x300) = 0;
    *(undefined4 *)((long)param_1 + 0x2c) = 1;
    pthread_create((pthread_t *)((long)param_1 + 0x18),(pthread_attr_t *)0x0,FUN_00117050,param_1);
    *(undefined4 *)((long)param_1 + 0x7c) = 1;
    uVar5 = 1;
  }
  else {
    piVar4 = __errno_location();
    *piVar4 = -0x1b51fffd;
    uVar5 = 0;
  }
  if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
                    /* WARNING: Subroutine does not return */
    __stack_chk_fail();
  }
  return uVar5;
}


==================================================================

### FUNC 00118190 (651 bytes) name=FUN_00118190

undefined8 FUN_00118190(long param_1)

{
  uint uVar1;
  long lVar2;
  int iVar3;
  uint uVar4;
  uint uVar5;
  int *piVar6;
  long lVar7;
  void *__dest;
  long local_60;
  undefined1 local_58 [8];
  short local_50;
  ushort local_4e;
  
  if (*(int *)(param_1 + 0x7c) == 0) {
    piVar6 = __errno_location();
    *piVar6 = -0x1b51fffc;
    return 0;
  }
  iVar3 = libusb_get_device_list(*(undefined8 *)(param_1 + 0x70),&local_60);
  if (iVar3 < 0) {
    piVar6 = __errno_location();
    *piVar6 = -0x1b51feff;
    return 0;
  }
  pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0xac8));
  iVar3 = *(int *)(param_1 + 0xac0) + -1;
  if (-1 < iVar3) {
    lVar7 = (long)iVar3;
    __dest = (void *)(param_1 + 0x340 + lVar7 * 0x3c);
    while( true ) {
      piVar6 = (int *)(param_1 + lVar7 * 0x3c + 0x378);
      *piVar6 = *piVar6 + -1;
      if (*piVar6 == 0) {
        if (iVar3 + 1 < *(int *)(param_1 + 0xac0)) {
          __dest = memmove(__dest,(void *)((long)__dest + 0x3c),
                           (ulong)(uint)((*(int *)(param_1 + 0xac0) + -1) - iVar3) * 0x3c);
        }
        *(int *)(param_1 + 0xac0) = *(int *)(param_1 + 0xac0) + -1;
      }
      __dest = (void *)((long)__dest + -0x3c);
      iVar3 = iVar3 + -1;
      if (iVar3 < 0) break;
      lVar7 = (long)iVar3;
    }
  }
  lVar7 = 0;
  do {
    lVar2 = *(long *)(local_60 + lVar7);
    if (lVar2 == 0) {
      pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0xac8));
      libusb_free_device_list(local_60,1);
      return 1;
    }
    iVar3 = libusb_get_device_descriptor(lVar2,local_58);
    if ((iVar3 == 0) && (local_50 == -0x7cc4)) {
      uVar4 = libusb_get_bus_number(lVar2);
      uVar5 = libusb_get_device_address(lVar2);
      iVar3 = *(int *)(param_1 + 0xac0) + -1;
      if (iVar3 != -1) {
        do {
          lVar2 = param_1 + (long)iVar3 * 0x3c;
          uVar1 = *(uint *)(lVar2 + 0x364);
          if (((uVar1 >> 0x10 == (uint)local_4e) && ((uVar1 >> 8 & 0xff) == (uVar4 & 0xff))) &&
             ((uVar1 & 0xff) == (uVar5 & 0xff))) {
            *(undefined4 *)(lVar2 + 0x378) = 5;
            goto LAB_001182a0;
          }
          iVar3 = iVar3 + -1;
        } while (iVar3 != -1);
      }
      if (*(uint *)(param_1 + 0xac0) < 0x20) {
        lVar2 = param_1 + 0x340 + (ulong)*(uint *)(param_1 + 0xac0) * 0x3c;
        *(uint *)(lVar2 + 0x24) = (uint)local_4e << 0x10 | uVar5 & 0xff | (uVar4 & 0xff) << 8;
        __sprintf_chk(lVar2,1,0x20,"%04x-%02x-%02x",local_4e,uVar4 & 0xff,uVar5 & 0xff);
        *(undefined8 *)(lVar2 + 0x2c) = 0;
        *(undefined4 *)(lVar2 + 0x34) = 0;
        iVar3 = *(int *)(param_1 + 0xac0);
        *(undefined4 *)(lVar2 + 0x38) = 5;
        *(int *)(param_1 + 0xac0) = iVar3 + 1;
      }
    }
LAB_001182a0:
    lVar7 = lVar7 + 8;
  } while( true );
}


==================================================================

### FUNC 00118440 (579 bytes) name=FUN_00118440

undefined8 FUN_00118440(long param_1,uint *param_2)

{
  long lVar1;
  byte bVar2;
  byte bVar3;
  int iVar4;
  int *piVar5;
  long lVar6;
  undefined8 uVar7;
  uint uVar8;
  long local_60;
  undefined1 local_58 [8];
  short local_50;
  ushort local_4e;
  
  if (*(int *)(param_1 + 0x7c) == 0) {
    piVar5 = __errno_location();
    *piVar5 = -0x1b51fffc;
    return 0;
  }
  if (*(int *)(param_1 + 0x80) == 0) {
    uVar8 = *param_2;
    lVar6 = libusb_get_device_list(*(undefined8 *)(param_1 + 0x70),&local_60);
    if (lVar6 < 0) {
      piVar5 = __errno_location();
      *piVar5 = -0x1b51feff;
    }
    else {
      for (lVar6 = 0; lVar1 = *(long *)(local_60 + lVar6), lVar1 != 0; lVar6 = lVar6 + 8) {
        iVar4 = libusb_get_device_descriptor(lVar1,local_58);
        if ((iVar4 == 0) && (local_50 == -0x7cc4)) {
          if (uVar8 == 0) {
            bVar2 = libusb_get_device_address(lVar1);
            bVar3 = libusb_get_bus_number(lVar1);
            uVar8 = (uint)bVar2 | (uint)local_4e << 0x10 | (uint)bVar3 << 8;
LAB_00118530:
            iVar4 = libusb_open(lVar1,param_1 + 0x68);
            if (iVar4 < 0) {
              piVar5 = __errno_location();
              *piVar5 = -0x1b51fdfe;
              libusb_free_device_list(local_60,1);
              return 0;
            }
            libusb_free_device_list(local_60,1);
            libusb_set_auto_detach_kernel_driver(*(undefined8 *)(param_1 + 0x68),1);
            iVar4 = libusb_set_configuration(*(undefined8 *)(param_1 + 0x68),2);
            if ((iVar4 < 0) &&
               (iVar4 = libusb_set_configuration(*(undefined8 *)(param_1 + 0x68),1), iVar4 < 0)) {
              piVar5 = __errno_location();
              *piVar5 = -0x1b51fdfb;
            }
            else {
              iVar4 = libusb_claim_interface(*(undefined8 *)(param_1 + 0x68),0);
              if (-1 < iVar4) {
                *(uint *)(param_1 + 0x78) = uVar8;
                uVar7 = FUN_00113bc0();
                *(undefined8 *)(param_1 + 0xaf8) = uVar7;
                *(uint *)(param_1 + 0x1e8) = uVar8;
                *(undefined4 *)(param_1 + 0x80) = 1;
                return 1;
              }
              piVar5 = __errno_location();
              *piVar5 = -0x1b51fdfa;
            }
            libusb_close(*(undefined8 *)(param_1 + 0x68));
            *(undefined8 *)(param_1 + 0x68) = 0;
            return 0;
          }
          if ((((uint)local_4e == uVar8 >> 0x10) &&
              (bVar2 = libusb_get_bus_number(lVar1), (uint)bVar2 == (uVar8 >> 8 & 0xff))) &&
             (bVar2 = libusb_get_device_address(lVar1), (uint)bVar2 == (uVar8 & 0xff)))
          goto LAB_00118530;
        }
      }
      piVar5 = __errno_location();
      *piVar5 = -0x1b51ffff;
    }
  }
  else {
    piVar5 = __errno_location();
    *piVar5 = -0x1b51fffd;
  }
  return 0;
}


==================================================================

### FUNC 001186b0 (301 bytes) name=FUN_001186b0

undefined4
FUN_001186b0(long param_1,undefined4 param_2,char *param_3,undefined8 param_4,undefined4 param_5,
            undefined4 param_6,char *param_7)

{
  undefined8 *puVar1;
  undefined4 uVar2;
  ulong uVar3;
  undefined8 *puVar4;
  undefined8 *puVar5;
  int iVar6;
  uint uVar7;
  bool bVar9;
  ulong uVar8;
  
  uVar8 = 0x110;
  iVar6 = 0x110;
  puVar1 = (undefined8 *)(param_1 + 0x1f0);
  bVar9 = ((ulong)puVar1 & 1) != 0;
  puVar4 = puVar1;
  if (bVar9) {
    *(undefined1 *)(param_1 + 0x1f0) = 0;
    uVar8 = 0x10f;
    iVar6 = 0x10f;
    puVar4 = (undefined8 *)(param_1 + 0x1f1);
  }
  if (((ulong)puVar4 & 2) == 0) {
    uVar7 = (uint)uVar8;
  }
  else {
    uVar7 = iVar6 - 2;
    uVar8 = (ulong)uVar7;
    *(undefined2 *)puVar4 = 0;
    puVar4 = (undefined8 *)((long)puVar4 + 2);
  }
  if (((ulong)puVar4 & 4) != 0) {
    *(undefined4 *)puVar4 = 0;
    uVar8 = (ulong)(uVar7 - 4);
    puVar4 = (undefined8 *)((long)puVar4 + 4);
  }
  for (uVar3 = uVar8 >> 3; uVar3 != 0; uVar3 = uVar3 - 1) {
    *puVar4 = 0;
    puVar4 = puVar4 + 1;
  }
  if ((uVar8 & 4) != 0) {
    *(undefined4 *)puVar4 = 0;
    puVar4 = (undefined8 *)((long)puVar4 + 4);
  }
  puVar5 = puVar4;
  if ((uVar8 & 2) != 0) {
    puVar5 = (undefined8 *)((long)puVar4 + 2);
    *(undefined2 *)puVar4 = 0;
  }
  if (bVar9) {
    *(undefined1 *)puVar5 = 0;
  }
  *(undefined4 *)(param_1 + 500) = param_5;
  *(undefined4 *)(param_1 + 0x1f0) = param_2;
  *(undefined4 *)(param_1 + 0x1f8) = 0;
  strncpy((char *)(param_1 + 0x1fc),param_3,0x40);
  *(undefined4 *)(param_1 + 0x27c) = param_6;
  strncpy((char *)(param_1 + 0x280),param_7,0x40);
  pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0x1c0));
  uVar2 = FUN_00118440(param_1,puVar1);
  pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0x1c0));
  return uVar2;
}


==================================================================

### FUNC 001187f0 (463 bytes) name=FUN_001187f0

void FUN_001187f0(long param_1,int param_2,undefined8 *param_3,int param_4)

{
  pthread_mutex_t *__mutex;
  long lVar1;
  uint uVar2;
  
  __mutex = (pthread_mutex_t *)(param_1 + 0xd8);
  pthread_mutex_lock(__mutex);
  if (param_2 == 0x5bb5b55c) {
    if (param_4 == 0x38) {
      *(undefined8 *)(param_1 + 0xb38) = *param_3;
      *(undefined8 *)(param_1 + 0xb40) = param_3[1];
      *(undefined8 *)(param_1 + 0xb48) = param_3[2];
      *(undefined8 *)(param_1 + 0xb50) = param_3[3];
      *(undefined8 *)(param_1 + 0xb58) = param_3[4];
      *(undefined8 *)(param_1 + 0xb60) = param_3[5];
      *(undefined8 *)(param_1 + 0xb68) = param_3[6];
    }
  }
  else if (param_2 < 0x5bb5b55d) {
    if ((param_2 == 0x5bb5b55b) && (param_4 == 0x38)) {
      *(undefined8 *)(param_1 + 0xb00) = *param_3;
      *(undefined8 *)(param_1 + 0xb08) = param_3[1];
      *(undefined8 *)(param_1 + 0xb10) = param_3[2];
      *(undefined8 *)(param_1 + 0xb18) = param_3[3];
      *(undefined8 *)(param_1 + 0xb20) = param_3[4];
      *(undefined8 *)(param_1 + 0xb28) = param_3[5];
      *(undefined8 *)(param_1 + 0xb30) = param_3[6];
      if ((*(int *)(param_1 + 0xb10) != 0) && (*(int *)(param_1 + 0xb14) != 0)) {
        pthread_mutex_unlock(__mutex);
        pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0xac8));
        if (*(int *)(param_1 + 0xac0) != 0) {
          lVar1 = param_1 + 0x340;
          uVar2 = 0;
          do {
            if (*(int *)(lVar1 + 0x24) == *(int *)(param_1 + 0x78)) {
              *(undefined4 *)(lVar1 + 0x28) = *(undefined4 *)(param_1 + 0xb00);
              __sprintf_chk(lVar1,1,0x20,"core-%d",*(undefined4 *)(param_1 + 0xb00));
            }
            uVar2 = uVar2 + 1;
            lVar1 = lVar1 + 0x3c;
          } while (uVar2 < *(uint *)(param_1 + 0xac0));
        }
        pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0xac8));
        pthread_mutex_lock(__mutex);
      }
    }
  }
  else if (param_2 < 0x5bb5b55f) {
    *(undefined8 *)(param_1 + 0xb70) = *param_3;
    *(undefined8 *)(param_1 + 0xb78) = param_3[1];
    pthread_mutex_unlock(__mutex);
    return;
  }
  pthread_mutex_unlock(__mutex);
  return;
}


==================================================================

### FUNC 001189f0 (198 bytes) name=FUN_001189f0

undefined8 FUN_001189f0(long param_1,undefined8 param_2,int param_3)

{
  int iVar1;
  undefined8 uVar2;
  int local_102c;
  undefined4 local_1028;
  undefined1 local_1024 [4092];
  
  pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0xb0));
  if (*(int *)(param_1 + 0x80) != 0) {
    iVar1 = libusb_bulk_transfer(*(undefined8 *)(param_1 + 0x68),3,param_2,param_3,&local_102c,500);
    if ((-1 < iVar1) && (param_3 == local_102c)) {
      iVar1 = libusb_bulk_transfer
                        (*(undefined8 *)(param_1 + 0x68),0x82,&local_1028,0x1000,&local_102c,2000);
      if ((-1 < iVar1) && (3 < local_102c)) {
        uVar2 = 1;
        FUN_001187f0(param_1,local_1028,local_1024,local_102c + -4);
        goto LAB_00118a50;
      }
    }
  }
  uVar2 = 0;
LAB_00118a50:
  pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0xb0));
  return uVar2;
}


==================================================================

### FUNC 00118ad0 (56 bytes) name=FUN_00118ad0

undefined8 FUN_00118ad0(long param_1,undefined4 param_2)

{
  int *piVar1;
  undefined8 uVar2;
  undefined4 local_c [3];
  
  local_c[0] = param_2;
  if (*(int *)(param_1 + 0x80) == 0) {
    piVar1 = __errno_location();
    *piVar1 = -0x1b51fffb;
    return 0;
  }
  uVar2 = FUN_001189f0(param_1,local_c,4);
  return uVar2;
}


==================================================================

### FUNC 00118b10 (57 bytes) name=FUN_00118b10

undefined8 FUN_00118b10(long param_1,undefined4 param_2,undefined4 param_3)

{
  int *piVar1;
  undefined8 uVar2;
  undefined4 local_18;
  undefined4 local_14;
  
  if (*(int *)(param_1 + 0x80) == 0) {
    piVar1 = __errno_location();
    *piVar1 = -0x1b51fffb;
    return 0;
  }
  local_18 = param_2;
  local_14 = param_3;
  uVar2 = FUN_001189f0(param_1,&local_18,8);
  return uVar2;
}


==================================================================

### FUNC 00118b50 (265 bytes) name=FUN_00118b50

void FUN_00118b50(long param_1,int param_2)

{
  pthread_t __th;
  
  if (param_2 == 0) {
    *(undefined4 *)(param_1 + 0x300) = 0;
  }
  if (*(int *)(param_1 + 0x80) == 0) {
    __th = *(pthread_t *)(param_1 + 0x10);
    *(undefined4 *)(param_1 + 0x28) = 0;
  }
  else {
    FUN_00118ad0(param_1);
    __th = *(pthread_t *)(param_1 + 0x10);
    *(undefined4 *)(param_1 + 0x28) = 0;
  }
  if (__th != 0) {
    pthread_join(__th,(void **)0x0);
    *(undefined8 *)(param_1 + 0x10) = 0;
  }
  *(undefined4 *)(param_1 + 0x30) = 0;
  pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0x100));
  pthread_cond_signal((pthread_cond_t *)(param_1 + 0x128));
  *(undefined1 *)(param_1 + 0x158) = 1;
  pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0x100));
  if (*(pthread_t *)(param_1 + 0x20) != 0) {
    pthread_join(*(pthread_t *)(param_1 + 0x20),(void **)0x0);
    *(undefined8 *)(param_1 + 0x20) = 0;
  }
  if (*(void **)(param_1 + 0x328) != (void *)0x0) {
    operator_delete__(*(void **)(param_1 + 0x328));
    *(undefined8 *)(param_1 + 0x328) = 0;
  }
  if (*(void **)(param_1 + 0x330) != (void *)0x0) {
    operator_delete__(*(void **)(param_1 + 0x330));
    *(undefined8 *)(param_1 + 0x330) = 0;
  }
  *(undefined4 *)(param_1 + 0x84) = 0;
  return;
}


==================================================================

### FUNC 00118c60 (92 bytes) name=FUN_00118c60

void FUN_00118c60(long param_1,undefined8 param_2,int param_3)

{
  if (param_3 == 0) {
    *(undefined4 *)(param_1 + 0x1e8) = 0;
  }
  if (*(int *)(param_1 + 0x84) != 0) {
    FUN_00118b50(param_1,param_3);
  }
  *(undefined4 *)(param_1 + 0x78) = 0;
  *(undefined4 *)(param_1 + 0x80) = 0;
  if (*(long *)(param_1 + 0x68) != 0) {
    libusb_release_interface(*(long *)(param_1 + 0x68),0);
    libusb_close(*(undefined8 *)(param_1 + 0x68));
    *(undefined8 *)(param_1 + 0x68) = 0;
  }
  return;
}


==================================================================

### FUNC 00118cc0 (66 bytes) name=FUN_00118cc0

void FUN_00118cc0(long param_1,undefined4 param_2,undefined4 param_3)

{
  pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0x1c0));
  FUN_00118c60(param_1,param_2,param_3);
  pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0x1c0));
  return;
}


==================================================================

### FUNC 00118d10 (48 bytes) name=FUN_00118d10

void FUN_00118d10(long param_1,undefined4 param_2)

{
  pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0x1c0));
  FUN_00118b50(param_1,param_2);
  pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0x1c0));
  return;
}


==================================================================

### FUNC 00118d40 (192 bytes) name=FUN_00118d40

void FUN_00118d40(long param_1)

{
  int iVar1;
  
  *(undefined4 *)(param_1 + 0x7c) = 0;
  *(undefined4 *)(param_1 + 0x2c) = 0;
  pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0x160));
  pthread_cond_signal((pthread_cond_t *)(param_1 + 0x188));
  *(undefined1 *)(param_1 + 0x1b8) = 1;
  pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0x160));
  if (*(pthread_t *)(param_1 + 0x18) == 0) {
    iVar1 = *(int *)(param_1 + 0x84);
  }
  else {
    pthread_join(*(pthread_t *)(param_1 + 0x18),(void **)0x0);
    iVar1 = *(int *)(param_1 + 0x84);
    *(undefined8 *)(param_1 + 0x18) = 0;
  }
  if (iVar1 == 0) {
    iVar1 = *(int *)(param_1 + 0x80);
  }
  else {
    FUN_00118d10(param_1,0);
    iVar1 = *(int *)(param_1 + 0x80);
  }
  if (iVar1 != 0) {
    FUN_00118cc0(param_1,0,0);
  }
  *(undefined4 *)(param_1 + 0xac0) = 0;
  if (*(long *)(param_1 + 0x70) != 0) {
    libusb_exit();
    *(undefined8 *)(param_1 + 0x70) = 0;
  }
  return;
}


==================================================================

### FUNC 00118e10 (140 bytes) name=FUN_00118e10

void FUN_00118e10(undefined8 *param_1)

{
  *param_1 = &PTR_FUN_0033ed30;
  FUN_00118d40();
  pthread_mutex_destroy((pthread_mutex_t *)(param_1 + 0x159));
  pthread_mutex_destroy((pthread_mutex_t *)(param_1 + 0x38));
  pthread_cond_destroy((pthread_cond_t *)(param_1 + 0x31));
  pthread_mutex_destroy((pthread_mutex_t *)(param_1 + 0x2c));
  pthread_cond_destroy((pthread_cond_t *)(param_1 + 0x25));
  pthread_mutex_destroy((pthread_mutex_t *)(param_1 + 0x20));
  pthread_mutex_destroy((pthread_mutex_t *)(param_1 + 0x1b));
  pthread_mutex_destroy((pthread_mutex_t *)(param_1 + 0x16));
  pthread_mutex_destroy((pthread_mutex_t *)(param_1 + 0x11));
  return;
}


==================================================================

### FUNC 00118f20 (18 bytes) name=FUN_00118f20

void FUN_00118f20(void *param_1)

{
  FUN_00118e10();
  operator_delete(param_1);
  return;
}


==================================================================

### FUNC 00118f40 (567 bytes) name=FUN_00118f40

undefined8 FUN_00118f40(void *param_1,int *param_2)

{
  uint uVar1;
  undefined8 uVar2;
  int iVar3;
  void *pvVar4;
  int *piVar5;
  undefined1 auStack_38 [40];
  
  if (*(int *)((long)param_1 + 0x80) == 0) {
    piVar5 = __errno_location();
    *piVar5 = -0x1b51fffb;
    return 0;
  }
  if (*(int *)((long)param_1 + 0x84) == 0) {
    if (((*param_2 == 0) || (*(long *)(param_2 + 4) == 0)) || (*(long *)(param_2 + 6) == 0)) {
      piVar5 = __errno_location();
      *piVar5 = -0x1b51ffff;
      return 0;
    }
    uVar1 = param_2[1];
    *(uint *)((long)param_1 + 0x338) = uVar1;
    if (*(void **)((long)param_1 + 0x328) != (void *)0x0) {
      operator_delete__(*(void **)((long)param_1 + 0x328));
      uVar1 = *(uint *)((long)param_1 + 0x338);
      *(undefined8 *)((long)param_1 + 0x328) = 0;
    }
    pvVar4 = operator_new__((ulong)uVar1 * 2 + 0x470);
    *(void **)((long)param_1 + 0x328) = pvVar4;
    if (*(void **)((long)param_1 + 0x330) != (void *)0x0) {
      operator_delete__(*(void **)((long)param_1 + 0x330));
      *(undefined8 *)((long)param_1 + 0x330) = 0;
    }
    pvVar4 = operator_new__((ulong)*(uint *)((long)param_1 + 0x338) + 0x4c);
    *(void **)((long)param_1 + 0x330) = pvVar4;
    if (*(void **)((long)param_1 + 0x328) != (void *)0x0) {
      if (pvVar4 != (void *)0x0) {
        uVar2 = *(undefined8 *)(param_2 + 4);
        *(undefined4 *)((long)param_1 + 8) = 0;
        *(undefined4 *)((long)param_1 + 0xc) = 0;
        *(undefined8 *)((long)param_1 + 0x50) = uVar2;
        *(undefined8 *)((long)param_1 + 0x48) = *(undefined8 *)(param_2 + 6);
        pthread_mutex_lock((pthread_mutex_t *)((long)param_1 + 0x100));
        *(undefined1 *)((long)param_1 + 0x158) = 0;
        pthread_mutex_unlock((pthread_mutex_t *)((long)param_1 + 0x100));
        *(undefined4 *)((long)param_1 + 0x30) = 1;
        pthread_create((pthread_t *)((long)param_1 + 0x20),(pthread_attr_t *)0x0,FUN_00116fb0,
                       param_1);
        *(undefined4 *)((long)param_1 + 0x1ec) = 0;
        *(undefined4 *)((long)param_1 + 0x28) = 1;
        pthread_create((pthread_t *)((long)param_1 + 0x10),(pthread_attr_t *)0x0,FUN_001170a0,
                       param_1);
        usleep(50000);
        iVar3 = FUN_00118ad0(param_1,0x6bb6b673);
        if (iVar3 != 0) {
          *(undefined4 *)((long)param_1 + 0x84) = 1;
          return 1;
        }
        FUN_00118d10(param_1,0);
        return 0;
      }
      operator_delete__(*(void **)((long)param_1 + 0x328));
      pvVar4 = *(void **)((long)param_1 + 0x330);
      *(undefined8 *)((long)param_1 + 0x328) = 0;
    }
    if (pvVar4 != (void *)0x0) {
      operator_delete__(pvVar4);
      *(undefined8 *)((long)param_1 + 0x330) = 0;
    }
    FUN_00113aa0(auStack_38,4);
    FUN_00116630(auStack_38,"Fail to allocate memory");
    FUN_00113b30(auStack_38);
    piVar5 = __errno_location();
    *piVar5 = -0x1b51fffe;
  }
  else {
    piVar5 = __errno_location();
    *piVar5 = -0x1b51fffd;
  }
  return 0;
}


==================================================================

### FUNC 001191a0 (175 bytes) name=FUN_001191a0

int FUN_001191a0(long param_1,undefined4 param_2,undefined4 param_3,undefined4 param_4,
                undefined8 param_5,undefined8 param_6,undefined4 param_7,undefined4 param_8)

{
  int iVar1;
  
  pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0x1c0));
  *(undefined8 *)(param_1 + 0x308) = 0;
  *(undefined4 *)(param_1 + 0x300) = param_2;
  *(undefined4 *)(param_1 + 0x308) = param_4;
  *(undefined4 *)(param_1 + 0x304) = param_3;
  *(undefined4 *)(param_1 + 0x324) = param_8;
  *(undefined8 *)(param_1 + 0x318) = param_6;
  *(undefined8 *)(param_1 + 0x310) = param_5;
  *(undefined4 *)(param_1 + 800) = param_7;
  iVar1 = FUN_00118f40(param_1);
  if (iVar1 == 0) {
    *(undefined4 *)(param_1 + 0x300) = 0;
  }
  pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0x1c0));
  return iVar1;
}


==================================================================

### FUNC 00119250 (44 bytes) name=FUN_00119250

undefined8 FUN_00119250(long param_1,undefined4 param_2)

{
  int *piVar1;
  undefined8 uVar2;
  
  if (*(int *)(param_1 + 0x80) == 0) {
    piVar1 = __errno_location();
    *piVar1 = -0x1b51fffb;
    return 0;
  }
  uVar2 = FUN_00118b10(param_1,0x6bb6b672,param_2);
  return uVar2;
}


==================================================================

### FUNC 00119280 (44 bytes) name=FUN_00119280

undefined8 FUN_00119280(long param_1,undefined4 param_2)

{
  int *piVar1;
  undefined8 uVar2;
  
  if (*(int *)(param_1 + 0x80) == 0) {
    piVar1 = __errno_location();
    *piVar1 = -0x1b51fffb;
    return 0;
  }
  uVar2 = FUN_00118b10(param_1,0x6bb6b676,param_2);
  return uVar2;
}


==================================================================

### FUNC 001192b0 (44 bytes) name=FUN_001192b0

undefined8 FUN_001192b0(long param_1,undefined4 param_2)

{
  int *piVar1;
  undefined8 uVar2;
  
  if (*(int *)(param_1 + 0x80) == 0) {
    piVar1 = __errno_location();
    *piVar1 = -0x1b51fffb;
    return 0;
  }
  uVar2 = FUN_00118b10(param_1,0x6bb6b677,param_2);
  return uVar2;
}


==================================================================

### FUNC 001192e0 (148 bytes) name=FUN_001192e0

undefined8 FUN_001192e0(long param_1,undefined8 *param_2)

{
  int iVar1;
  int *piVar2;
  
  if (*(int *)(param_1 + 0x80) == 0) {
    piVar2 = __errno_location();
    *piVar2 = -0x1b51fffb;
    return 0;
  }
  if (param_2 != (undefined8 *)0x0) {
    *(undefined8 *)(param_1 + 0xb70) = 0;
    *(undefined8 *)(param_1 + 0xb78) = 0;
    iVar1 = FUN_00118ad0(param_1,0x6bb6b66f);
    if ((iVar1 != 0) && (*(int *)(param_1 + 0xb70) != 0)) {
      *param_2 = *(undefined8 *)(param_1 + 0xb70);
      param_2[1] = *(undefined8 *)(param_1 + 0xb78);
      return 1;
    }
    return 0;
  }
  piVar2 = __errno_location();
  *piVar2 = -0x1b51ffff;
  return 0;
}


==================================================================

### FUNC 00119380 (107 bytes) name=FUN_00119380

void FUN_00119380(long param_1,undefined8 param_2,int param_3)

{
  __uid_t __uid;
  passwd *ppVar1;
  
  __uid = getuid();
  ppVar1 = getpwuid(__uid);
  __snprintf_chk(param_2,(long)param_3,1,0xffffffffffffffff,"%s/%s.%d.%lld",ppVar1->pw_dir,
                 ".magcore.cali",*(undefined4 *)(param_1 + 0xb00),*(undefined8 *)(param_1 + 0xb78));
  return;
}


==================================================================

### FUNC 001193f0 (190 bytes) name=FUN_001193f0

bool FUN_001193f0(undefined8 param_1)

{
  int iVar1;
  FILE *__stream;
  long lVar2;
  long in_FS_OFFSET;
  bool bVar3;
  uint local_138 [4];
  char local_128 [264];
  long local_20;
  
  local_20 = *(long *)(in_FS_OFFSET + 0x28);
  iVar1 = FUN_001192e0(param_1,local_138);
  if (iVar1 != 0) {
    bVar3 = false;
    if (0x6400000 < local_138[0]) goto LAB_0011942a;
    FUN_00119380(param_1,local_128,0x100);
    __stream = fopen(local_128,"rb");
    if (__stream != (FILE *)0x0) {
      fseek(__stream,0,2);
      lVar2 = ftell(__stream);
      bVar3 = local_138[0] != (uint)lVar2;
      fclose(__stream);
      goto LAB_0011942a;
    }
  }
  bVar3 = true;
LAB_0011942a:
  if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
    return bVar3;
  }
                    /* WARNING: Subroutine does not return */
  __stack_chk_fail();
}


==================================================================

### FUNC 001194c0 (794 bytes) name=FUN_001194c0

undefined8 FUN_001194c0(long param_1,undefined8 *param_2,undefined8 *param_3,uint param_4)

{
  int iVar1;
  int iVar2;
  uint uVar3;
  int *piVar4;
  long lVar5;
  ulong uVar6;
  ulong uVar7;
  undefined8 *puVar8;
  undefined8 *puVar9;
  bool bVar10;
  
  if (*(int *)(param_1 + 0x80) == 0) {
    piVar4 = __errno_location();
    *piVar4 = -0x1b51fffb;
    return 0;
  }
  if ((param_2 == (undefined8 *)0x0) || (param_3 == (undefined8 *)0x0)) {
    piVar4 = __errno_location();
    *piVar4 = -0x1b51ffff;
    return 0;
  }
  puVar8 = (undefined8 *)(param_1 + 0xb00);
  uVar7 = 0x38;
  bVar10 = ((ulong)puVar8 & 1) != 0;
  if (bVar10) {
    *(undefined1 *)(param_1 + 0xb00) = 0;
    puVar8 = (undefined8 *)(param_1 + 0xb01);
    uVar7 = 0x37;
  }
  puVar9 = puVar8;
  if (((ulong)puVar8 & 2) != 0) {
    puVar9 = (undefined8 *)((long)puVar8 + 2);
    uVar7 = (ulong)((int)uVar7 - 2);
    *(undefined2 *)puVar8 = 0;
  }
  if (((ulong)puVar9 & 4) != 0) {
    *(undefined4 *)puVar9 = 0;
    uVar7 = (ulong)((int)uVar7 - 4);
    puVar9 = (undefined8 *)((long)puVar9 + 4);
  }
  for (uVar6 = uVar7 >> 3; uVar6 != 0; uVar6 = uVar6 - 1) {
    *puVar9 = 0;
    puVar9 = puVar9 + 1;
  }
  if ((uVar7 & 4) != 0) {
    *(undefined4 *)puVar9 = 0;
    puVar9 = (undefined8 *)((long)puVar9 + 4);
  }
  if ((uVar7 & 2) != 0) {
    *(undefined2 *)puVar9 = 0;
    puVar9 = (undefined8 *)((long)puVar9 + 2);
  }
  if (bVar10) {
    *(undefined1 *)puVar9 = 0;
  }
  puVar8 = (undefined8 *)(param_1 + 0xb38);
  uVar7 = 0x38;
  bVar10 = ((ulong)puVar8 & 1) != 0;
  if (bVar10) {
    *(undefined1 *)(param_1 + 0xb38) = 0;
    puVar8 = (undefined8 *)(param_1 + 0xb39);
    uVar7 = 0x37;
  }
  puVar9 = puVar8;
  if (((ulong)puVar8 & 2) != 0) {
    puVar9 = (undefined8 *)((long)puVar8 + 2);
    uVar7 = (ulong)((int)uVar7 - 2);
    *(undefined2 *)puVar8 = 0;
  }
  if (((ulong)puVar9 & 4) != 0) {
    *(undefined4 *)puVar9 = 0;
    uVar7 = (ulong)((int)uVar7 - 4);
    puVar9 = (undefined8 *)((long)puVar9 + 4);
  }
  for (uVar6 = uVar7 >> 3; uVar6 != 0; uVar6 = uVar6 - 1) {
    *puVar9 = 0;
    puVar9 = puVar9 + 1;
  }
  if ((uVar7 & 4) != 0) {
    *(undefined4 *)puVar9 = 0;
    puVar9 = (undefined8 *)((long)puVar9 + 4);
  }
  if ((uVar7 & 2) != 0) {
    *(undefined2 *)puVar9 = 0;
    puVar9 = (undefined8 *)((long)puVar9 + 2);
  }
  if (bVar10) {
    *(undefined1 *)puVar9 = 0;
  }
  iVar1 = FUN_00118ad0(param_1,0x6bb6b66b);
  iVar2 = FUN_00118ad0(param_1,0x6bb6b66c);
  if ((iVar2 != 0) && (iVar1 != 0)) {
    uVar3 = FUN_00113bc0();
    do {
      usleep(10000);
      if ((*(int *)(param_1 + 0xb10) != 0) && (*(int *)(param_1 + 0xb38) != 0)) break;
      lVar5 = FUN_00113bc0();
    } while (lVar5 - (ulong)uVar3 < (ulong)param_4);
    if ((*(int *)(param_1 + 0xb10) != 0) && (*(int *)(param_1 + 0xb38) != 0)) {
      *param_2 = *(undefined8 *)(param_1 + 0xb00);
      param_2[1] = *(undefined8 *)(param_1 + 0xb08);
      param_2[2] = *(undefined8 *)(param_1 + 0xb10);
      param_2[3] = *(undefined8 *)(param_1 + 0xb18);
      param_2[4] = *(undefined8 *)(param_1 + 0xb20);
      param_2[5] = *(undefined8 *)(param_1 + 0xb28);
      param_2[6] = *(undefined8 *)(param_1 + 0xb30);
      *param_3 = *(undefined8 *)(param_1 + 0xb38);
      param_3[1] = *(undefined8 *)(param_1 + 0xb40);
      param_3[2] = *(undefined8 *)(param_1 + 0xb48);
      param_3[3] = *(undefined8 *)(param_1 + 0xb50);
      param_3[4] = *(undefined8 *)(param_1 + 0xb58);
      param_3[5] = *(undefined8 *)(param_1 + 0xb60);
      param_3[6] = *(undefined8 *)(param_1 + 0xb68);
      return 1;
    }
    piVar4 = __errno_location();
    *piVar4 = -0x1b51fff8;
  }
  return 0;
}


==================================================================

### FUNC 00119830 (337 bytes) name=FUN_00119830

bool FUN_00119830(long param_1,undefined8 *param_2,undefined8 *param_3)

{
  long lVar1;
  int iVar2;
  int *piVar3;
  ulong uVar4;
  undefined1 local_95 [69];
  undefined8 uStack_50;
  int local_3c;
  
  if (*(int *)(param_1 + 0x80) == 0) {
    uStack_50 = 0x119975;
    piVar3 = __errno_location();
    *piVar3 = -0x1b51fffb;
    return false;
  }
  if ((param_2 != (undefined8 *)0x0) && (param_3 != (undefined8 *)0x0)) {
    uVar4 = (ulong)local_95 >> 2;
    *(undefined4 *)(uVar4 * 4) = 0x6bb6b66d;
    lVar1 = uVar4 * 4;
    *(undefined8 *)(uVar4 * 4 + 4) = *param_2;
    *(undefined8 *)(lVar1 + 0xc) = param_2[1];
    *(undefined8 *)(lVar1 + 0x14) = param_2[2];
    *(undefined8 *)(lVar1 + 0x1c) = param_2[3];
    *(undefined8 *)(lVar1 + 0x24) = param_2[4];
    *(undefined8 *)(lVar1 + 0x2c) = param_2[5];
    *(undefined8 *)(lVar1 + 0x34) = param_2[6];
    local_3c = FUN_001189f0(param_1,lVar1,0x3c);
    *(undefined4 *)(uVar4 * 4) = 0x6bb6b66e;
    *(undefined8 *)(uVar4 * 4 + 4) = *param_3;
    *(undefined8 *)(lVar1 + 0xc) = param_3[1];
    *(undefined8 *)(lVar1 + 0x14) = param_3[2];
    *(undefined8 *)(lVar1 + 0x1c) = param_3[3];
    *(undefined8 *)(lVar1 + 0x24) = param_3[4];
    *(undefined8 *)(lVar1 + 0x2c) = param_3[5];
    *(undefined8 *)(lVar1 + 0x34) = param_3[6];
    iVar2 = FUN_001189f0(param_1,lVar1,0x3c);
    return local_3c != 0 && iVar2 != 0;
  }
  uStack_50 = 0x11985c;
  piVar3 = __errno_location();
  *piVar3 = -0x1b51ffff;
  return false;
}


==================================================================

### FUNC 00119990 (163 bytes) name=FUN_00119990

undefined8 FUN_00119990(void *param_1)

{
  int iVar1;
  undefined8 uVar2;
  long in_FS_OFFSET;
  pthread_t local_60;
  pthread_attr_t local_58;
  long local_20;
  
  local_20 = *(long *)(in_FS_OFFSET + 0x28);
  uVar2 = FUN_001193f0();
  if ((int)uVar2 != 0) {
    iVar1 = pthread_attr_init(&local_58);
    uVar2 = 0xffffffff;
    if (iVar1 == 0) {
      iVar1 = pthread_attr_setdetachstate(&local_58,1);
      if (iVar1 == 0) {
        iVar1 = pthread_create(&local_60,&local_58,FUN_00119e00,param_1);
        if (iVar1 == 0) {
          pthread_attr_destroy(&local_58);
          uVar2 = 1;
          goto LAB_001199b2;
        }
      }
      pthread_attr_destroy(&local_58);
      uVar2 = 0xffffffff;
    }
  }
LAB_001199b2:
  if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
    return uVar2;
  }
                    /* WARNING: Subroutine does not return */
  __stack_chk_fail();
}


==================================================================

### FUNC 00119a40 (697 bytes) name=FUN_00119a40

undefined8 FUN_00119a40(long param_1,undefined8 param_2)

{
  int iVar1;
  int iVar2;
  ulong uVar3;
  void *pvVar4;
  ulong uVar5;
  void *pvVar6;
  ulong uVar7;
  ulong uVar8;
  int iVar9;
  int local_5c;
  undefined1 local_58 [40];
  
  *(undefined8 *)(param_1 + 0xb70) = 0;
  *(undefined8 *)(param_1 + 0xb78) = 0;
  iVar1 = FUN_00118ad0(param_1,0x6bb6b670);
  if (((iVar1 != 0) && (*(int *)(param_1 + 0xb70) != 0)) && (*(uint *)(param_1 + 0xb70) < 0x6400001)
     ) {
    iVar1 = *(int *)(param_1 + 0xb70);
    uVar3 = (ulong)iVar1;
    pvVar4 = operator_new__(uVar3);
    if (pvVar4 != (void *)0x0) {
      local_5c = 0;
      FUN_00113aa0(local_58,2);
      FUN_00116630(local_58,"First running on new host, it will cost some time for initializing...")
      ;
      FUN_00113b30(local_58);
      if (*(code **)(param_1 + 0x58) != (code *)0x0) {
        (**(code **)(param_1 + 0x58))
                  (*(undefined4 *)(param_1 + 0x33c),0,0,*(undefined8 *)(param_1 + 0x60));
      }
      iVar9 = iVar1;
      if (iVar1 < 1) {
        uVar8 = 0;
      }
      else {
        uVar8 = 0;
        pvVar6 = pvVar4;
        do {
          iVar2 = 0x80000;
          if (iVar9 < 0x80001) {
            iVar2 = iVar9;
          }
          iVar2 = libusb_bulk_transfer
                            (*(undefined8 *)(param_1 + 0x68),0x84,pvVar6,iVar2,&local_5c,60000);
          if (iVar2 < 0) {
            __printf_chk(1,&DAT_00131fca,*(undefined8 *)(param_1 + 0x68),iVar9);
            operator_delete__(pvVar4);
            if (*(code **)(param_1 + 0x58) != (code *)0x0) {
              (**(code **)(param_1 + 0x58))
                        (*(undefined4 *)(param_1 + 0x33c),0xfffffffe,uVar8,
                         *(undefined8 *)(param_1 + 0x60));
              return 0;
            }
            return 0;
          }
          iVar9 = iVar9 - local_5c;
          pvVar6 = (void *)((long)pvVar6 + (long)local_5c);
          if (*(code **)(param_1 + 0x58) != (code *)0x0) {
            uVar5 = ((long)(iVar1 - iVar9) * 100) / (long)uVar3;
            uVar7 = 99;
            if ((long)uVar5 < 100) {
              uVar7 = uVar5;
            }
            if ((int)uVar8 < (int)uVar7) {
              (**(code **)(param_1 + 0x58))
                        (*(undefined4 *)(param_1 + 0x33c),0,uVar7 & 0xffffffff,
                         *(undefined8 *)(param_1 + 0x60));
              uVar8 = uVar7 & 0xffffffff;
            }
          }
        } while (0 < iVar9);
      }
      if (iVar9 == 0) {
        FUN_00106fb0(local_58,param_2,0);
        FUN_001070c0(local_58,pvVar4,uVar3,1);
        FUN_00106d80(local_58);
        if (*(code **)(param_1 + 0x58) != (code *)0x0) {
          (**(code **)(param_1 + 0x58))
                    (*(undefined4 *)(param_1 + 0x33c),0,100,*(undefined8 *)(param_1 + 0x60));
        }
        operator_delete__(pvVar4);
        return 1;
      }
      operator_delete__(pvVar4);
      if (*(code **)(param_1 + 0x58) == (code *)0x0) {
        return 0;
      }
      (**(code **)(param_1 + 0x58))
                (*(undefined4 *)(param_1 + 0x33c),0xfffffffd,uVar8,*(undefined8 *)(param_1 + 0x60));
      return 0;
    }
  }
  if (*(code **)(param_1 + 0x58) != (code *)0x0) {
    (**(code **)(param_1 + 0x58))
              (*(undefined4 *)(param_1 + 0x33c),0xffffffff,0,*(undefined8 *)(param_1 + 0x60));
    return 0;
  }
  return 0;
}


==================================================================

### FUNC 00119d90 (109 bytes) name=FUN_00119d90

undefined4 FUN_00119d90(undefined8 param_1)

{
  int iVar1;
  undefined4 uVar2;
  long in_FS_OFFSET;
  undefined1 auStack_128 [264];
  long local_20;
  
  local_20 = *(long *)(in_FS_OFFSET + 0x28);
  iVar1 = FUN_001193f0();
  uVar2 = 1;
  if (iVar1 != 0) {
    FUN_00119380(param_1,auStack_128,0x100);
    uVar2 = FUN_00119a40(param_1,auStack_128);
  }
  if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
    return uVar2;
  }
                    /* WARNING: Subroutine does not return */
  __stack_chk_fail();
}


==================================================================

### FUNC 00119e00 (16 bytes) name=FUN_00119e00

undefined8 FUN_00119e00(void)

{
  FUN_00119d90();
  return 0;
}


==================================================================

### FUNC 00119e10 (90 bytes) name=FUN_00119e10

void FUN_00119e10(undefined8 *param_1)

{
  *param_1 = &PTR_FUN_0033ed70;
  if ((void *)param_1[1] != (void *)0x0) {
    operator_delete__((void *)param_1[1]);
    param_1[1] = 0;
  }
  param_1[2] = 0;
  if ((void *)param_1[3] != (void *)0x0) {
    operator_delete__((void *)param_1[3]);
    param_1[3] = 0;
  }
  if ((void *)param_1[4] != (void *)0x0) {
    operator_delete__((void *)param_1[4]);
    param_1[4] = 0;
  }
  return;
}


==================================================================

### FUNC 00119e70 (18 bytes) name=FUN_00119e70

void FUN_00119e70(void *param_1)

{
  FUN_00119e10();
  operator_delete(param_1);
  return;
}


==================================================================

### FUNC 00119e90 (79 bytes) name=FUN_00119e90

void FUN_00119e90(undefined8 *param_1)

{
  param_1[1] = 0;
  param_1[2] = 0;
  param_1[3] = 0;
  param_1[5] = 0;
  *param_1 = &PTR_FUN_0033ed70;
  param_1[4] = 0;
  *(undefined4 *)(param_1 + 6) = 0;
  *(undefined4 *)((long)param_1 + 0x34) = 0;
  *(undefined4 *)(param_1 + 7) = 0;
  *(undefined4 *)((long)param_1 + 0x3c) = 0;
  return;
}


==================================================================

### FUNC 00119ee0 (291 bytes) name=FUN_00119ee0

undefined8 FUN_00119ee0(long param_1,uint param_2,int param_3,int param_4,uint param_5)

{
  ulong __n;
  void *pvVar1;
  long lVar2;
  
  *(undefined4 *)(param_1 + 0x3c) = 0;
  if (*(void **)(param_1 + 8) != (void *)0x0) {
    operator_delete__(*(void **)(param_1 + 8));
    *(undefined8 *)(param_1 + 8) = 0;
  }
  *(undefined8 *)(param_1 + 0x10) = 0;
  if (*(void **)(param_1 + 0x18) != (void *)0x0) {
    operator_delete__(*(void **)(param_1 + 0x18));
    *(undefined8 *)(param_1 + 0x18) = 0;
  }
  if (*(void **)(param_1 + 0x20) != (void *)0x0) {
    operator_delete__(*(void **)(param_1 + 0x20));
    *(undefined8 *)(param_1 + 0x20) = 0;
  }
  if ((param_2 != 0) && (param_3 != 0)) {
    *(int *)(param_1 + 0x38) = param_3;
    *(undefined4 *)(param_1 + 0x30) = 0;
    *(uint *)(param_1 + 0x34) = param_2;
    pvVar1 = operator_new__((((ulong)param_5 + 1 >> 1) + (ulong)(param_3 * param_2)) * 2);
    *(void **)(param_1 + 8) = pvVar1;
    if (pvVar1 == (void *)0x0) {
      *(undefined8 *)(param_1 + 0x10) = 0;
    }
    else {
      __n = (ulong)param_2 * 4;
      lVar2 = (long)pvVar1 + (ulong)(param_5 & 0xfffffffe);
      *(long *)(param_1 + 0x10) = lVar2;
      *(long *)(param_1 + 0x28) = lVar2;
      pvVar1 = operator_new__(__n);
      *(void **)(param_1 + 0x18) = pvVar1;
      if (pvVar1 != (void *)0x0) {
        memset(pvVar1,0,__n);
        if (param_4 != 0) {
          pvVar1 = operator_new__((ulong)param_2 * 2);
          *(void **)(param_1 + 0x20) = pvVar1;
          if (pvVar1 == (void *)0x0) {
            return 0;
          }
        }
        *(undefined4 *)(param_1 + 0x3c) = 1;
        return 1;
      }
    }
  }
  return 0;
}


==================================================================

### FUNC 0011a010 (291 bytes) name=FUN_0011a010

bool FUN_0011a010(long param_1,ushort *param_2)

{
  ushort uVar1;
  ushort uVar2;
  uint uVar3;
  ushort *__dest;
  uint uVar4;
  ushort *puVar5;
  ushort *puVar6;
  int *piVar7;
  
  if (*(int *)(param_1 + 0x3c) == 0) {
    return false;
  }
  piVar7 = *(int **)(param_1 + 0x18);
  if (piVar7 == (int *)0x0) {
    return false;
  }
  uVar4 = *(int *)(param_1 + 0x30) + 1;
  *(uint *)(param_1 + 0x30) = uVar4;
  __dest = *(ushort **)(param_1 + 0x28);
  uVar3 = *(uint *)(param_1 + 0x34);
  if (*(uint *)(param_1 + 0x38) < uVar4) {
    uVar4 = uVar3 >> 2;
    puVar5 = __dest;
    puVar6 = param_2;
    if (uVar3 >> 2 == 0) goto LAB_0011a0b6;
    do {
      uVar1 = puVar5[1];
      *piVar7 = *piVar7 + ((uint)*puVar6 - (uint)*puVar5);
      uVar2 = puVar5[2];
      piVar7[1] = piVar7[1] + ((uint)puVar6[1] - (uint)uVar1);
      uVar1 = puVar5[3];
      piVar7[2] = piVar7[2] + ((uint)puVar6[2] - (uint)uVar2);
      piVar7[3] = piVar7[3] + ((uint)puVar6[3] - (uint)uVar1);
      uVar4 = uVar4 - 1;
      puVar5 = puVar5 + 4;
      puVar6 = puVar6 + 4;
      piVar7 = piVar7 + 4;
    } while (uVar4 != 0);
  }
  else {
    uVar4 = uVar3 >> 2;
    puVar5 = param_2;
    if (uVar3 >> 2 == 0) goto LAB_0011a0b6;
    do {
      *piVar7 = *piVar7 + (uint)*puVar5;
      piVar7[1] = piVar7[1] + (uint)puVar5[1];
      piVar7[2] = piVar7[2] + (uint)puVar5[2];
      piVar7[3] = piVar7[3] + (uint)puVar5[3];
      uVar4 = uVar4 - 1;
      puVar5 = puVar5 + 4;
      piVar7 = piVar7 + 4;
    } while (uVar4 != 0);
  }
  uVar3 = *(uint *)(param_1 + 0x34);
LAB_0011a0b6:
  memcpy(__dest,param_2,(ulong)uVar3 * 2);
  if (*(uint *)(param_1 + 0x30) % *(uint *)(param_1 + 0x38) == 0) {
    *(undefined8 *)(param_1 + 0x28) = *(undefined8 *)(param_1 + 0x10);
  }
  else {
    *(long *)(param_1 + 0x28) = *(long *)(param_1 + 0x28) + (ulong)*(uint *)(param_1 + 0x34) * 2;
  }
  return *(uint *)(param_1 + 0x38) <= *(uint *)(param_1 + 0x30);
}


==================================================================

### FUNC 0011a140 (214 bytes) name=FUN_0011a140

bool FUN_0011a140(long param_1,void *param_2,int param_3)

{
  ushort uVar1;
  ushort uVar2;
  int iVar3;
  uint uVar4;
  int iVar5;
  uint uVar6;
  long lVar7;
  ushort *puVar8;
  ushort *puVar9;
  
  if (*(int *)(param_1 + 0x3c) == 0) {
    return false;
  }
  uVar4 = *(int *)(param_1 + 0x30) + 1;
  *(uint *)(param_1 + 0x30) = uVar4;
  if (*(uint *)(param_1 + 0x38) < uVar4) {
    if (*(uint *)(param_1 + 0x38) != 1) {
      return false;
    }
    puVar9 = *(ushort **)(param_1 + 0x10);
    iVar3 = *(int *)(param_1 + 0x34);
    uVar6 = 1;
    if (iVar3 != 0) {
      lVar7 = (long)param_2 + 2;
      puVar8 = puVar9;
      do {
        uVar1 = *(ushort *)(lVar7 + -2);
        uVar2 = *puVar8;
        *puVar8 = uVar1;
        iVar5 = (uint)uVar1 - (uint)uVar2;
        if (((iVar5 <= param_3) && (-iVar5 <= param_3)) && (iVar5 != 0)) {
          *(ushort *)(lVar7 + -2) = uVar1 - (short)(iVar5 >> 1);
        }
        lVar7 = lVar7 + 2;
        puVar8 = puVar8 + 1;
      } while (lVar7 != (long)param_2 + (ulong)(iVar3 - 1) * 2 + 4);
      uVar6 = 1;
    }
  }
  else {
    memcpy(*(void **)(param_1 + 0x28),param_2,(ulong)*(uint *)(param_1 + 0x34) * 2);
    uVar4 = *(uint *)(param_1 + 0x30);
    uVar6 = *(uint *)(param_1 + 0x38);
    if (uVar4 % uVar6 != 0) {
      *(long *)(param_1 + 0x28) = *(long *)(param_1 + 0x28) + (ulong)*(uint *)(param_1 + 0x34) * 2;
      goto LAB_0011a197;
    }
    puVar9 = *(ushort **)(param_1 + 0x10);
  }
  *(ushort **)(param_1 + 0x28) = puVar9;
LAB_0011a197:
  return uVar6 <= uVar4;
}


==================================================================

### FUNC 0011a230 (42 bytes) name=FUN_0011a230

void FUN_0011a230(long param_1)

{
  if (*(int *)(param_1 + 0x3c) == 0) {
    return;
  }
  *(undefined4 *)(param_1 + 0x30) = 0;
  *(undefined8 *)(param_1 + 0x28) = *(undefined8 *)(param_1 + 0x10);
  memset(*(void **)(param_1 + 0x18),0,(ulong)*(uint *)(param_1 + 0x34) << 2);
  return;
}


==================================================================

### FUNC 0011a270 (345 bytes) name=FUN_0011a270

/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

void * FUN_0011a270(long param_1)

{
  void *__s;
  uint uVar1;
  uint uVar2;
  uint uVar3;
  ulong uVar4;
  void *pvVar5;
  uint uVar6;
  uint uVar7;
  double dVar8;
  double dVar9;
  double dVar10;
  
  if ((*(int *)(param_1 + 0x3c) != 0) && (*(long *)(param_1 + 0x18) != 0)) {
    __s = *(void **)(param_1 + 0x20);
    if (__s != (void *)0x0) {
      uVar6 = *(uint *)(param_1 + 0x38);
      if (*(uint *)(param_1 + 0x30) < uVar6) {
        return (void *)0x0;
      }
      if (uVar6 < 2) {
        memset(__s,0,(ulong)*(uint *)(param_1 + 0x34) * 2);
        __s = *(void **)(param_1 + 0x20);
      }
      else {
        uVar7 = *(uint *)(param_1 + 0x34);
        dVar10 = _DAT_00131fe8 / (double)((uVar6 - 1) * uVar6 * uVar6);
        if (uVar7 != 0) {
          uVar2 = 0;
          pvVar5 = __s;
          while( true ) {
            dVar9 = 0.0;
            if (uVar6 != 0) {
              uVar1 = 0;
              uVar3 = uVar2;
              do {
                uVar4 = (ulong)uVar3;
                uVar1 = uVar1 + 1;
                uVar3 = uVar3 + uVar7;
                dVar8 = (double)(int)(*(ushort *)(*(long *)(param_1 + 0x10) + uVar4 * 2) * uVar6 -
                                     *(int *)(*(long *)(param_1 + 0x18) + (ulong)uVar2 * 4));
                dVar9 = dVar9 + dVar8 * dVar8;
              } while (uVar1 != uVar6);
            }
            uVar4 = (ulong)uVar2;
            dVar9 = dVar9 * dVar10;
            dVar8 = SQRT(dVar9);
            __s = pvVar5;
            if (NAN(dVar8)) {
              dVar8 = sqrt(dVar9);
              __s = *(void **)(param_1 + 0x20);
              uVar7 = *(uint *)(param_1 + 0x34);
            }
            uVar2 = uVar2 + 1;
            *(short *)((long)pvVar5 + uVar4 * 2) = (short)(int)dVar8;
            if (uVar7 <= uVar2) break;
            uVar6 = *(uint *)(param_1 + 0x38);
            pvVar5 = __s;
          }
        }
      }
    }
    return __s;
  }
  return (void *)0x0;
}


==================================================================

### FUNC 0011a3d0 (1781 bytes) name=FUN_0011a3d0

/* WARNING: Restarted to delay deadcode elimination for space: stack */

undefined4
FUN_0011a3d0(uint param_1,uint *param_2,int *param_3,uint param_4,code *param_5,undefined8 param_6)

{
  uint uVar1;
  undefined8 uVar2;
  uint uVar3;
  int iVar4;
  int *piVar5;
  long lVar6;
  ulong uVar7;
  undefined4 uVar8;
  int *piVar9;
  undefined4 *puVar10;
  int *piVar11;
  long lVar12;
  ulong uVar13;
  long in_FS_OFFSET;
  bool bVar14;
  byte bVar15;
  uint local_3e8;
  uint local_3e4;
  uint local_3e0;
  uint local_3dc;
  uint local_3d8;
  uint local_3d4;
  undefined4 local_3d0;
  undefined4 local_3cc;
  undefined4 local_3c8;
  undefined4 local_3c4;
  int local_3b8 [4];
  undefined4 local_3a8;
  undefined4 local_3a4;
  undefined4 local_3a0;
  undefined4 local_39c;
  undefined4 local_398;
  undefined4 local_394;
  undefined4 local_390;
  undefined4 local_38c;
  char local_388 [32];
  char local_368 [32];
  undefined8 local_348;
  undefined4 local_340;
  undefined4 local_33c;
  undefined8 local_338;
  undefined8 local_330;
  undefined1 local_328 [556];
  undefined4 local_fc;
  undefined4 local_f4;
  undefined4 local_f0;
  undefined4 local_ec;
  undefined4 local_e8;
  undefined4 local_e4;
  undefined4 local_e0;
  undefined4 local_dc;
  undefined4 local_d8;
  undefined4 local_d4;
  undefined4 local_d0;
  undefined4 local_cc;
  undefined4 local_c8;
  undefined4 local_c4;
  undefined4 local_64;
  undefined4 local_60;
  undefined4 local_5c;
  undefined4 local_58;
  undefined4 local_54;
  int local_50;
  int local_4c;
  int local_48;
  long local_40;
  
  bVar15 = 0;
  uVar7 = (ulong)param_4;
  local_40 = *(long *)(in_FS_OFFSET + 0x28);
  if (((((param_2 != (uint *)0x0) && (param_3 != (int *)0x0)) &&
       (uVar3 = *param_2, (uVar3 & 3) == 0)) && (((param_2[2] & 3) == 0 && ((param_2[4] & 3) == 0)))
      ) && (uVar3 <= param_2[2])) {
    uVar1 = param_2[1];
    if (((uVar1 <= param_2[3]) && (uVar1 != 0)) &&
       ((param_2[3] != 0 && ((param_2[5] != 0 && (0x87 < param_4)))))) {
      uVar13 = (ulong)param_1;
      if (*param_3 == 0x5bb5b55b) {
        param_3 = param_3 + 0x22;
        uVar7 = (ulong)(param_4 - 0x88);
      }
      else {
        if (param_4 < 0x98) goto LAB_0011a500;
        piVar5 = (int *)((long)param_3 + ((ulong)param_4 - 0x98));
        if (*piVar5 == 0x5bb5b57b) {
          iVar4 = piVar5[1] + 0x88;
          uVar7 = (ulong)(param_4 - iVar4);
          param_3 = (int *)((long)param_3 + (long)iVar4);
        }
      }
      if (0x374 < (uint)uVar7) {
        if (*(int *)((&DAT_00340d10)[uVar13 * 0x95] + 0x80) != 0) {
          piVar5 = __errno_location();
          uVar8 = 0;
          *piVar5 = -0x1b51fffd;
          goto LAB_0011a50d;
        }
        *(undefined8 *)(&DAT_00340d18 + uVar13 * 0x4a8) = param_6;
        piVar5 = local_3b8;
        piVar9 = param_3;
        piVar11 = piVar5;
        for (lVar6 = 0x6e; lVar6 != 0; lVar6 = lVar6 + -1) {
          *(undefined8 *)piVar11 = *(undefined8 *)piVar9;
          piVar9 = piVar9 + 2;
          piVar11 = piVar11 + 2;
        }
        bVar14 = local_3b8[0] == 0x374;
        *piVar11 = *piVar9;
        uVar8 = 0;
        if (bVar14) {
          if ((uVar3 != local_3b8[2]) || (uVar1 != local_3b8[3])) {
            *param_2 = local_3b8[2];
            param_2[2] = local_3b8[2];
            param_2[4] = 0x10;
            param_2[1] = local_3b8[3];
            param_2[3] = local_3b8[3];
            param_2[5] = local_3b8[3];
          }
          lVar6 = uVar13 * 0x4a8;
          *(undefined8 *)(&DAT_00340d40 + lVar6) = *(undefined8 *)param_2;
          *(undefined8 *)(&DAT_00340d48 + lVar6) = *(undefined8 *)(param_2 + 2);
          *(undefined8 *)(&DAT_00340d50 + lVar6) = *(undefined8 *)(param_2 + 4);
          if (local_3b8[1] - 0x10002U < 2) {
            if ((DAT_00340ce0 != 0) && (DAT_00340ce0 != local_48)) {
              piVar5 = __errno_location();
              *piVar5 = -0x1b51fff4;
              goto LAB_0011a50d;
            }
            if ((ulong)(uint)(local_3b8[2] * local_3b8[3]) * 2 + 0x374 <= uVar7) {
              lVar12 = uVar13 * 0x4a8;
              *(undefined4 *)(&DAT_00340d58 + lVar12) = local_340;
              *(int *)(&DAT_00340d5c + lVar12) = local_48;
              puVar10 = (undefined4 *)(&DAT_00340d60 + lVar12);
              for (lVar6 = 0x14; lVar6 != 0; lVar6 = lVar6 + -1) {
                *puVar10 = 0;
                puVar10 = puVar10 + 1;
              }
              uVar3 = param_2[2];
              *(uint *)(&DAT_00340d60 + lVar12) = *param_2;
              *(uint *)(&DAT_00340d64 + lVar12) = param_2[1];
              *(uint *)(&DAT_00340da0 + lVar12) = uVar3;
              *(uint *)(&DAT_00340da4 + lVar12) = param_2[3];
              *(uint *)(&DAT_00340da8 + lVar12) = param_2[4];
              *(uint *)(&DAT_00340dac + lVar12) = param_2[5];
              *(undefined4 *)(&DAT_00340d98 + lVar12) = 1;
              *(undefined4 *)(&DAT_00340d9c + lVar12) = 1;
              *(undefined4 *)(&DAT_00340d68 + lVar12) = local_390;
              *(undefined4 *)(&DAT_00340d6c + lVar12) = local_38c;
              strncpy(&DAT_00340d70 + lVar12,local_368,0x20);
              (&DAT_00340d8f)[lVar12] = 0;
              strncpy(&DAT_00340d90 + lVar12,local_388,8);
              (&DAT_00340d97)[lVar12] = 0;
              *(undefined4 *)(&DAT_00340db0 + lVar12) = local_3a0;
              *(undefined4 *)(&DAT_00340db4 + lVar12) = local_39c;
              *(undefined4 *)(&DAT_00340db8 + lVar12) = local_398;
              *(undefined4 *)(&DAT_00340dbc + lVar12) = local_394;
              *(undefined8 *)(&DAT_00340dc8 + lVar12) = local_338;
              *(undefined8 *)(&DAT_00340dc0 + lVar12) = local_348;
              *(undefined8 *)(&DAT_00340dd0 + lVar12) = local_330;
              *(undefined4 *)(&DAT_00340dd8 + lVar12) = local_33c;
              piVar9 = (int *)(&DAT_00340ddc + lVar12);
              uVar3 = 0x374;
              bVar14 = ((ulong)piVar9 & 4) != 0;
              piVar11 = piVar9;
              if (bVar14) {
                piVar11 = (int *)(&DAT_00340de0 + (ulong)bVar15 * -8 + lVar12);
                piVar5 = local_3b8 + (ulong)bVar15 * -2 + 1;
                *piVar9 = local_3b8[0];
                uVar3 = 0x370;
              }
              for (uVar7 = (ulong)(uVar3 >> 3); uVar7 != 0; uVar7 = uVar7 - 1) {
                *(undefined8 *)piVar11 = *(undefined8 *)piVar5;
                piVar5 = piVar5 + (ulong)bVar15 * -4 + 2;
                piVar11 = piVar11 + (ulong)bVar15 * -4 + 2;
              }
              if (!bVar14) {
                *piVar11 = *piVar5;
              }
              local_3e8 = *param_2;
              local_3d0 = 4;
              local_3cc = 1;
              local_3e4 = param_2[1];
              lVar12 = uVar13 * 0x4a8;
              local_3c8 = 1;
              local_3c4 = 5;
              local_3e0 = param_2[2];
              local_3dc = param_2[3];
              local_3d8 = param_2[4];
              local_3d4 = param_2[5];
              lVar6 = *(long *)(&DAT_00340d08 + lVar12);
              *(undefined4 *)(lVar6 + 0xb4) = local_e4;
              *(undefined4 *)(lVar6 + 8) = 0;
              *(undefined4 *)(lVar6 + 0xc) = 0;
              *(undefined4 *)(lVar6 + 0x58) = 1;
              *(undefined4 *)(lVar6 + 0xb8) = local_f4;
              *(undefined4 *)(lVar6 + 0x70) = 1;
              *(undefined4 *)(lVar6 + 0xc0) = 0;
              *(undefined4 *)(lVar6 + 0xbc) = local_f0;
              *(undefined4 *)(lVar6 + 0xc4) = 0;
              *(undefined4 *)(lVar6 + 200) = 0;
              *(undefined4 *)(lVar6 + 0xcc) = 0;
              *(undefined4 *)(lVar6 + 0xd0) = 0;
              *(undefined4 *)(lVar6 + 0xd8) = local_ec;
              *(undefined4 *)(lVar6 + 0xd4) = 0;
              uVar2 = *(undefined8 *)(&DAT_00340d08 + lVar12);
              *(undefined4 *)(lVar6 + 0x10) = local_e0;
              *(undefined4 *)(lVar6 + 0xdc) = local_e8;
              *(undefined4 *)(lVar6 + 0x14) = local_dc;
              *(undefined4 *)(lVar6 + 0x18) = local_d8;
              *(undefined4 *)(lVar6 + 0x1c) = local_d4;
              *(undefined4 *)(lVar6 + 0x20) = local_d0;
              *(undefined4 *)(lVar6 + 0x24) = local_cc;
              *(undefined4 *)(lVar6 + 0x30) = local_c8;
              *(undefined4 *)(lVar6 + 0x34) = local_c4;
              *(undefined4 *)(&DAT_00340d28 + lVar12) = local_fc;
              FUN_001079d0(uVar2);
              iVar4 = FUN_00109670(*(undefined8 *)(&DAT_00340d08 + lVar12),&local_3e8);
              if (iVar4 != 0) {
                lVar6 = *(long *)(&DAT_00340d08 + lVar12);
                *(undefined4 *)(lVar6 + 0x4c) = local_58;
                FUN_00109d40(lVar6,local_54);
                lVar6 = *(long *)(&DAT_00340d08 + lVar12);
                *(undefined4 *)(lVar6 + 0x8c) = local_60;
                *(undefined4 *)(lVar6 + 0x88) = local_64;
                iVar4 = FUN_001101e0(lVar6,local_5c,local_3a8,local_3a4);
                lVar6 = *(long *)(&DAT_00340d08 + lVar12);
                *(undefined4 *)(lVar6 + 0x44) = local_39c;
                *(undefined4 *)(lVar6 + 0x48) = local_3a0;
                if ((local_50 == 0) || (local_4c == 0)) {
                  *(undefined4 *)(lVar6 + 0x3c) = local_39c;
                  *(undefined4 *)(lVar6 + 0x40) = local_3a0;
                }
                else {
                  *(int *)(lVar6 + 0x3c) = local_50;
                  *(int *)(lVar6 + 0x40) = local_4c;
                }
                FUN_00110030(lVar6,local_328,0x21c);
                if (iVar4 != 0) {
                  FUN_00111720(*(undefined8 *)(&DAT_00340d08 + uVar13 * 0x4a8),param_3 + 0xdd,1,1,1,
                               1);
                  if (param_5 == (code *)0x0) {
                    uVar8 = 1;
                  }
                  else {
                    uVar8 = 1;
                    (*param_5)(param_1,local_3a0,2,*(undefined8 *)(&DAT_00340d18 + uVar13 * 0x4a8));
                  }
                }
                goto LAB_0011a50d;
              }
              goto LAB_0011a4ee;
            }
          }
          piVar5 = __errno_location();
          *piVar5 = -0x1b51ffff;
        }
        else {
LAB_0011a4ee:
          piVar5 = __errno_location();
          *piVar5 = -0x1b51fffd;
        }
        goto LAB_0011a50d;
      }
    }
  }
LAB_0011a500:
  piVar5 = __errno_location();
  uVar8 = 0;
  *piVar5 = -0x1b51ffff;
LAB_0011a50d:
  if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
                    /* WARNING: Subroutine does not return */
    __stack_chk_fail();
  }
  return uVar8;
}


==================================================================

### FUNC 0011aad0 (248 bytes) name=FUN_0011aad0

undefined * FUN_0011aad0(void)

{
  __uid_t __uid;
  int iVar1;
  tm *ptVar2;
  passwd *ppVar3;
  long lVar4;
  char *pcVar5;
  long in_FS_OFFSET;
  byte bVar6;
  time_t local_130;
  char local_128 [264];
  long local_20;
  
  bVar6 = 0;
  local_20 = *(long *)(in_FS_OFFSET + 0x28);
  time(&local_130);
  ptVar2 = localtime(&local_130);
  pcVar5 = local_128;
  for (lVar4 = 0x20; lVar4 != 0; lVar4 = lVar4 + -1) {
    pcVar5[0] = '\0';
    pcVar5[1] = '\0';
    pcVar5[2] = '\0';
    pcVar5[3] = '\0';
    pcVar5[4] = '\0';
    pcVar5[5] = '\0';
    pcVar5[6] = '\0';
    pcVar5[7] = '\0';
    pcVar5 = pcVar5 + ((ulong)bVar6 * -2 + 1) * 8;
  }
  __uid = getuid();
  ppVar3 = getpwuid(__uid);
  __snprintf_chk(local_128,0x100,1,0x100,"%s/.maglog",ppVar3->pw_dir);
  iVar1 = access(local_128,0);
  if (iVar1 != 0) {
    mkdir(local_128,0x1c0);
  }
  __sprintf_chk(&DAT_00340be0,1,0x100,"%s/coresdk-%d-%02d-%02d.log",local_128,
                ptVar2->tm_year + 0x76c,ptVar2->tm_mon + 1,ptVar2->tm_mday);
  if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
    return &DAT_00340be0;
  }
                    /* WARNING: Subroutine does not return */
  __stack_chk_fail();
}


==================================================================

### FUNC 0011abd0 (400 bytes) name=MAG_NewChannel

undefined8 MAG_NewChannel(uint param_1)

{
  int *piVar1;
  void *pvVar2;
  long lVar3;
  ulong uVar4;
  long *plVar5;
  
  if (0x80 < param_1) {
    piVar1 = __errno_location();
    *piVar1 = -0x1b51ffff;
    return 0;
  }
  uVar4 = (ulong)param_1;
  if ((((&DAT_00340d10)[uVar4 * 0x95] != 0) || (*(long *)(&DAT_00340d08 + uVar4 * 0x4a8) != 0)) ||
     (*(long *)(&DAT_00340d00 + uVar4 * 0x4a8) != 0)) {
    piVar1 = __errno_location();
    *piVar1 = -0x1b51fffd;
    return 0;
  }
  plVar5 = (long *)(&DAT_00340d00 + uVar4 * 0x4a8);
  for (lVar3 = 0x95; lVar3 != 0; lVar3 = lVar3 + -1) {
    *plVar5 = 0;
    plVar5 = plVar5 + 1;
  }
  pvVar2 = operator_new(0x188);
  FUN_0011fa80(pvVar2);
  *(void **)(&DAT_00340d00 + uVar4 * 0x4a8) = pvVar2;
  pvVar2 = operator_new(0x7818);
  FUN_00111c30(pvVar2);
  *(void **)(&DAT_00340d08 + uVar4 * 0x4a8) = pvVar2;
  pvVar2 = operator_new(0xb80);
  FUN_00117470(pvVar2);
  lVar3 = uVar4 * 0x4a8;
  (&DAT_00340d10)[uVar4 * 0x95] = pvVar2;
  if ((*(long *)(&DAT_00340d08 + lVar3) == 0) || (pvVar2 == (void *)0x0)) {
    pvVar2 = *(void **)(&DAT_00340d00 + uVar4 * 0x4a8);
    if (pvVar2 != (void *)0x0) {
      FUN_0011fd30(pvVar2);
      operator_delete(pvVar2);
      *(undefined8 *)(&DAT_00340d00 + uVar4 * 0x4a8) = 0;
    }
    plVar5 = *(long **)(&DAT_00340d08 + uVar4 * 0x4a8);
    if (plVar5 == (long *)0x0) goto LAB_0011ad32;
  }
  else {
    if (*(long *)(&DAT_00340d00 + lVar3) != 0) {
      *(uint *)((long)pvVar2 + 0x33c) = param_1;
      return 1;
    }
    plVar5 = *(long **)(&DAT_00340d08 + lVar3);
  }
  (**(code **)(*plVar5 + 8))();
  *(undefined8 *)(&DAT_00340d08 + uVar4 * 0x4a8) = 0;
LAB_0011ad32:
  plVar5 = (long *)(&DAT_00340d10)[uVar4 * 0x95];
  if (plVar5 != (long *)0x0) {
    (**(code **)(*plVar5 + 8))();
    (&DAT_00340d10)[uVar4 * 0x95] = 0;
  }
  piVar1 = __errno_location();
  *piVar1 = -0x1b51fffe;
  return 0;
}


==================================================================

### FUNC 0011ad90 (61 bytes) name=MAG_IsChannelAvailable

bool MAG_IsChannelAvailable(uint param_1)

{
  long lVar1;
  bool bVar2;
  
  bVar2 = false;
  if (((param_1 < 0x81) &&
      (lVar1 = (ulong)param_1 * 0x4a8, (&DAT_00340d10)[(ulong)param_1 * 0x95] != 0)) &&
     (*(long *)(&DAT_00340d08 + lVar1) != 0)) {
    bVar2 = *(long *)(&DAT_00340d00 + lVar1) != 0;
  }
  return bVar2;
}


==================================================================

### FUNC 0011add0 (92 bytes) name=MAG_RevisedTemp2InnerTemp

ulong MAG_RevisedTemp2InnerTemp(uint param_1,undefined4 param_2)

{
  ushort uVar1;
  int iVar2;
  int *piVar3;
  ulong uVar4;
  
  iVar2 = MAG_IsChannelAvailable(param_1);
  if (iVar2 == 0) {
    uVar4 = 0xffffffff;
  }
  else if (*(int *)(*(long *)(&DAT_00340d08 + (ulong)param_1 * 0x4a8) + 0x214) == 0) {
    piVar3 = __errno_location();
    *piVar3 = -0x1b51fffb;
    uVar4 = 0xfffffffe;
  }
  else {
    uVar1 = FUN_0010b8d0(*(long *)(&DAT_00340d08 + (ulong)param_1 * 0x4a8),param_2);
    uVar4 = (ulong)uVar1;
  }
  return uVar4;
}


==================================================================

### FUNC 0011ae40 (92 bytes) name=MAG_RevisedTemp2Gray

ulong MAG_RevisedTemp2Gray(uint param_1,undefined4 param_2)

{
  ushort uVar1;
  int iVar2;
  int *piVar3;
  ulong uVar4;
  
  iVar2 = MAG_IsChannelAvailable(param_1);
  if (iVar2 == 0) {
    uVar4 = 0xffffffff;
  }
  else if (*(int *)(*(long *)(&DAT_00340d08 + (ulong)param_1 * 0x4a8) + 0x214) == 0) {
    piVar3 = __errno_location();
    *piVar3 = -0x1b51fffb;
    uVar4 = 0xfffffffe;
  }
  else {
    uVar1 = FUN_0010b990(*(long *)(&DAT_00340d08 + (ulong)param_1 * 0x4a8),param_2);
    uVar4 = (ulong)uVar1;
  }
  return uVar4;
}


==================================================================

### FUNC 0011aeb0 (300 bytes) name=MAG_GetCurrentOffset

undefined4 MAG_GetCurrentOffset(uint param_1,long param_2,undefined4 *param_3,undefined4 *param_4)

{
  int iVar1;
  int iVar2;
  undefined4 uVar3;
  void *__dest;
  int *piVar4;
  ulong uVar5;
  long lVar6;
  
  if (((param_2 == 0) || (param_3 == (undefined4 *)0x0)) || (param_4 == (undefined4 *)0x0)) {
    piVar4 = __errno_location();
    uVar3 = 0;
    *piVar4 = -0x1b51ffff;
  }
  else {
    *param_3 = 0;
    *param_4 = 0;
    iVar2 = MAG_IsChannelAvailable((ulong)param_1);
    uVar3 = 0;
    if (iVar2 != 0) {
      lVar6 = (ulong)param_1 * 0x4a8;
      if (*(int *)(*(long *)(&DAT_00340d08 + lVar6) + 0x214) == 0) {
        piVar4 = __errno_location();
        *piVar4 = -0x1b51fffa;
        uVar3 = 0;
      }
      else {
        iVar2 = *(int *)(&DAT_00340d60 + lVar6);
        iVar1 = *(int *)(&DAT_00340d64 + lVar6);
        uVar5 = (ulong)(uint)(iVar2 * iVar1);
        __dest = operator_new__(uVar5 << 2);
        if (__dest == (void *)0x0) {
          piVar4 = __errno_location();
          *piVar4 = -0x1b51fffe;
        }
        else {
          memcpy(__dest,*(void **)(*(long *)(&DAT_00340d08 + lVar6) + 0x268),uVar5 * 2);
          uVar3 = FUN_001142f0(param_2,__dest,iVar2,iVar1,param_3,param_4);
          operator_delete__(__dest);
        }
      }
    }
  }
  return uVar3;
}


==================================================================

### FUNC 0011aff0 (60 bytes) name=MAG_GetCurrentCameraInnerTemperature

undefined4 MAG_GetCurrentCameraInnerTemperature(uint param_1)

{
  long lVar1;
  int iVar2;
  undefined4 uVar3;
  
  iVar2 = MAG_IsChannelAvailable(param_1);
  uVar3 = 0x80000000;
  if (((iVar2 != 0) && (lVar1 = *(long *)(&DAT_00340d08 + (ulong)param_1 * 0x4a8), lVar1 != 0)) &&
     (*(int *)(lVar1 + 0x214) != 0)) {
    uVar3 = *(undefined4 *)(lVar1 + 0x44);
  }
  return uVar3;
}


==================================================================

### FUNC 0011b030 (60 bytes) name=MAG_GetCameraTemperature

undefined4 MAG_GetCameraTemperature(uint param_1)

{
  long lVar1;
  int iVar2;
  undefined4 uVar3;
  
  iVar2 = MAG_IsChannelAvailable(param_1);
  uVar3 = 0x80000000;
  if (((iVar2 != 0) && (lVar1 = *(long *)(&DAT_00340d08 + (ulong)param_1 * 0x4a8), lVar1 != 0)) &&
     (*(int *)(lVar1 + 0x214) != 0)) {
    uVar3 = *(undefined4 *)(lVar1 + 0x48);
  }
  return uVar3;
}


==================================================================

### FUNC 0011b070 (60 bytes) name=MAG_GetSenorTemperature

undefined4 MAG_GetSenorTemperature(uint param_1)

{
  long lVar1;
  int iVar2;
  undefined4 uVar3;
  
  iVar2 = MAG_IsChannelAvailable(param_1);
  uVar3 = 0x80000000;
  if (((iVar2 != 0) && (lVar1 = *(long *)(&DAT_00340d08 + (ulong)param_1 * 0x4a8), lVar1 != 0)) &&
     (*(int *)(lVar1 + 0x214) != 0)) {
    uVar3 = *(undefined4 *)(lVar1 + 0x44);
  }
  return uVar3;
}


==================================================================

### FUNC 0011b0b0 (41 bytes) name=MAG_IsInitialized

undefined4 MAG_IsInitialized(uint param_1)

{
  int iVar1;
  undefined4 uVar2;
  
  iVar1 = MAG_IsChannelAvailable(param_1);
  uVar2 = 0;
  if (iVar1 != 0) {
    uVar2 = *(undefined4 *)((&DAT_00340d10)[(ulong)param_1 * 0x95] + 0x7c);
  }
  return uVar2;
}


==================================================================

### FUNC 0011b0e0 (18 bytes) name=MAG_GetLocalIp

undefined8 MAG_GetLocalIp(void)

{
  MAG_IsChannelAvailable(0);
  return 0;
}


==================================================================

### FUNC 0011b100 (7 bytes) name=MAG_SetFilter

void MAG_SetFilter(undefined4 param_1)

{
  DAT_00340ce0 = param_1;
  return;
}


==================================================================

### FUNC 0011b110 (10 bytes) name=MAG_EnableAutoReConnect

void MAG_EnableAutoReConnect(undefined4 param_1)

{
  DAT_0033f5e0 = param_1;
  return;
}


==================================================================

### FUNC 0011b120 (38 bytes) name=MAG_EnumCameras

undefined8 MAG_EnumCameras(void)

{
  int iVar1;
  undefined8 uVar2;
  
  iVar1 = MAG_IsChannelAvailable(0);
  if (iVar1 == 0) {
    return 0;
  }
  uVar2 = FUN_00118190(DAT_00340d10);
  return uVar2;
}


==================================================================

### FUNC 0011b150 (44 bytes) name=MAG_IsLinked

undefined4 MAG_IsLinked(uint param_1)

{
  int iVar1;
  undefined4 uVar2;
  
  iVar1 = MAG_IsChannelAvailable(param_1);
  uVar2 = 0;
  if (iVar1 != 0) {
    uVar2 = *(undefined4 *)((&DAT_00340d10)[(ulong)param_1 * 0x95] + 0x80);
  }
  return uVar2;
}


==================================================================

### FUNC 0011b180 (16 bytes) name=MAG_IsListening

undefined8 MAG_IsListening(void)

{
  MAG_IsChannelAvailable();
  return 0;
}


==================================================================

### FUNC 0011b190 (16 bytes) name=MAG_ListenTo

undefined8 MAG_ListenTo(void)

{
  MAG_IsChannelAvailable();
  return 0;
}


==================================================================

### FUNC 0011b1a0 (61 bytes) name=MAG_GetRecentHeartBeat

int MAG_GetRecentHeartBeat(uint param_1)

{
  long lVar1;
  int iVar2;
  
  iVar2 = MAG_IsChannelAvailable(param_1);
  if (iVar2 == 0) {
    return -1;
  }
  lVar1 = (&DAT_00340d10)[(ulong)param_1 * 0x95];
  iVar2 = FUN_00113bc0();
  return iVar2 - (int)*(undefined8 *)(lVar1 + 0xaf8);
}


==================================================================

### FUNC 0011b1f0 (60 bytes) name=MAG_SetReConnectCallBack

bool MAG_SetReConnectCallBack(uint param_1,undefined8 param_2,undefined8 param_3)

{
  long lVar1;
  int iVar2;
  
  iVar2 = MAG_IsChannelAvailable(param_1);
  if (iVar2 != 0) {
    lVar1 = (&DAT_00340d10)[(ulong)param_1 * 0x95];
    *(undefined8 *)(lVar1 + 0x40) = param_3;
    *(undefined8 *)(lVar1 + 0x38) = param_2;
  }
  return iVar2 != 0;
}


==================================================================

### FUNC 0011b230 (71 bytes) name=MAG_GetCamInfo

void MAG_GetCamInfo(uint param_1,void *param_2,uint param_3)

{
  int iVar1;
  uint uVar2;
  
  iVar1 = MAG_IsChannelAvailable(param_1);
  if (iVar1 != 0) {
    uVar2 = 0x50;
    if (param_3 < 0x51) {
      uVar2 = param_3;
    }
    memcpy(param_2,&DAT_00340d60 + (ulong)param_1 * 0x4a8,(ulong)uVar2);
    return;
  }
  return;
}


==================================================================

### FUNC 0011b280 (18 bytes) name=MAG_GetMulticastState

undefined8 MAG_GetMulticastState(void)

{
  MAG_IsChannelAvailable(0);
  return 0;
}


==================================================================

### FUNC 0011b2a0 (113 bytes) name=MAG_GetTerminalList

int MAG_GetTerminalList(void *param_1,uint param_2)

{
  uint uVar1;
  int iVar2;
  int *piVar3;
  int iVar4;
  
  iVar4 = 0;
  iVar2 = MAG_IsChannelAvailable(0);
  if (iVar2 != 0) {
    if (*(int *)(DAT_00340d10 + 0x7c) == 0) {
      piVar3 = __errno_location();
      *piVar3 = -0x1b51fffc;
      return 0;
    }
    iVar4 = *(int *)(DAT_00340d10 + 0xac0);
    if (((param_1 != (void *)0x0) && (iVar4 != 0)) && (param_2 != 0)) {
      uVar1 = iVar4 * 0x3c;
      if (param_2 <= (uint)(iVar4 * 0x3c)) {
        uVar1 = param_2;
      }
      memcpy(param_1,(void *)(DAT_00340d10 + 0x340),(ulong)uVar1);
    }
  }
  return iVar4;
}


==================================================================

### FUNC 0011b320 (37 bytes) name=MAG_IsProcessingImage

undefined4 MAG_IsProcessingImage(uint param_1)

{
  int iVar1;
  undefined4 uVar2;
  
  iVar1 = MAG_IsChannelAvailable(param_1);
  uVar2 = 0;
  if (iVar1 != 0) {
    uVar2 = *(undefined4 *)(&DAT_00340d20 + (ulong)param_1 * 0x4a8);
  }
  return uVar2;
}


==================================================================

### FUNC 0011b350 (134 bytes) name=MAG_PrepareProcessImage

undefined8 MAG_PrepareProcessImage(uint param_1,long param_2,undefined8 param_3)

{
  long lVar1;
  int iVar2;
  int *piVar3;
  undefined8 uVar4;
  
  iVar2 = MAG_IsChannelAvailable(param_1);
  if (iVar2 != 0) {
    if (*(int *)(&DAT_00340d20 + (ulong)param_1 * 0x4a8) == 0) {
      lVar1 = (&DAT_00340d10)[(ulong)param_1 * 0x95];
      if (*(int *)(lVar1 + 0x80) == 0) {
        piVar3 = __errno_location();
        *piVar3 = -0x1b51fffb;
      }
      else {
        if (param_2 != 0) {
          *(long *)(lVar1 + 0x58) = param_2;
          *(undefined8 *)(lVar1 + 0x60) = param_3;
          uVar4 = FUN_00119990();
          return uVar4;
        }
        piVar3 = __errno_location();
        *piVar3 = -0x1b51ffff;
      }
    }
    else {
      piVar3 = __errno_location();
      *piVar3 = -0x1b51fffd;
    }
  }
  return 0xffffffff;
}


==================================================================

### FUNC 0011b3f0 (62 bytes) name=MAG_WillStartImmediately

bool MAG_WillStartImmediately(uint param_1)

{
  int iVar1;
  
  iVar1 = MAG_IsChannelAvailable(param_1);
  if (iVar1 != 0) {
    iVar1 = MAG_IsLinked(param_1);
    if (iVar1 != 0) {
      iVar1 = FUN_001193f0((&DAT_00340d10)[(ulong)param_1 * 0x95]);
      return iVar1 == 0;
    }
  }
  return false;
}


==================================================================

### FUNC 0011b440 (69 bytes) name=MAG_TransferPulseImage

undefined8 MAG_TransferPulseImage(uint param_1)

{
  int iVar1;
  
  iVar1 = MAG_IsChannelAvailable(param_1);
  if (iVar1 != 0) {
    *(undefined4 *)(&DAT_0034115c + (ulong)param_1 * 0x4a8) = 0;
    *(undefined4 *)(&DAT_00341158 + (ulong)param_1 * 0x4a8) = 1;
  }
  return 0;
}


==================================================================

### FUNC 0011b490 (160 bytes) name=MAG_StopProcessImage

void MAG_StopProcessImage(uint param_1)

{
  void *pvVar1;
  int iVar2;
  long lVar3;
  
  iVar2 = MAG_IsChannelAvailable(param_1);
  if (iVar2 != 0) {
    if (*(int *)((&DAT_00340d10)[(ulong)param_1 * 0x95] + 0x84) != 0) {
      FUN_00118d10((&DAT_00340d10)[(ulong)param_1 * 0x95],0);
    }
    lVar3 = (ulong)param_1 * 0x4a8;
    *(undefined4 *)(&DAT_00340d20 + lVar3) = 0;
    *(undefined4 *)(&DAT_00340d24 + lVar3) = 0;
    *(undefined8 *)(&DAT_00340d38 + lVar3) = 0;
    FUN_0011fca0(*(undefined8 *)(&DAT_00340d00 + lVar3));
    FUN_001071e0(*(undefined8 *)(&DAT_00340d08 + lVar3));
    pvVar1 = *(void **)(&DAT_00340d30 + lVar3);
    if (pvVar1 != (void *)0x0) {
      operator_delete__(pvVar1);
      *(undefined8 *)(&DAT_00340d30 + lVar3) = 0;
    }
  }
  return;
}


==================================================================

### FUNC 0011b540 (151 bytes) name=MAG_Initialize

bool MAG_Initialize(uint param_1,undefined8 param_2)

{
  int iVar1;
  long lVar2;
  bool bVar3;
  
  iVar1 = MAG_IsChannelAvailable(param_1);
  bVar3 = false;
  if (iVar1 != 0) {
    lVar2 = (ulong)param_1 * 0x4a8;
    *(undefined4 *)(&DAT_00340d24 + lVar2) = 0;
    *(undefined4 *)(&DAT_00340d20 + lVar2) = 0;
    *(undefined8 *)(&DAT_00340d30 + lVar2) = 0;
    *(undefined8 *)(&DAT_00340d38 + lVar2) = 0;
    *(undefined4 *)(&DAT_0034119c + lVar2) = 0xffffe0c0;
    lVar2 = (&DAT_00340d10)[(ulong)param_1 * 0x95];
    if (*(int *)(lVar2 + 0x7c) != 0) {
      FUN_00118d40();
      lVar2 = (&DAT_00340d10)[(ulong)param_1 * 0x95];
    }
    iVar1 = FUN_00117fc0(lVar2,param_2);
    bVar3 = iVar1 != 0;
  }
  return bVar3;
}


==================================================================

### FUNC 0011b5e0 (161 bytes) name=MAG_Free

void MAG_Free(uint param_1)

{
  long lVar1;
  int iVar2;
  ulong uVar3;
  
  iVar2 = MAG_IsChannelAvailable();
  if (iVar2 != 0) {
    uVar3 = (ulong)param_1;
    if (*(int *)(&DAT_00340d20 + uVar3 * 0x4a8) != 0) {
      MAG_StopProcessImage(param_1);
    }
    lVar1 = (&DAT_00340d10)[uVar3 * 0x95];
    if (*(int *)(lVar1 + 0x84) == 0) {
      iVar2 = *(int *)(lVar1 + 0x80);
    }
    else {
      FUN_00118d10(lVar1,0);
      lVar1 = (&DAT_00340d10)[uVar3 * 0x95];
      iVar2 = *(int *)(lVar1 + 0x80);
    }
    if (iVar2 == 0) {
      iVar2 = *(int *)(lVar1 + 0x7c);
    }
    else {
      FUN_00118cc0(lVar1,0,0);
      iVar2 = *(int *)((&DAT_00340d10)[uVar3 * 0x95] + 0x7c);
    }
    if (iVar2 != 0) {
      FUN_00118d40();
      return;
    }
  }
  return;
}


==================================================================

### FUNC 0011b6a0 (195 bytes) name=MAG_DelChannel

void MAG_DelChannel(uint param_1)

{
  void *pvVar1;
  long *plVar2;
  ulong uVar3;
  
  if (0x80 < param_1) {
    return;
  }
  uVar3 = (ulong)param_1;
  if ((&DAT_00340d10)[uVar3 * 0x95] == 0) {
LAB_0011b6eb:
    pvVar1 = *(void **)(&DAT_00340d00 + uVar3 * 0x4a8);
    if (pvVar1 != (void *)0x0) {
      FUN_0011fd30(pvVar1);
      operator_delete(pvVar1);
      *(undefined8 *)(&DAT_00340d00 + uVar3 * 0x4a8) = 0;
    }
    plVar2 = *(long **)(&DAT_00340d08 + uVar3 * 0x4a8);
    if (plVar2 == (long *)0x0) goto LAB_0011b738;
  }
  else {
    plVar2 = *(long **)(&DAT_00340d08 + uVar3 * 0x4a8);
    if (plVar2 == (long *)0x0) goto LAB_0011b6eb;
    if (*(long *)(&DAT_00340d00 + uVar3 * 0x4a8) != 0) {
      MAG_Free();
      goto LAB_0011b6eb;
    }
  }
  (**(code **)(*plVar2 + 8))(plVar2);
  *(undefined8 *)(&DAT_00340d08 + uVar3 * 0x4a8) = 0;
LAB_0011b738:
  plVar2 = (long *)(&DAT_00340d10)[uVar3 * 0x95];
  if (plVar2 != (long *)0x0) {
    (**(code **)(*plVar2 + 8))();
    (&DAT_00340d10)[uVar3 * 0x95] = 0;
  }
  return;
}


==================================================================

### FUNC 0011b770 (92 bytes) name=MAG_DisLinkCamera

void MAG_DisLinkCamera(uint param_1)

{
  int iVar1;
  
  iVar1 = MAG_IsChannelAvailable();
  if (iVar1 != 0) {
    if (*(int *)(&DAT_00340d20 + (ulong)param_1 * 0x4a8) != 0) {
      MAG_StopProcessImage(param_1);
    }
    FUN_00118cc0((&DAT_00340d10)[(ulong)param_1 * 0x95],1,0);
    return;
  }
  return;
}


==================================================================

### FUNC 0011b7e0 (45 bytes) name=MAG_StopListen

void MAG_StopListen(uint param_1)

{
  int iVar1;
  
  iVar1 = MAG_IsChannelAvailable();
  if ((iVar1 != 0) && (*(int *)(&DAT_00340d20 + (ulong)param_1 * 0x4a8) != 0)) {
    MAG_StopProcessImage(param_1);
    return;
  }
  return;
}


==================================================================

### FUNC 0011b810 (52 bytes) name=MAG_SetFFCMode

bool MAG_SetFFCMode(uint param_1,undefined4 param_2)

{
  int iVar1;
  
  iVar1 = MAG_IsChannelAvailable(param_1);
  if (iVar1 != 0) {
    *(undefined4 *)(&DAT_0034118c + (ulong)param_1 * 0x4a8) = param_2;
  }
  return iVar1 != 0;
}


==================================================================

### FUNC 0011b850 (123 bytes) name=FUN_0011b850

undefined8 FUN_0011b850(ulong param_1,int param_2)

{
  long lVar1;
  int iVar2;
  long lVar3;
  
  param_1 = param_1 & 0xffffffff;
  if ((param_2 != 0) || (*(int *)(&DAT_0034118c + param_1 * 0x4a8) == 0)) {
    lVar3 = param_1 * 0x4a8;
    *(undefined4 *)(&DAT_00341190 + lVar3) = 1;
    iVar2 = FUN_00119250((&DAT_00340d10)[param_1 * 0x95],0,0);
    if (iVar2 != 0) {
      lVar1 = *(long *)(&DAT_00340d08 + lVar3);
      *(undefined4 *)(lVar1 + 0x40) = *(undefined4 *)(lVar1 + 0x48);
      *(undefined4 *)(lVar1 + 0x3c) = *(undefined4 *)(lVar1 + 0x44);
      *(undefined4 *)(&DAT_00341170 + lVar3) = 0;
      return 1;
    }
  }
  return 0;
}


==================================================================

### FUNC 0011b8e0 (937 bytes) name=FUN_0011b8e0

void FUN_0011b8e0(uint param_1,long param_2)

{
  uint *puVar1;
  byte bVar2;
  long lVar3;
  long lVar4;
  long lVar5;
  ulong uVar6;
  time_t tVar7;
  ulong uVar8;
  int iVar9;
  uint uVar10;
  uint uVar11;
  int iVar12;
  uint uVar13;
  uint uVar14;
  
  uVar8 = (ulong)param_1;
  lVar4 = uVar8 * 0x4a8;
  if (*(int *)(&DAT_00340d20 + lVar4) == 0) {
    return;
  }
  lVar3 = (&DAT_00340d10)[uVar8 * 0x95];
  uVar13 = *(int *)(&DAT_00341174 + lVar4) + 1;
  bVar2 = *(byte *)(lVar3 + 0xb07);
  *(uint *)(&DAT_00341174 + lVar4) = uVar13;
  if (bVar2 - 1 < 2) {
    if (uVar13 < 0x14) {
      return;
    }
  }
  else if ((bVar2 == 4) && (uVar13 < 8)) {
    return;
  }
  lVar5 = uVar8 * 0x4a8;
  iVar9 = *(int *)(param_2 + 0x28) + (int)*(short *)(lVar3 + 0xb46);
  iVar12 = (int)*(short *)(lVar3 + 0xb46) + *(int *)(param_2 + 0x2c);
  lVar4 = *(long *)(&DAT_00340d08 + lVar5);
  *(int *)(param_2 + 0x28) = iVar9;
  puVar1 = (uint *)(&DAT_00341170 + lVar5);
  *(int *)(param_2 + 0x2c) = iVar12;
  *(int *)(lVar4 + 0x44) = iVar12;
  *(int *)(lVar4 + 0x48) = iVar9;
  *(int *)(&DAT_00340db0 + lVar5) = iVar9;
  *(undefined4 *)(&DAT_00340db4 + lVar5) = *(undefined4 *)(param_2 + 0x2c);
  uVar13 = *puVar1;
  if ((int)uVar13 < 0) {
    FUN_0011b850(param_1,1);
    return;
  }
  uVar11 = *(uint *)(lVar3 + 0xb48);
  uVar14 = uVar13 + 1;
  *puVar1 = uVar14;
  if (uVar14 <= uVar11) {
    uVar10 = *(int *)(lVar3 + 0xb38) + uVar11 + *(int *)(lVar3 + 0xb4c);
LAB_0011ba18:
    FUN_0010e340(lVar4,uVar13,uVar10);
    return;
  }
  uVar10 = *(int *)(lVar3 + 0xb38) + uVar11;
  if (uVar14 <= uVar10) {
    if (uVar14 == uVar10) {
      FUN_00119250((&DAT_00340d10)[uVar8 * 0x95],1,0);
      uVar11 = *(uint *)(lVar3 + 0xb48);
      uVar14 = *puVar1;
    }
    lVar5 = uVar8 * 0x4a8;
    FUN_00107640(*(undefined8 *)(&DAT_00340d08 + lVar5),param_2 + 0x4c,uVar11 + 1 == uVar14);
    uVar10 = *(int *)(lVar3 + 0xb38) + *(int *)(lVar3 + 0xb48) + *(int *)(lVar3 + 0xb4c);
    lVar4 = *(long *)(&DAT_00340d08 + lVar5);
    uVar13 = *(int *)(&DAT_00341170 + lVar5) - 1;
    goto LAB_0011ba18;
  }
  uVar10 = uVar10 + *(int *)(lVar3 + 0xb4c);
  if (uVar14 <= uVar10) goto LAB_0011ba18;
  *(undefined4 *)(&DAT_00341190 + lVar5) = 0;
  if (bVar2 < 7) {
    uVar6 = 1L << (bVar2 & 0x3f);
    if ((uVar6 & 0x69) == 0) {
      if (((uVar6 & 0x16) == 0) || (4 < *(uint *)(&DAT_00341178 + lVar5))) goto LAB_0011bb98;
      uVar13 = *puVar1;
      iVar9 = 100;
      if (uVar13 != 0x82 - uVar10) goto LAB_0011bba8;
      *(uint *)(&DAT_00341178 + lVar5) = *(uint *)(&DAT_00341178 + lVar5) + 1;
    }
    else {
      uVar13 = *puVar1;
      iVar9 = 0x1e;
      if ((*(int *)(&DAT_00341178 + lVar5) != 0) || (uVar13 != 0x4b)) goto LAB_0011bba8;
      *(undefined4 *)(&DAT_00341178 + lVar5) = 1;
    }
  }
  else {
LAB_0011bb98:
    iVar9 = 100;
    uVar13 = *(uint *)(&DAT_00341170 + uVar8 * 0x4a8);
LAB_0011bba8:
    if ((uVar13 < *(int *)(lVar3 + 0xb50) + uVar10) &&
       ((uVar13 < uVar10 + iVar9 ||
        (uVar13 = *(int *)(*(long *)(&DAT_00340d08 + uVar8 * 0x4a8) + 0x3c) -
                  *(int *)(param_2 + 0x2c), uVar11 = (int)uVar13 >> 0x1f,
        (uVar13 ^ uVar11) - uVar11 <= *(uint *)(lVar3 + 0xb54))))) goto LAB_0011babe;
  }
  FUN_0011b850(param_1,0);
LAB_0011babe:
  lVar4 = uVar8 * 0x4a8;
  if (*(int *)(&DAT_0034116c + lVar4) == 0) {
    tVar7 = time((time_t *)0x0);
    *(time_t *)(&DAT_00340dc0 + lVar4) = tVar7;
    *(undefined8 *)(&DAT_00340dc8 + lVar4) = 0;
    *(undefined8 *)(&DAT_00340dd0 + lVar4) = 0;
    *(undefined4 *)(&DAT_00340dd8 + lVar4) = 0;
    if (*(int *)(&DAT_00341190 + lVar4) != 0) {
      *(uint *)(param_2 + 0x44) = *(uint *)(param_2 + 0x44) | 0x40000;
    }
    lVar4 = uVar8 * 0x4a8;
    uVar8 = FUN_00111720(*(undefined8 *)(&DAT_00340d08 + lVar4),param_2 + 0x4c,0,1,0,1);
    if ((uVar8 & 1) != 0) {
                    /* WARNING: Could not recover jumptable at 0x0011bc5a. Too many branches */
                    /* WARNING: Treating indirect jump as call */
      (**(code **)(&DAT_00340d38 + lVar4))
                (param_1,*(undefined4 *)(param_2 + 0x44),2,*(undefined8 *)(&DAT_00340d18 + lVar4));
      return;
    }
  }
  return;
}


==================================================================

### FUNC 0011bcc0 (29 bytes) name=MAG_TriggerFFC

undefined8 MAG_TriggerFFC(undefined4 param_1)

{
  int iVar1;
  undefined8 uVar2;
  
  iVar1 = MAG_IsChannelAvailable();
  if (iVar1 == 0) {
    return 0;
  }
  uVar2 = FUN_0011b850(param_1,1);
  return uVar2;
}


==================================================================

### FUNC 0011bce0 (16 bytes) name=MAG_SetIoAlarmState

undefined8 MAG_SetIoAlarmState(void)

{
  MAG_IsChannelAvailable();
  return 0;
}


==================================================================

### FUNC 0011bcf0 (84 bytes) name=MAG_SetColorPalette

void MAG_SetColorPalette(uint param_1,uint param_2)

{
  int iVar1;
  
  iVar1 = MAG_IsChannelAvailable(param_1);
  if (iVar1 != 0) {
    if (10 < param_2) {
      param_2 = 0;
    }
    *(uint *)(&DAT_00340d28 + (ulong)param_1 * 0x4a8) = param_2;
    FUN_001079d0(*(undefined8 *)(&DAT_00340d08 + (ulong)param_1 * 0x4a8),param_2);
    return;
  }
  return;
}


==================================================================

### FUNC 0011bd60 (227 bytes) name=MAG_SetSubsectionEnlargePara

undefined8
MAG_SetSubsectionEnlargePara(uint param_1,int param_2,int param_3,byte param_4,byte param_5)

{
  int iVar1;
  int *piVar2;
  long lVar3;
  ulong uVar4;
  long lVar5;
  
  uVar4 = (ulong)param_1;
  iVar1 = MAG_IsChannelAvailable(uVar4);
  if (iVar1 != 0) {
    if ((param_2 < param_3) && (param_4 < param_5)) {
      lVar5 = uVar4 * 0x4a8;
      pthread_mutex_lock((pthread_mutex_t *)(*(long *)(&DAT_00340d08 + lVar5) + 0x218));
      lVar3 = *(long *)(&DAT_00340d08 + lVar5);
      *(int *)(lVar3 + 0x14) = param_2;
      *(int *)(lVar3 + 0x18) = param_3;
      *(uint *)(lVar3 + 0x1c) = (uint)param_4;
      *(uint *)(lVar3 + 0x20) = (uint)param_5;
      *(undefined4 *)(lVar3 + 0x10) = 1;
      *(undefined4 *)(lVar3 + 0x28) = 0;
      if ((*(int *)(lVar3 + 0x214) != 0) && (*(int *)((&DAT_00340d10)[uVar4 * 0x95] + 0x80) == 0)) {
        FUN_00111240(lVar3,0);
        lVar3 = *(long *)(&DAT_00340d08 + lVar5);
      }
      pthread_mutex_unlock((pthread_mutex_t *)(lVar3 + 0x218));
      return 1;
    }
    piVar2 = __errno_location();
    *piVar2 = -0x1b51ffff;
  }
  return 0;
}


==================================================================

### FUNC 0011be50 (217 bytes) name=MAG_SetAutoEnlargePara

void MAG_SetAutoEnlargePara(uint param_1,uint param_2,int param_3,int param_4)

{
  int iVar1;
  long lVar2;
  long lVar3;
  
  iVar1 = MAG_IsChannelAvailable(param_1);
  if (iVar1 != 0) {
    if (param_2 < 2) {
      param_2 = 2;
    }
    if (param_3 < -100) {
      param_3 = -100;
    }
    if (param_4 < -100) {
      param_4 = -100;
    }
    lVar2 = (ulong)param_1 * 0x4a8;
    pthread_mutex_lock((pthread_mutex_t *)(*(long *)(&DAT_00340d08 + lVar2) + 0x218));
    lVar3 = *(long *)(&DAT_00340d08 + lVar2);
    if (100 < param_3) {
      param_3 = 100;
    }
    if (100 < param_4) {
      param_4 = 100;
    }
    *(uint *)(lVar3 + 0x24) = param_2;
    *(int *)(lVar3 + 0x30) = param_3;
    *(int *)(lVar3 + 0x34) = param_4;
    *(undefined4 *)(lVar3 + 0x10) = 0;
    *(undefined4 *)(lVar3 + 0x28) = 0;
    if ((*(int *)(lVar3 + 0x214) != 0) &&
       (*(int *)((&DAT_00340d10)[(ulong)param_1 * 0x95] + 0x80) == 0)) {
      FUN_00111240(lVar3,0);
      lVar3 = *(long *)(&DAT_00340d08 + lVar2);
    }
    pthread_mutex_unlock((pthread_mutex_t *)(lVar3 + 0x218));
    return;
  }
  return;
}


==================================================================

### FUNC 0011bf30 (165 bytes) name=MAG_SetIsothermalPara

void MAG_SetIsothermalPara(uint param_1,int param_2,int param_3)

{
  int iVar1;
  long lVar2;
  long lVar3;
  
  iVar1 = MAG_IsChannelAvailable(param_1);
  if (iVar1 == 0) {
    return;
  }
  lVar2 = (ulong)param_1 * 0x4a8;
  pthread_mutex_lock((pthread_mutex_t *)(*(long *)(&DAT_00340d08 + lVar2) + 0x218));
  lVar3 = *(long *)(&DAT_00340d08 + lVar2);
  *(uint *)(lVar3 + 0x28) = (uint)(param_2 <= param_3);
  *(undefined4 *)(lVar3 + 0x10) = 0;
  *(int *)(lVar3 + 0x14) = param_2;
  *(int *)(lVar3 + 0x18) = param_3;
  if ((*(int *)(lVar3 + 0x214) != 0) &&
     (*(int *)((&DAT_00340d10)[(ulong)param_1 * 0x95] + 0x80) == 0)) {
    FUN_00111240(lVar3,0);
    lVar3 = *(long *)(&DAT_00340d08 + lVar2);
  }
  pthread_mutex_unlock((pthread_mutex_t *)(lVar3 + 0x218));
  return;
}


==================================================================

### FUNC 0011bfe0 (16 bytes) name=MAG_SetUserROIs

undefined8 MAG_SetUserROIs(void)

{
  MAG_IsChannelAvailable();
  return 0;
}


==================================================================

### FUNC 0011bff0 (16 bytes) name=MAG_ResetCamera

undefined8 MAG_ResetCamera(void)

{
  MAG_IsChannelAvailable();
  return 0;
}


==================================================================

### FUNC 0011c000 (71 bytes) name=MAG_GetFilteredRaw

undefined8 MAG_GetFilteredRaw(uint param_1)

{
  int iVar1;
  int *piVar2;
  
  iVar1 = MAG_IsChannelAvailable(param_1);
  if (iVar1 == 0) {
    return 0;
  }
  if (*(int *)(*(long *)(&DAT_00340d08 + (ulong)param_1 * 0x4a8) + 0x214) != 0) {
    return *(undefined8 *)(*(long *)(&DAT_00340d08 + (ulong)param_1 * 0x4a8) + 0x268);
  }
  piVar2 = __errno_location();
  *piVar2 = -0x1b51fffa;
  return 0;
}


==================================================================

### FUNC 0011c050 (165 bytes) name=MAG_GetOutputBMPdata

undefined8 MAG_GetOutputBMPdata(uint param_1,undefined8 *param_2,long *param_3)

{
  int iVar1;
  int *piVar2;
  
  iVar1 = MAG_IsChannelAvailable(param_1);
  if (iVar1 != 0) {
    if ((param_2 == (undefined8 *)0x0) || (param_3 == (long *)0x0)) {
      piVar2 = __errno_location();
      *piVar2 = -0x1b51ffff;
      return 0;
    }
    if (*(int *)(*(long *)(&DAT_00340d08 + (ulong)param_1 * 0x4a8) + 0x214) != 0) {
      *param_2 = *(undefined8 *)(*(long *)(&DAT_00340d08 + (ulong)param_1 * 0x4a8) + 0x200);
      *param_3 = *(long *)(&DAT_00340d08 + (ulong)param_1 * 0x4a8) + 0xad8;
      return 1;
    }
    piVar2 = __errno_location();
    *piVar2 = -0x1b51fffa;
  }
  return 0;
}


==================================================================

### FUNC 0011c100 (319 bytes) name=MAG_GetOutputBMPdataRGB24

undefined8 MAG_GetOutputBMPdataRGB24(uint param_1,undefined1 *param_2,uint param_3,int param_4)

{
  undefined1 *puVar1;
  long lVar2;
  int iVar3;
  byte *pbVar4;
  int *piVar5;
  uint uVar6;
  uint uVar7;
  undefined1 *puVar8;
  undefined1 *puVar9;
  undefined8 uVar10;
  
  uVar10 = 0;
  iVar3 = MAG_IsChannelAvailable(param_1);
  if (iVar3 != 0) {
    lVar2 = *(long *)(&DAT_00340d08 + (ulong)param_1 * 0x4a8);
    if (*(int *)(lVar2 + 0x214) == 0) {
      piVar5 = __errno_location();
      *piVar5 = -0x1b51fffa;
      return 0;
    }
    uVar7 = *(int *)(lVar2 + 0xadc) * *(int *)(lVar2 + 0xae0);
    uVar6 = (int)uVar7 >> 0x1f;
    iVar3 = (uVar7 ^ uVar6) - uVar6;
    if ((param_2 == (undefined1 *)0x0) || (param_3 < (uint)(iVar3 * 3))) {
      piVar5 = __errno_location();
      *piVar5 = -0x1b51ffff;
      return 0;
    }
    if (param_4 == 0) {
      if (iVar3 != 0) {
        pbVar4 = *(byte **)(lVar2 + 0x200);
        puVar9 = param_2;
        do {
          puVar8 = puVar9 + 3;
          puVar1 = (undefined1 *)(lVar2 + 0xb00 + (ulong)*pbVar4 * 4);
          *puVar9 = puVar1[2];
          puVar9[1] = puVar1[1];
          puVar9[2] = *puVar1;
          pbVar4 = pbVar4 + 1;
          puVar9 = puVar8;
        } while (param_2 + (ulong)(iVar3 - 1) * 3 + 3 != puVar8);
      }
    }
    else if (iVar3 != 0) {
      pbVar4 = *(byte **)(lVar2 + 0x200);
      puVar9 = param_2;
      do {
        puVar8 = puVar9 + 3;
        puVar1 = (undefined1 *)(lVar2 + 0xb00 + (ulong)*pbVar4 * 4);
        *puVar9 = *puVar1;
        puVar9[1] = puVar1[1];
        puVar9[2] = puVar1[2];
        pbVar4 = pbVar4 + 1;
        puVar9 = puVar8;
      } while (puVar8 != param_2 + (ulong)(iVar3 - 1) * 3 + 3);
    }
    uVar10 = 1;
  }
  return uVar10;
}


==================================================================

### FUNC 0011c250 (71 bytes) name=MAG_GetOutputRawData

undefined8 MAG_GetOutputRawData(uint param_1)

{
  int iVar1;
  int *piVar2;
  
  iVar1 = MAG_IsChannelAvailable(param_1);
  if (iVar1 == 0) {
    return 0;
  }
  if (*(int *)(*(long *)(&DAT_00340d08 + (ulong)param_1 * 0x4a8) + 0x214) != 0) {
    return *(undefined8 *)(*(long *)(&DAT_00340d08 + (ulong)param_1 * 0x4a8) + 0x268);
  }
  piVar2 = __errno_location();
  *piVar2 = -0x1b51fffa;
  return 0;
}


==================================================================

### FUNC 0011c2a0 (165 bytes) name=MAG_GetOutputColorBardata

undefined8 MAG_GetOutputColorBardata(uint param_1,undefined8 *param_2,long *param_3)

{
  int iVar1;
  int *piVar2;
  
  iVar1 = MAG_IsChannelAvailable(param_1);
  if (iVar1 != 0) {
    if ((param_2 == (undefined8 *)0x0) || (param_3 == (long *)0x0)) {
      piVar2 = __errno_location();
      *piVar2 = -0x1b51ffff;
      return 0;
    }
    if (*(int *)(*(long *)(&DAT_00340d08 + (ulong)param_1 * 0x4a8) + 0x214) != 0) {
      *param_2 = *(undefined8 *)(*(long *)(&DAT_00340d08 + (ulong)param_1 * 0x4a8) + 0x2a8);
      *param_3 = *(long *)(&DAT_00340d08 + (ulong)param_1 * 0x4a8) + 0xf00;
      return 1;
    }
    piVar2 = __errno_location();
    *piVar2 = -0x1b51fffa;
  }
  return 0;
}


==================================================================

### FUNC 0011c350 (165 bytes) name=MAG_GetOutputVideoData

undefined8 MAG_GetOutputVideoData(uint param_1,undefined8 *param_2,long *param_3)

{
  long lVar1;
  int iVar2;
  int *piVar3;
  
  iVar2 = MAG_IsChannelAvailable(param_1);
  if (iVar2 != 0) {
    if ((param_2 == (undefined8 *)0x0) || (param_3 == (long *)0x0)) {
      piVar3 = __errno_location();
      *piVar3 = -0x1b51ffff;
      return 0;
    }
    lVar1 = *(long *)(&DAT_00340d00 + (ulong)param_1 * 0x4a8);
    if (*(int *)(lVar1 + 0x168) != 0) {
      *param_2 = *(undefined8 *)(lVar1 + 0x170);
      *param_3 = *(long *)(&DAT_00340d00 + (ulong)param_1 * 0x4a8) + 0x138;
      return 1;
    }
    piVar3 = __errno_location();
    *piVar3 = -0x1b51fffa;
  }
  return 0;
}


==================================================================

### FUNC 0011c400 (70 bytes) name=MAG_GetOutputVideoYV12

undefined8 MAG_GetOutputVideoYV12(uint param_1)

{
  int iVar1;
  int *piVar2;
  
  iVar1 = MAG_IsChannelAvailable(param_1);
  if (iVar1 == 0) {
    return 0;
  }
  if (*(int *)(*(long *)(&DAT_00340d00 + (ulong)param_1 * 0x4a8) + 0x168) != 0) {
    return *(undefined8 *)(*(long *)(&DAT_00340d00 + (ulong)param_1 * 0x4a8) + 0x180);
  }
  piVar2 = __errno_location();
  *piVar2 = -0x1b51fffa;
  return 0;
}


==================================================================

### FUNC 0011c450 (57 bytes) name=MAG_GetVideoPPS

undefined8 MAG_GetVideoPPS(uint param_1)

{
  int iVar1;
  int *piVar2;
  
  iVar1 = MAG_IsChannelAvailable(param_1);
  if ((iVar1 != 0) && (*(int *)(*(long *)(&DAT_00340d00 + (ulong)param_1 * 0x4a8) + 0x168) == 0)) {
    piVar2 = __errno_location();
    *piVar2 = -0x1b51fffa;
  }
  return 0;
}


==================================================================

### FUNC 0011c490 (57 bytes) name=MAG_GetVideoSPS

undefined8 MAG_GetVideoSPS(uint param_1)

{
  int iVar1;
  int *piVar2;
  
  iVar1 = MAG_IsChannelAvailable(param_1);
  if ((iVar1 != 0) && (*(int *)(*(long *)(&DAT_00340d00 + (ulong)param_1 * 0x4a8) + 0x168) == 0)) {
    piVar2 = __errno_location();
    *piVar2 = -0x1b51fffa;
  }
  return 0;
}


==================================================================

### FUNC 0011c4d0 (57 bytes) name=MAG_GetVideoVCL

undefined8 MAG_GetVideoVCL(uint param_1)

{
  int iVar1;
  int *piVar2;
  
  iVar1 = MAG_IsChannelAvailable(param_1);
  if ((iVar1 != 0) && (*(int *)(*(long *)(&DAT_00340d00 + (ulong)param_1 * 0x4a8) + 0x168) == 0)) {
    piVar2 = __errno_location();
    *piVar2 = -0x1b51fffa;
  }
  return 0;
}


==================================================================

### FUNC 0011c510 (91 bytes) name=MAG_GetTemperatureData

undefined8
MAG_GetTemperatureData(uint param_1,undefined8 param_2,undefined4 param_3,undefined4 param_4)

{
  int iVar1;
  undefined8 uVar2;
  
  iVar1 = MAG_IsChannelAvailable(param_1);
  if (iVar1 == 0) {
    return 0;
  }
  uVar2 = FUN_0010ee00(*(undefined8 *)(&DAT_00340d08 + (ulong)param_1 * 0x4a8),param_2,param_3,
                       param_4,0);
  return uVar2;
}


==================================================================

### FUNC 0011c570 (443 bytes) name=MAG_GetTemperatureData_Raw

undefined8 MAG_GetTemperatureData_Raw(ulong param_1,int *param_2,uint param_3,int param_4)

{
  ushort uVar1;
  ushort uVar2;
  ushort *puVar3;
  int iVar4;
  int iVar5;
  int *piVar6;
  uint uVar7;
  undefined8 uVar8;
  uint uVar9;
  long lVar10;
  
  uVar8 = 0;
  iVar4 = MAG_IsChannelAvailable();
  if (iVar4 != 0) {
    if ((param_2 == (int *)0x0) || (param_3 < 5)) {
      piVar6 = __errno_location();
      uVar8 = 0;
      *piVar6 = -0x1b51ffff;
    }
    else {
      lVar10 = *(long *)(&DAT_00340d08 + (param_1 & 0xffffffff) * 0x4a8);
      if (*(int *)(lVar10 + 0x214) == 0) {
        piVar6 = __errno_location();
        *piVar6 = -0x1b51fffb;
      }
      else {
        puVar3 = *(ushort **)(lVar10 + 0x268);
        iVar4 = *(int *)(lVar10 + 0x4b9c);
        iVar5 = *(int *)(lVar10 + 0x4b98);
        uVar1 = puVar3[*(uint *)(lVar10 + 0x4bac)];
        uVar2 = puVar3[*(uint *)(lVar10 + 0x4ba8)];
        if (param_4 != 0) {
          iVar4 = FUN_0010ad30(*(undefined4 *)(lVar10 + 0xb8),lVar10,iVar4);
          iVar5 = FUN_0010ad30(*(undefined4 *)(lVar10 + 0xb8),lVar10,iVar5,
                               *(undefined4 *)(lVar10 + 0x4ba8));
        }
        uVar9 = (uint)uVar1;
        lVar10 = (param_1 & 0xffffffff) * 0x4a8;
        uVar7 = *(int *)(&DAT_00340d64 + lVar10) * *(int *)(&DAT_00340d60 + lVar10);
        if (param_3 >> 2 <=
            (uint)(*(int *)(&DAT_00340d64 + lVar10) * *(int *)(&DAT_00340d60 + lVar10))) {
          uVar7 = param_3 >> 2;
        }
        if (uVar9 < uVar2) {
          for (; uVar7 != 0; uVar7 = uVar7 - 1) {
            *param_2 = (int)((ulong)((long)(int)(*puVar3 - uVar9) *
                                    ((long)((ulong)(uint)(iVar5 - iVar4) << 0x20) /
                                    (long)(int)(uVar2 - uVar9))) >> 0x20) + iVar4;
            puVar3 = puVar3 + 1;
            param_2 = param_2 + 1;
          }
        }
        else {
          for (; uVar7 != 0; uVar7 = uVar7 - 1) {
            *param_2 = iVar4;
            param_2 = param_2 + 1;
          }
        }
        uVar8 = 1;
      }
    }
  }
  return uVar8;
}


==================================================================

### FUNC 0011c750 (142 bytes) name=MAG_GetFixPara

undefined4 MAG_GetFixPara(uint param_1,undefined8 *param_2)

{
  long lVar1;
  int iVar2;
  int *piVar3;
  undefined4 uVar4;
  
  uVar4 = 0;
  iVar2 = MAG_IsChannelAvailable(param_1);
  if (iVar2 != 0) {
    if (param_2 == (undefined8 *)0x0) {
      piVar3 = __errno_location();
      *piVar3 = -0x1b51ffff;
      return 0;
    }
    lVar1 = *(long *)(&DAT_00340d08 + (ulong)param_1 * 0x4a8);
    *param_2 = *(undefined8 *)(lVar1 + 0xb4);
    param_2[1] = *(undefined8 *)(lVar1 + 0xbc);
    param_2[2] = *(undefined8 *)(lVar1 + 0xc4);
    param_2[3] = *(undefined8 *)(lVar1 + 0xcc);
    param_2[4] = *(undefined8 *)(lVar1 + 0xd4);
    *(undefined4 *)(param_2 + 5) = *(undefined4 *)(lVar1 + 0xdc);
    uVar4 = *(undefined4 *)(*(long *)(&DAT_00340d08 + (ulong)param_1 * 0x4a8) + 0xb0);
  }
  return uVar4;
}


==================================================================

### FUNC 0011c7f0 (253 bytes) name=MAG_SetFixPara

int * MAG_SetFixPara(uint param_1,undefined8 *param_2,undefined4 param_3)

{
  long lVar1;
  int *piVar2;
  long lVar3;
  
  piVar2 = (int *)MAG_IsChannelAvailable(param_1);
  if ((int)piVar2 != 0) {
    if (param_2 == (undefined8 *)0x0) {
      piVar2 = __errno_location();
      *piVar2 = -0x1b51ffff;
      return piVar2;
    }
    lVar3 = (ulong)param_1 * 0x4a8;
    pthread_mutex_lock((pthread_mutex_t *)(*(long *)(&DAT_00340d08 + lVar3) + 0x218));
    lVar1 = *(long *)(&DAT_00340d08 + lVar3);
    *(undefined4 *)(lVar1 + 0xb0) = param_3;
    *(undefined8 *)(lVar1 + 0xb4) = *param_2;
    *(undefined8 *)(lVar1 + 0xbc) = param_2[1];
    *(undefined8 *)(lVar1 + 0xc4) = param_2[2];
    *(undefined8 *)(lVar1 + 0xcc) = param_2[3];
    *(undefined8 *)(lVar1 + 0xd4) = param_2[4];
    *(undefined4 *)(lVar1 + 0xdc) = *(undefined4 *)(param_2 + 5);
    FUN_00109440(*(long *)(&DAT_00340d08 + lVar3),*(long *)(&DAT_00340d08 + lVar3) + 0xb4);
    pthread_mutex_unlock((pthread_mutex_t *)(*(long *)(&DAT_00340d08 + lVar3) + 0x218));
    piVar2 = (int *)(ulong)*(uint *)((&DAT_00340d10)[(ulong)param_1 * 0x95] + 0x80);
  }
  return piVar2;
}


==================================================================

### FUNC 0011c900 (84 bytes) name=MAG_SetEXLevel

void MAG_SetEXLevel(uint param_1,undefined4 param_2,undefined4 param_3,undefined4 param_4)

{
  int iVar1;
  
  iVar1 = MAG_IsChannelAvailable(param_1);
  if (iVar1 == 0) {
    return;
  }
  FUN_0010f990(*(undefined8 *)(&DAT_00340d08 + (ulong)param_1 * 0x4a8),param_2,param_3,param_4);
  return;
}


==================================================================

### FUNC 0011c960 (43 bytes) name=MAG_GetEXLevel

undefined8 MAG_GetEXLevel(uint param_1)

{
  int iVar1;
  undefined8 uVar2;
  
  iVar1 = MAG_IsChannelAvailable(param_1);
  if (iVar1 == 0) {
    return 0;
  }
  uVar2 = FUN_0010fa80(*(undefined8 *)(&DAT_00340d08 + (ulong)param_1 * 0x4a8));
  return uVar2;
}


==================================================================

### FUNC 0011c9a0 (61 bytes) name=MAG_SetDetailEnhancement

void MAG_SetDetailEnhancement(uint param_1,uint param_2,undefined4 param_3)

{
  long lVar1;
  int iVar2;
  uint uVar3;
  
  iVar2 = MAG_IsChannelAvailable(param_1);
  if (iVar2 != 0) {
    uVar3 = 0;
    if (param_2 < 0x21) {
      uVar3 = param_2;
    }
    lVar1 = *(long *)(&DAT_00340d08 + (ulong)param_1 * 0x4a8);
    *(undefined4 *)(lVar1 + 0x68) = param_3;
    *(uint *)(lVar1 + 0x2c) = uVar3;
  }
  return;
}


==================================================================

### FUNC 0011c9e0 (109 bytes) name=MAG_FixTemperature

ulong MAG_FixTemperature(undefined4 param_1,uint param_2,ulong param_3,int param_4,int param_5)

{
  int iVar1;
  ulong uVar2;
  
  iVar1 = MAG_IsChannelAvailable(param_2);
  if (iVar1 == 0) {
    return param_3 & 0xffffffff;
  }
  uVar2 = FUN_0010ad30(param_1,*(undefined8 *)(&DAT_00340d08 + (ulong)param_2 * 0x4a8),
                       param_3 & 0xffffffff,
                       param_5 * *(int *)(&DAT_00340d40 + (ulong)param_2 * 0x4a8) + param_4);
  return uVar2;
}


==================================================================

### FUNC 0011ca60 (86 bytes) name=MAG_FixTemperature2

ulong MAG_FixTemperature2(undefined4 param_1,uint param_2,ulong param_3,undefined4 param_4)

{
  int iVar1;
  ulong uVar2;
  
  iVar1 = MAG_IsChannelAvailable(param_2);
  if (iVar1 == 0) {
    return param_3 & 0xffffffff;
  }
  uVar2 = FUN_0010ad30(param_1,*(undefined8 *)(&DAT_00340d08 + (ulong)param_2 * 0x4a8),
                       param_3 & 0xffffffff,param_4);
  return uVar2;
}


==================================================================

### FUNC 0011cac0 (45 bytes) name=MAG_GetFrameStatisticalData

long MAG_GetFrameStatisticalData(uint param_1)

{
  int iVar1;
  
  iVar1 = MAG_IsChannelAvailable(param_1);
  if (iVar1 != 0) {
    return *(long *)(&DAT_00340d08 + (ulong)param_1 * 0x4a8) + 0x4b80;
  }
  return 0;
}


==================================================================

### FUNC 0011cb00 (42 bytes) name=MAG_GetRemoteInfo

undefined * MAG_GetRemoteInfo(uint param_1)

{
  int iVar1;
  
  iVar1 = MAG_IsChannelAvailable(param_1);
  if (iVar1 != 0) {
    return &DAT_0034117c + (ulong)param_1 * 0x4a8;
  }
  return (undefined *)0x0;
}


==================================================================

### FUNC 0011cb40 (152 bytes) name=MAG_GetTemperatureProbe

void MAG_GetTemperatureProbe(uint param_1,int param_2,int param_3,undefined4 param_4)

{
  int iVar1;
  long lVar2;
  int *piVar3;
  long in_FS_OFFSET;
  byte bVar4;
  int local_88 [22];
  long local_30;
  
  bVar4 = 0;
  local_30 = *(long *)(in_FS_OFFSET + 0x28);
  iVar1 = MAG_IsChannelAvailable(param_1);
  if (iVar1 != 0) {
    piVar3 = local_88;
    for (lVar2 = 10; lVar2 != 0; lVar2 = lVar2 + -1) {
      *(undefined8 *)piVar3 = 0;
      piVar3 = (int *)((long)piVar3 + ((ulong)bVar4 * -2 + 1) * 8);
    }
    MAG_GetCamInfo(param_1,local_88,0x50);
    FUN_0010ded0(*(undefined8 *)(&DAT_00340d08 + (ulong)param_1 * 0x4a8),
                 param_3 * local_88[0] + param_2,param_4,0);
  }
  if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
    return;
  }
                    /* WARNING: Subroutine does not return */
  __stack_chk_fail();
}


==================================================================

### FUNC 0011cbe0 (67 bytes) name=MAG_GetTemperatureProbe2

undefined8 MAG_GetTemperatureProbe2(uint param_1,undefined4 param_2,undefined4 param_3)

{
  int iVar1;
  undefined8 uVar2;
  
  iVar1 = MAG_IsChannelAvailable(param_1);
  if (iVar1 != 0) {
    uVar2 = FUN_0010ded0(*(undefined8 *)(&DAT_00340d08 + (ulong)param_1 * 0x4a8),param_2,param_3,0);
    return uVar2;
  }
  return 0x80000001;
}


==================================================================

### FUNC 0011cc30 (119 bytes) name=MAG_GetLineTemperatureInfo

void MAG_GetLineTemperatureInfo
               (uint param_1,undefined8 param_2,undefined4 param_3,undefined8 param_4,
               undefined4 param_5,undefined4 param_6,undefined4 param_7,undefined4 param_8)

{
  int iVar1;
  
  iVar1 = MAG_IsChannelAvailable(param_1);
  if (iVar1 != 0) {
    FUN_0010d7e0(*(undefined8 *)(&DAT_00340d08 + (ulong)param_1 * 0x4a8),param_2,param_3,param_4,
                 param_5,param_6,param_7,param_8,0);
  }
  return;
}


==================================================================

### FUNC 0011ccb0 (139 bytes) name=MAG_GetRectTemperatureInfo

undefined4
MAG_GetRectTemperatureInfo
          (uint param_1,undefined4 param_2,undefined4 param_3,undefined4 param_4,undefined4 param_5,
          undefined8 param_6)

{
  int iVar1;
  undefined4 uVar2;
  
  iVar1 = MAG_IsChannelAvailable(param_1);
  uVar2 = 0;
  if ((iVar1 != 0) && (*(int *)(*(long *)(&DAT_00340d08 + (ulong)param_1 * 0x4a8) + 0x214) != 0)) {
    uVar2 = FUN_0010c3e0(*(long *)(&DAT_00340d08 + (ulong)param_1 * 0x4a8),param_2,param_3,param_4,
                         param_5,param_6,0);
  }
  return uVar2;
}


==================================================================

### FUNC 0011cd40 (107 bytes) name=MAG_GetEllipseTemperatureInfo

undefined4
MAG_GetEllipseTemperatureInfo
          (uint param_1,undefined4 param_2,undefined4 param_3,undefined4 param_4,undefined4 param_5,
          undefined8 param_6)

{
  int iVar1;
  undefined4 uVar2;
  
  iVar1 = MAG_IsChannelAvailable(param_1);
  uVar2 = 0;
  if (iVar1 != 0) {
    uVar2 = FUN_0010c780(*(undefined8 *)(&DAT_00340d08 + (ulong)param_1 * 0x4a8),param_2,param_3,
                         param_4,param_5,param_6,0);
  }
  return uVar2;
}


==================================================================

### FUNC 0011cdb0 (91 bytes) name=MAG_GetRgnTemperatureInfo

undefined8
MAG_GetRgnTemperatureInfo(uint param_1,undefined8 param_2,undefined4 param_3,undefined8 param_4)

{
  int iVar1;
  undefined8 uVar2;
  
  iVar1 = MAG_IsChannelAvailable(param_1);
  if (iVar1 == 0) {
    return 0;
  }
  uVar2 = FUN_0010dc40(*(undefined8 *)(&DAT_00340d08 + (ulong)param_1 * 0x4a8),param_2,param_3,
                       param_4,0);
  return uVar2;
}


==================================================================

### FUNC 0011ce10 (62 bytes) name=MAG_UseTemperatureMask

undefined8 MAG_UseTemperatureMask(uint param_1,undefined4 param_2)

{
  int iVar1;
  undefined8 uVar2;
  
  iVar1 = MAG_IsChannelAvailable(param_1);
  if (iVar1 == 0) {
    return 0;
  }
  uVar2 = FUN_0010ebe0(*(undefined8 *)(&DAT_00340d08 + (ulong)param_1 * 0x4a8),param_2);
  return uVar2;
}


==================================================================

### FUNC 0011ce50 (62 bytes) name=MAG_IsUsingTemperatureMask

bool MAG_IsUsingTemperatureMask(uint param_1)

{
  int iVar1;
  bool bVar2;
  
  iVar1 = MAG_IsChannelAvailable(param_1);
  bVar2 = false;
  if ((iVar1 != 0) && (*(int *)(*(long *)(&DAT_00340d08 + (ulong)param_1 * 0x4a8) + 0x208) != 0)) {
    bVar2 = *(int *)(*(long *)(&DAT_00340d08 + (ulong)param_1 * 0x4a8) + 0x210) != 0;
  }
  return bVar2;
}


==================================================================

### FUNC 0011ce90 (91 bytes) name=MAG_SaveBMP

undefined8 MAG_SaveBMP(uint param_1,undefined4 param_2,undefined8 param_3)

{
  int iVar1;
  undefined8 uVar2;
  
  iVar1 = MAG_IsChannelAvailable(param_1);
  if (iVar1 == 0) {
    return 0;
  }
  if (*(int *)(*(long *)(&DAT_00340d00 + (ulong)param_1 * 0x4a8) + 0x168) == 0) {
    uVar2 = FUN_00112480(*(undefined8 *)(&DAT_00340d08 + (ulong)param_1 * 0x4a8),param_2,param_3);
    return uVar2;
  }
  uVar2 = FUN_00120300(*(long *)(&DAT_00340d00 + (ulong)param_1 * 0x4a8),param_3);
  return uVar2;
}


==================================================================

### FUNC 0011cf00 (16 bytes) name=MAG_SetPTZCmd

undefined8 MAG_SetPTZCmd(void)

{
  MAG_IsChannelAvailable();
  return 0;
}


==================================================================

### FUNC 0011cf10 (16 bytes) name=MAG_QueryPTZState

undefined8 MAG_QueryPTZState(void)

{
  MAG_IsChannelAvailable();
  return 0;
}


==================================================================

### FUNC 0011cf20 (16 bytes) name=MAG_SetSerialCmd

undefined8 MAG_SetSerialCmd(void)

{
  MAG_IsChannelAvailable();
  return 0;
}


==================================================================

### FUNC 0011cf30 (16 bytes) name=MAG_SetVideoContrast

undefined8 MAG_SetVideoContrast(void)

{
  MAG_IsChannelAvailable();
  return 0;
}


==================================================================

### FUNC 0011cf40 (22 bytes) name=MAG_SetSerialCallBack

bool MAG_SetSerialCallBack(void)

{
  int iVar1;
  
  iVar1 = MAG_IsChannelAvailable();
  return iVar1 != 0;
}


==================================================================

### FUNC 0011cf60 (16 bytes) name=MAG_SetVideoBrightness

undefined8 MAG_SetVideoBrightness(void)

{
  MAG_IsChannelAvailable();
  return 0;
}


==================================================================

### FUNC 0011cf70 (65 bytes) name=MAG_LockFrame

void MAG_LockFrame(uint param_1)

{
  int iVar1;
  
  iVar1 = MAG_IsChannelAvailable(param_1);
  if (iVar1 == 0) {
    return;
  }
  pthread_mutex_lock((pthread_mutex_t *)(*(long *)(&DAT_00340d00 + (ulong)param_1 * 0x4a8) + 0xb0));
  pthread_mutex_lock((pthread_mutex_t *)(*(long *)(&DAT_00340d08 + (ulong)param_1 * 0x4a8) + 0x218))
  ;
  return;
}


==================================================================

### FUNC 0011cfc0 (65 bytes) name=MAG_UnLockFrame

void MAG_UnLockFrame(uint param_1)

{
  int iVar1;
  
  iVar1 = MAG_IsChannelAvailable(param_1);
  if (iVar1 == 0) {
    return;
  }
  pthread_mutex_unlock
            ((pthread_mutex_t *)(*(long *)(&DAT_00340d08 + (ulong)param_1 * 0x4a8) + 0x218));
  pthread_mutex_unlock
            ((pthread_mutex_t *)(*(long *)(&DAT_00340d00 + (ulong)param_1 * 0x4a8) + 0xb0));
  return;
}


==================================================================

### FUNC 0011d010 (93 bytes) name=FUN_0011d010

undefined8
FUN_0011d010(undefined4 param_1,undefined8 param_2,undefined8 param_3,undefined4 param_4,
            undefined8 param_5,undefined8 param_6)

{
  int iVar1;
  undefined8 uVar2;
  
  iVar1 = MAG_IsChannelAvailable();
  if (iVar1 != 0) {
    uVar2 = FUN_0011a3d0(param_1,param_2,param_3,param_4,param_5,param_6);
    return uVar2;
  }
  return 0;
}


==================================================================

### FUNC 0011d080 (5 bytes) name=MAG_LoadBufferedDDT

undefined8
MAG_LoadBufferedDDT(undefined4 param_1,undefined8 param_2,undefined8 param_3,undefined4 param_4,
                   undefined8 param_5,undefined8 param_6)

{
  int iVar1;
  undefined8 uVar2;
  
  iVar1 = MAG_IsChannelAvailable();
  if (iVar1 != 0) {
    uVar2 = FUN_0011a3d0(param_1,param_2,param_3,param_4,param_5,param_6);
    return uVar2;
  }
  return 0;
}


==================================================================

### FUNC 0011d090 (16 bytes) name=MAG_SDStorageMGT

undefined8 MAG_SDStorageMGT(void)

{
  MAG_IsChannelAvailable();
  return 0;
}


==================================================================

### FUNC 0011d0a0 (16 bytes) name=MAG_SDStorageBMP

undefined8 MAG_SDStorageBMP(void)

{
  MAG_IsChannelAvailable();
  return 0;
}


==================================================================

### FUNC 0011d0b0 (16 bytes) name=MAG_SDStorageMGSStart

undefined8 MAG_SDStorageMGSStart(void)

{
  MAG_IsChannelAvailable();
  return 0;
}


==================================================================

### FUNC 0011d0c0 (16 bytes) name=MAG_SDStorageMGSStop

undefined8 MAG_SDStorageMGSStop(void)

{
  MAG_IsChannelAvailable();
  return 0;
}


==================================================================

### FUNC 0011d0d0 (16 bytes) name=MAG_SDStorageAviStart

undefined8 MAG_SDStorageAviStart(void)

{
  MAG_IsChannelAvailable();
  return 0;
}


==================================================================

### FUNC 0011d0e0 (16 bytes) name=MAG_SDStorageAviStop

undefined8 MAG_SDStorageAviStop(void)

{
  MAG_IsChannelAvailable();
  return 0;
}


==================================================================

### FUNC 0011d0f0 (32 bytes) name=MAG_SDCardStorage

undefined8 MAG_SDCardStorage(undefined8 param_1,uint param_2)

{
  int iVar1;
  int *piVar2;
  
  iVar1 = MAG_IsChannelAvailable();
  if ((iVar1 != 0) && (4 < param_2)) {
    piVar2 = __errno_location();
    *piVar2 = -0x1b51ffff;
  }
  return 0;
}


==================================================================

### FUNC 0011d110 (1488 bytes) name=FUN_0011d110

undefined8 FUN_0011d110(uint param_1)

{
  int *piVar1;
  undefined *puVar2;
  int iVar3;
  undefined8 uVar4;
  long lVar5;
  ulong uVar6;
  uint uVar7;
  ulong uVar8;
  long lVar9;
  undefined8 *puVar10;
  undefined8 *puVar11;
  ulong uVar12;
  long in_FS_OFFSET;
  bool bVar13;
  byte bVar14;
  undefined *local_d8 [4];
  int local_b8;
  uint local_b4;
  undefined4 local_b0;
  undefined4 local_a8;
  undefined4 local_a4;
  undefined4 local_a0;
  undefined1 local_78 [40];
  undefined4 local_50;
  float local_4c;
  char local_48 [8];
  long local_40;
  
  bVar14 = 0;
  uVar12 = (ulong)param_1;
  local_40 = *(long *)(in_FS_OFFSET + 0x28);
  iVar3 = FUN_001194c0((&DAT_00340d10)[uVar12 * 0x95],&local_b8,local_78,500);
  if ((iVar3 == 0) &&
     (iVar3 = FUN_001194c0((&DAT_00340d10)[uVar12 * 0x95],&local_b8,local_78,1000), iVar3 == 0)) {
    FUN_00113aa0(local_d8,4);
    FUN_00116630(local_d8,"Failed to get parameters from remote camera");
    FUN_00113b30(local_d8);
    uVar4 = 0;
  }
  else {
    puVar2 = PTR__S_empty_rep_storage_0033efd0;
    uVar7 = local_b4 >> 0x18;
    iVar3 = local_b8;
    if ((uVar7 < 2) && (1 < local_b8 + 0xf67670e7U)) {
      if (local_b8 == 0x9898f1c) {
        iVar3 = 0x9898f1c;
      }
      else if ((2 < local_b8 + 0xf67670e1U) && (iVar3 = 0x9898f2b, local_b8 != 0x9898f2b)) {
        __printf_chk(1,"[SDK]unsupported device type %d\n");
        uVar4 = 0;
        goto LAB_0011d523;
      }
    }
    lVar9 = uVar12 * 0x4a8;
    *(undefined4 *)(&DAT_00341180 + lVar9) = local_a0;
    *(int *)(&DAT_0034117c + lVar9) = iVar3;
    *(uint *)(&DAT_00341184 + lVar9) = local_b4 & 0xffffff;
    *(undefined4 *)(&DAT_00341188 + lVar9) = local_b0;
    *(undefined4 *)(&DAT_00341160 + lVar9) = 0;
    puVar11 = (undefined8 *)(&DAT_00340d60 + lVar9);
    for (lVar5 = 10; lVar5 != 0; lVar5 = lVar5 + -1) {
      *puVar11 = 0;
      puVar11 = puVar11 + (ulong)bVar14 * -2 + 1;
    }
    *(int *)(&DAT_00340d58 + lVar9) = iVar3;
    *(undefined4 *)(&DAT_00340d5c + lVar9) = 0;
    local_d8[0] = puVar2 + 0x18;
    *(undefined4 *)(&DAT_00340d68 + lVar9) = 0;
    *(undefined4 *)(&DAT_00340d6c + lVar9) = 0;
    if (uVar7 < 7) {
      switch(uVar7) {
      case 0:
        std::string::assign((char *)local_d8,0x132017);
        break;
      case 1:
        std::string::assign((char *)local_d8,0x132036);
        break;
      case 2:
        std::string::assign((char *)local_d8,0x132039);
        break;
      case 3:
        std::string::assign((char *)local_d8,0x13202e);
        break;
      case 4:
        std::string::assign((char *)local_d8,0x13203f);
        break;
      case 5:
        std::string::assign((char *)local_d8,0x132020);
        break;
      case 6:
        std::string::assign((char *)local_d8,0x132026);
      }
    }
    else {
      std::string::assign((char *)local_d8,0x132042);
    }
    lVar5 = uVar12 * 0x4a8;
    __snprintf_chk(&DAT_00340d70 + lVar5,0x20,1,0x20,&DAT_0013201a,local_d8[0],local_b8);
    __strcpy_chk(&DAT_00340d90 + lVar5,local_d8[0],8);
    *(undefined4 *)(&DAT_00340d64 + lVar5) = local_a4;
    *(undefined4 *)(&DAT_00340d60 + lVar5) = local_a8;
    *(undefined4 *)(&DAT_00340da4 + lVar5) = local_a4;
    *(undefined4 *)(&DAT_00340da0 + lVar5) = local_a8;
    *(undefined4 *)(&DAT_00340d98 + lVar5) = local_a0;
    *(undefined4 *)(&DAT_00340d9c + lVar5) = local_a0;
    uVar8 = 0xac;
    lVar5 = *(long *)(&DAT_00340d08 + lVar5);
    puVar11 = (undefined8 *)(lVar5 + 8);
    bVar13 = ((ulong)puVar11 & 1) != 0;
    if (bVar13) {
      *(undefined1 *)(lVar5 + 8) = 0;
      puVar11 = (undefined8 *)(lVar5 + 9);
      uVar8 = 0xab;
    }
    puVar10 = puVar11;
    if (((ulong)puVar11 & 2) != 0) {
      puVar10 = (undefined8 *)((long)puVar11 + 2);
      uVar8 = (ulong)((int)uVar8 - 2);
      *(undefined2 *)puVar11 = 0;
    }
    if (((ulong)puVar10 & 4) != 0) {
      *(undefined4 *)puVar10 = 0;
      uVar8 = (ulong)((int)uVar8 - 4);
      puVar10 = (undefined8 *)((long)puVar10 + 4);
    }
    for (uVar6 = uVar8 >> 3; uVar6 != 0; uVar6 = uVar6 - 1) {
      *puVar10 = 0;
      puVar10 = puVar10 + (ulong)bVar14 * -2 + 1;
    }
    if ((uVar8 & 4) != 0) {
      *(undefined4 *)puVar10 = 0;
      puVar10 = (undefined8 *)((long)puVar10 + 4);
    }
    puVar11 = puVar10;
    if ((uVar8 & 2) != 0) {
      puVar11 = (undefined8 *)((long)puVar10 + 2);
      *(undefined2 *)puVar10 = 0;
    }
    if (bVar13) {
      *(undefined1 *)puVar11 = 0;
    }
    lVar5 = *(long *)(&DAT_00340d08 + uVar12 * 0x4a8);
    *(undefined4 *)(lVar5 + 0x38) = 200;
    *(undefined4 *)(lVar5 + 8) = 0;
    *(undefined4 *)(lVar5 + 0x10) = 0;
    *(undefined4 *)(lVar5 + 0x14) = 20000;
    *(undefined4 *)(lVar5 + 0x18) = 100000;
    *(undefined4 *)(lVar5 + 0x1c) = 0;
    *(undefined4 *)(lVar5 + 0x20) = 0xff;
    *(undefined4 *)(lVar5 + 0x24) = 5;
    *(undefined4 *)(lVar5 + 0x58) = 1;
    *(undefined4 *)(lVar5 + 0x70) = 1;
    *(undefined4 *)(lVar5 + 0x4c) = 1;
    *(undefined4 *)(lVar5 + 0x54) = 1;
    if (local_4c == 0.0) {
      *(undefined4 *)(lVar5 + 0x8c) = 0;
      *(undefined4 *)(lVar5 + 0x88) = 0;
      lVar9 = 0;
      do {
        *(int *)(lVar5 + 0x90 + lVar9 * 4) = local_48[lVar9] * 0x32;
        lVar9 = lVar9 + 1;
      } while (lVar9 != 8);
    }
    else {
      *(float *)(lVar5 + 0x8c) = local_4c;
      *(undefined8 *)(lVar5 + 0x90) = 0;
      *(undefined8 *)(lVar5 + 0x98) = 0;
      *(undefined8 *)(lVar5 + 0xa0) = 0;
      *(undefined8 *)(lVar5 + 0xa8) = 0;
      *(undefined4 *)(lVar5 + 0x88) = local_50;
      __printf_chk((double)*(float *)(*(long *)(&DAT_00340d08 + uVar12 * 0x4a8) + 0x8c),1,
                   "slope=%f, p=%d\n",
                   *(undefined4 *)(*(long *)(&DAT_00340d08 + uVar12 * 0x4a8) + 0x88));
      lVar5 = *(long *)(&DAT_00340d08 + uVar12 * 0x4a8);
    }
    *(undefined4 *)(lVar5 + 0xb4) = 0x41a00000;
    *(undefined4 *)(lVar5 + 0xb8) = 0x3f800000;
    *(undefined4 *)(lVar5 + 0xbc) = 0x41a00000;
    *(undefined4 *)(lVar5 + 0xc0) = 0x3ecccccd;
    *(undefined4 *)(lVar5 + 0xc4) = 0x41a00000;
    *(undefined4 *)(lVar5 + 200) = 0;
    *(undefined4 *)(lVar5 + 0xcc) = 0;
    *(undefined4 *)(lVar5 + 0xd0) = 0;
    *(undefined4 *)(lVar5 + 0xd4) = 0;
    *(undefined4 *)(lVar5 + 0xd8) = 0x3f7f4b1f;
    *(undefined4 *)(lVar5 + 0xdc) = 0x3f800000;
    if ((allocator *)(local_d8[0] + -0x18) != (allocator *)puVar2) {
      piVar1 = (int *)(local_d8[0] + -8);
      if (PTR___pthread_key_create_0033efe0 == (undefined *)0x0) {
        iVar3 = *(int *)(local_d8[0] + -8);
        *(int *)(local_d8[0] + -8) = iVar3 + -1;
      }
      else {
        LOCK();
        iVar3 = *piVar1;
        *piVar1 = *piVar1 + -1;
        UNLOCK();
      }
      if (iVar3 < 1) {
        std::string::_Rep::_M_destroy((allocator *)(local_d8[0] + -0x18));
      }
    }
    uVar4 = 1;
  }
LAB_0011d523:
  if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
    return uVar4;
  }
                    /* WARNING: Subroutine does not return */
  __stack_chk_fail();
}


==================================================================

### FUNC 0011d780 (230 bytes) name=MAG_LinkCameraEx

bool MAG_LinkCameraEx(uint param_1,undefined4 param_2,undefined2 param_3,undefined8 param_4,
                     undefined8 param_5,undefined4 param_6,undefined8 param_7,undefined8 param_8)

{
  long lVar1;
  int iVar2;
  bool bVar3;
  
  iVar2 = MAG_IsChannelAvailable();
  bVar3 = false;
  if (iVar2 != 0) {
    lVar1 = (&DAT_00340d10)[(ulong)param_1 * 0x95];
    if (*(int *)(lVar1 + 0x80) == 0) {
      iVar2 = FUN_001186b0(lVar1,param_2,param_7,param_8,param_3,param_6,param_4,param_5);
      if (iVar2 != 0) {
        iVar2 = FUN_0011d110(param_1,param_2);
        if (iVar2 == 0) {
          FUN_00118cc0((&DAT_00340d10)[(ulong)param_1 * 0x95],1,0);
        }
      }
      bVar3 = *(int *)((&DAT_00340d10)[(ulong)param_1 * 0x95] + 0x80) != 0;
    }
  }
  return bVar3;
}


==================================================================

### FUNC 0011d880 (41 bytes) name=MAG_LinkCamera

void MAG_LinkCamera(undefined8 param_1,undefined8 param_2)

{
  MAG_LinkCameraEx(param_1,param_2,0x833c,&DAT_00131fd1,&DAT_00131fd1,0,&DAT_00131fd1,&DAT_00131fd1)
  ;
  return;
}


==================================================================

### FUNC 0011d8b0 (919 bytes) name=FUN_0011d8b0

undefined4 FUN_0011d8b0(uint param_1,uint *param_2,long param_3,int param_4,undefined4 param_5)

{
  uint uVar1;
  uint uVar2;
  int iVar3;
  int *piVar4;
  void *pvVar5;
  undefined8 *puVar6;
  long lVar7;
  long lVar8;
  uint *puVar9;
  uint *puVar10;
  ulong uVar11;
  undefined4 uVar12;
  undefined8 *puVar13;
  long in_FS_OFFSET;
  uint local_178;
  uint local_174;
  uint local_170;
  uint local_16c;
  uint local_168;
  uint local_164;
  undefined4 local_160;
  undefined4 local_15c;
  undefined4 local_158;
  undefined4 local_154;
  undefined1 local_148 [264];
  long local_40;
  
  local_40 = *(long *)(in_FS_OFFSET + 0x28);
  if (((param_2 != (uint *)0x0) && (param_3 != 0)) && (param_4 == 2)) {
    uVar11 = (ulong)param_1;
    uVar1 = *param_2;
    if ((((uVar1 == *(uint *)(&DAT_00340d60 + uVar11 * 0x4a8)) &&
         (uVar2 = param_2[1], uVar2 == *(uint *)(&DAT_00340d64 + uVar11 * 0x4a8))) &&
        (((uVar1 & 3) == 0 && (((param_2[2] & 3) == 0 && ((param_2[4] & 3) == 0)))))) &&
       ((uVar1 <= param_2[2] &&
        ((((uVar2 <= param_2[3] && (uVar2 != 0)) && (param_2[3] != 0)) && (param_2[5] != 0)))))) {
      lVar8 = uVar11 * 0x4a8;
      if (*(int *)(&DAT_00340d20 + lVar8) != 0) goto LAB_0011dafd;
      if (*(int *)((&DAT_00340d10)[uVar11 * 0x95] + 0x80) == 0) {
        piVar4 = __errno_location();
        *piVar4 = -0x1b51fffb;
        uVar12 = 0;
        goto LAB_0011d8f7;
      }
      *(undefined4 *)(&DAT_00340d24 + lVar8) = 2;
      *(undefined4 *)(&DAT_00341178 + lVar8) = 0;
      *(undefined4 *)(&DAT_00341174 + lVar8) = 0;
      puVar9 = param_2;
      puVar10 = (uint *)(&DAT_00340d40 + lVar8);
      for (lVar7 = 6; lVar7 != 0; lVar7 = lVar7 + -1) {
        *puVar10 = *puVar9;
        puVar9 = puVar9 + 1;
        puVar10 = puVar10 + 1;
      }
      pvVar5 = *(void **)(&DAT_00340d30 + lVar8);
      uVar1 = *param_2 * param_2[1] * 2;
      if (pvVar5 != (void *)0x0) {
        operator_delete__(pvVar5);
        *(undefined8 *)(&DAT_00340d30 + lVar8) = 0;
      }
      lVar8 = uVar11 * 0x4a8;
      pvVar5 = operator_new__((ulong)uVar1 + 0x98);
      puVar13 = (undefined8 *)(&DAT_00340d30 + lVar8);
      *puVar13 = pvVar5;
      if (pvVar5 == (void *)0x0) {
        piVar4 = __errno_location();
        uVar12 = 0;
        *piVar4 = -0x1b51fffe;
        goto LAB_0011d8f7;
      }
      local_178 = *param_2;
      local_160 = 4;
      local_15c = 1;
      local_158 = 1;
      local_154 = 5;
      local_174 = param_2[1];
      local_170 = param_2[2];
      local_16c = param_2[3];
      local_168 = param_2[4];
      local_164 = param_2[5];
      puVar6 = &DAT_00340d10 + uVar11 * 0x95;
      iVar3 = FUN_00119d90(*puVar6);
      if (iVar3 != 0) {
        iVar3 = FUN_00109670(*(undefined8 *)(&DAT_00340d08 + lVar8),&local_178);
        if (iVar3 == 0) {
          if ((void *)*puVar13 != (void *)0x0) {
            operator_delete__((void *)*puVar13);
            *puVar13 = 0;
          }
        }
        else {
          FUN_00119380(*puVar6,local_148,0x100);
          iVar3 = FUN_00112bc0(*(undefined8 *)(&DAT_00340d08 + lVar8),local_148);
          if (iVar3 != 0) {
            *(undefined4 *)(&DAT_00341150 + lVar8) = 0xffffffff;
            piVar4 = __errno_location();
            *piVar4 = -0x1b51fff9;
            *(uint *)(&DAT_00340da8 + lVar8) = param_2[4];
            *(uint *)(&DAT_00340dac + lVar8) = param_2[5];
            FUN_0011b850(param_1,1);
            iVar3 = FUN_001191a0(*puVar6,1,uVar1,0,*puVar13,FUN_0011b8e0,0,param_5);
            if (iVar3 != 0) {
              *(long *)(&DAT_00340d38 + lVar8) = param_3;
              *(undefined4 *)(&DAT_00341158 + lVar8) = 0;
              *(undefined4 *)(&DAT_00341154 + lVar8) = param_5;
              *(undefined4 *)(&DAT_0034115c + lVar8) = 0;
              uVar12 = 1;
              *(undefined4 *)(&DAT_0034116c + lVar8) = 0;
              *(undefined4 *)(&DAT_00341170 + lVar8) = 0xffffffff;
              *(undefined4 *)(&DAT_00340d20 + lVar8) = 1;
              goto LAB_0011d8f7;
            }
            if ((void *)*puVar13 != (void *)0x0) {
              operator_delete__((void *)*puVar13);
              *puVar13 = 0;
              uVar12 = 0;
              goto LAB_0011d8f7;
            }
            goto LAB_0011db08;
          }
        }
LAB_0011dafd:
        piVar4 = __errno_location();
        *piVar4 = -0x1b51fffd;
      }
LAB_0011db08:
      uVar12 = 0;
      goto LAB_0011d8f7;
    }
  }
  piVar4 = __errno_location();
  uVar12 = 0;
  *piVar4 = -0x1b51ffff;
LAB_0011d8f7:
  if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
    return uVar12;
  }
                    /* WARNING: Subroutine does not return */
  __stack_chk_fail();
}


==================================================================

### FUNC 0011dc50 (90 bytes) name=MAG_StartProcessImage

undefined8
MAG_StartProcessImage
          (uint param_1,undefined8 param_2,undefined8 param_3,undefined4 param_4,undefined8 param_5)

{
  int iVar1;
  undefined8 uVar2;
  
  iVar1 = MAG_IsChannelAvailable();
  if (iVar1 == 0) {
    return 0;
  }
  *(undefined8 *)(&DAT_00340d18 + (ulong)param_1 * 0x4a8) = param_5;
  uVar2 = FUN_0011d8b0(param_1,param_2,param_3,param_4,0);
  return uVar2;
}


==================================================================

### FUNC 0011dcb0 (93 bytes) name=MAG_StartProcessPulseImage

undefined8
MAG_StartProcessPulseImage
          (uint param_1,undefined8 param_2,undefined8 param_3,undefined4 param_4,undefined8 param_5)

{
  int iVar1;
  undefined8 uVar2;
  
  iVar1 = MAG_IsChannelAvailable();
  if (iVar1 == 0) {
    return 0;
  }
  *(undefined8 *)(&DAT_00340d18 + (ulong)param_1 * 0x4a8) = param_5;
  uVar2 = FUN_0011d8b0(param_1,param_2,param_3,param_4,1);
  return uVar2;
}


==================================================================

### FUNC 0011dd20 (2 bytes) name=FUN_0011dd20

void FUN_0011dd20(void)

{
  return;
}


==================================================================

### FUNC 0011dd30 (148 bytes) name=FUN_0011dd30

float FUN_0011dd30(float param_1,float *param_2,long param_3,int param_4)

{
  float fVar1;
  float *pfVar2;
  long lVar3;
  int iVar4;
  long lVar5;
  float fVar6;
  
  fVar1 = *param_2;
  fVar6 = fVar1;
  if ((fVar1 <= param_1) &&
     (fVar6 = param_2[(long)param_4 + -1], param_1 <= param_2[(long)param_4 + -1])) {
    fVar6 = param_1;
  }
  if ((param_4 < 2) || (fVar6 < fVar1)) {
    lVar5 = 0;
    lVar3 = 4;
  }
  else {
    lVar5 = 0;
    pfVar2 = param_2;
    while( true ) {
      pfVar2 = pfVar2 + 1;
      iVar4 = (int)lVar5 + 1;
      if ((iVar4 == param_4 + -1) || (fVar6 < *pfVar2)) break;
      lVar5 = (long)iVar4;
    }
    lVar5 = lVar5 * 4;
    lVar3 = lVar5 + 4;
  }
  fVar1 = *(float *)((long)param_2 + lVar5);
  if (fVar1 < *(float *)((long)param_2 + lVar3)) {
    return ((fVar6 - fVar1) * (*(float *)(param_3 + lVar3) - *(float *)(param_3 + lVar5))) /
           (*(float *)((long)param_2 + lVar3) - fVar1) + *(float *)(param_3 + lVar5);
  }
  return *(float *)(param_3 + lVar5);
}


==================================================================

### FUNC 0011ddd0 (79 bytes) name=MAG_SetEstimateUnderArmTempMode

int MAG_SetEstimateUnderArmTempMode(uint param_1,int param_2)

{
  int iVar1;
  int *piVar2;
  
  iVar1 = MAG_IsChannelAvailable(param_1);
  if (iVar1 != 0) {
    if (param_2 - 1U < 2) {
      *(int *)(&DAT_00341194 + (ulong)param_1 * 0x4a8) = param_2;
      return param_2;
    }
    piVar2 = __errno_location();
    *piVar2 = -0x1b51ffff;
  }
  return 0;
}


==================================================================

### FUNC 0011de30 (38 bytes) name=MAG_GetEstimateUnderArmTempMode

undefined4 MAG_GetEstimateUnderArmTempMode(uint param_1)

{
  int iVar1;
  undefined4 uVar2;
  
  iVar1 = MAG_IsChannelAvailable(param_1);
  uVar2 = 0;
  if (iVar1 != 0) {
    uVar2 = *(undefined4 *)(&DAT_00341194 + (ulong)param_1 * 0x4a8);
  }
  return uVar2;
}


==================================================================

### FUNC 0011de60 (34 bytes) name=MAG_GetEstimatedEnvTemp

ulong MAG_GetEstimatedEnvTemp(uint param_1)

{
  ulong uVar1;
  
  uVar1 = MAG_IsChannelAvailable(param_1);
  if ((int)uVar1 != 0) {
    uVar1 = (ulong)*(uint *)(&DAT_00341198 + (ulong)param_1 * 0x4a8);
  }
  return uVar1;
}


==================================================================

### FUNC 0011de90 (58 bytes) name=MAG_SetEnvTempEstimateMode

ulong MAG_SetEnvTempEstimateMode(uint param_1,uint param_2,undefined4 param_3)

{
  ulong uVar1;
  
  uVar1 = MAG_IsChannelAvailable(param_1);
  if ((int)uVar1 != 0) {
    *(uint *)(&DAT_0034119c + (ulong)param_1 * 0x4a8) = param_2;
    *(undefined4 *)(&DAT_003411a0 + (ulong)param_1 * 0x4a8) = param_3;
    uVar1 = (ulong)param_2;
  }
  return uVar1;
}


==================================================================

### FUNC 0011ded0 (2778 bytes) name=MAG_EstimateUnderArmTempFromForeheadRect

/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

ulong MAG_EstimateUnderArmTempFromForeheadRect
                (uint param_1,undefined4 param_2,undefined4 param_3,undefined4 param_4,
                undefined4 param_5)

{
  long lVar1;
  int iVar2;
  undefined4 uVar3;
  uint uVar4;
  int iVar5;
  undefined4 uVar6;
  int iVar7;
  int iVar8;
  ulong uVar9;
  int *piVar10;
  long lVar11;
  undefined4 *puVar12;
  char *pcVar13;
  undefined4 *puVar14;
  char *pcVar15;
  long in_FS_OFFSET;
  undefined1 uVar16;
  bool bVar17;
  byte bVar18;
  float fVar19;
  float fVar20;
  float fVar21;
  float fVar22;
  float local_21c;
  undefined8 local_218;
  undefined8 local_210;
  undefined4 local_208;
  undefined4 local_1f8;
  undefined4 local_1f4;
  undefined4 local_1f0;
  undefined4 local_1ec;
  float local_1e8;
  undefined4 local_1e4;
  undefined4 local_1e0;
  undefined4 local_1dc;
  undefined4 local_1d8;
  undefined4 local_1d4;
  undefined4 local_1d0;
  undefined4 local_1cc;
  undefined4 local_1c8;
  undefined4 local_1c4;
  undefined4 local_1c0;
  undefined4 local_1bc;
  undefined4 local_1b8;
  undefined4 local_1a8;
  undefined4 local_1a4;
  undefined4 local_1a0;
  undefined4 local_19c;
  undefined4 local_198;
  undefined4 local_194;
  undefined4 local_190;
  undefined4 local_18c;
  undefined4 local_188;
  undefined4 local_184;
  undefined4 local_180;
  undefined4 local_17c;
  undefined4 local_178;
  undefined4 local_174;
  undefined4 local_170;
  undefined4 local_16c;
  undefined4 local_168;
  undefined4 local_158;
  undefined4 local_154;
  undefined4 local_150;
  undefined4 local_14c;
  undefined4 local_148;
  undefined4 local_144;
  undefined4 local_140;
  undefined4 local_13c;
  undefined4 local_138;
  undefined4 local_134;
  undefined4 local_130;
  undefined4 local_12c;
  undefined4 local_128;
  undefined4 local_124;
  undefined4 local_120;
  undefined4 local_11c;
  undefined4 local_118;
  undefined4 local_108;
  undefined4 local_104;
  undefined4 local_100;
  undefined4 local_fc;
  undefined4 local_f8;
  undefined4 local_f4;
  undefined4 local_f0;
  undefined4 local_ec;
  undefined4 local_e8;
  undefined4 local_e4;
  undefined4 local_e0;
  undefined4 local_dc;
  undefined4 local_d8;
  undefined4 local_d4;
  undefined4 local_d0;
  undefined4 local_cc;
  undefined4 local_c8;
  undefined4 local_b8;
  undefined4 local_b4;
  undefined4 local_b0;
  undefined4 local_ac;
  undefined4 local_a8;
  undefined4 local_a4;
  undefined4 local_a0;
  undefined4 local_9c;
  undefined4 local_98;
  undefined4 local_94;
  undefined4 local_90;
  undefined4 local_8c;
  undefined4 local_88;
  undefined4 local_84;
  undefined4 local_80;
  undefined4 local_7c;
  undefined4 local_78;
  char local_68 [3];
  undefined1 local_65;
  long local_40;
  
  bVar18 = 0;
  local_40 = *(long *)(in_FS_OFFSET + 0x28);
  uVar9 = MAG_IsChannelAvailable();
  if ((int)uVar9 == 0) goto LAB_0011dfa0;
  uVar9 = (ulong)param_1;
  local_218 = 0;
  lVar11 = uVar9 * 0x4a8;
  local_210 = 0;
  local_208 = 0;
  if (*(int *)(*(long *)(&DAT_00340d08 + lVar11) + 0x214) == 0) {
    if (*(int *)((&DAT_00340d10)[uVar9 * 0x95] + 0x80) == 0) {
      piVar10 = __errno_location();
      *piVar10 = -0x1b51fffa;
      uVar9 = 0xfffffffb;
    }
    else {
      iVar2 = MAG_GetRectTemperatureInfo(param_1,param_2,param_3,param_4,param_5,&local_218);
      if (iVar2 == 0) {
        piVar10 = __errno_location();
        *piVar10 = -0x1b51fff8;
        uVar9 = 0xfffffffe;
      }
      else {
        piVar10 = __errno_location();
        *piVar10 = -0x1b51fff8;
        uVar9 = 0xfffffffd;
      }
    }
    goto LAB_0011dfa0;
  }
  iVar2 = FUN_0010c3e0(*(long *)(&DAT_00340d08 + lVar11),param_2,param_3,param_4,param_5,&local_218,
                       0);
  uVar6 = local_208;
  if (iVar2 == 0) {
    piVar10 = __errno_location();
    *piVar10 = -0x1b51ffff;
    uVar9 = 0xffffffff;
    goto LAB_0011dfa0;
  }
  uVar3 = FUN_0010ded0(*(undefined8 *)(&DAT_00340d08 + lVar11),local_208,3,0);
  uVar4 = FUN_0010ad30(*(undefined4 *)(*(long *)(&DAT_00340d08 + lVar11) + 0xb8),
                       *(long *)(&DAT_00340d08 + lVar11),uVar3,uVar6);
  lVar1 = *(long *)(&DAT_00340d08 + lVar11);
  iVar5 = FUN_0010ad30(*(undefined4 *)(lVar1 + 0xb8),lVar1,*(undefined4 *)(lVar1 + 0x4ba0),
                       (*(uint *)(&DAT_00340d60 + lVar11) >> 1) +
                       *(uint *)(&DAT_00340d60 + lVar11) * *(int *)(&DAT_00340d64 + lVar11));
  uVar6 = FUN_0010ded0(*(long *)(&DAT_00340d08 + lVar11),
                       *(undefined4 *)(*(long *)(&DAT_00340d08 + lVar11) + 0x4bac),7,0);
  lVar1 = *(long *)(&DAT_00340d08 + lVar11);
  iVar7 = FUN_0010ad30(*(undefined4 *)(lVar1 + 0xb8),lVar1,uVar6,*(undefined4 *)(lVar1 + 0x4bac));
  iVar2 = *(int *)(&DAT_00340db0 + lVar11);
  uVar16 = 1;
  __sprintf_chk(local_68,1,0x20,&DAT_0013201d,*(undefined4 *)(&DAT_00340d58 + lVar11));
  local_65 = 0;
  lVar11 = 4;
  pcVar13 = local_68;
  pcVar15 = "621";
  do {
    if (lVar11 == 0) break;
    lVar11 = lVar11 + -1;
    uVar16 = *pcVar13 == *pcVar15;
    pcVar13 = pcVar13 + (ulong)bVar18 * -2 + 1;
    pcVar15 = pcVar15 + (ulong)bVar18 * -2 + 1;
  } while ((bool)uVar16);
  if ((bool)uVar16) {
    iVar2 = iVar2 + -12000;
    goto LAB_0011e115;
  }
  lVar11 = 4;
  bVar17 = false;
  pcVar13 = local_68;
  pcVar15 = "620";
  do {
    if (lVar11 == 0) break;
    lVar11 = lVar11 + -1;
    bVar17 = *pcVar13 == *pcVar15;
    pcVar13 = pcVar13 + (ulong)bVar18 * -2 + 1;
    pcVar15 = pcVar15 + (ulong)bVar18 * -2 + 1;
  } while (bVar17);
  if (bVar17) {
LAB_0011e3e8:
    iVar2 = iVar2 + -10000;
  }
  else {
    lVar11 = 4;
    bVar17 = false;
    pcVar13 = local_68;
    pcVar15 = "321";
    do {
      if (lVar11 == 0) break;
      lVar11 = lVar11 + -1;
      bVar17 = *pcVar13 == *pcVar15;
      pcVar13 = pcVar13 + (ulong)bVar18 * -2 + 1;
      pcVar15 = pcVar15 + (ulong)bVar18 * -2 + 1;
    } while (bVar17);
    if (bVar17) goto LAB_0011e3e8;
    lVar11 = 4;
    bVar17 = false;
    pcVar13 = local_68;
    pcVar15 = "210";
    do {
      if (lVar11 == 0) break;
      lVar11 = lVar11 + -1;
      bVar17 = *pcVar13 == *pcVar15;
      pcVar13 = pcVar13 + (ulong)bVar18 * -2 + 1;
      pcVar15 = pcVar15 + (ulong)bVar18 * -2 + 1;
    } while (bVar17);
    if (bVar17) goto LAB_0011e3e8;
    lVar11 = 4;
    bVar17 = false;
    pcVar13 = local_68;
    pcVar15 = "150";
    do {
      if (lVar11 == 0) break;
      lVar11 = lVar11 + -1;
      bVar17 = *pcVar13 == *pcVar15;
      pcVar13 = pcVar13 + (ulong)bVar18 * -2 + 1;
      pcVar15 = pcVar15 + (ulong)bVar18 * -2 + 1;
    } while (bVar17);
    if (bVar17) goto LAB_0011e3e8;
    lVar11 = 4;
    bVar17 = false;
    pcVar13 = local_68;
    pcVar15 = "120";
    do {
      if (lVar11 == 0) break;
      lVar11 = lVar11 + -1;
      bVar17 = *pcVar13 == *pcVar15;
      pcVar13 = pcVar13 + (ulong)bVar18 * -2 + 1;
      pcVar15 = pcVar15 + (ulong)bVar18 * -2 + 1;
    } while (bVar17);
    if (bVar17) goto LAB_0011e3e8;
    lVar11 = 4;
    bVar17 = false;
    pcVar13 = local_68;
    pcVar15 = "340";
    do {
      if (lVar11 == 0) break;
      lVar11 = lVar11 + -1;
      bVar17 = *pcVar13 == *pcVar15;
      pcVar13 = pcVar13 + (ulong)bVar18 * -2 + 1;
      pcVar15 = pcVar15 + (ulong)bVar18 * -2 + 1;
    } while (bVar17);
    if (bVar17) {
LAB_0011e9a3:
      iVar2 = iVar2 + *(int *)(&DAT_0034119c + uVar9 * 0x4a8);
    }
    else {
      lVar11 = 4;
      bVar17 = false;
      pcVar13 = local_68;
      pcVar15 = "320";
      do {
        if (lVar11 == 0) break;
        lVar11 = lVar11 + -1;
        bVar17 = *pcVar13 == *pcVar15;
        pcVar13 = pcVar13 + (ulong)bVar18 * -2 + 1;
        pcVar15 = pcVar15 + (ulong)bVar18 * -2 + 1;
      } while (bVar17);
      if (((((bVar17) || (iVar8 = strcmp(local_68,"211"), iVar8 == 0)) ||
           (iVar8 = strcmp(local_68,"140"), iVar8 == 0)) ||
          ((iVar8 = strcmp(local_68,"130"), iVar8 == 0 ||
           (iVar8 = strcmp(local_68,"160"), iVar8 == 0)))) ||
         (iVar8 = strcmp(local_68,"100"), iVar8 == 0)) goto LAB_0011e9a3;
      iVar8 = strcmp(local_68,"330");
      if (iVar8 == 0) {
        iVar2 = iVar2 + -6000;
      }
      else {
        if (0x27f < *(uint *)(&DAT_00340d60 + uVar9 * 0x4a8)) goto LAB_0011e3e8;
        iVar2 = iVar2 + -8000;
      }
    }
  }
LAB_0011e115:
  iVar8 = iVar2;
  if (((*(int *)(&DAT_003411a0 + uVar9 * 0x4a8) == 0) && (iVar8 = iVar7, iVar7 <= iVar2)) &&
     (iVar8 = iVar2, iVar5 < iVar2)) {
    iVar8 = iVar5;
  }
  iVar2 = 15000;
  if (*(int *)(&DAT_00341194 + uVar9 * 0x4a8) == 2) {
    if ((14999 < iVar8) && (iVar2 = 40000, iVar8 < 0x9c41)) {
      iVar2 = iVar8;
    }
  }
  else {
    if ((14999 < iVar8) && (iVar2 = 35000, iVar8 < 0x88b9)) {
      iVar2 = iVar8;
    }
    uVar4 = uVar4 - 500;
  }
  *(int *)(&DAT_00341198 + uVar9 * 0x4a8) = iVar2;
  if ((uVar4 - 26000 < 0x3e81) && ((30999 < (int)uVar4 || (4999 < (int)(uVar4 - iVar2))))) {
    if (*(int *)(&DAT_00341194 + uVar9 * 0x4a8) == 2) {
      local_1f8 = 0x42000000;
      local_21c = DAT_00132190;
      local_1f4 = 0x42020000;
      local_1f0 = 0x42040000;
      local_1ec = 0x42060000;
      local_1e8 = DAT_00132190;
      local_1e4 = 0x420a0000;
      local_1e0 = 0x420c0000;
      local_1dc = 0x420e0000;
      local_1d8 = 0x42100000;
      local_1d4 = 0x42120000;
      local_1d0 = 0x42140000;
      local_1cc = 0x42160000;
      local_1c8 = 0x42180000;
      local_1c4 = 0x421a0000;
      local_1c0 = 0x421c0000;
      local_1bc = 0x421e0000;
      local_1b8 = 0x42200000;
      local_1a8 = 0x42113333;
      local_1a4 = 0x42120000;
      local_1a0 = 0x42126666;
      local_19c = 0x4213999a;
      local_198 = 0x42153333;
      local_194 = 0x4216cccd;
      local_190 = 0x42193333;
      local_18c = 0x421c0000;
      local_188 = 0x421ecccd;
      local_184 = 0x42213333;
      local_180 = 0x4222cccd;
      local_17c = 0x4224cccd;
      local_178 = 0x42266666;
      local_174 = 0x42286666;
      local_170 = 0x422a0000;
      local_16c = 0x422c0000;
      local_168 = 0x422e0000;
      local_158 = 0x420ecccd;
      local_154 = 0x42100000;
      local_150 = 0x4210cccd;
      local_14c = 0x4211999a;
      local_148 = 0x42126666;
      local_144 = 0x4212cccd;
      local_140 = 0x42140000;
      local_13c = 0x42153333;
      local_138 = 0x42193333;
      local_134 = 0x421b3333;
      local_130 = 0x421d999a;
      local_12c = 0x42206666;
      local_128 = 0x4222cccd;
      local_124 = 0x4225999a;
      local_120 = 0x42286666;
      local_11c = 0x422acccd;
      local_118 = 0x422d999a;
      local_108 = 0x420f999a;
      local_104 = 0x42100000;
      local_100 = 0x4210cccd;
      local_fc = 0x42113333;
      local_f8 = 0x4211999a;
      local_f4 = 0x42120000;
      local_f0 = 0x4212cccd;
      local_ec = 0x4213999a;
      local_e8 = 0x4215999a;
      local_e4 = 0x42173333;
      local_e0 = 0x421a0000;
      local_dc = 0x421ccccd;
      local_d8 = 0x421f3333;
      local_d4 = 0x4221999a;
      local_d0 = 0x4223999a;
      local_cc = 0x42260000;
      fVar19 = (float)iVar2 * DAT_00131e34;
      local_c8 = 0x42280000;
      local_b8 = 0x420f999a;
      local_b4 = 0x42100000;
      local_b0 = 0x42106666;
      local_ac = 0x4210cccd;
      local_a8 = 0x4211999a;
      local_a4 = 0x42120000;
      local_a0 = 0x42126666;
      local_9c = 0x4212cccd;
      local_98 = 0x4213999a;
      local_94 = 0x4214cccd;
      local_90 = 0x42166666;
      local_8c = 0x42193333;
      local_88 = 0x421c6666;
      local_84 = 0x421e6666;
      local_80 = 0x42206666;
      local_7c = 0x42226666;
      local_78 = 0x42246666;
      if (fVar19 <= DAT_00132188) {
        local_21c = DAT_00132188;
        puVar12 = &local_158;
        puVar14 = &local_1a8;
        fVar22 = DAT_00132184;
      }
      else if (DAT_0013218c < fVar19) {
        puVar12 = &local_b8;
        puVar14 = &local_108;
        fVar22 = DAT_0013218c;
      }
      else {
        local_21c = DAT_0013218c;
        puVar12 = &local_108;
        puVar14 = &local_158;
        fVar22 = DAT_00132188;
      }
      fVar21 = (float)(int)uVar4 * DAT_00131e34;
      fVar20 = (float)FUN_0011dd30(fVar21,&local_1f8,puVar14,0x11);
      fVar20 = DAT_00131e3c * fVar20;
      fVar21 = (float)FUN_0011dd30(fVar21,&local_1f8,puVar12,0x11);
      fVar20 = ((fVar19 - fVar22) * (fVar21 * DAT_00131e3c - fVar20)) / (local_21c - fVar22) +
               fVar20;
    }
    else {
      if ((int)uVar4 < 30000) {
        fVar20 = (float)((int)((uVar4 - 20000) * 0x7c) / 1000 + 34000);
      }
      else if ((int)uVar4 < 0x89e4) {
        fVar19 = (float)(int)uVar4;
        fVar20 = ((DAT_00132194 * fVar19 * fVar19 * fVar19 - DAT_00132198 * fVar19 * fVar19) +
                 fVar19 * _DAT_0013219c) - _DAT_001321a0;
      }
      else {
        fVar20 = (float)(int)(uVar4 - 0x89e4) * _DAT_001321a4 + _DAT_001321a8;
      }
      fVar19 = _DAT_001321ac;
      if (24999 < iVar2) {
        fVar19 = DAT_00131e30;
      }
      fVar20 = (float)(25000 - iVar2) * fVar19 + fVar20;
      if (*(int *)(&DAT_00341194 + uVar9 * 0x4a8) == 3) {
        if (fVar20 <= _DAT_001321b0) {
          fVar20 = (fVar20 + _DAT_001321b8) * DAT_00131e4c;
        }
        else {
          fVar20 = fVar20 - _DAT_001321b4;
        }
      }
      else if (fVar20 < _DAT_001321bc) {
        fVar20 = (fVar20 - _DAT_001321bc) * DAT_00131e4c + _DAT_001321bc;
      }
    }
    uVar9 = (ulong)((int)fVar20 | 1);
  }
  else {
    uVar9 = (ulong)(uVar4 & 0xfffffffe);
  }
LAB_0011dfa0:
  if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
                    /* WARNING: Subroutine does not return */
    __stack_chk_fail();
  }
  return uVar9;
}


==================================================================

### FUNC 0011e9f0 (147 bytes) name=MAG_LoadDDT

ulong MAG_LoadDDT(undefined4 param_1,undefined8 param_2,undefined8 param_3,undefined8 param_4,
                 undefined8 param_5)

{
  undefined4 uVar1;
  void *pvVar2;
  ulong uVar3;
  undefined1 local_58 [40];
  
  pvVar2 = operator_new__(4000000);
  FUN_00107130(local_58,param_3);
  uVar1 = FUN_00106f60(local_58,pvVar2,1,4000000);
  FUN_00106db0(local_58);
  uVar3 = FUN_0011d010(param_1,param_2,pvVar2,uVar1,param_4,param_5);
  if (pvVar2 != (void *)0x0) {
    operator_delete__(pvVar2);
    uVar3 = uVar3 & 0xffffffff;
  }
  return uVar3;
}


==================================================================

### FUNC 0011eac0 (1632 bytes) name=FUN_0011eac0

undefined8 FUN_0011eac0(ulong param_1,undefined8 param_2)

{
  undefined4 uVar1;
  int iVar2;
  undefined4 uVar3;
  int *piVar4;
  undefined8 uVar5;
  char *__src;
  void *pvVar6;
  long lVar7;
  undefined8 *puVar8;
  long lVar9;
  long in_FS_OFFSET;
  byte bVar10;
  undefined2 local_488;
  undefined2 local_486;
  undefined2 local_482;
  undefined2 local_480;
  undefined2 local_47e;
  undefined2 local_47c;
  undefined1 local_478 [32];
  undefined1 local_458 [32];
  tm local_438;
  undefined4 local_3f8;
  undefined4 local_3f4;
  undefined4 local_3f0;
  undefined1 local_3ec [44];
  char local_3c0 [20];
  char local_3ac [32];
  char local_38c [32];
  undefined8 local_36c;
  undefined8 local_364;
  undefined8 local_348;
  undefined8 local_340;
  undefined8 local_338;
  undefined8 local_330;
  undefined4 local_328;
  undefined4 local_324;
  undefined4 local_320;
  undefined4 local_258;
  undefined4 local_254;
  undefined4 local_250;
  undefined4 local_24c;
  undefined4 local_248;
  undefined4 local_244;
  undefined4 local_240;
  undefined4 local_23c;
  undefined4 local_238;
  undefined4 local_234;
  undefined4 local_230;
  undefined4 local_22c;
  undefined4 local_228;
  undefined4 local_224;
  undefined4 local_220;
  undefined4 local_21c;
  undefined4 local_16c;
  undefined4 local_164;
  undefined4 local_160;
  int local_11c;
  int local_118;
  int local_114;
  undefined4 local_10c;
  int local_108;
  int local_104;
  long local_40;
  
  bVar10 = 0;
  param_1 = param_1 & 0xffffffff;
  lVar9 = param_1 * 0x4a8;
  local_40 = *(long *)(in_FS_OFFSET + 0x28);
  if (*(int *)(*(long *)(&DAT_00340d08 + lVar9) + 0x214) == 0) {
    piVar4 = __errno_location();
    *piVar4 = -0x1b51fffa;
    uVar5 = 0;
  }
  else {
    iVar2 = FUN_00112480(*(long *)(&DAT_00340d08 + lVar9),0,param_2);
    if (iVar2 == 0) {
      piVar4 = __errno_location();
      *piVar4 = -0x1b51fff7;
      uVar5 = 0;
    }
    else {
      puVar8 = (undefined8 *)&local_3f8;
      for (lVar7 = 0x75; lVar7 != 0; lVar7 = lVar7 + -1) {
        *puVar8 = 0;
        puVar8 = puVar8 + (ulong)bVar10 * -2 + 1;
      }
      local_3f8 = 0x3ac;
      local_3f4 = 0x10000;
      local_3f0 = 0x198;
      uVar3 = *(undefined4 *)(&DAT_00340d5c + lVar9);
      uVar1 = *(undefined4 *)(&DAT_00340d58 + lVar9);
      *(undefined4 *)puVar8 = 0;
      local_320 = uVar3;
      __sprintf_chk(local_3ec,1,0x14,"%d",uVar1);
      localtime_r((time_t *)(&DAT_00340dc0 + lVar9),&local_438);
      __sprintf_chk(local_3c0,1,0x14,"%4d%02d%02d%02d%02d%02d",local_438.tm_year + 0x76c,
                    local_438.tm_mon + 1,local_438.tm_mday,local_438.tm_hour,local_438.tm_min,
                    local_438.tm_sec);
      FUN_00113c20(&local_488);
      FUN_001161f0(local_478,0x100);
      FUN_00116490(local_478,"%d-%02d-%02d %02d-%02d-%02d",local_488,local_486,local_482,local_480,
                   local_47e,local_47c);
      __src = (char *)FUN_00116550(local_478);
      lVar9 = param_1 * 0x4a8;
      strncpy(local_3c0,__src,0x14);
      strncpy(local_38c,&DAT_00340d70 + lVar9,0x20);
      strncpy(local_3ac,&DAT_00340d90 + lVar9,0x20);
      local_36c = *(undefined8 *)(&DAT_00340db0 + lVar9);
      local_364 = *(undefined8 *)(&DAT_00340db8 + lVar9);
      lVar9 = *(long *)(&DAT_00340d08 + lVar9);
      if (*(uint *)(lVar9 + 0x78) < *(uint *)(lVar9 + 0x1764)) {
        lVar7 = lVar9 + 0x1760 + (ulong)*(uint *)(lVar9 + 0x78) * 0x21c;
        local_348 = *(undefined8 *)(lVar7 + 8);
        local_340 = *(undefined8 *)(lVar7 + 0x10);
        local_338 = *(undefined8 *)(lVar7 + 0x18);
        local_330 = *(undefined8 *)(lVar7 + 0x20);
        local_324 = *(undefined4 *)(lVar7 + 0x2c);
        local_328 = *(undefined4 *)(lVar7 + 0x28);
      }
      lVar7 = param_1 * 0x4a8;
      local_258 = 0xe8;
      if ((*(int *)(&DAT_00340d20 + lVar7) == 0) && (0x10001 < *(int *)(&DAT_00340de0 + lVar7))) {
        local_254 = *(undefined4 *)(&DAT_00341098 + lVar7);
        local_24c = *(undefined4 *)(&DAT_003410a0 + lVar7);
        local_250 = *(undefined4 *)(&DAT_0034109c + lVar7);
        local_248 = *(undefined4 *)(&DAT_003410a4 + lVar7);
        local_244 = *(undefined4 *)(&DAT_003410a8 + lVar7);
        local_240 = *(undefined4 *)(&DAT_003410ac + lVar7);
        local_238 = *(undefined4 *)(&DAT_003410b4 + lVar7);
        local_23c = *(undefined4 *)(&DAT_003410b0 + lVar7);
        local_234 = *(undefined4 *)(&DAT_003410b8 + lVar7);
        local_230 = *(undefined4 *)(&DAT_003410bc + lVar7);
        local_22c = *(undefined4 *)(&DAT_003410c0 + lVar7);
        local_228 = *(undefined4 *)(&DAT_003410c4 + lVar7);
        local_224 = *(undefined4 *)(&DAT_003410c8 + lVar7);
        local_220 = *(undefined4 *)(&DAT_003410cc + lVar7);
        local_21c = *(undefined4 *)(&DAT_003410d0 + lVar7);
      }
      else {
        local_24c = *(undefined4 *)(lVar9 + 0xb8);
        local_250 = 0;
        local_248 = *(undefined4 *)(lVar9 + 0xbc);
        local_254 = *(undefined4 *)(&DAT_00340d28 + param_1 * 0x4a8);
        local_244 = *(undefined4 *)(lVar9 + 0xd8);
        local_240 = *(undefined4 *)(lVar9 + 0xdc);
        local_238 = *(undefined4 *)(lVar9 + 0x10);
        local_23c = *(undefined4 *)(lVar9 + 0xb4);
        local_234 = *(undefined4 *)(lVar9 + 0x14);
        local_230 = *(undefined4 *)(lVar9 + 0x18);
        local_22c = *(undefined4 *)(lVar9 + 0x1c);
        local_228 = *(undefined4 *)(lVar9 + 0x20);
        local_224 = *(undefined4 *)(lVar9 + 0x24);
        local_220 = *(undefined4 *)(lVar9 + 0x30);
        local_21c = *(undefined4 *)(lVar9 + 0x34);
      }
      FUN_00106fb0(local_458,param_2,1);
      FUN_00106f90(local_458,0,2);
      uVar3 = FUN_00106e70(local_458);
      FUN_001070c0(local_458,&local_3f8,0x3ac,1);
      pvVar6 = operator_new__((ulong)(uint)(*(int *)(&DAT_00340d44 + param_1 * 0x4a8) *
                                           *(int *)(&DAT_00340d40 + param_1 * 0x4a8)) << 2);
      if (pvVar6 != (void *)0x0) {
        lVar9 = param_1 * 0x4a8;
        iVar2 = FUN_0010ee00(*(undefined8 *)(&DAT_00340d08 + lVar9),pvVar6,
                             *(int *)(&DAT_00340d40 + lVar9) * *(int *)(&DAT_00340d44 + lVar9) * 4,0
                             ,1);
        if (iVar2 != 0) {
          local_16c = FUN_00106e70(local_458);
          local_11c = *(int *)(&DAT_00340d40 + param_1 * 0x4a8);
          local_118 = *(int *)(&DAT_00340d44 + param_1 * 0x4a8);
          local_114 = local_11c * local_118 * 4;
          FUN_001070c0(local_458,pvVar6,(long)local_114,1);
        }
        operator_delete__(pvVar6);
      }
      local_164 = FUN_00106e70(local_458);
      local_10c = 0x428;
      FUN_001070c0(local_458,*(long *)(&DAT_00340d08 + param_1 * 0x4a8) + 0xf00,0x428,1);
      local_160 = FUN_00106e70(local_458);
      lVar9 = param_1 * 0x4a8;
      local_108 = *(int *)(&DAT_00340d50 + lVar9);
      local_104 = *(int *)(&DAT_00340d54 + lVar9);
      FUN_001070c0(local_458,*(undefined8 *)(*(long *)(&DAT_00340d08 + lVar9) + 0x2a8),
                   (long)(local_108 * local_104),1);
      FUN_00106f90(local_458,uVar3,0);
      FUN_001070c0(local_458,&local_3f8,0x3ac,1);
      FUN_00106d80(local_458);
      FUN_00116360(local_478);
      uVar5 = 1;
    }
  }
  if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
    return uVar5;
  }
                    /* WARNING: Subroutine does not return */
  __stack_chk_fail();
}


==================================================================

### FUNC 0011f1b0 (299 bytes) name=MAG_SaveMGT

undefined4 MAG_SaveMGT(uint param_1,long param_2)

{
  int iVar1;
  undefined4 uVar2;
  int *piVar3;
  undefined8 uVar4;
  ulong uVar5;
  undefined2 local_58;
  undefined2 local_56;
  undefined2 local_52;
  undefined2 local_50;
  undefined2 local_4e;
  undefined2 local_4c;
  undefined1 local_48 [32];
  
  iVar1 = MAG_IsChannelAvailable();
  if (iVar1 == 0) {
    return 0;
  }
  uVar5 = (ulong)param_1;
  if (*(int *)(*(long *)(&DAT_00340d08 + uVar5 * 0x4a8) + 0x214) == 0) {
    piVar3 = __errno_location();
    *piVar3 = -0x1b51fffa;
    return 0;
  }
  FUN_001161f0(local_48,0x100);
  if (param_2 == 0) {
    FUN_00113c20(&local_58);
    FUN_00116490(local_48,"%d-%02d-%02d %02d-%02d-%02d.mgt",local_58,local_56,local_52,local_50,
                 local_4e,local_4c);
  }
  else {
    FUN_00116630(local_48,param_2);
  }
  pthread_mutex_lock((pthread_mutex_t *)(*(long *)(&DAT_00340d08 + uVar5 * 0x4a8) + 0x218));
  uVar4 = FUN_00116550(local_48);
  uVar2 = FUN_0011eac0(param_1,uVar4);
  pthread_mutex_unlock((pthread_mutex_t *)(*(long *)(&DAT_00340d08 + uVar5 * 0x4a8) + 0x218));
  FUN_00116360(local_48);
  return uVar2;
}


==================================================================

### FUNC 0011f300 (1165 bytes) name=FUN_0011f300

int FUN_0011f300(uint param_1,undefined8 *param_2,undefined8 param_3)

{
  undefined2 uVar1;
  undefined4 uVar2;
  int *piVar3;
  long lVar4;
  ulong uVar5;
  long lVar6;
  uint uVar7;
  long lVar8;
  int iVar9;
  undefined8 *puVar10;
  undefined8 *puVar11;
  undefined8 *puVar12;
  ulong uVar13;
  long in_FS_OFFSET;
  bool bVar14;
  byte bVar15;
  undefined1 local_3d8 [32];
  undefined1 local_3b8 [4];
  int local_3b4;
  int local_3b0;
  int local_3ac;
  undefined1 local_3a8 [4];
  undefined1 local_3a4 [4];
  undefined8 local_3a0;
  undefined8 local_398;
  undefined4 local_390;
  undefined4 local_38c;
  undefined8 local_388;
  undefined1 local_369;
  undefined8 local_368;
  undefined8 local_360;
  undefined8 local_358;
  ulong local_350;
  undefined8 local_348;
  undefined4 local_340;
  undefined4 local_33c;
  undefined8 local_338;
  undefined8 local_330;
  undefined8 local_328 [69];
  undefined4 local_fc;
  undefined4 local_f8;
  undefined4 local_f4;
  undefined4 local_f0;
  undefined4 local_ec;
  undefined4 local_e8;
  undefined4 local_e4;
  undefined4 local_e0;
  undefined4 local_dc;
  undefined4 local_d8;
  undefined4 local_d4;
  undefined4 local_d0;
  undefined4 local_cc;
  undefined4 local_c8;
  undefined4 local_c4;
  undefined4 local_64;
  undefined4 local_60;
  undefined1 local_5c [4];
  undefined4 local_58;
  undefined4 local_54;
  undefined4 local_50;
  undefined4 local_4c;
  undefined4 local_48;
  long local_40;
  
  bVar15 = 0;
  uVar13 = (ulong)param_1;
  lVar8 = uVar13 * 0x4a8;
  local_40 = *(long *)(in_FS_OFFSET + 0x28);
  lVar6 = *(long *)(&DAT_00340d08 + lVar8);
  if (*(int *)(lVar6 + 0x214) == 0) {
    piVar3 = __errno_location();
    *piVar3 = -0x1b51fffa;
    iVar9 = 0;
  }
  else {
    iVar9 = *(int *)(lVar6 + 0x7810);
    puVar10 = (undefined8 *)local_3b8;
    puVar12 = puVar10;
    for (lVar4 = 0x6e; lVar4 != 0; lVar4 = lVar4 + -1) {
      *puVar12 = 0;
      puVar12 = puVar12 + 1;
    }
    local_3b4 = 0x10003 - (uint)(iVar9 == 0);
    local_3b8 = (undefined1  [4])0x374;
    local_48 = *(undefined4 *)(&DAT_00340d5c + lVar8);
    local_340 = *(undefined4 *)(&DAT_00340d58 + lVar8);
    local_348 = *(undefined8 *)(&DAT_00340dc0 + lVar8);
    local_3b0 = *(int *)(&DAT_00340d40 + lVar8);
    local_3ac = *(int *)(&DAT_00340d44 + lVar8);
    FUN_001101b0(lVar6,local_5c,local_3a8,local_3a4);
    lVar6 = *(long *)(&DAT_00340d08 + lVar8);
    local_58 = *(undefined4 *)(lVar6 + 0x4c);
    local_54 = *(undefined4 *)(lVar6 + 0x50);
    local_60 = *(undefined4 *)(lVar6 + 0x8c);
    local_64 = *(undefined4 *)(lVar6 + 0x88);
    local_3a0 = *(undefined8 *)(&DAT_00340db0 + lVar8);
    local_398 = *(undefined8 *)(&DAT_00340db8 + lVar8);
    local_50 = *(undefined4 *)(lVar6 + 0x3c);
    local_369 = 0;
    local_4c = *(undefined4 *)(lVar6 + 0x40);
    local_38c = *(undefined4 *)(&DAT_00340d6c + lVar8);
    local_390 = *(undefined4 *)(&DAT_00340d68 + lVar8);
    local_388 = *(undefined8 *)(&DAT_00340d90 + lVar8);
    local_368 = *(undefined8 *)(&DAT_00340d70 + lVar8);
    local_360 = *(undefined8 *)(&DAT_00340d78 + lVar8);
    local_358 = *(undefined8 *)(&DAT_00340d80 + lVar8);
    local_350 = *(ulong *)(&DAT_00340d88 + lVar8) & 0xffffffffffffff;
    local_33c = *(undefined4 *)(&DAT_00340dd8 + lVar8);
    local_338 = *(undefined8 *)(&DAT_00340dc8 + lVar8);
    local_330 = *(undefined8 *)(&DAT_00340dd0 + lVar8);
    if (*(uint *)(lVar6 + 0x78) < *(uint *)(lVar6 + 0x1764)) {
      puVar12 = (undefined8 *)(lVar6 + 0x1768 + (ulong)*(uint *)(lVar6 + 0x78) * 0x21c);
      puVar11 = local_328;
      for (lVar8 = 0x43; lVar8 != 0; lVar8 = lVar8 + -1) {
        *puVar11 = *puVar12;
        puVar12 = puVar12 + (ulong)bVar15 * -2 + 1;
        puVar11 = puVar11 + (ulong)bVar15 * -2 + 1;
      }
      *(undefined4 *)puVar11 = *(undefined4 *)puVar12;
    }
    local_f4 = *(undefined4 *)(lVar6 + 0xb8);
    local_f8 = 0;
    local_f0 = *(undefined4 *)(lVar6 + 0xbc);
    local_ec = *(undefined4 *)(lVar6 + 0xd8);
    local_fc = *(undefined4 *)(&DAT_00340d28 + uVar13 * 0x4a8);
    local_e8 = *(undefined4 *)(lVar6 + 0xdc);
    local_e0 = *(undefined4 *)(lVar6 + 0x10);
    local_e4 = *(undefined4 *)(lVar6 + 0xb4);
    local_dc = *(undefined4 *)(lVar6 + 0x14);
    local_d8 = *(undefined4 *)(lVar6 + 0x18);
    local_d4 = *(undefined4 *)(lVar6 + 0x1c);
    local_d0 = *(undefined4 *)(lVar6 + 0x20);
    local_cc = *(undefined4 *)(lVar6 + 0x24);
    local_c8 = *(undefined4 *)(lVar6 + 0x30);
    local_c4 = *(undefined4 *)(lVar6 + 0x34);
    if (param_2 == (undefined8 *)0x0) {
      FUN_00106fb0(local_3d8,param_3,0);
      FUN_001070c0(local_3d8,puVar10,0x374,1);
      FUN_001070c0(local_3d8,*(undefined8 *)(*(long *)(&DAT_00340d08 + uVar13 * 0x4a8) + 0x268),
                   (ulong)(uint)(local_3ac * local_3b0) * 2,1);
      FUN_00106d80(local_3d8);
      uVar7 = local_3b0 * local_3ac;
    }
    else {
      bVar14 = ((ulong)param_2 & 1) != 0;
      uVar7 = 0x374;
      puVar12 = param_2;
      if (bVar14) {
        puVar12 = (undefined8 *)((long)param_2 + 1);
        puVar10 = (undefined8 *)(local_3b8 + 1);
        *(undefined1 *)param_2 = local_3b8[0];
        uVar7 = 0x373;
      }
      puVar11 = puVar12;
      if (((ulong)puVar12 & 2) != 0) {
        uVar1 = *(undefined2 *)puVar10;
        puVar11 = (undefined8 *)((long)puVar12 + 2);
        puVar10 = (undefined8 *)((long)puVar10 + 2);
        uVar7 = uVar7 - 2;
        *(undefined2 *)puVar12 = uVar1;
      }
      puVar12 = puVar11;
      if (((ulong)puVar11 & 4) != 0) {
        uVar2 = *(undefined4 *)puVar10;
        puVar12 = (undefined8 *)((long)puVar11 + 4);
        puVar10 = (undefined8 *)((long)puVar10 + 4);
        uVar7 = uVar7 - 4;
        *(undefined4 *)puVar11 = uVar2;
      }
      lVar6 = 0;
      for (uVar5 = (ulong)(uVar7 >> 3); uVar5 != 0; uVar5 = uVar5 - 1) {
        *puVar12 = *puVar10;
        puVar10 = puVar10 + (ulong)bVar15 * -2 + 1;
        puVar12 = puVar12 + (ulong)bVar15 * -2 + 1;
      }
      if ((uVar7 & 4) != 0) {
        *(undefined4 *)puVar12 = *(undefined4 *)puVar10;
        lVar6 = 4;
      }
      if ((uVar7 & 2) != 0) {
        *(undefined2 *)((long)puVar12 + lVar6) = *(undefined2 *)((long)puVar10 + lVar6);
        lVar6 = lVar6 + 2;
      }
      if (bVar14) {
        *(undefined1 *)((long)puVar12 + lVar6) = *(undefined1 *)((long)puVar10 + lVar6);
      }
      uVar7 = local_3ac * local_3b0;
      memcpy((void *)((long)param_2 + 0x374),
             *(void **)(*(long *)(&DAT_00340d08 + uVar13 * 0x4a8) + 0x268),(ulong)uVar7 * 2);
    }
    iVar9 = uVar7 * 2 + 0x374;
  }
  if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
                    /* WARNING: Subroutine does not return */
    __stack_chk_fail();
  }
  return iVar9;
}


==================================================================

### FUNC 0011f830 (318 bytes) name=MAG_SaveDDT

bool MAG_SaveDDT(uint param_1,long param_2)

{
  int iVar1;
  int *piVar2;
  undefined8 uVar3;
  ulong uVar4;
  undefined2 local_58;
  undefined2 local_56;
  undefined2 local_52;
  undefined2 local_50;
  undefined2 local_4e;
  undefined2 local_4c;
  undefined1 local_48 [32];
  
  iVar1 = MAG_IsChannelAvailable();
  if (iVar1 == 0) {
    return false;
  }
  uVar4 = (ulong)param_1;
  if (*(int *)(*(long *)(&DAT_00340d08 + uVar4 * 0x4a8) + 0x214) == 0) {
    piVar2 = __errno_location();
    *piVar2 = -0x1b51fffa;
    return false;
  }
  FUN_001161f0(local_48,0x100);
  if (param_2 == 0) {
    FUN_00113c20(&local_58);
    FUN_00116490(local_48,"%d-%02d-%02d %02d-%02d-%02d.ddt",local_58,local_56,local_52,local_50,
                 local_4e,local_4c);
  }
  else {
    FUN_00116630(local_48,param_2);
  }
  pthread_mutex_lock((pthread_mutex_t *)(*(long *)(&DAT_00340d08 + uVar4 * 0x4a8) + 0x218));
  uVar3 = FUN_00116550(local_48);
  iVar1 = FUN_0011f300(param_1,0,uVar3);
  pthread_mutex_unlock((pthread_mutex_t *)(*(long *)(&DAT_00340d08 + uVar4 * 0x4a8) + 0x218));
  FUN_00116360(local_48);
  return 0 < iVar1;
}


==================================================================

### FUNC 0011f990 (215 bytes) name=MAG_SaveDDT2Buffer

int MAG_SaveDDT2Buffer(uint param_1,long param_2,ulong param_3)

{
  int iVar1;
  int iVar2;
  int *piVar3;
  long lVar4;
  
  iVar1 = MAG_IsChannelAvailable();
  if (iVar1 != 0) {
    if ((param_2 == 0) ||
       (lVar4 = (ulong)param_1 * 0x4a8,
       (param_3 & 0xffffffff) <
       (ulong)(uint)(*(int *)(&DAT_00340d44 + lVar4) * *(int *)(&DAT_00340d40 + lVar4)) * 2 + 0x374)
       ) {
      piVar3 = __errno_location();
      *piVar3 = -0x1b51ffff;
      return 0;
    }
    if (*(int *)(*(long *)(&DAT_00340d08 + lVar4) + 0x214) != 0) {
      pthread_mutex_lock((pthread_mutex_t *)(*(long *)(&DAT_00340d08 + lVar4) + 0x218));
      iVar2 = FUN_0011f300(param_1,param_2,&DAT_00131fd1);
      pthread_mutex_unlock((pthread_mutex_t *)(*(long *)(&DAT_00340d08 + lVar4) + 0x218));
      iVar1 = 0;
      if (-1 < iVar2) {
        iVar1 = iVar2;
      }
      return iVar1;
    }
    piVar3 = __errno_location();
    *piVar3 = -0x1b51fffa;
  }
  return 0;
}


==================================================================

### FUNC 0011fa80 (511 bytes) name=FUN_0011fa80

void FUN_0011fa80(undefined8 *param_1)

{
  long lVar1;
  int iVar2;
  undefined8 *puVar3;
  ulong uVar4;
  ulong uVar5;
  char *pcVar6;
  undefined8 *puVar7;
  long in_FS_OFFSET;
  bool bVar8;
  byte bVar9;
  pthread_mutexattr_t apStack_28 [2];
  long local_20;
  
  bVar9 = 0;
  local_20 = *(long *)(in_FS_OFFSET + 0x28);
  iVar2 = pthread_mutexattr_init(apStack_28);
  if (iVar2 == 0) {
    iVar2 = pthread_mutexattr_settype(apStack_28,1);
    if (iVar2 == 0) {
      iVar2 = pthread_mutex_init((pthread_mutex_t *)(param_1 + 0x16),apStack_28);
      if (iVar2 == 0) {
        iVar2 = pthread_mutexattr_destroy(apStack_28);
        if (iVar2 == 0) {
          bVar8 = ((ulong)param_1 & 1) != 0;
          param_1[0x1b] = 0;
          param_1[0x1c] = 0;
          param_1[0x1d] = 0;
          param_1[0x1e] = 0;
          param_1[0x1f] = 0;
          uVar5 = 0xac;
          puVar3 = param_1;
          if (bVar8) {
            *(undefined1 *)param_1 = 0;
            puVar3 = (undefined8 *)((long)param_1 + 1);
            uVar5 = 0xab;
          }
          puVar7 = puVar3;
          if (((ulong)puVar3 & 2) != 0) {
            puVar7 = (undefined8 *)((long)puVar3 + 2);
            uVar5 = (ulong)((int)uVar5 - 2);
            *(undefined2 *)puVar3 = 0;
          }
          if (((ulong)puVar7 & 4) != 0) {
            *(undefined4 *)puVar7 = 0;
            uVar5 = (ulong)((int)uVar5 - 4);
            puVar7 = (undefined8 *)((long)puVar7 + 4);
          }
          for (uVar4 = uVar5 >> 3; uVar4 != 0; uVar4 = uVar4 - 1) {
            *puVar7 = 0;
            puVar7 = puVar7 + (ulong)bVar9 * -2 + 1;
          }
          if ((uVar5 & 4) != 0) {
            *(undefined4 *)puVar7 = 0;
            puVar7 = (undefined8 *)((long)puVar7 + 4);
          }
          if ((uVar5 & 2) != 0) {
            *(undefined2 *)puVar7 = 0;
            puVar7 = (undefined8 *)((long)puVar7 + 2);
          }
          if (bVar8) {
            *(undefined1 *)puVar7 = 0;
          }
          lVar1 = *(long *)(in_FS_OFFSET + 0x28);
          param_1[0x20] = 0;
          *(undefined4 *)(param_1 + 0x21) = 0;
          *(undefined4 *)((long)param_1 + 0x164) = 0;
          *(undefined4 *)(param_1 + 0x2d) = 0;
          param_1[0x2e] = 0;
          param_1[0x2f] = 0;
          param_1[0x30] = 0;
          if (local_20 == lVar1) {
            return;
          }
                    /* WARNING: Subroutine does not return */
          __stack_chk_fail();
        }
        puVar3 = (undefined8 *)__cxa_allocate_exception(8);
        pcVar6 = "pthread_mutexattr_destroy failed\n";
      }
      else {
        puVar3 = (undefined8 *)__cxa_allocate_exception(8);
        pcVar6 = "pthread_mutex_init failed\n";
      }
    }
    else {
      puVar3 = (undefined8 *)__cxa_allocate_exception(8);
      pcVar6 = "pthread_mutexattr_settype failed\n";
    }
  }
  else {
    puVar3 = (undefined8 *)__cxa_allocate_exception(8);
    pcVar6 = "pthread_mutexattr_init failed\n";
  }
  *puVar3 = pcVar6;
                    /* WARNING: Subroutine does not return */
  __cxa_throw(puVar3,&PTR_vtable_0033ec10,0);
}


==================================================================

### FUNC 0011fca0 (142 bytes) name=FUN_0011fca0

void FUN_0011fca0(long param_1)

{
  pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0xb0));
  if (*(void **)(param_1 + 0x170) != (void *)0x0) {
    operator_delete__(*(void **)(param_1 + 0x170));
    *(undefined8 *)(param_1 + 0x170) = 0;
  }
  if (*(void **)(param_1 + 0x178) != (void *)0x0) {
    operator_delete__(*(void **)(param_1 + 0x178));
    *(undefined8 *)(param_1 + 0x178) = 0;
  }
  if (*(void **)(param_1 + 0x180) != (void *)0x0) {
    operator_delete__(*(void **)(param_1 + 0x180));
    *(undefined8 *)(param_1 + 0x180) = 0;
  }
  *(undefined4 *)(param_1 + 0x164) = 0;
  *(undefined4 *)(param_1 + 0x168) = 0;
  pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0xb0));
  return;
}


==================================================================

### FUNC 0011fd30 (22 bytes) name=FUN_0011fd30

void FUN_0011fd30(long param_1)

{
  FUN_0011fca0();
  pthread_mutex_destroy((pthread_mutex_t *)(param_1 + 0xb0));
  return;
}


==================================================================

### FUNC 0011fd50 (859 bytes) name=FUN_0011fd50

undefined4 FUN_0011fd50(long param_1,undefined8 *param_2)

{
  pthread_mutex_t *__mutex;
  uint uVar1;
  int iVar2;
  int *piVar3;
  void *pvVar4;
  ulong uVar5;
  ulong uVar6;
  undefined8 *puVar7;
  undefined8 *puVar8;
  bool bVar9;
  byte bVar10;
  undefined1 auStack_38 [32];
  
  bVar10 = 0;
  __mutex = (pthread_mutex_t *)(param_1 + 0xb0);
  FUN_0011fca0();
  pthread_mutex_lock(__mutex);
  *(undefined8 *)(param_1 + 0xd8) = *param_2;
  uVar1 = *(uint *)(param_1 + 0xd8);
  *(undefined8 *)(param_1 + 0xe0) = param_2[1];
  *(undefined8 *)(param_1 + 0xe8) = param_2[2];
  *(undefined8 *)(param_1 + 0xf0) = param_2[3];
  *(undefined8 *)(param_1 + 0xf8) = param_2[4];
  if (((((uVar1 & 3) == 0) && (3 < uVar1)) && (*(int *)(param_1 + 0xdc) != 0)) &&
     (*(long *)(param_1 + 0xd8) == *(long *)(param_1 + 0xe0))) {
    *(uint *)(param_1 + 0x100) = uVar1 * *(int *)(param_1 + 0xdc);
    iVar2 = *(int *)(param_1 + 0xe4) * *(int *)(param_1 + 0xe0);
    *(int *)(param_1 + 0x104) = iVar2;
    pvVar4 = operator_new__((ulong)(uint)(iVar2 * 4));
    *(void **)(param_1 + 0x170) = pvVar4;
    pvVar4 = operator_new__((ulong)(uint)(*(int *)(param_1 + 0x104) * 4));
    *(void **)(param_1 + 0x178) = pvVar4;
    pvVar4 = operator_new__((ulong)((uint)(*(int *)(param_1 + 0x104) * 3) >> 1));
    *(void **)(param_1 + 0x180) = pvVar4;
    if (((*(long *)(param_1 + 0x170) != 0) && (*(long *)(param_1 + 0x178) != 0)) &&
       (pvVar4 != (void *)0x0)) {
      puVar8 = (undefined8 *)(param_1 + 0x10c);
      uVar6 = 0x2c;
      bVar9 = ((ulong)puVar8 & 1) != 0;
      if (bVar9) {
        *(undefined1 *)(param_1 + 0x10c) = 0;
        puVar8 = (undefined8 *)(param_1 + 0x10d);
        uVar6 = 0x2b;
      }
      puVar7 = puVar8;
      if (((ulong)puVar8 & 2) != 0) {
        puVar7 = (undefined8 *)((long)puVar8 + 2);
        uVar6 = (ulong)((int)uVar6 - 2);
        *(undefined2 *)puVar8 = 0;
      }
      if (((ulong)puVar7 & 4) != 0) {
        *(undefined4 *)puVar7 = 0;
        uVar6 = (ulong)((int)uVar6 - 4);
        puVar7 = (undefined8 *)((long)puVar7 + 4);
      }
      for (uVar5 = uVar6 >> 3; uVar5 != 0; uVar5 = uVar5 - 1) {
        *puVar7 = 0;
        puVar7 = puVar7 + (ulong)bVar10 * -2 + 1;
      }
      if ((uVar6 & 4) != 0) {
        *(undefined4 *)puVar7 = 0;
        puVar7 = (undefined8 *)((long)puVar7 + 4);
      }
      puVar8 = puVar7;
      if ((uVar6 & 2) != 0) {
        puVar8 = (undefined8 *)((long)puVar7 + 2);
        *(undefined2 *)puVar7 = 0;
      }
      if (bVar9) {
        *(undefined1 *)puVar8 = 0;
      }
      *(undefined2 *)(param_1 + 0x118) = 1;
      puVar8 = (undefined8 *)(param_1 + 0x138);
      *(undefined4 *)(param_1 + 0x10c) = 0x28;
      *(undefined2 *)(param_1 + 0x11a) = 0x18;
      *(undefined4 *)(param_1 + 0x11c) = 0;
      uVar6 = 0x2c;
      *(undefined4 *)(param_1 + 0x110) = *(undefined4 *)(param_1 + 0xd8);
      bVar9 = ((ulong)puVar8 & 1) != 0;
      *(undefined4 *)(param_1 + 0x114) = *(undefined4 *)(param_1 + 0xdc);
      if (bVar9) {
        *(undefined1 *)(param_1 + 0x138) = 0;
        puVar8 = (undefined8 *)(param_1 + 0x139);
        uVar6 = 0x2b;
      }
      puVar7 = puVar8;
      if (((ulong)puVar8 & 2) != 0) {
        puVar7 = (undefined8 *)((long)puVar8 + 2);
        uVar6 = (ulong)((int)uVar6 - 2);
        *(undefined2 *)puVar8 = 0;
      }
      if (((ulong)puVar7 & 4) != 0) {
        *(undefined4 *)puVar7 = 0;
        uVar6 = (ulong)((int)uVar6 - 4);
        puVar7 = (undefined8 *)((long)puVar7 + 4);
      }
      for (uVar5 = uVar6 >> 3; uVar5 != 0; uVar5 = uVar5 - 1) {
        *puVar7 = 0;
        puVar7 = puVar7 + (ulong)bVar10 * -2 + 1;
      }
      if ((uVar6 & 4) != 0) {
        *(undefined4 *)puVar7 = 0;
        puVar7 = (undefined8 *)((long)puVar7 + 4);
      }
      puVar8 = puVar7;
      if ((uVar6 & 2) != 0) {
        puVar8 = (undefined8 *)((long)puVar7 + 2);
        *(undefined2 *)puVar7 = 0;
      }
      if (bVar9) {
        *(undefined1 *)puVar8 = 0;
      }
      *(undefined4 *)(param_1 + 0x138) = 0x28;
      *(undefined2 *)(param_1 + 0x146) = 0x18;
      *(undefined4 *)(param_1 + 0x148) = 0;
      *(undefined4 *)(param_1 + 0x164) = 1;
      *(undefined4 *)(param_1 + 0x13c) = *(undefined4 *)(param_1 + 0xe0);
      *(undefined4 *)(param_1 + 0x140) = *(undefined4 *)(param_1 + 0xe4);
      *(undefined2 *)(param_1 + 0x144) = 1;
      pthread_mutex_unlock(__mutex);
      return *(undefined4 *)(param_1 + 0x164);
    }
    FUN_00113aa0(auStack_38,4);
    FUN_00116630(auStack_38,"Failed to allocate memory");
    FUN_00113b30(auStack_38);
    pthread_mutex_unlock(__mutex);
    piVar3 = __errno_location();
    *piVar3 = -0x1b51fffe;
    return 0;
  }
  FUN_00113aa0(auStack_38,4);
  FUN_00116630(auStack_38,"Failed to configurate CFuncitons due to parameter error");
  FUN_00113b30(auStack_38);
  pthread_mutex_unlock(__mutex);
  piVar3 = __errno_location();
  *piVar3 = -0x1b51ffff;
  return 0;
}


==================================================================

### FUNC 001200e0 (539 bytes) name=FUN_001200e0

undefined8 FUN_001200e0(long param_1,void *param_2)

{
  byte bVar1;
  undefined1 uVar2;
  pthread_mutex_t *__mutex;
  ulong uVar3;
  undefined1 *puVar4;
  uint uVar5;
  int iVar6;
  long lVar7;
  int iVar8;
  ulong uVar9;
  int iVar10;
  uint uVar11;
  long lVar12;
  uint uVar13;
  uint local_58;
  
  __mutex = (pthread_mutex_t *)(param_1 + 0xb0);
  pthread_mutex_lock(__mutex);
  if ((*(int *)(param_1 + 0x164) != 0) && (param_2 != (void *)0x0)) {
    uVar11 = *(uint *)(param_1 + 0xe4);
    local_58 = *(uint *)(param_1 + 0xe0);
    if (*(int *)(param_1 + 0x7c) == 0) {
      uVar11 = *(uint *)(param_1 + 0xe0);
      local_58 = *(uint *)(param_1 + 0xe4);
    }
    uVar5 = local_58 * uVar11;
    memcpy(*(void **)(param_1 + 0x180),param_2,(ulong)(uVar5 * 3 >> 1));
    lVar7 = (ulong)uVar5 + (long)param_2;
    lVar12 = (ulong)(uVar5 >> 2) + lVar7;
    if (local_58 != 0) {
      uVar5 = 0;
      uVar13 = (local_58 * 3 + -3) * uVar11;
      do {
        if (uVar11 != 0) {
          uVar3 = 0;
          puVar4 = (undefined1 *)((ulong)uVar13 + *(long *)(param_1 + 0x170));
          do {
            bVar1 = *(byte *)((long)param_2 + uVar3);
            uVar9 = uVar3 >> 1 & 0x7fffffff;
            iVar6 = *(byte *)(lVar12 + uVar9) - 0x80;
            iVar8 = *(byte *)(lVar7 + uVar9) - 0x80;
            iVar10 = (iVar6 * 0x15e >> 8) + (uint)bVar1;
            if (iVar10 < 0) {
              iVar10 = 0;
            }
            iVar6 = (iVar8 * -0x55 + iVar6 * -0xb3 >> 8) + (uint)bVar1;
            if (iVar6 < 0) {
              iVar6 = 0;
            }
            iVar8 = (uint)bVar1 + (iVar8 * 0x1bb >> 8);
            if (iVar8 < 0) {
              iVar8 = 0;
            }
            uVar2 = (undefined1)iVar8;
            if (0xff < iVar8) {
              uVar2 = 0xff;
            }
            if (0xff < iVar6) {
              iVar6 = 0xff;
            }
            *puVar4 = uVar2;
            puVar4[1] = (char)iVar6;
            if (0xff < iVar10) {
              iVar10 = 0xff;
            }
            uVar3 = uVar3 + 1;
            puVar4[2] = (char)iVar10;
            puVar4 = puVar4 + 3;
          } while ((uint)uVar3 < uVar11);
          param_2 = (void *)((long)param_2 + (ulong)(uVar11 - 1) + 1);
        }
        if ((uVar5 & 1) != 0) {
          lVar7 = lVar7 + (ulong)(uVar11 >> 1);
          lVar12 = lVar12 + (ulong)(uVar11 >> 1);
        }
        uVar5 = uVar5 + 1;
        uVar13 = uVar13 + uVar11 * -3;
      } while (uVar5 != local_58);
    }
    *(undefined4 *)(param_1 + 0x168) = 1;
    pthread_mutex_unlock(__mutex);
    return 1;
  }
  pthread_mutex_unlock(__mutex);
  return 0;
}


==================================================================

### FUNC 00120300 (484 bytes) name=FUN_00120300

undefined8 FUN_00120300(long param_1,long param_2)

{
  pthread_mutex_t *__mutex;
  void *__src;
  uint uVar1;
  int *piVar2;
  void *__dest;
  undefined8 uVar3;
  ulong __n;
  undefined2 local_78;
  int local_76;
  undefined2 local_72;
  undefined2 local_70;
  undefined4 local_6e;
  undefined2 local_68;
  undefined2 local_66;
  undefined2 local_62;
  undefined2 local_60;
  undefined2 local_5e;
  undefined2 local_5c;
  undefined1 local_58 [40];
  
  __mutex = (pthread_mutex_t *)(param_1 + 0xb0);
  pthread_mutex_lock(__mutex);
  if ((*(int *)(param_1 + 0x164) == 0) || (*(int *)(param_1 + 0x168) == 0)) {
    pthread_mutex_unlock(__mutex);
    piVar2 = __errno_location();
    *piVar2 = -0x1b51fffa;
  }
  else {
    __src = *(void **)(param_1 + 0x170);
    uVar1 = *(int *)(param_1 + 0x100) * 3;
    __n = (ulong)uVar1;
    __dest = operator_new__(__n);
    if (__dest != (void *)0x0) {
      memcpy(__dest,__src,__n);
      pthread_mutex_unlock(__mutex);
      FUN_001161f0(local_58,0x100);
      if (param_2 == 0) {
        FUN_00113c20(&local_68);
        FUN_00116490(local_58,"%d-%02d-%02d %02d-%02d-%02d.bmp",local_68,local_66,local_62,local_60,
                     local_5e,local_5c);
      }
      else {
        FUN_00116630(local_58,param_2);
      }
      local_76 = uVar1 + 0x36;
      local_78 = 0x4d42;
      local_72 = 0;
      local_70 = 0;
      local_6e = 0x36;
      uVar3 = FUN_00116550(local_58);
      FUN_00106fb0(&local_68,uVar3,0);
      FUN_001070c0(&local_68,&local_78,0xe,1);
      FUN_001070c0(&local_68,param_1 + 0x10c,0x28,1);
      FUN_001070c0(&local_68,__dest,__n,1);
      FUN_00106d80(&local_68);
      operator_delete__(__dest);
      FUN_00116360(local_58);
      return 1;
    }
    pthread_mutex_unlock(__mutex);
    piVar2 = __errno_location();
    *piVar2 = -0x1b51fffe;
  }
  return 0;
}


==================================================================

### FUNC 00120550 (132 bytes) name=FUN_00120550

long FUN_00120550(byte param_1,long *param_2,char param_3)

{
  char *pcVar1;
  long lVar2;
  int iVar3;
  long lVar4;
  long lVar5;
  int iVar6;
  long lVar7;
  long lVar8;
  
  if (param_1 == 0) {
    return 0;
  }
  lVar8 = 0;
  do {
    iVar3 = *(int *)(*param_2 + 8 + lVar8);
    if (0 < iVar3) {
      lVar7 = *(long *)(*param_2 + lVar8);
      lVar2 = lVar7 + 0x28;
      do {
        if (*(byte *)(lVar7 + 4) != 0) {
          lVar4 = *(long *)(lVar7 + 0x10);
          if (*(char *)(lVar4 + 2) == param_3) {
            return lVar4;
          }
          iVar6 = 0;
          while( true ) {
            lVar5 = lVar4 + 0x20;
            iVar6 = iVar6 + 1;
            if ((int)(uint)*(byte *)(lVar7 + 4) <= iVar6) break;
            pcVar1 = (char *)(lVar4 + 0x22);
            lVar4 = lVar5;
            if (*pcVar1 == param_3) {
              return lVar5;
            }
          }
        }
        lVar7 = lVar7 + 0x28;
      } while (lVar7 != lVar2 + (ulong)(iVar3 - 1) * 0x28);
    }
    lVar8 = lVar8 + 0x10;
  } while (lVar8 != ((ulong)(param_1 - 1) + 1) * 0x10);
  return 0;
}


==================================================================

### FUNC 001205e0 (5 bytes) name=libusb_get_bus_number

undefined1 libusb_get_bus_number(long param_1)

{
  return *(undefined1 *)(param_1 + 0x38);
}


==================================================================

### FUNC 001205f0 (5 bytes) name=libusb_get_port_number

undefined1 libusb_get_port_number(long param_1)

{
  return *(undefined1 *)(param_1 + 0x39);
}


==================================================================

### FUNC 00120600 (5 bytes) name=libusb_get_parent

undefined8 libusb_get_parent(long param_1)

{
  return *(undefined8 *)(param_1 + 0x40);
}


==================================================================

### FUNC 00120610 (5 bytes) name=libusb_get_device_address

undefined1 libusb_get_device_address(long param_1)

{
  return *(undefined1 *)(param_1 + 0x48);
}


==================================================================

### FUNC 00120620 (4 bytes) name=libusb_get_device_speed

undefined4 libusb_get_device_speed(long param_1)

{
  return *(undefined4 *)(param_1 + 0x4c);
}


==================================================================

### FUNC 00120630 (26 bytes) name=libusb_ref_device

pthread_mutex_t * libusb_ref_device(pthread_mutex_t *param_1)

{
  pthread_mutex_lock(param_1);
  param_1[1].__data.__lock = param_1[1].__data.__lock + 1;
  pthread_mutex_unlock(param_1);
  return param_1;
}


==================================================================

### FUNC 00120650 (113 bytes) name=FUN_00120650

undefined8 FUN_00120650(long param_1,long param_2)

{
  pthread_mutex_t *__mutex;
  long lVar1;
  long lVar2;
  undefined8 uVar3;
  
  __mutex = (pthread_mutex_t *)(param_1 + 0x20);
  pthread_mutex_lock(__mutex);
  lVar1 = *(long *)(param_1 + 0x18);
  if (param_1 + 0x10 != lVar1) {
    lVar2 = *(long *)(lVar1 + 0x10);
    while( true ) {
      if (lVar2 == param_2) {
        uVar3 = libusb_ref_device();
        pthread_mutex_unlock(__mutex);
        return uVar3;
      }
      lVar1 = *(long *)(lVar1 + 8);
      if (param_1 + 0x10 == lVar1) break;
      lVar2 = *(long *)(lVar1 + 0x10);
    }
  }
  pthread_mutex_unlock(__mutex);
  return 0;
}


==================================================================

### FUNC 001206d0 (5 bytes) name=libusb_get_device

undefined8 libusb_get_device(long param_1)

{
  return *(undefined8 *)(param_1 + 0x40);
}


==================================================================

### FUNC 001206e0 (35 bytes) name=libusb_dev_mem_alloc

void * libusb_dev_mem_alloc(long param_1,size_t param_2)

{
  void *pvVar1;
  int *piVar2;
  
  if (*(int *)(*(long *)(param_1 + 0x40) + 0x7c) != 0) {
    switch(PTR_FUN_0033eb10) {
    case (undefined *)0x12a3d0:
      pvVar1 = mmap((void *)0x0,param_2,3,1,*(int *)(param_1 + 0x4c),0);
      if (pvVar1 == (void *)0xffffffffffffffff) {
        piVar2 = __errno_location();
        FUN_00120cd0(*(undefined8 *)(*(long *)(param_1 + 0x40) + 0x30),1,"op_dev_mem_alloc",
                     "alloc dev mem failed errno %d",*piVar2);
        return (void *)0x0;
      }
      return pvVar1;
    }
  }
  return (void *)0x0;
}


==================================================================

### FUNC 00120710 (27 bytes) name=libusb_dev_mem_free

undefined4 libusb_dev_mem_free(long param_1,void *param_2,size_t param_3)

{
  int iVar1;
  int *piVar2;
  
  switch(PTR_FUN_0033eb18) {
  case (undefined *)0x12a380:
    break;
  default:
    return 0xfffffff4;
  }
  iVar1 = munmap(param_2,param_3);
  if (iVar1 != 0) {
    piVar2 = __errno_location();
    FUN_00120cd0(*(undefined8 *)(*(long *)(param_1 + 0x40) + 0x30),1,"op_dev_mem_free",
                 "free dev mem failed errno %d",*piVar2);
    return 0xffffff9d;
  }
  return 0;
}


==================================================================

### FUNC 00120730 (25 bytes) name=libusb_set_auto_detach_kernel_driver

undefined8 libusb_set_auto_detach_kernel_driver(long param_1,undefined4 param_2)

{
  if ((DAT_0033ea68._2_1_ & 2) != 0) {
    *(undefined4 *)(param_1 + 0x48) = param_2;
    return 0;
  }
  return 0xfffffff4;
}


==================================================================

### FUNC 00120750 (22 bytes) name=libusb_set_debug

void libusb_set_debug(undefined4 *param_1,undefined4 param_2)

{
  if (param_1 == (undefined4 *)0x0) {
    param_1 = DAT_003665e8;
  }
  if (param_1[1] == 0) {
    *param_1 = param_2;
  }
  return;
}


==================================================================

### FUNC 00120770 (83 bytes) name=libusb_has_capability

uint libusb_has_capability(int param_1)

{
  uint uVar1;
  
  if (param_1 == 1) {
    return (uint)(DAT_0033ea80 == 0);
  }
  uVar1 = 1;
  if (param_1 != 0) {
    if (param_1 == 0x100) {
      return DAT_0033ea68 & 0x10000;
    }
    if (param_1 == 0x101) {
      return DAT_0033ea68 & 0x20000;
    }
    uVar1 = 0;
  }
  return uVar1;
}


==================================================================

### FUNC 001207e0 (130 bytes) name=FUN_001207e0

void FUN_001207e0(long param_1)

{
  long lVar1;
  long lVar2;
  int iVar3;
  
  lVar1 = *(long *)(param_1 + 0x30);
  *(undefined4 *)(param_1 + 0x7c) = 1;
  pthread_mutex_lock((pthread_mutex_t *)(lVar1 + 0x20));
  lVar2 = *(long *)(param_1 + 0x30);
  *(undefined8 *)(param_1 + 0x58) = *(undefined8 *)(lVar2 + 0x18);
  *(long *)(param_1 + 0x50) = lVar2 + 0x10;
  **(long **)(lVar2 + 0x18) = param_1 + 0x50;
  *(long *)(lVar2 + 0x18) = param_1 + 0x50;
  pthread_mutex_unlock((pthread_mutex_t *)(lVar2 + 0x20));
  iVar3 = libusb_has_capability(1);
  if ((iVar3 != 0) && (*(long *)(*(long *)(param_1 + 0x30) + 0x1e8) != 0)) {
    FUN_00124710(lVar1,param_1,1);
    return;
  }
  return;
}


==================================================================

### FUNC 00120870 (139 bytes) name=FUN_00120870

pthread_mutex_t * FUN_00120870(undefined8 param_1,undefined8 param_2)

{
  int iVar1;
  pthread_mutex_t *__mutex;
  pthread_mutex_t *ppVar2;
  
  __mutex = calloc(1,DAT_0033eb78 + 0x80);
  if (__mutex == (pthread_mutex_t *)0x0) {
    ppVar2 = (pthread_mutex_t *)0x0;
  }
  else {
    iVar1 = pthread_mutex_init(__mutex,(pthread_mutexattr_t *)0x0);
    if (iVar1 == 0) {
      *(undefined8 *)((long)__mutex + 0x30) = param_1;
      __mutex[1].__data.__lock = 1;
      *(undefined8 *)((long)__mutex + 0x60) = param_2;
      *(undefined4 *)((long)__mutex + 0x4c) = 0;
      iVar1 = libusb_has_capability(1);
      ppVar2 = __mutex;
      if (iVar1 == 0) {
        FUN_001207e0(__mutex);
        return __mutex;
      }
    }
    else {
      ppVar2 = (pthread_mutex_t *)0x0;
      free(__mutex);
    }
  }
  return ppVar2;
}


==================================================================

### FUNC 00120910 (140 bytes) name=FUN_00120910

void FUN_00120910(pthread_mutex_t *param_1)

{
  pthread_mutex_t *__mutex;
  long lVar1;
  long *plVar2;
  int iVar3;
  
  lVar1 = *(long *)((long)param_1 + 0x30);
  pthread_mutex_lock(param_1);
  __mutex = (pthread_mutex_t *)(lVar1 + 0x20);
  *(undefined4 *)((long)param_1 + 0x7c) = 0;
  pthread_mutex_unlock(param_1);
  pthread_mutex_lock(__mutex);
  plVar2 = *(long **)((long)param_1 + 0x58);
  *plVar2 = param_1[2].__align;
  *(long **)(param_1[2].__align + 8) = plVar2;
  param_1[2].__align = 0;
  *(undefined8 *)((long)param_1 + 0x58) = 0;
  pthread_mutex_unlock(__mutex);
  iVar3 = libusb_has_capability(1);
  if ((iVar3 != 0) && (*(long *)(*(long *)((long)param_1 + 0x30) + 0x1e8) != 0)) {
    FUN_00124710(lVar1,param_1,2);
    return;
  }
  return;
}


==================================================================

### FUNC 001209b0 (770 bytes) name=FUN_001209b0

void FUN_001209b0(int *param_1,int param_2,undefined8 param_3,undefined8 param_4,undefined8 param_5)

{
  undefined *puVar1;
  undefined4 uVar2;
  uint uVar3;
  int iVar4;
  int iVar5;
  long lVar6;
  long lVar7;
  char *pcVar8;
  long in_FS_OFFSET;
  undefined8 in_stack_fffffffffffffb88;
  undefined4 uVar9;
  timeval local_458;
  char local_448 [1032];
  long local_40;
  
  uVar9 = (undefined4)((ulong)in_stack_fffffffffffffb88 >> 0x20);
  local_40 = *(long *)(in_FS_OFFSET + 0x28);
  if ((param_1 == (int *)0x0) && (param_1 = DAT_003665e8, DAT_003665e8 == (int *)0x0)) {
    pcVar8 = getenv("LIBUSB_DEBUG");
    if (pcVar8 == (char *)0x0) goto switchD_00120af6_caseD_0;
    lVar6 = strtol(pcVar8,(char **)0x0,10);
    iVar4 = (int)lVar6;
  }
  else {
    iVar4 = *param_1;
  }
  if ((((iVar4 != 0) && ((1 < iVar4 || (param_2 != 2)))) && ((2 < iVar4 || (param_2 != 3)))) &&
     ((3 < iVar4 || (param_2 != 4)))) {
    gettimeofday(&local_458,(__timezone_ptr_t)0x0);
    puVar1 = PTR_stderr_0033efd8;
    if ((iVar4 == 4) && (DAT_003665f0 == 0)) {
      DAT_003665f0 = 1;
      fwrite("[timestamp] [threadID] facility level [function call] <message>\n",1,0x40,
             *(FILE **)PTR_stderr_0033efd8);
      fwrite("--------------------------------------------------------------------------------\n",1,
             0x51,*(FILE **)puVar1);
    }
    if (local_458.tv_usec < DAT_00366608) {
      local_458.tv_usec = local_458.tv_usec + 1000000;
      local_458.tv_sec = local_458.tv_sec - 1;
    }
    local_458.tv_sec = local_458.tv_sec - DAT_00366600;
    local_458.tv_usec = local_458.tv_usec - DAT_00366608;
    switch(param_2) {
    case 0:
      goto switchD_00120af6_caseD_0;
    case 1:
      pcVar8 = "error";
      break;
    case 2:
      pcVar8 = "warning";
      break;
    case 3:
      pcVar8 = "info";
      break;
    case 4:
      pcVar8 = "debug";
      break;
    default:
      pcVar8 = "unknown";
    }
    if (iVar4 != 4) {
      uVar3 = __snprintf_chk(local_448,0x400,1,0x400,"libusb: %s [%s] ",pcVar8,param_3);
    }
    else {
      uVar2 = FUN_00127550();
      uVar3 = __snprintf_chk(local_448,0x400,1,0x400,"[%2d.%06d] [%08x] libusb: %s [%s] ",
                             local_458.tv_sec & 0xffffffff,CONCAT44(uVar9,(int)local_458.tv_usec),
                             uVar2,pcVar8,param_3);
    }
    if (uVar3 < 0x400) {
      lVar6 = (long)(int)uVar3;
      lVar7 = 0x400 - lVar6;
      pcVar8 = local_448 + lVar6;
    }
    else {
      lVar7 = 0x400;
      lVar6 = 0;
      uVar3 = 0;
      pcVar8 = local_448;
    }
    local_448[lVar6] = '\0';
    iVar4 = __vsnprintf_chk(pcVar8,lVar7,1,0xffffffffffffffff,param_4,param_5);
    if ((iVar4 < 0) || (iVar5 = uVar3 + iVar4, 0x3ff < iVar5)) {
      iVar4 = 0x400 - uVar3;
      iVar5 = uVar3 + iVar4;
    }
    if (0x3ff < (long)iVar5 + 2U) {
      iVar4 = (iVar4 + 0x3fe) - iVar5;
    }
    pcVar8 = local_448 + lVar6 + iVar4;
    pcVar8[0] = '\n';
    pcVar8[1] = '\0';
    fputs(local_448,*(FILE **)PTR_stderr_0033efd8);
  }
switchD_00120af6_caseD_0:
  if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
                    /* WARNING: Subroutine does not return */
    __stack_chk_fail();
  }
  return;
}


==================================================================

### FUNC 00120cd0 (133 bytes) name=FUN_00120cd0

void FUN_00120cd0(void)

{
  FUN_001209b0();
  return;
}


==================================================================

### FUNC 00120d60 (113 bytes) name=FUN_00120d60

undefined8 FUN_00120d60(long param_1)

{
  byte bVar1;
  undefined8 uVar2;
  
  uVar2 = FUN_00123690();
  if (-1 < (int)uVar2) {
    bVar1 = *(byte *)(param_1 + 0x79);
    if (bVar1 < 9) {
      if (bVar1 == 0) {
        FUN_00120cd0(0,4,"usbi_sanitize_device","zero configurations, maybe an unauthorized device")
        ;
      }
      *(byte *)(param_1 + 0x49) = bVar1;
      uVar2 = 0;
    }
    else {
      FUN_00120cd0(*(undefined8 *)(param_1 + 0x30),1,"usbi_sanitize_device",
                   "too many configurations");
      uVar2 = 0xffffffff;
    }
  }
  return uVar2;
}


==================================================================

### FUNC 00120de0 (145 bytes) name=libusb_get_port_numbers

int libusb_get_port_numbers(long param_1,void *param_2,int param_3)

{
  undefined8 uVar1;
  int iVar2;
  int iVar3;
  char *pcVar4;
  
  uVar1 = *(undefined8 *)(param_1 + 0x30);
  if (param_3 < 1) {
    iVar3 = -2;
  }
  else {
    pcVar4 = (char *)((long)param_2 + (long)param_3 + -1);
    iVar2 = param_3;
    do {
      if (*(char *)(param_1 + 0x39) == '\0') break;
      iVar2 = iVar2 + -1;
      if (iVar2 == -1) {
        FUN_00120cd0(uVar1,2,"libusb_get_port_numbers","port numbers array is too small");
        return -8;
      }
      *pcVar4 = *(char *)(param_1 + 0x39);
      param_1 = *(long *)(param_1 + 0x40);
      pcVar4 = pcVar4 + -1;
    } while (param_1 != 0);
    iVar3 = param_3 - iVar2;
    if (iVar2 < param_3) {
      memmove(param_2,(void *)((long)param_2 + (long)iVar2),(long)iVar3);
      return iVar3;
    }
  }
  return iVar3;
}


==================================================================

### FUNC 00120e80 (14 bytes) name=libusb_get_port_path

void libusb_get_port_path
               (undefined8 param_1,undefined8 param_2,undefined8 param_3,undefined1 param_4)

{
  libusb_get_port_numbers(param_2,param_3,param_4);
  return;
}


==================================================================

### FUNC 00120e90 (115 bytes) name=libusb_get_max_packet_size

ulong libusb_get_max_packet_size(long param_1,undefined1 param_2)

{
  int iVar1;
  long lVar2;
  ulong uVar3;
  long local_20 [2];
  
  iVar1 = libusb_get_active_config_descriptor(param_1,local_20);
  if (iVar1 < 0) {
    FUN_00120cd0(*(undefined8 *)(param_1 + 0x30),1,"libusb_get_max_packet_size",
                 "could not retrieve active config descriptor");
    uVar3 = 0xffffff9d;
  }
  else {
    uVar3 = 0xfffffffb;
    lVar2 = FUN_00120550(*(undefined1 *)(local_20[0] + 4),local_20[0] + 0x10,param_2);
    if (lVar2 != 0) {
      uVar3 = (ulong)*(ushort *)(lVar2 + 4);
    }
    libusb_free_config_descriptor(local_20[0]);
  }
  return uVar3;
}


==================================================================

### FUNC 00120f10 (144 bytes) name=libusb_get_max_iso_packet_size

uint libusb_get_max_iso_packet_size(long param_1,undefined1 param_2)

{
  int iVar1;
  long lVar2;
  uint uVar3;
  long local_20 [2];
  
  iVar1 = libusb_get_active_config_descriptor(param_1,local_20);
  if (iVar1 < 0) {
    FUN_00120cd0(*(undefined8 *)(param_1 + 0x30),1,"libusb_get_max_iso_packet_size",
                 "could not retrieve active config descriptor");
    uVar3 = 0xffffff9d;
  }
  else {
    uVar3 = 0xfffffffb;
    lVar2 = FUN_00120550(*(undefined1 *)(local_20[0] + 4),local_20[0] + 0x10,param_2);
    if (lVar2 != 0) {
      uVar3 = *(ushort *)(lVar2 + 4) & 0x7ff;
      if ((*(byte *)(lVar2 + 3) & 1) != 0) {
        uVar3 = uVar3 * ((*(ushort *)(lVar2 + 4) >> 0xb & 3) + 1);
      }
    }
    libusb_free_config_descriptor(local_20[0]);
  }
  return uVar3;
}


==================================================================

### FUNC 00120fb0 (164 bytes) name=libusb_unref_device

void libusb_unref_device(pthread_mutex_t *param_1)

{
  int iVar1;
  
  if (param_1 != (pthread_mutex_t *)0x0) {
    pthread_mutex_lock(param_1);
    iVar1 = param_1[1].__data.__lock + -1;
    param_1[1].__data.__lock = iVar1;
    pthread_mutex_unlock(param_1);
    if (iVar1 == 0) {
      FUN_00120cd0(0,4,"libusb_unref_device","destroy device %d.%d",
                   *(undefined1 *)((long)param_1 + 0x38),*(undefined1 *)((long)param_1 + 0x48));
      libusb_unref_device(*(undefined8 *)((long)param_1 + 0x40));
      if (PTR_FUN_0033eb38 != (undefined *)0x0) {
        (*(code *)PTR_FUN_0033eb38)(param_1);
      }
      iVar1 = libusb_has_capability(1);
      if (iVar1 == 0) {
        FUN_00120910(param_1);
      }
      pthread_mutex_destroy(param_1);
      free(param_1);
      return;
    }
  }
  return;
}


==================================================================

### FUNC 00121060 (71 bytes) name=libusb_free_device_list

void libusb_free_device_list(long *param_1,int param_2)

{
  long lVar1;
  long *plVar2;
  
  if (param_1 != (long *)0x0) {
    if (param_2 != 0) {
      lVar1 = *param_1;
      plVar2 = param_1;
      while (lVar1 != 0) {
        plVar2 = plVar2 + 1;
        libusb_unref_device();
        lVar1 = *plVar2;
      }
    }
    free(param_1);
    return;
  }
  return;
}


==================================================================

### FUNC 001210b0 (185 bytes) name=FUN_001210b0

ulong * FUN_001210b0(ulong *param_1,undefined8 param_2)

{
  long lVar1;
  ulong *puVar2;
  ulong uVar3;
  ulong uVar4;
  
  uVar4 = *param_1;
  if (param_1[1] <= uVar4) {
    FUN_00120cd0(0,4,"discovered_devs_append","need to increase capacity");
    uVar3 = param_1[1];
    puVar2 = realloc(param_1,uVar3 * 8 + 0x50);
    if (puVar2 == (ulong *)0x0) {
      uVar4 = 0;
      if (*param_1 != 0) {
        do {
          lVar1 = uVar4 + 2;
          uVar4 = uVar4 + 1;
          libusb_unref_device(param_1[lVar1]);
        } while (uVar4 < *param_1);
      }
      free(param_1);
      puVar2 = (ulong *)0x0;
    }
    else {
      puVar2[1] = uVar3 + 8;
      uVar3 = libusb_ref_device(param_2);
      puVar2[uVar4 + 2] = uVar3;
      *puVar2 = *puVar2 + 1;
    }
    return puVar2;
  }
  uVar3 = libusb_ref_device(param_2);
  param_1[uVar4 + 2] = uVar3;
  *param_1 = *param_1 + 1;
  return param_1;
}


==================================================================

### FUNC 00121170 (454 bytes) name=libusb_get_device_list

ulong libusb_get_device_list(long param_1,undefined8 *param_2)

{
  long lVar1;
  int iVar2;
  void *pvVar3;
  undefined8 uVar4;
  ulong uVar5;
  ulong *__ptr;
  ulong uVar6;
  ulong *local_30;
  
  local_30 = malloc(0x50);
  if (local_30 != (ulong *)0x0) {
    *local_30 = 0;
    local_30[1] = 8;
  }
  if (param_1 == 0) {
    param_1 = DAT_003665e8;
  }
  FUN_00120cd0(0,4,"libusb_get_device_list",&DAT_00131fd1);
  if (local_30 == (ulong *)0x0) {
    return 0xfffffffffffffff5;
  }
  iVar2 = libusb_has_capability(1);
  if (iVar2 == 0) {
    iVar2 = (*DAT_0033ea80)(param_1,&local_30);
  }
  else {
    if (PTR_thunk_FUN_0012c710_0033ea88 != (undefined *)0x0) {
      (*(code *)PTR_thunk_FUN_0012c710_0033ea88)();
    }
    pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0x20));
    for (lVar1 = *(long *)(param_1 + 0x18); param_1 + 0x10 != lVar1; lVar1 = *(long *)(lVar1 + 8)) {
      local_30 = (ulong *)FUN_001210b0(local_30,lVar1 + -0x50);
      if (local_30 == (ulong *)0x0) {
        iVar2 = -0xb;
        goto LAB_00121253;
      }
    }
    iVar2 = 0;
LAB_00121253:
    pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0x20));
  }
  __ptr = local_30;
  if (iVar2 < 0) {
    uVar6 = (ulong)iVar2;
  }
  else {
    uVar6 = *local_30;
    pvVar3 = calloc(uVar6 + 1,8);
    if (pvVar3 == (void *)0x0) {
      uVar6 = 0xfffffffffffffff5;
      goto LAB_001212c0;
    }
    *(undefined8 *)((long)pvVar3 + uVar6 * 8) = 0;
    if (0 < (long)uVar6) {
      uVar5 = 0;
      do {
        uVar4 = libusb_ref_device(__ptr[uVar5 + 2]);
        *(undefined8 *)((long)pvVar3 + uVar5 * 8) = uVar4;
        uVar5 = uVar5 + 1;
        __ptr = local_30;
      } while (uVar6 != uVar5);
    }
    *param_2 = pvVar3;
  }
  if (__ptr == (ulong *)0x0) {
    return uVar6;
  }
LAB_001212c0:
  uVar5 = 0;
  if (*__ptr != 0) {
    do {
      lVar1 = uVar5 + 2;
      uVar5 = uVar5 + 1;
      libusb_unref_device(__ptr[lVar1]);
    } while (uVar5 < *__ptr);
  }
  free(__ptr);
  return uVar6;
}


==================================================================

### FUNC 00121360 (83 bytes) name=FUN_00121360

undefined8 FUN_00121360(long param_1)

{
  ssize_t sVar1;
  undefined8 uVar2;
  undefined1 local_9;
  
  local_9 = 1;
  sVar1 = write(*(int *)(param_1 + 0xc),&local_9,1);
  uVar2 = 0;
  if (sVar1 != 1) {
    FUN_00120cd0(param_1,2,"usbi_signal_event","internal signalling write failed");
    uVar2 = 0xffffffff;
  }
  return uVar2;
}


==================================================================

### FUNC 001213c0 (78 bytes) name=FUN_001213c0

undefined8 FUN_001213c0(long param_1)

{
  ssize_t sVar1;
  undefined8 uVar2;
  undefined1 local_9;
  
  sVar1 = read(*(int *)(param_1 + 8),&local_9,1);
  uVar2 = 0;
  if (sVar1 != 1) {
    FUN_00120cd0(param_1,2,"usbi_clear_event","internal signalling read failed");
    uVar2 = 0xffffffff;
  }
  return uVar2;
}


==================================================================

### FUNC 00121420 (358 bytes) name=libusb_wrap_fd

int libusb_wrap_fd(long param_1,undefined4 param_2,undefined8 *param_3)

{
  undefined *puVar1;
  size_t __n;
  int iVar2;
  pthread_mutex_t *__mutex;
  
  __n = DAT_0033eb80;
  FUN_00120cd0(0,4,"libusb_wrap_fd","wrap %d",param_2);
  puVar1 = PTR_FUN_0033ea90;
  if (param_1 == 0) {
    param_1 = DAT_003665e8;
  }
  if (PTR_FUN_0033ea90 == (undefined *)0x0) {
    iVar2 = -0xc;
  }
  else {
    __mutex = malloc(__n + 0x50);
    if (__mutex == (pthread_mutex_t *)0x0) {
      iVar2 = -0xb;
    }
    else {
      iVar2 = pthread_mutex_init(__mutex,(pthread_mutexattr_t *)0x0);
      if (iVar2 == 0) {
        *(undefined8 *)((long)__mutex + 0x40) = 0;
        *(undefined4 *)((long)__mutex + 0x48) = 0;
        __mutex[1].__align = 0;
        memset((void *)((long)__mutex + 0x4c),0,__n);
        iVar2 = (*(code *)puVar1)(param_1,__mutex,param_2);
        if (iVar2 < 0) {
          FUN_00120cd0(0,4,"libusb_wrap_fd","wrap %d returns %d",param_2,iVar2);
          pthread_mutex_destroy(__mutex);
          free(__mutex);
          return iVar2;
        }
        pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0x58));
        *(undefined8 *)((long)__mutex + 0x38) = *(undefined8 *)(param_1 + 0x50);
        *(long *)((long)__mutex + 0x30) = param_1 + 0x48;
        **(long **)(param_1 + 0x50) = (long)__mutex + 0x30;
        *(long *)(param_1 + 0x50) = (long)__mutex + 0x30;
        pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0x58));
        *param_3 = __mutex;
        iVar2 = 0;
      }
      else {
        free(__mutex);
        iVar2 = -99;
      }
    }
  }
  return iVar2;
}


==================================================================

### FUNC 001215a0 (370 bytes) name=libusb_open

int libusb_open(long param_1,undefined8 *param_2)

{
  long lVar1;
  size_t __n;
  int iVar2;
  pthread_mutex_t *__mutex;
  undefined8 uVar3;
  
  __n = DAT_0033eb80;
  lVar1 = *(long *)(param_1 + 0x30);
  FUN_00120cd0(0,4,"libusb_open","open %d.%d",*(undefined1 *)(param_1 + 0x38),
               *(undefined1 *)(param_1 + 0x48));
  iVar2 = -4;
  if (*(int *)(param_1 + 0x7c) != 0) {
    __mutex = malloc(__n + 0x50);
    if (__mutex == (pthread_mutex_t *)0x0) {
      iVar2 = -0xb;
    }
    else {
      iVar2 = pthread_mutex_init(__mutex,(pthread_mutexattr_t *)0x0);
      if (iVar2 == 0) {
        uVar3 = libusb_ref_device(param_1);
        *(undefined8 *)((long)__mutex + 0x40) = uVar3;
        *(undefined4 *)((long)__mutex + 0x48) = 0;
        __mutex[1].__align = 0;
        memset((void *)((long)__mutex + 0x4c),0,__n);
        iVar2 = (*(code *)PTR_FUN_0033ea98)(__mutex);
        if (iVar2 < 0) {
          FUN_00120cd0(0,4,"libusb_open","open %d.%d returns %d",*(undefined1 *)(param_1 + 0x38),
                       *(undefined1 *)(param_1 + 0x48),iVar2);
          libusb_unref_device(param_1);
          pthread_mutex_destroy(__mutex);
          free(__mutex);
          return iVar2;
        }
        pthread_mutex_lock((pthread_mutex_t *)(lVar1 + 0x58));
        *(undefined8 *)((long)__mutex + 0x38) = *(undefined8 *)(lVar1 + 0x50);
        *(long *)((long)__mutex + 0x30) = lVar1 + 0x48;
        **(long **)(lVar1 + 0x50) = (long)__mutex + 0x30;
        *(long *)(lVar1 + 0x50) = (long)__mutex + 0x30;
        pthread_mutex_unlock((pthread_mutex_t *)(lVar1 + 0x58));
        *param_2 = __mutex;
        iVar2 = 0;
      }
      else {
        free(__mutex);
        iVar2 = -99;
      }
    }
  }
  return iVar2;
}


==================================================================

### FUNC 00121730 (191 bytes) name=libusb_open_device_with_vid_pid

undefined8 libusb_open_device_with_vid_pid(undefined8 param_1,short param_2,short param_3)

{
  int iVar1;
  long lVar2;
  long lVar3;
  long *local_58;
  undefined8 local_50;
  undefined1 local_48 [8];
  short local_40;
  short local_3e;
  
  local_50 = 0;
  lVar2 = libusb_get_device_list(param_1,&local_58);
  if (lVar2 < 0) {
    local_50 = 0;
  }
  else {
    lVar2 = *local_58;
    if (lVar2 != 0) {
      lVar3 = 8;
      while (iVar1 = libusb_get_device_descriptor(lVar2,local_48), -1 < iVar1) {
        if ((local_40 == param_2) && (local_3e == param_3)) {
          iVar1 = libusb_open(lVar2,&local_50);
          if (iVar1 < 0) {
            local_50 = 0;
          }
          break;
        }
        lVar2 = *(long *)((long)local_58 + lVar3);
        lVar3 = lVar3 + 8;
        if (lVar2 == 0) break;
      }
    }
    libusb_free_device_list(local_58,1);
  }
  return local_50;
}


==================================================================

### FUNC 00121800 (788 bytes) name=libusb_close

void libusb_close(pthread_mutex_t *param_1)

{
  long lVar1;
  long *plVar2;
  undefined8 *puVar3;
  long *plVar4;
  long *plVar5;
  void *pvVar6;
  
  if (param_1 != (pthread_mutex_t *)0x0) {
    FUN_00120cd0(0,4,"libusb_close",&DAT_00131fd1);
    lVar1 = *(long *)(*(long *)((long)param_1 + 0x40) + 0x30);
    pvVar6 = pthread_getspecific(*(pthread_key_t *)(lVar1 + 0x134));
    if (pvVar6 == (void *)0x0) {
      pthread_mutex_lock((pthread_mutex_t *)(lVar1 + 400));
      if (((*(long *)(lVar1 + 0x1b8) == 0) && (*(long *)(lVar1 + 0x1e8) == lVar1 + 0x1e0)) &&
         (*(long *)(lVar1 + 0x1f8) == lVar1 + 0x1f0)) {
        *(int *)(lVar1 + 0x1bc) = *(int *)(lVar1 + 0x1bc) + 1;
        FUN_00121360(lVar1);
      }
      else {
        *(int *)(lVar1 + 0x1bc) = *(int *)(lVar1 + 0x1bc) + 1;
      }
      pthread_mutex_unlock((pthread_mutex_t *)(lVar1 + 400));
      libusb_lock_events(lVar1);
    }
    pthread_mutex_lock((pthread_mutex_t *)(lVar1 + 200));
    plVar4 = (long *)(*(long **)(lVar1 + 0xc0))[1];
    plVar2 = *(long **)(lVar1 + 0xc0);
    while (plVar5 = plVar4, (long *)(lVar1 + 0xb8) != plVar2) {
      if (param_1 == (pthread_mutex_t *)plVar2[0xd]) {
        pthread_mutex_lock((pthread_mutex_t *)(plVar2 + 8));
        if ((*(byte *)(plVar2 + 7) & 4) == 0) {
          FUN_00120cd0(lVar1,1,"do_close",
                       "Device handle closed while transfer was still being processed, but the device is still connected as far as we know"
                      );
          if ((*(byte *)(plVar2 + 7) & 2) == 0) {
            FUN_00120cd0(lVar1,1,"do_close",
                         "A cancellation hasn\'t even been scheduled on the transfer for which the device is closing"
                        );
          }
          else {
            FUN_00120cd0(lVar1,2,"do_close",
                         "A cancellation for an in-flight transfer hasn\'t completed but closing the device handle"
                        );
          }
        }
        pthread_mutex_unlock((pthread_mutex_t *)(plVar2 + 8));
        plVar4 = (long *)plVar2[1];
        *plVar4 = *plVar2;
        *(long **)(*plVar2 + 8) = plVar4;
        *plVar2 = 0;
        plVar2[1] = 0;
        plVar2[0xd] = 0;
        FUN_00120cd0(0,4,"do_close",
                     "Removed transfer %p from the in-flight list because device handle %p closed",
                     plVar2 + 0xd,param_1);
      }
      plVar4 = (long *)plVar5[1];
      plVar2 = plVar5;
    }
    pthread_mutex_unlock((pthread_mutex_t *)(lVar1 + 200));
    pthread_mutex_lock((pthread_mutex_t *)(lVar1 + 0x58));
    puVar3 = *(undefined8 **)((long)param_1 + 0x38);
    *puVar3 = *(undefined8 *)((long)param_1 + 0x30);
    *(undefined8 **)(*(long *)((long)param_1 + 0x30) + 8) = puVar3;
    *(undefined8 *)((long)param_1 + 0x30) = 0;
    *(undefined8 *)((long)param_1 + 0x38) = 0;
    pthread_mutex_unlock((pthread_mutex_t *)(lVar1 + 0x58));
    (*(code *)PTR_FUN_0033eaa0)(param_1);
    libusb_unref_device(*(undefined8 *)((long)param_1 + 0x40));
    pthread_mutex_destroy(param_1);
    free(param_1);
    if (pvVar6 == (void *)0x0) {
      pthread_mutex_lock((pthread_mutex_t *)(lVar1 + 400));
      *(int *)(lVar1 + 0x1bc) = *(int *)(lVar1 + 0x1bc) + -1;
      if (((*(long *)(lVar1 + 0x1b8) == 0) && (*(long *)(lVar1 + 0x1e8) == lVar1 + 0x1e0)) &&
         (*(long *)(lVar1 + 0x1f8) == lVar1 + 0x1f0)) {
        FUN_001213c0(lVar1);
      }
      pthread_mutex_unlock((pthread_mutex_t *)(lVar1 + 400));
      libusb_unlock_events(lVar1);
      return;
    }
  }
  return;
}


==================================================================

### FUNC 00121b50 (316 bytes) name=libusb_get_configuration

int libusb_get_configuration(long param_1,uint *param_2)

{
  int iVar1;
  byte local_19;
  
  FUN_00120cd0(0,4,"libusb_get_configuration",&DAT_00131fd1);
  if ((PTR_FUN_0033eac8 == (undefined *)0x0) ||
     (iVar1 = (*(code *)PTR_FUN_0033eac8)(param_1,param_2), iVar1 == -0xc)) {
    local_19 = 0;
    FUN_00120cd0(0,4,"libusb_get_configuration","falling back to control message");
    iVar1 = libusb_control_transfer(param_1,0x80,8,0,0,&local_19,1,1000);
    if (iVar1 == 0) {
      FUN_00120cd0(*(undefined8 *)(*(long *)(param_1 + 0x40) + 0x30),1,"libusb_get_configuration",
                   "zero bytes returned in ctrl transfer?");
      return -1;
    }
    if (iVar1 == 1) {
      *param_2 = (uint)local_19;
      goto LAB_00121c18;
    }
    FUN_00120cd0(0,4,"libusb_get_configuration","control failed, error %d",iVar1);
  }
  if (iVar1 != 0) {
    return iVar1;
  }
LAB_00121c18:
  FUN_00120cd0(0,4,"libusb_get_configuration","active config %d",*param_2);
  return 0;
}


==================================================================

### FUNC 00121ca0 (66 bytes) name=libusb_set_configuration

/* WARNING: Switch with 1 destination removed at 0x00121ce0 */

undefined8 libusb_set_configuration(long param_1,undefined4 param_2)

{
  int iVar1;
  long lVar2;
  int iVar3;
  int *piVar4;
  undefined8 uVar5;
  undefined8 uStack_20;
  
  uStack_20 = 0x121cca;
  FUN_00120cd0(0,4,"libusb_set_configuration","configuration %d",param_2);
  lVar2 = *(long *)(param_1 + 0x40);
  uStack_20._4_4_ = param_2;
  iVar3 = ioctl(*(int *)(param_1 + 0x4c),0x80045505,(long)&uStack_20 + 4);
  if (iVar3 == 0) {
    *(undefined4 *)(lVar2 + 0x94) = uStack_20._4_4_;
    uVar5 = 0;
  }
  else {
    piVar4 = __errno_location();
    iVar1 = *piVar4;
    if (iVar1 == 0x16) {
      uVar5 = 0xfffffffb;
    }
    else if (iVar1 == 0x10) {
      uVar5 = 0xfffffffa;
    }
    else {
      uVar5 = 0xfffffffc;
      if (iVar1 != 0x13) {
        FUN_00120cd0(*(undefined8 *)(*(long *)(param_1 + 0x40) + 0x30),1,"op_set_configuration",
                     "failed, error %d errno %d",iVar3);
        return 0xffffff9d;
      }
    }
  }
  return uVar5;
}


==================================================================

### FUNC 00121cf0 (153 bytes) name=libusb_claim_interface

int libusb_claim_interface(pthread_mutex_t *param_1,int param_2)

{
  int iVar1;
  ulong uVar2;
  
  FUN_00120cd0(0,4,"libusb_claim_interface","interface %d",param_2);
  if (param_2 < 0x20) {
    iVar1 = -4;
    if (*(int *)(*(long *)((long)param_1 + 0x40) + 0x7c) != 0) {
      iVar1 = 0;
      pthread_mutex_lock(param_1);
      uVar2 = (ulong)(1 << ((byte)param_2 & 0x1f));
      if ((param_1[1].__align & uVar2) == 0) {
        iVar1 = (*(code *)PTR_FUN_0033ead8)(param_1,param_2);
        if (iVar1 == 0) {
          param_1[1].__align = param_1[1].__align | uVar2;
        }
      }
      pthread_mutex_unlock(param_1);
    }
  }
  else {
    iVar1 = -2;
  }
  return iVar1;
}


==================================================================

### FUNC 00121da0 (149 bytes) name=libusb_release_interface

int libusb_release_interface(pthread_mutex_t *param_1,int param_2)

{
  int iVar1;
  uint uVar2;
  
  FUN_00120cd0(0,4,"libusb_release_interface","interface %d",param_2);
  iVar1 = -2;
  if (param_2 < 0x20) {
    iVar1 = -5;
    pthread_mutex_lock(param_1);
    uVar2 = 1 << ((byte)param_2 & 0x1f);
    if ((param_1[1].__align & (long)(int)uVar2) != 0) {
      iVar1 = (*(code *)PTR_FUN_0033eae0)(param_1,param_2);
      if (iVar1 == 0) {
        param_1[1].__align = param_1[1].__align & (long)(int)~uVar2;
      }
    }
    pthread_mutex_unlock(param_1);
  }
  return iVar1;
}


==================================================================

### FUNC 00121e40 (160 bytes) name=libusb_set_interface_alt_setting

/* WARNING: Switch with 1 destination removed at 0x00121eb9 */

undefined8 libusb_set_interface_alt_setting(pthread_mutex_t *param_1,int param_2,undefined4 param_3)

{
  int iVar1;
  undefined8 uVar2;
  int *piVar3;
  int iStack_28;
  undefined4 uStack_24;
  undefined8 uStack_20;
  
  uStack_20 = 0x121e6e;
  FUN_00120cd0(0,4,"libusb_set_interface_alt_setting","interface %d altsetting %d",param_2,param_3);
  if (param_2 < 0x20) {
    uStack_20 = 0x121e7b;
    pthread_mutex_lock(param_1);
    if (*(int *)(*(long *)((long)param_1 + 0x40) + 0x7c) == 0) {
      uStack_20 = 0x121ee8;
      pthread_mutex_unlock(param_1);
      uVar2 = 0xfffffffc;
    }
    else {
      if ((param_1[1].__align & (long)(1 << ((byte)param_2 & 0x1f))) != 0) {
        uStack_20 = 0x121e9f;
        pthread_mutex_unlock(param_1);
        iStack_28 = param_2;
        uStack_24 = param_3;
        iVar1 = ioctl(*(int *)((long)param_1 + 0x4c),0x80085504,&iStack_28);
        uVar2 = 0;
        if (iVar1 != 0) {
          piVar3 = __errno_location();
          if (*piVar3 == 0x16) {
            uVar2 = 0xfffffffb;
          }
          else {
            uVar2 = 0xfffffffc;
            if (*piVar3 != 0x13) {
              FUN_00120cd0(*(undefined8 *)(*(long *)((long)param_1 + 0x40) + 0x30),1,
                           "op_set_interface","setintf failed error %d errno %d",iVar1);
              uVar2 = 0xffffff9d;
            }
          }
        }
        return uVar2;
      }
      uStack_20 = 0x121ed5;
      pthread_mutex_unlock(param_1);
      uVar2 = 0xfffffffb;
    }
  }
  else {
    uVar2 = 0xfffffffe;
  }
  return uVar2;
}


==================================================================

### FUNC 00121ef0 (94 bytes) name=libusb_clear_halt

/* WARNING: Switch with 1 destination removed at 0x00121f40 */

undefined8 libusb_clear_halt(long param_1,undefined1 param_2)

{
  int iVar1;
  int *piVar2;
  undefined8 uVar3;
  undefined8 uStack_20;
  
  uStack_20 = 0x121f1c;
  FUN_00120cd0(0,4,"libusb_clear_halt","endpoint %x",param_2);
  if (*(int *)(*(long *)(param_1 + 0x40) + 0x7c) == 0) {
    return 0xfffffffc;
  }
  uStack_20 = (ulong)CONCAT14(param_2,(undefined4)uStack_20);
  iVar1 = ioctl(*(int *)(param_1 + 0x4c),0x80045515,(long)&uStack_20 + 4);
  uVar3 = 0;
  if (iVar1 != 0) {
    piVar2 = __errno_location();
    if (*piVar2 == 2) {
      uVar3 = 0xfffffffb;
    }
    else {
      uVar3 = 0xfffffffc;
      if (*piVar2 != 0x13) {
        FUN_00120cd0(*(undefined8 *)(*(long *)(param_1 + 0x40) + 0x30),1,"op_clear_halt",
                     "clear_halt failed error %d errno %d",iVar1);
        uVar3 = 0xffffff9d;
      }
    }
  }
  return uVar3;
}


==================================================================

### FUNC 00121f60 (70 bytes) name=libusb_reset_device

/* WARNING: Switch with 1 destination removed at 0x00121f9d */

undefined8 libusb_reset_device(pthread_mutex_t *param_1)

{
  int iVar1;
  int iVar2;
  int *piVar3;
  undefined8 uVar4;
  int iVar5;
  ulong uVar6;
  undefined8 uVar7;
  
  FUN_00120cd0(0,4,"libusb_reset_device",&DAT_00131fd1);
  if (*(int *)(*(long *)((long)param_1 + 0x40) + 0x7c) == 0) {
    return 0xfffffffc;
  }
  iVar1 = *(int *)((long)param_1 + 0x4c);
  iVar2 = 0;
  do {
    while ((param_1[1].__align & 1L << ((byte)iVar2 & 0x3f)) == 0) {
      iVar2 = iVar2 + 1;
      if (iVar2 == 0x20) goto LAB_00129708;
    }
    iVar5 = iVar2 + 1;
    FUN_00127c80(param_1,iVar2);
    iVar2 = iVar5;
  } while (iVar5 != 0x20);
LAB_00129708:
  pthread_mutex_lock(param_1);
  iVar1 = ioctl(iVar1,0x5514,0);
  if (iVar1 == 0) {
    uVar7 = 0;
    iVar1 = 0;
    do {
      uVar6 = 1L << ((byte)iVar1 & 0x3f);
      if (((param_1[1].__align & uVar6) != 0) && (iVar2 = FUN_001295a0(param_1,iVar1), iVar2 != 0))
      {
        uVar7 = 0xfffffffb;
        uVar4 = libusb_error_name(iVar2);
        FUN_00120cd0(*(undefined8 *)(*(long *)((long)param_1 + 0x40) + 0x30),2,"op_reset_device",
                     "failed to re-claim interface %d after reset: %s",iVar1,uVar4);
        param_1[1].__align = param_1[1].__align & ~uVar6;
      }
      iVar1 = iVar1 + 1;
    } while (iVar1 != 0x20);
  }
  else {
    piVar3 = __errno_location();
    uVar7 = 0xfffffffb;
    if (*piVar3 != 0x13) {
      uVar7 = 0xffffff9d;
      FUN_00120cd0(*(undefined8 *)(*(long *)((long)param_1 + 0x40) + 0x30),1,"op_reset_device",
                   "reset failed error %d errno %d",iVar1);
    }
  }
  pthread_mutex_unlock(param_1);
  return uVar7;
}


==================================================================

### FUNC 00121fb0 (131 bytes) name=libusb_alloc_streams

undefined8
libusb_alloc_streams(long param_1,undefined4 param_2,undefined8 param_3,undefined4 param_4)

{
  undefined8 uVar1;
  
  FUN_00120cd0(0,4,"libusb_alloc_streams","streams %u eps %d",param_2,param_4);
  if (*(int *)(*(long *)(param_1 + 0x40) + 0x7c) == 0) {
    uVar1 = 0xfffffffc;
  }
  else {
    switch(PTR_FUN_0033eb00) {
    case (undefined *)0x128900:
      uVar1 = FUN_001287c0(param_1,0x8008551c,param_2,param_3,param_4);
      return uVar1;
    default:
      uVar1 = 0xfffffff4;
    }
  }
  return uVar1;
}


==================================================================

### FUNC 00122040 (104 bytes) name=libusb_free_streams

undefined8 libusb_free_streams(long param_1,undefined8 param_2,undefined4 param_3)

{
  undefined8 uVar1;
  
  FUN_00120cd0(0,4,"libusb_free_streams","eps %d",param_3);
  if (*(int *)(*(long *)(param_1 + 0x40) + 0x7c) == 0) {
    uVar1 = 0xfffffffc;
  }
  else {
    switch(PTR_FUN_0033eb08) {
    case (undefined *)0x1288e0:
      uVar1 = FUN_001287c0(param_1,0x8008551d,0,param_2,param_3);
      return uVar1;
    default:
      uVar1 = 0xfffffff4;
    }
  }
  return uVar1;
}


==================================================================

### FUNC 001220c0 (104 bytes) name=libusb_kernel_driver_active

ulong libusb_kernel_driver_active(long param_1,undefined4 param_2)

{
  int iVar1;
  ulong uVar2;
  int *piVar3;
  long lVar4;
  char *pcVar5;
  char *pcVar6;
  long in_FS_OFFSET;
  bool bVar7;
  byte bVar8;
  undefined4 uStack_128;
  char acStack_124 [260];
  long lStack_20;
  
  bVar8 = 0;
  lStack_20 = 0x1220ea;
  FUN_00120cd0(0,4,"libusb_kernel_driver_active","interface %d",param_2);
  if (*(int *)(*(long *)(param_1 + 0x40) + 0x7c) == 0) {
    uVar2 = 0xfffffffc;
  }
  else {
    switch(PTR_FUN_0033eb20) {
    case (undefined *)0x128040:
      lStack_20 = *(long *)(in_FS_OFFSET + 0x28);
      uStack_128 = param_2;
      iVar1 = ioctl(*(int *)(param_1 + 0x4c),0x41045508,&uStack_128);
      if (iVar1 == 0) {
        lVar4 = 6;
        bVar7 = true;
        pcVar5 = acStack_124;
        pcVar6 = "usbfs";
        do {
          if (lVar4 == 0) break;
          lVar4 = lVar4 + -1;
          bVar7 = *pcVar5 == *pcVar6;
          pcVar5 = pcVar5 + (ulong)bVar8 * -2 + 1;
          pcVar6 = pcVar6 + (ulong)bVar8 * -2 + 1;
        } while (bVar7);
        uVar2 = (ulong)!bVar7;
      }
      else {
        piVar3 = __errno_location();
        if (*piVar3 == 0x3d) {
          uVar2 = 0;
        }
        else {
          uVar2 = 0xfffffffc;
          if (*piVar3 != 0x13) {
            FUN_00120cd0(*(undefined8 *)(*(long *)(param_1 + 0x40) + 0x30),1,
                         "op_kernel_driver_active","get driver failed error %d errno %d",iVar1);
            uVar2 = 0xffffff9d;
          }
        }
      }
      if (lStack_20 != *(long *)(in_FS_OFFSET + 0x28)) {
                    /* WARNING: Subroutine does not return */
        __stack_chk_fail();
      }
      return uVar2;
    default:
      uVar2 = 0xfffffff4;
    }
  }
  return uVar2;
}


==================================================================

### FUNC 00122130 (104 bytes) name=libusb_detach_kernel_driver

undefined8 libusb_detach_kernel_driver(long param_1,undefined4 param_2)

{
  int iVar1;
  int iVar2;
  int *piVar3;
  undefined8 uVar4;
  long lVar5;
  char *pcVar6;
  char *pcVar7;
  long in_FS_OFFSET;
  bool bVar8;
  byte bVar9;
  undefined4 uStack_138;
  undefined4 uStack_134;
  undefined8 uStack_130;
  undefined4 uStack_128;
  char acStack_124 [260];
  long lStack_20;
  
  bVar9 = 0;
  lStack_20 = 0x12215a;
  FUN_00120cd0(0,4,"libusb_detach_kernel_driver","interface %d",param_2);
  if (*(int *)(*(long *)(param_1 + 0x40) + 0x7c) == 0) {
    return 0xfffffffc;
  }
  switch(PTR_FUN_0033eb28) {
  case (undefined *)0x127f30:
    break;
  default:
    return 0xfffffff4;
  }
  iVar2 = *(int *)(param_1 + 0x4c);
  lStack_20 = *(long *)(in_FS_OFFSET + 0x28);
  uStack_134 = 0x5516;
  uStack_130 = 0;
  uStack_138 = param_2;
  uStack_128 = param_2;
  iVar1 = ioctl(iVar2,0x41045508,&uStack_128);
  bVar8 = iVar1 == 0;
  if (bVar8) {
    lVar5 = 6;
    pcVar6 = acStack_124;
    pcVar7 = "usbfs";
    do {
      if (lVar5 == 0) break;
      lVar5 = lVar5 + -1;
      bVar8 = *pcVar6 == *pcVar7;
      pcVar6 = pcVar6 + (ulong)bVar9 * -2 + 1;
      pcVar7 = pcVar7 + (ulong)bVar9 * -2 + 1;
    } while (bVar8);
    if (!bVar8) goto LAB_00127f9c;
  }
  else {
LAB_00127f9c:
    iVar2 = ioctl(iVar2,0xc0105512,&uStack_138);
    uVar4 = 0;
    if (iVar2 == 0) goto LAB_00127fff;
    piVar3 = __errno_location();
    iVar1 = *piVar3;
    if (iVar1 != 0x3d) {
      if (iVar1 == 0x16) {
        uVar4 = 0xfffffffe;
      }
      else {
        uVar4 = 0xfffffffc;
        if (iVar1 != 0x13) {
          FUN_00120cd0(*(undefined8 *)(*(long *)(param_1 + 0x40) + 0x30),1,"op_detach_kernel_driver"
                       ,"detach failed error %d errno %d",iVar2);
          uVar4 = 0xffffff9d;
        }
      }
      goto LAB_00127fff;
    }
  }
  uVar4 = 0xfffffffb;
LAB_00127fff:
  if (lStack_20 == *(long *)(in_FS_OFFSET + 0x28)) {
    return uVar4;
  }
                    /* WARNING: Subroutine does not return */
  __stack_chk_fail();
}


==================================================================

### FUNC 001221a0 (104 bytes) name=libusb_attach_kernel_driver

uint libusb_attach_kernel_driver(long param_1,undefined4 param_2)

{
  int iVar1;
  int iVar2;
  uint uVar3;
  int *piVar4;
  undefined4 uStack_28;
  undefined4 uStack_24;
  undefined8 uStack_20;
  
  uStack_20 = 0x1221ca;
  FUN_00120cd0(0,4,"libusb_attach_kernel_driver","interface %d",param_2);
  if (*(int *)(*(long *)(param_1 + 0x40) + 0x7c) == 0) {
    uVar3 = 0xfffffffc;
  }
  else {
    switch(PTR_FUN_0033eb30) {
    case (undefined *)0x127bc0:
      uStack_24 = 0x5517;
      uStack_20 = 0;
      uStack_28 = param_2;
      iVar2 = ioctl(*(int *)(param_1 + 0x4c),0xc0105512,&uStack_28);
      if (iVar2 < 0) {
        piVar4 = __errno_location();
        iVar1 = *piVar4;
        if (iVar1 == 0x3d) {
          uVar3 = 0xfffffffb;
        }
        else if (iVar1 == 0x16) {
          uVar3 = 0xfffffffe;
        }
        else if (iVar1 == 0x13) {
          uVar3 = 0xfffffffc;
        }
        else {
          uVar3 = 0xfffffffa;
          if (iVar1 != 0x10) {
            FUN_00120cd0(*(undefined8 *)(*(long *)(param_1 + 0x40) + 0x30),1,
                         "op_attach_kernel_driver","attach failed error %d errno %d",iVar2);
            return 0xffffff9d;
          }
        }
      }
      else {
        uVar3 = -(uint)(iVar2 == 0) & 0xfffffffb;
      }
      return uVar3;
    default:
      uVar3 = 0xfffffff4;
    }
  }
  return uVar3;
}


==================================================================

### FUNC 00122210 (973 bytes) name=libusb_init

int libusb_init(undefined8 *param_1)

{
  pthread_mutex_t *__mutex;
  long *plVar1;
  undefined8 *puVar2;
  long *plVar3;
  long *plVar4;
  long *plVar5;
  int iVar6;
  char *__nptr;
  int *__ptr;
  long lVar7;
  
  __nptr = getenv("LIBUSB_DEBUG");
  pthread_mutex_lock((pthread_mutex_t *)&DAT_00366620);
  if (DAT_00366600 == 0) {
    gettimeofday((timeval *)&DAT_00366600,(__timezone_ptr_t)0x0);
  }
  if ((param_1 == (undefined8 *)0x0) && (DAT_003665e8 != (int *)0x0)) {
    FUN_00120cd0(0,4,"libusb_init","reusing default context");
    DAT_00366648 = DAT_00366648 + 1;
    pthread_mutex_unlock((pthread_mutex_t *)&DAT_00366620);
    return 0;
  }
  __ptr = calloc(1,0x218);
  if (__ptr == (int *)0x0) {
    iVar6 = -0xb;
  }
  else {
    if (__nptr != (char *)0x0) {
      lVar7 = strtol(__nptr,(char **)0x0,10);
      *__ptr = (int)lVar7;
      if ((int)lVar7 != 0) {
        __ptr[1] = 1;
      }
    }
    if (DAT_003665e8 == (int *)0x0) {
      DAT_00366648 = DAT_00366648 + 1;
      DAT_003665e8 = __ptr;
      FUN_00120cd0(0,4,"libusb_init","created default context");
    }
    __mutex = (pthread_mutex_t *)(__ptr + 8);
    plVar1 = (long *)(__ptr + 4);
    FUN_00120cd0(0,4,"libusb_init","libusb v%u.%u.%u.%u%s",1,0,0x15,0x2b94,&DAT_00131fd1);
    pthread_mutex_init(__mutex,(pthread_mutexattr_t *)0x0);
    pthread_mutex_init((pthread_mutex_t *)(__ptr + 0x16),(pthread_mutexattr_t *)0x0);
    pthread_mutex_init((pthread_mutex_t *)(__ptr + 0x24),(pthread_mutexattr_t *)0x0);
    *(long **)(__ptr + 6) = plVar1;
    *(long **)(__ptr + 4) = plVar1;
    *(int **)(__ptr + 0x14) = __ptr + 0x12;
    *(int **)(__ptr + 0x12) = __ptr + 0x12;
    *(int **)(__ptr + 0x22) = __ptr + 0x20;
    *(int **)(__ptr + 0x20) = __ptr + 0x20;
    pthread_mutex_lock((pthread_mutex_t *)&DAT_003665c0);
    if (DAT_0033f5e4 != 0) {
      DAT_003666e8 = (int *)&DAT_003666e0;
      DAT_0033f5e4 = 0;
      DAT_003666e0 = &DAT_003666e0;
    }
    *(int **)(__ptr + 0x84) = DAT_003666e8;
    *(undefined8 ***)(__ptr + 0x82) = &DAT_003666e0;
    *(int **)DAT_003666e8 = __ptr + 0x82;
    DAT_003666e8 = __ptr + 0x82;
    pthread_mutex_unlock((pthread_mutex_t *)&DAT_003665c0);
    if ((PTR_FUN_0033ea70 == (undefined *)0x0) ||
       (iVar6 = (*(code *)PTR_FUN_0033ea70)(__ptr), iVar6 == 0)) {
      iVar6 = FUN_001269e0(__ptr);
      if (-1 < iVar6) {
        pthread_mutex_unlock((pthread_mutex_t *)&DAT_00366620);
        if (param_1 == (undefined8 *)0x0) {
          return 0;
        }
        *param_1 = __ptr;
        return 0;
      }
      if (PTR_FUN_0033ea78 != (undefined *)0x0) {
        (*(code *)PTR_FUN_0033ea78)();
      }
    }
    if (__ptr == DAT_003665e8) {
      DAT_003665e8 = (int *)0x0;
      DAT_00366648 = DAT_00366648 + -1;
    }
    pthread_mutex_lock((pthread_mutex_t *)&DAT_003665c0);
    puVar2 = *(undefined8 **)(__ptr + 0x84);
    *puVar2 = *(undefined8 *)(__ptr + 0x82);
    *(undefined8 **)(*(long *)(__ptr + 0x82) + 8) = puVar2;
    __ptr[0x82] = 0;
    __ptr[0x83] = 0;
    __ptr[0x84] = 0;
    __ptr[0x85] = 0;
    pthread_mutex_unlock((pthread_mutex_t *)&DAT_003665c0);
    pthread_mutex_lock(__mutex);
    plVar5 = (long *)(*(long **)(__ptr + 6))[1];
    plVar4 = *(long **)(__ptr + 6);
    while (plVar3 = plVar5, plVar1 != plVar4) {
      *plVar3 = *plVar4;
      *(long **)(*plVar4 + 8) = plVar3;
      *plVar4 = 0;
      plVar4[1] = 0;
      libusb_unref_device();
      plVar5 = (long *)plVar3[1];
      plVar4 = plVar3;
    }
    pthread_mutex_unlock(__mutex);
    pthread_mutex_destroy((pthread_mutex_t *)(__ptr + 0x16));
    pthread_mutex_destroy(__mutex);
    pthread_mutex_destroy((pthread_mutex_t *)(__ptr + 0x24));
    free(__ptr);
  }
  pthread_mutex_unlock((pthread_mutex_t *)&DAT_00366620);
  return iVar6;
}


==================================================================

### FUNC 00122600 (627 bytes) name=libusb_exit

void libusb_exit(void *param_1)

{
  undefined8 *puVar1;
  long *plVar2;
  long *plVar3;
  long *plVar4;
  int iVar5;
  undefined8 local_38;
  undefined8 local_30;
  
  local_38 = 0;
  local_30 = 0;
  FUN_00120cd0(0,4,"libusb_exit",&DAT_00131fd1);
  if (param_1 == (void *)0x0) {
    param_1 = DAT_003665e8;
  }
  pthread_mutex_lock((pthread_mutex_t *)&DAT_00366620);
  if (param_1 == DAT_003665e8) {
    DAT_00366648 = DAT_00366648 + -1;
    if (0 < DAT_00366648) {
      FUN_00120cd0(0,4,"libusb_exit","not destroying default context");
      pthread_mutex_unlock((pthread_mutex_t *)&DAT_00366620);
      return;
    }
    FUN_00120cd0(0,4,"libusb_exit","destroying default context");
    DAT_003665e8 = (void *)0x0;
  }
  pthread_mutex_unlock((pthread_mutex_t *)&DAT_00366620);
  pthread_mutex_lock((pthread_mutex_t *)&DAT_003665c0);
  puVar1 = *(undefined8 **)((long)param_1 + 0x210);
  *puVar1 = *(undefined8 *)((long)param_1 + 0x208);
  *(undefined8 **)(*(long *)((long)param_1 + 0x208) + 8) = puVar1;
  *(undefined8 *)((long)param_1 + 0x208) = 0;
  *(undefined8 *)((long)param_1 + 0x210) = 0;
  pthread_mutex_unlock((pthread_mutex_t *)&DAT_003665c0);
  iVar5 = libusb_has_capability(1);
  if (iVar5 != 0) {
    FUN_00124af0(param_1);
    if (*(long *)((long)param_1 + 0x50) == (long)param_1 + 0x48) {
      libusb_handle_events_timeout(param_1,&local_38);
    }
    pthread_mutex_lock((pthread_mutex_t *)((long)param_1 + 0x20));
    plVar4 = (long *)(*(long **)((long)param_1 + 0x18))[1];
    plVar3 = *(long **)((long)param_1 + 0x18);
    while (plVar2 = plVar4, (long *)((long)param_1 + 0x10) != plVar3) {
      *plVar2 = *plVar3;
      *(long **)(*plVar3 + 8) = plVar2;
      *plVar3 = 0;
      plVar3[1] = 0;
      libusb_unref_device();
      plVar4 = (long *)plVar2[1];
      plVar3 = plVar2;
    }
    pthread_mutex_unlock((pthread_mutex_t *)((long)param_1 + 0x20));
  }
  if (*(long *)((long)param_1 + 0x18) != (long)param_1 + 0x10) {
    FUN_00120cd0(param_1,2,"libusb_exit","some libusb_devices were leaked");
  }
  if ((long)param_1 + 0x48 != *(long *)((long)param_1 + 0x50)) {
    FUN_00120cd0(param_1,2,"libusb_exit","application left some devices open");
  }
  FUN_00126c20(param_1);
  if (PTR_FUN_0033ea78 != (undefined *)0x0) {
    (*(code *)PTR_FUN_0033ea78)();
  }
  pthread_mutex_destroy((pthread_mutex_t *)((long)param_1 + 0x58));
  pthread_mutex_destroy((pthread_mutex_t *)((long)param_1 + 0x20));
  pthread_mutex_destroy((pthread_mutex_t *)((long)param_1 + 0x90));
  free(param_1);
  return;
}


==================================================================

### FUNC 00122890 (196 bytes) name=libusb_error_name

char * libusb_error_name(undefined4 param_1)

{
  switch(param_1) {
  case 0:
    return "LIBUSB_SUCCESS / LIBUSB_TRANSFER_COMPLETED";
  case 1:
    return "LIBUSB_TRANSFER_ERROR";
  case 2:
    return "LIBUSB_TRANSFER_TIMED_OUT";
  case 3:
    return "LIBUSB_TRANSFER_CANCELLED";
  case 4:
    return "LIBUSB_TRANSFER_STALL";
  case 5:
    return "LIBUSB_TRANSFER_NO_DEVICE";
  case 6:
    return "LIBUSB_TRANSFER_OVERFLOW";
  case 0xffffff9d:
    return "LIBUSB_ERROR_OTHER";
  default:
    return "**UNKNOWN**";
  case 0xfffffff4:
    return "LIBUSB_ERROR_NOT_SUPPORTED";
  case 0xfffffff5:
    return "LIBUSB_ERROR_NO_MEM";
  case 0xfffffff6:
    return "LIBUSB_ERROR_INTERRUPTED";
  case 0xfffffff7:
    return "LIBUSB_ERROR_PIPE";
  case 0xfffffff8:
    return "LIBUSB_ERROR_OVERFLOW";
  case 0xfffffff9:
    return "LIBUSB_ERROR_TIMEOUT";
  case 0xfffffffa:
    return "LIBUSB_ERROR_BUSY";
  case 0xfffffffb:
    return "LIBUSB_ERROR_NOT_FOUND";
  case 0xfffffffc:
    return "LIBUSB_ERROR_NO_DEVICE";
  case 0xfffffffd:
    return "LIBUSB_ERROR_ACCESS";
  case 0xfffffffe:
    return "LIBUSB_ERROR_INVALID_PARAM";
  case 0xffffffff:
    return "LIBUSB_ERROR_IO";
  }
}


==================================================================

### FUNC 00122a00 (8 bytes) name=libusb_get_version

undefined * libusb_get_version(void)

{
  return &DAT_0033ea30;
}


==================================================================

### FUNC 00122a10 (169 bytes) name=FUN_00122a10

void FUN_00122a10(long *param_1)

{
  long lVar1;
  int iVar2;
  long lVar3;
  void *__ptr;
  void *__ptr_00;
  int iVar4;
  long lVar5;
  
  __ptr_00 = (void *)*param_1;
  if ((__ptr_00 != (void *)0x0) && (0 < (int)param_1[1])) {
    lVar5 = 0;
    iVar4 = 0;
    do {
      free(*(void **)((long)__ptr_00 + lVar5 + 0x18));
      __ptr = *(void **)((long)__ptr_00 + lVar5 + 0x10);
      if ((__ptr != (void *)0x0) && (*(char *)((long)__ptr_00 + lVar5 + 4) != '\0')) {
        lVar3 = 0;
        iVar2 = 0;
        do {
          lVar1 = lVar3 + 0x10;
          iVar2 = iVar2 + 1;
          lVar3 = lVar3 + 0x20;
          free(*(void **)((long)__ptr + lVar1));
          __ptr = *(void **)((long)__ptr_00 + lVar5 + 0x10);
        } while (iVar2 < (int)(uint)*(byte *)((long)__ptr_00 + lVar5 + 4));
      }
      free(__ptr);
      iVar4 = iVar4 + 1;
      lVar5 = lVar5 + 0x28;
      __ptr_00 = (void *)*param_1;
    } while (iVar4 < (int)param_1[1]);
  }
  free(__ptr_00);
  *param_1 = 0;
  return;
}


==================================================================

### FUNC 00122ac0 (81 bytes) name=FUN_00122ac0

void FUN_00122ac0(long param_1)

{
  int iVar1;
  long lVar2;
  long lVar3;
  void *__ptr;
  
  __ptr = *(void **)(param_1 + 0x10);
  if ((__ptr != (void *)0x0) && (*(char *)(param_1 + 4) != '\0')) {
    lVar2 = 0;
    iVar1 = 0;
    do {
      lVar3 = (long)__ptr + lVar2;
      iVar1 = iVar1 + 1;
      lVar2 = lVar2 + 0x10;
      FUN_00122a10(lVar3);
      __ptr = *(void **)(param_1 + 0x10);
    } while (iVar1 < (int)(uint)*(byte *)(param_1 + 4));
  }
  free(__ptr);
  free(*(void **)(param_1 + 0x18));
  return;
}


==================================================================

### FUNC 00122b20 (262 bytes) name=FUN_00122b20

int FUN_00122b20(uint *param_1,char *param_2,uint *param_3,int param_4)

{
  uint uVar1;
  uint *puVar2;
  byte *pbVar3;
  uint *puVar4;
  int iVar5;
  char cVar6;
  
  iVar5 = (int)param_1;
  cVar6 = *param_2;
  if (cVar6 == '\0') {
    return 0;
  }
  do {
    if (cVar6 == 'd') {
      param_3 = (uint *)((long)param_3 + (ulong)((uint)param_3 & 1));
      if (param_4 == 0) {
        *param_3 = (uint)*(byte *)((long)param_1 + 3) << 0x18 |
                   (uint)*(byte *)((long)param_1 + 2) << 0x10 | (uint)(byte)*param_1 |
                   (uint)*(byte *)((long)param_1 + 1) << 8;
      }
      else {
        *param_3 = *param_1;
      }
      puVar2 = param_1 + 1;
      puVar4 = param_3 + 1;
LAB_00122b76:
      cVar6 = param_2[1];
      param_1 = puVar2;
      param_3 = puVar4;
    }
    else {
      puVar2 = param_1;
      puVar4 = param_3;
      if ('d' < cVar6) {
        if (cVar6 == 'u') {
          puVar4 = param_3 + 4;
          puVar2 = param_1 + 4;
          *(undefined8 *)param_3 = *(undefined8 *)param_1;
          *(undefined8 *)(param_3 + 2) = *(undefined8 *)(param_1 + 2);
        }
        else if (cVar6 == 'w') {
          pbVar3 = (byte *)((long)param_3 + (ulong)((uint)param_3 & 1));
          if (param_4 == 0) {
            *(short *)pbVar3 = (short)*param_1;
          }
          else {
            *(short *)pbVar3 = (short)*param_1;
          }
          puVar2 = (uint *)((long)param_1 + 2);
          puVar4 = (uint *)(pbVar3 + 2);
        }
        goto LAB_00122b76;
      }
      if (cVar6 != 'b') goto LAB_00122b76;
      uVar1 = *param_1;
      param_1 = (uint *)((long)param_1 + 1);
      *(byte *)param_3 = (byte)uVar1;
      cVar6 = param_2[1];
      param_3 = (uint *)((long)param_3 + 1);
    }
    param_2 = param_2 + 1;
    if (cVar6 == '\0') {
      return (int)param_1 - iVar5;
    }
  } while( true );
}


==================================================================

### FUNC 00122c40 (2570 bytes) name=FUN_00122c40

int FUN_00122c40(undefined8 param_1,long param_2,uint param_3,undefined4 param_4,undefined8 *param_5
                )

{
  byte *pbVar1;
  byte bVar2;
  byte *__ptr;
  void *pvVar3;
  void *pvVar4;
  char *pcVar5;
  char *pcVar6;
  ulong uVar7;
  void *pvVar8;
  int iVar9;
  uint uVar10;
  uint uVar11;
  void *pvVar12;
  int iVar13;
  int iVar14;
  undefined8 *local_d8;
  void *local_c8;
  void *local_c0;
  int local_b0;
  int local_ac;
  uint local_a8;
  int local_a0;
  int local_80;
  byte local_68;
  char local_67;
  byte local_58;
  char local_57;
  byte local_48;
  char local_47;
  
  __ptr = malloc(0x28);
  if (__ptr == (byte *)0x0) {
    return -0xb;
  }
  uVar11 = 9;
  pcVar5 = "short config descriptor read %d/%d";
  uVar10 = param_3;
  if (8 < (int)param_3) {
    FUN_00122b20(param_2,"bbwbbbbb",__ptr,param_4,param_3,9);
    uVar10 = (uint)__ptr[1];
    if (__ptr[1] == 2) {
      bVar2 = *__ptr;
      uVar7 = (ulong)bVar2;
      if (bVar2 < 9) {
        pcVar5 = "invalid config bLength (%d)";
      }
      else {
        uVar11 = (uint)bVar2;
        if ((int)param_3 < (int)(uint)bVar2) {
          pcVar5 = "short config descriptor read %d/%d";
          uVar10 = param_3;
          goto LAB_0012352f;
        }
        bVar2 = __ptr[4];
        if (bVar2 < 0x21) {
          local_d8 = calloc((ulong)bVar2,0x10);
          *(undefined8 **)(__ptr + 0x10) = local_d8;
          if (local_d8 == (undefined8 *)0x0) {
            iVar14 = -0xb;
          }
          else {
            pvVar8 = (void *)(uVar7 + param_2);
            __ptr[0x18] = 0;
            __ptr[0x19] = 0;
            __ptr[0x1a] = 0;
            __ptr[0x1b] = 0;
            __ptr[0x1c] = 0;
            __ptr[0x1d] = 0;
            __ptr[0x1e] = 0;
            __ptr[0x1f] = 0;
            iVar14 = param_3 - uVar11;
            __ptr[0x20] = 0;
            __ptr[0x21] = 0;
            __ptr[0x22] = 0;
            __ptr[0x23] = 0;
            if (bVar2 != 0) {
              local_80 = 0;
              do {
                pvVar12 = pvVar8;
                if (1 < iVar14) {
                  do {
                    FUN_00122b20(pvVar12,"bb",&local_68,0);
                    if (local_68 < 2) {
                      iVar14 = -1;
                      FUN_00120cd0(param_1,1,"parse_configuration",
                                   "invalid extra config desc len (%d)");
                      goto LAB_00122e2c;
                    }
                    if (iVar14 < (int)(uint)local_68) {
                      FUN_00120cd0(param_1,2,"parse_configuration",
                                   "short extra config desc read %d/%d",iVar14,(uint)local_68);
                      __ptr[4] = (byte)local_80;
                      goto LAB_00123143;
                    }
                    if (((byte)(local_67 - 4U) < 2) || ((byte)(local_67 - 1U) < 2)) break;
                    FUN_00120cd0(0,4,"parse_configuration");
                    iVar14 = iVar14 - (uint)local_68;
                    pvVar12 = (void *)((long)pvVar12 + (ulong)local_68);
                  } while (1 < iVar14);
                  iVar9 = (int)pvVar12 - (int)pvVar8;
                  if ((iVar9 != 0) && (*(int *)(__ptr + 0x20) == 0)) {
                    pvVar3 = malloc((long)iVar9);
                    *(void **)(__ptr + 0x18) = pvVar3;
                    if (pvVar3 == (void *)0x0) {
                      iVar14 = -0xb;
LAB_00122e2c:
                      FUN_00122ac0(__ptr);
                      goto LAB_00122e36;
                    }
                    memcpy(pvVar3,pvVar8,(long)iVar9);
                    *(int *)(__ptr + 0x20) = iVar9;
                  }
                }
                *(undefined4 *)(local_d8 + 1) = 0;
                if (iVar14 < 9) {
LAB_00123617:
                  __ptr[4] = (byte)local_80;
                  break;
                }
                iVar9 = 0;
                local_a8 = 0xffffffff;
                local_ac = 0;
                pvVar8 = pvVar12;
                iVar13 = iVar14;
LAB_00122ef9:
                pvVar3 = (void *)*local_d8;
                pvVar4 = realloc(pvVar3,(long)(iVar9 + 1) * 0x28);
                if (pvVar4 == (void *)0x0) {
                  iVar14 = -0xb;
                  free(pvVar3);
LAB_0012306a:
                  FUN_00122a10(local_d8);
                  goto LAB_00122e2c;
                }
                *local_d8 = pvVar4;
                pbVar1 = (byte *)((long)pvVar4 + (long)*(int *)(local_d8 + 1) * 0x28);
                FUN_00122b20(pvVar8,"bbbbbbbbb",pbVar1,0);
                if (pbVar1[1] != 4) {
                  FUN_00120cd0(param_1,1,"parse_interface","unexpected descriptor %x (expected %x)",
                               pbVar1[1],4);
                  goto LAB_001231af;
                }
                bVar2 = *pbVar1;
                uVar7 = (ulong)bVar2;
                if (bVar2 < 9) {
                  pcVar5 = "invalid interface bLength (%d)";
LAB_0012304d:
                  pcVar6 = "parse_interface";
LAB_00123054:
                  iVar14 = -1;
                  FUN_00120cd0(param_1,1,pcVar6,pcVar5,uVar7);
                  goto LAB_0012306a;
                }
                if ((int)(uint)bVar2 <= iVar13) {
                  uVar7 = (ulong)pbVar1[4];
                  if (0x20 < pbVar1[4]) {
                    pcVar5 = "too many endpoints (%d)";
                    goto LAB_0012304d;
                  }
                  *(int *)(local_d8 + 1) = *(int *)(local_d8 + 1) + 1;
                  pbVar1[0x18] = 0;
                  pbVar1[0x19] = 0;
                  pbVar1[0x1a] = 0;
                  pbVar1[0x1b] = 0;
                  pbVar1[0x1c] = 0;
                  pbVar1[0x1d] = 0;
                  pbVar1[0x1e] = 0;
                  pbVar1[0x1f] = 0;
                  pbVar1[0x20] = 0;
                  pbVar1[0x21] = 0;
                  pbVar1[0x22] = 0;
                  pbVar1[0x23] = 0;
                  pbVar1[0x10] = 0;
                  pbVar1[0x11] = 0;
                  pbVar1[0x12] = 0;
                  pbVar1[0x13] = 0;
                  pbVar1[0x14] = 0;
                  pbVar1[0x15] = 0;
                  pbVar1[0x16] = 0;
                  pbVar1[0x17] = 0;
                  if (local_a8 == 0xffffffff) {
                    local_a8 = (uint)pbVar1[2];
                  }
                  bVar2 = *pbVar1;
                  iVar13 = iVar13 - (uint)bVar2;
                  local_ac = local_ac + (uint)bVar2;
                  pvVar3 = (void *)((ulong)bVar2 + (long)pvVar8);
                  pvVar8 = pvVar3;
                  if (1 < iVar13) {
                    do {
                      FUN_00122b20(pvVar8,"bb",&local_58,0);
                      uVar7 = (ulong)local_58;
                      if (local_58 < 2) {
                        pcVar5 = "invalid extra intf desc len (%d)";
                        goto LAB_0012304d;
                      }
                      uVar10 = (uint)local_58;
                      if (iVar13 < (int)uVar10) {
                        pcVar5 = "short extra intf desc read %d/%d";
                        goto LAB_00123197;
                      }
                      if (((byte)(local_57 - 4U) < 2) || ((byte)(local_57 - 1U) < 2)) break;
                      iVar13 = iVar13 - uVar10;
                      pvVar8 = (void *)((long)pvVar8 + uVar7);
                      local_ac = local_ac + uVar10;
                    } while (1 < iVar13);
                    iVar9 = (int)pvVar8 - (int)pvVar3;
                    if (iVar9 == 0) goto LAB_001230bc;
                    pvVar4 = malloc((long)iVar9);
                    *(void **)(pbVar1 + 0x18) = pvVar4;
                    if (pvVar4 != (void *)0x0) {
                      memcpy(pvVar4,pvVar3,(long)iVar9);
                      *(int *)(pbVar1 + 0x20) = iVar9;
                      goto LAB_001230bc;
                    }
LAB_00123656:
                    iVar14 = -0xb;
                    goto LAB_0012306a;
                  }
LAB_001230bc:
                  if (pbVar1[4] != 0) {
                    local_c0 = calloc((ulong)pbVar1[4],0x20);
                    *(void **)(pbVar1 + 0x10) = local_c0;
                    if (local_c0 == (void *)0x0) goto LAB_00123656;
                    if (iVar13 < 2) {
LAB_00123419:
                      iVar14 = -1;
                      FUN_00120cd0(param_1,1,"parse_endpoint","short endpoint descriptor read %d/%d"
                                   ,iVar13,2);
                      goto LAB_0012306a;
                    }
                    local_b0 = 0;
                    while( true ) {
                      local_c8 = (void *)((long)local_c0 + 0x20);
                      FUN_00122b20(pvVar8,"bb",&local_48,0);
                      if (local_47 != '\x05') break;
                      uVar10 = (uint)local_48;
                      if (iVar13 < (int)uVar10) {
                        FUN_00120cd0(param_1,2,"parse_endpoint",
                                     "short endpoint descriptor read %d/%d",iVar13);
                        goto LAB_0012339a;
                      }
                      if (local_48 < 9) {
                        if (local_48 < 7) {
                          pcVar5 = "invalid endpoint bLength (%d)";
LAB_00123364:
                          uVar7 = (ulong)uVar10;
                          pcVar6 = "parse_endpoint";
                          goto LAB_00123054;
                        }
                        FUN_00122b20(pvVar8,&DAT_0013317f,local_c0,param_4);
                      }
                      else {
                        FUN_00122b20(pvVar8,"bbbbwbbb",local_c0,param_4);
                      }
                      uVar7 = (ulong)local_48;
                      uVar11 = (uint)local_48;
                      iVar9 = iVar13 - (uint)local_48;
                      pvVar4 = (void *)(uVar7 + (long)pvVar8);
                      pvVar3 = pvVar4;
                      if (iVar9 < 2) {
LAB_001233bc:
                        *(undefined8 *)((long)local_c0 + 0x10) = 0;
                        *(undefined4 *)((long)local_c0 + 0x18) = 0;
                      }
                      else {
                        do {
                          uVar11 = (uint)uVar7;
                          FUN_00122b20(pvVar3,"bb",&local_48,0);
                          uVar10 = (uint)local_48;
                          if (local_48 < 2) {
                            pcVar5 = "invalid extra ep desc len (%d)";
                            goto LAB_00123364;
                          }
                          if (iVar9 < (int)uVar10) {
                            FUN_00120cd0(param_1,2,"parse_endpoint","short extra ep desc read %d/%d"
                                         ,iVar9,uVar10);
                            goto LAB_001233d0;
                          }
                          if (((byte)(local_47 - 4U) < 2) || ((byte)(local_47 - 1U) < 2)) break;
                          FUN_00120cd0(0,4,"parse_endpoint");
                          iVar9 = iVar9 - (uint)local_48;
                          uVar11 = uVar11 + local_48;
                          uVar7 = (ulong)uVar11;
                          pvVar3 = (void *)((long)pvVar3 + (ulong)local_48);
                        } while (1 < iVar9);
                        local_a0 = (int)pvVar4;
                        local_a0 = (int)pvVar3 - local_a0;
                        if (local_a0 == 0) goto LAB_001233bc;
                        pvVar3 = malloc((long)local_a0);
                        *(void **)((long)local_c0 + 0x10) = pvVar3;
                        if (pvVar3 == (void *)0x0) {
                          *(undefined4 *)((long)local_c0 + 0x18) = 0;
                          iVar14 = -0xb;
                          goto LAB_0012306a;
                        }
                        memcpy(pvVar3,pvVar4,(long)local_a0);
                        *(int *)((long)local_c0 + 0x18) = local_a0;
                      }
LAB_001233d0:
                      if (uVar11 == 0) goto LAB_0012339a;
                      local_b0 = local_b0 + 1;
                      local_ac = local_ac + uVar11;
                      pvVar8 = (void *)((long)pvVar8 + (long)(int)uVar11);
                      iVar13 = iVar13 - uVar11;
                      if ((int)(uint)pbVar1[4] <= local_b0) goto LAB_001230cd;
                      local_c0 = local_c8;
                      if (iVar13 < 2) goto LAB_00123419;
                    }
                    FUN_00120cd0(param_1,1,"parse_endpoint","unexpected descriptor %x (expected %x)"
                                 ,local_47,5);
LAB_0012339a:
                    pbVar1[4] = (byte)local_b0;
                  }
LAB_001230cd:
                  if (((iVar13 < 9) || (*(char *)((long)pvVar8 + 1) != '\x04')) ||
                     (*(byte *)((long)pvVar8 + 2) != local_a8)) goto LAB_001231af;
                  iVar9 = *(int *)(local_d8 + 1);
                  goto LAB_00122ef9;
                }
                uVar7 = (ulong)(uint)bVar2;
                pcVar5 = "short intf descriptor read %d/%d";
LAB_00123197:
                FUN_00120cd0(param_1,2,"parse_interface",pcVar5,iVar13,uVar7);
LAB_001231af:
                if (local_ac == 0) goto LAB_00123617;
                local_80 = local_80 + 1;
                iVar14 = iVar14 - local_ac;
                pvVar8 = (void *)((long)local_ac + (long)pvVar12);
                local_d8 = local_d8 + 2;
              } while (local_80 < (int)(uint)__ptr[4]);
            }
            if (-1 < iVar14) {
LAB_00123143:
              if (iVar14 != 0) {
                FUN_00120cd0(param_1,2,"raw_desc_to_config","still %d bytes of descriptor data left"
                             ,iVar14);
              }
              *param_5 = __ptr;
              return 0;
            }
          }
          goto LAB_00122e36;
        }
        pcVar5 = "too many interfaces (%d)";
      }
      iVar14 = -1;
      FUN_00120cd0(param_1,1,"parse_configuration",pcVar5,bVar2);
      goto LAB_00122e36;
    }
    pcVar5 = "unexpected descriptor %x (expected %x)";
    uVar11 = 2;
  }
LAB_0012352f:
  iVar14 = -1;
  FUN_00120cd0(param_1,1,"parse_configuration",pcVar5,uVar10,uVar11);
LAB_00122e36:
  FUN_00120cd0(param_1,1,"raw_desc_to_config","parse_configuration failed with error %d",iVar14);
  free(__ptr);
  return iVar14;
}


==================================================================

### FUNC 00123690 (162 bytes) name=FUN_00123690

int FUN_00123690(long param_1)

{
  int iVar1;
  int local_c;
  
  local_c = 0;
  iVar1 = (**(code **)(PTR_PTR_0033ed80 + 0x48))(param_1,param_1 + 0x68,&local_c);
  if (-1 < iVar1) {
    if (local_c == 0) {
      *(undefined2 *)(param_1 + 0x6a) = *(undefined2 *)(param_1 + 0x6a);
      *(undefined2 *)(param_1 + 0x70) = *(undefined2 *)(param_1 + 0x70);
      *(undefined2 *)(param_1 + 0x72) = *(undefined2 *)(param_1 + 0x72);
      *(undefined2 *)(param_1 + 0x74) = *(undefined2 *)(param_1 + 0x74);
    }
    return 0;
  }
  return iVar1;
}


==================================================================

### FUNC 00123740 (72 bytes) name=libusb_get_device_descriptor

undefined8 libusb_get_device_descriptor(long param_1,undefined8 *param_2)

{
  FUN_00120cd0(0,4,"libusb_get_device_descriptor",&DAT_00131fd1);
  *param_2 = *(undefined8 *)(param_1 + 0x68);
  param_2[1] = *(undefined8 *)(param_1 + 0x70);
  *(undefined2 *)(param_2 + 2) = *(undefined2 *)(param_1 + 0x78);
  return 0;
}


==================================================================

### FUNC 00123790 (291 bytes) name=libusb_get_active_config_descriptor

ulong libusb_get_active_config_descriptor(long param_1,undefined8 param_2)

{
  undefined *puVar1;
  uint uVar2;
  ulong uVar3;
  void *__ptr;
  long in_FS_OFFSET;
  undefined4 local_8c;
  undefined1 local_88 [2];
  ushort local_86;
  undefined1 local_58 [24];
  long local_40;
  
  puVar1 = PTR_PTR_0033ed80;
  local_40 = *(long *)(in_FS_OFFSET + 0x28);
  local_8c = 0;
  uVar3 = (**(code **)(PTR_PTR_0033ed80 + 0x50))(param_1,local_58,9,&local_8c);
  if (-1 < (int)uVar3) {
    if ((int)uVar3 < 9) {
      FUN_00120cd0(*(undefined8 *)(param_1 + 0x30),1,"libusb_get_active_config_descriptor",
                   "short config descriptor read %d/%d",uVar3 & 0xffffffff,9);
      uVar3 = 0xffffffff;
    }
    else {
      FUN_00122b20(local_58,&DAT_001331f6,local_88,local_8c);
      __ptr = malloc((ulong)local_86);
      if (__ptr == (void *)0x0) {
        uVar3 = 0xfffffff5;
      }
      else {
        uVar2 = (**(code **)(puVar1 + 0x50))(param_1,__ptr,(ulong)local_86,&local_8c);
        if (-1 < (int)uVar2) {
          uVar2 = FUN_00122c40(*(undefined8 *)(param_1 + 0x30),__ptr,uVar2,local_8c,param_2);
        }
        uVar3 = (ulong)uVar2;
        free(__ptr);
      }
    }
  }
  if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
    return uVar3;
  }
                    /* WARNING: Subroutine does not return */
  __stack_chk_fail();
}


==================================================================

### FUNC 001238c0 (350 bytes) name=libusb_get_config_descriptor

ulong libusb_get_config_descriptor(long param_1,byte param_2,undefined8 param_3)

{
  undefined *puVar1;
  uint uVar2;
  ulong uVar3;
  void *__ptr;
  long in_FS_OFFSET;
  undefined4 local_8c;
  undefined1 local_88 [2];
  ushort local_86;
  undefined1 local_58 [24];
  long local_40;
  
  local_40 = *(long *)(in_FS_OFFSET + 0x28);
  local_8c = 0;
  FUN_00120cd0(0,4,"libusb_get_config_descriptor","index %d",param_2);
  puVar1 = PTR_PTR_0033ed80;
  uVar3 = 0xfffffffb;
  if (param_2 < *(byte *)(param_1 + 0x49)) {
    uVar3 = (**(code **)(PTR_PTR_0033ed80 + 0x58))(param_1,param_2,local_58,9,&local_8c);
    if (-1 < (int)uVar3) {
      if ((int)uVar3 < 9) {
        FUN_00120cd0(*(undefined8 *)(param_1 + 0x30),1,"libusb_get_config_descriptor",
                     "short config descriptor read %d/%d",uVar3 & 0xffffffff,9);
        uVar3 = 0xffffffff;
      }
      else {
        FUN_00122b20(local_58,&DAT_001331f6,local_88,local_8c);
        __ptr = malloc((ulong)local_86);
        if (__ptr == (void *)0x0) {
          uVar3 = 0xfffffff5;
        }
        else {
          uVar2 = (**(code **)(puVar1 + 0x58))(param_1,param_2,__ptr,(ulong)local_86,&local_8c);
          if (-1 < (int)uVar2) {
            uVar2 = FUN_00122c40(*(undefined8 *)(param_1 + 0x30),__ptr,uVar2,local_8c,param_3);
          }
          uVar3 = (ulong)uVar2;
          free(__ptr);
        }
      }
    }
  }
  if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
    return uVar3;
  }
                    /* WARNING: Subroutine does not return */
  __stack_chk_fail();
}


==================================================================

### FUNC 00123a30 (229 bytes) name=FUN_00123a30

undefined8 FUN_00123a30(long param_1,char param_2,uint *param_3)

{
  undefined *puVar1;
  undefined8 uVar2;
  byte bVar3;
  long in_FS_OFFSET;
  undefined1 local_4c [4];
  undefined1 local_48 [5];
  char local_43;
  long local_40;
  
  local_40 = *(long *)(in_FS_OFFSET + 0x28);
  FUN_00120cd0(0,4,"usbi_get_config_index_by_value","value %d",param_2);
  puVar1 = PTR_PTR_0033ed80;
  if (*(char *)(param_1 + 0x49) != '\0') {
    bVar3 = 0;
    do {
      uVar2 = (**(code **)(puVar1 + 0x58))(param_1,(uint)bVar3,local_48,6,local_4c);
      if ((int)uVar2 < 0) {
        *param_3 = 0xffffffff;
        goto LAB_00123ad9;
      }
      if (local_43 == param_2) {
        *param_3 = (uint)bVar3;
        uVar2 = 0;
        goto LAB_00123ad9;
      }
      bVar3 = bVar3 + 1;
    } while (bVar3 < *(byte *)(param_1 + 0x49));
  }
  *param_3 = 0xffffffff;
  uVar2 = 0;
LAB_00123ad9:
  if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
    return uVar2;
  }
                    /* WARNING: Subroutine does not return */
  __stack_chk_fail();
}


==================================================================

### FUNC 00123b20 (146 bytes) name=libusb_get_config_descriptor_by_value

ulong libusb_get_config_descriptor_by_value(long param_1,undefined1 param_2,undefined8 param_3)

{
  ulong uVar1;
  uint local_24;
  undefined8 local_20 [2];
  
  local_20[0] = 0;
  if (*(code **)(PTR_PTR_0033ed80 + 0x60) == (code *)0x0) {
    uVar1 = FUN_00123a30(param_1,param_2,&local_24);
    if (-1 < (int)uVar1) {
      if (local_24 != 0xffffffff) {
        uVar1 = libusb_get_config_descriptor(param_1,local_24 & 0xff,param_3);
        return uVar1;
      }
      uVar1 = 0xfffffffb;
    }
  }
  else {
    uVar1 = (**(code **)(PTR_PTR_0033ed80 + 0x60))(param_1,param_2,local_20,&local_24);
    if (-1 < (int)uVar1) {
      uVar1 = FUN_00122c40(*(undefined8 *)(param_1 + 0x30),local_20[0],uVar1 & 0xffffffff,local_24,
                           param_3);
    }
  }
  return uVar1;
}


==================================================================

### FUNC 00123bc0 (25 bytes) name=libusb_free_config_descriptor

void libusb_free_config_descriptor(void *param_1)

{
  if (param_1 != (void *)0x0) {
    FUN_00122ac0();
    free(param_1);
    return;
  }
  return;
}


==================================================================

### FUNC 00123bf0 (223 bytes) name=libusb_get_ss_endpoint_companion_descriptor

undefined8
libusb_get_ss_endpoint_companion_descriptor(undefined8 param_1,long param_2,undefined8 *param_3)

{
  void *pvVar1;
  char *pcVar2;
  int iVar3;
  long lVar4;
  byte local_38;
  char local_37;
  
  iVar3 = *(int *)(param_2 + 0x18);
  lVar4 = *(long *)(param_2 + 0x10);
  *param_3 = 0;
  while( true ) {
    if (iVar3 < 2) {
      return 0xfffffffb;
    }
    FUN_00122b20(lVar4,"bb",&local_38,0);
    if ((local_38 < 2) || (iVar3 < (int)(uint)local_38)) break;
    if (local_37 == '0') {
      if (5 < local_38) {
        pvVar1 = malloc(6);
        *param_3 = pvVar1;
        if (pvVar1 != (void *)0x0) {
          FUN_00122b20(lVar4,&DAT_001331f4,pvVar1,0);
          return 0;
        }
        return 0xfffffff5;
      }
      pcVar2 = "invalid ss-ep-comp-desc length %d";
      goto LAB_00123ca7;
    }
    iVar3 = iVar3 - (uint)local_38;
    lVar4 = lVar4 + (ulong)local_38;
  }
  pcVar2 = "invalid descriptor length %d";
LAB_00123ca7:
  FUN_00120cd0(param_1,1,"libusb_get_ss_endpoint_companion_descriptor",pcVar2);
  return 0xffffffff;
}


==================================================================

### FUNC 00123ce0 (5 bytes) name=libusb_free_ss_endpoint_companion_descriptor

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

void libusb_free_ss_endpoint_companion_descriptor(void *__ptr)

{
  (*(code *)PTR_free_0033f1e0)();
  return;
}


==================================================================

### FUNC 00123cf0 (77 bytes) name=libusb_free_bos_descriptor

void libusb_free_bos_descriptor(void *param_1)

{
  long lVar1;
  int iVar2;
  
  if (param_1 == (void *)0x0) {
    return;
  }
  iVar2 = 0;
  if (*(char *)((long)param_1 + 4) != '\0') {
    do {
      lVar1 = (long)iVar2;
      iVar2 = iVar2 + 1;
      free(*(void **)((long)param_1 + lVar1 * 8 + 8));
    } while (iVar2 < (int)(uint)*(byte *)((long)param_1 + 4));
  }
  free(param_1);
  return;
}


==================================================================

### FUNC 00123d50 (1119 bytes) name=libusb_get_bos_descriptor

uint libusb_get_bos_descriptor(long param_1,undefined8 *param_2)

{
  undefined8 uVar1;
  uint uVar2;
  void *__ptr;
  void *pvVar3;
  void *__dest;
  char *pcVar4;
  uint uVar5;
  byte bVar6;
  void *__src;
  ulong __size;
  uint uVar7;
  long in_FS_OFFSET;
  undefined1 local_78 [2];
  ushort local_76;
  undefined1 local_74;
  byte local_68;
  byte local_67;
  byte local_64;
  byte local_58;
  byte local_57;
  undefined4 local_48;
  undefined1 local_44;
  long local_40;
  
  local_48 = 0;
  local_44 = 0;
  local_40 = *(long *)(in_FS_OFFSET + 0x28);
  uVar2 = libusb_control_transfer(param_1,0x80,6,0xf00,0,&local_48,5,1000);
  if ((int)uVar2 < 0) {
    if (uVar2 != 0xfffffff7) {
      FUN_00120cd0(*(undefined8 *)(*(long *)(param_1 + 0x40) + 0x30),1,"libusb_get_bos_descriptor",
                   "failed to read BOS (%d)",uVar2);
    }
    goto LAB_00123ff6;
  }
  if ((int)uVar2 < 5) {
    FUN_00120cd0(*(undefined8 *)(*(long *)(param_1 + 0x40) + 0x30),1,"libusb_get_bos_descriptor",
                 "short BOS read %d/%d",uVar2,5);
    uVar2 = 0xffffffff;
    goto LAB_00123ff6;
  }
  FUN_00122b20(&local_48,&DAT_00133181,local_78,0);
  FUN_00120cd0(0,4,"libusb_get_bos_descriptor",
               "found BOS descriptor: size %d bytes, %d capabilities",local_76,local_74);
  __ptr = calloc((ulong)local_76,1);
  if (__ptr == (void *)0x0) {
    uVar2 = 0xfffffff5;
    goto LAB_00123ff6;
  }
  uVar2 = libusb_control_transfer(param_1,0x80,6,0xf00,0,__ptr,local_76,1000);
  if ((int)uVar2 < 0) {
    FUN_00120cd0(*(undefined8 *)(*(long *)(param_1 + 0x40) + 0x30),1,"libusb_get_bos_descriptor",
                 "failed to read BOS (%d)",uVar2);
  }
  else {
    uVar1 = *(undefined8 *)(*(long *)(param_1 + 0x40) + 0x30);
    if ((int)uVar2 < 5) {
      FUN_00120cd0(uVar1,1,"parse_bos","short bos descriptor read %d/%d",uVar2,5);
      uVar2 = 0xffffffff;
    }
    else {
      FUN_00122b20(__ptr,&DAT_00133181,&local_68,0);
      pcVar4 = "unexpected descriptor %x (expected %x)";
      bVar6 = 0xf;
      uVar5 = (uint)local_67;
      if (local_67 == 0xf) {
        if (local_68 < 5) {
          FUN_00120cd0(uVar1,1,"parse_bos","invalid bos bLength (%d)",local_68,0xf);
          uVar2 = 0xffffffff;
        }
        else {
          if ((int)uVar2 < (int)(uint)local_68) {
            pcVar4 = "short bos descriptor read %d/%d";
            bVar6 = local_68;
            uVar5 = uVar2;
            goto LAB_00124134;
          }
          pvVar3 = calloc(1,(ulong)local_64 * 8 + 8);
          if (pvVar3 == (void *)0x0) {
            uVar2 = 0xfffffff5;
          }
          else {
            FUN_00122b20(__ptr,&DAT_00133181,pvVar3,0);
            uVar5 = (uint)local_64;
            uVar2 = uVar2 - local_68;
            __src = (void *)((ulong)local_68 + (long)__ptr);
            if (local_64 != 0) {
              if ((int)uVar2 < 3) {
                uVar5 = 0;
              }
              else {
                uVar5 = 0;
                do {
                  FUN_00122b20(__src,"bbb",&local_58,0);
                  bVar6 = local_58;
                  if (local_57 != 0x10) {
                    pcVar4 = "unexpected descriptor %x (expected %x)";
                    uVar7 = 0x10;
                    uVar2 = (uint)local_57;
                    goto LAB_00123fc6;
                  }
                  if (local_58 < 3) {
                    FUN_00120cd0(uVar1,1,"parse_bos","invalid dev-cap bLength (%d)");
                    libusb_free_bos_descriptor(pvVar3);
                    uVar2 = 0xffffffff;
                    goto LAB_00123fec;
                  }
                  uVar7 = (uint)local_58;
                  if ((int)uVar2 < (int)uVar7) {
                    pcVar4 = "short dev-cap descriptor read %d/%d";
                    goto LAB_00123fc6;
                  }
                  __size = (ulong)local_58;
                  __dest = malloc(__size);
                  *(void **)((long)pvVar3 + (long)(int)uVar5 * 8 + 8) = __dest;
                  if (__dest == (void *)0x0) {
                    libusb_free_bos_descriptor(pvVar3);
                    uVar2 = 0xfffffff5;
                    goto LAB_00123fec;
                  }
                  memcpy(__dest,__src,__size);
                  uVar5 = uVar5 + 1;
                  __src = (void *)((long)__src + __size);
                  uVar2 = uVar2 - bVar6;
                  if ((int)(uint)local_64 <= (int)uVar5) goto LAB_00123fde;
                } while (2 < (int)uVar2);
              }
              uVar7 = 3;
              pcVar4 = "short dev-cap descriptor read %d/%d";
LAB_00123fc6:
              FUN_00120cd0(uVar1,2,"parse_bos",pcVar4,uVar2,uVar7);
            }
LAB_00123fde:
            *(char *)((long)pvVar3 + 4) = (char)uVar5;
            *param_2 = pvVar3;
            uVar2 = 0;
          }
        }
      }
      else {
LAB_00124134:
        FUN_00120cd0(uVar1,1,"parse_bos",pcVar4,uVar5,bVar6);
        uVar2 = 0xffffffff;
      }
    }
  }
LAB_00123fec:
  free(__ptr);
LAB_00123ff6:
  if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
    return uVar2;
  }
                    /* WARNING: Subroutine does not return */
  __stack_chk_fail();
}


==================================================================

### FUNC 001241d0 (165 bytes) name=libusb_get_usb_2_0_extension_descriptor

undefined8
libusb_get_usb_2_0_extension_descriptor(undefined8 param_1,byte *param_2,undefined8 *param_3)

{
  void *pvVar1;
  undefined8 uVar2;
  
  if (param_2[2] == 2) {
    if (*param_2 < 7) {
      FUN_00120cd0(param_1,1,"libusb_get_usb_2_0_extension_descriptor",
                   "short dev-cap descriptor read %d/%d",*param_2,7);
      uVar2 = 0xffffffff;
    }
    else {
      pvVar1 = malloc(8);
      if (pvVar1 == (void *)0x0) {
        uVar2 = 0xfffffff5;
      }
      else {
        FUN_00122b20(param_2,&DAT_0013325d,pvVar1,0);
        *param_3 = pvVar1;
        uVar2 = 0;
      }
    }
  }
  else {
    FUN_00120cd0(param_1,1,"libusb_get_usb_2_0_extension_descriptor",
                 "unexpected bDevCapabilityType %x (expected %x)",param_2[2],2);
    uVar2 = 0xfffffffe;
  }
  return uVar2;
}


==================================================================

### FUNC 00124290 (5 bytes) name=libusb_free_usb_2_0_extension_descriptor

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

void libusb_free_usb_2_0_extension_descriptor(void *__ptr)

{
  (*(code *)PTR_free_0033f1e0)();
  return;
}


==================================================================

### FUNC 001242a0 (165 bytes) name=libusb_get_ss_usb_device_capability_descriptor

undefined8
libusb_get_ss_usb_device_capability_descriptor(undefined8 param_1,byte *param_2,undefined8 *param_3)

{
  void *pvVar1;
  undefined8 uVar2;
  
  if (param_2[2] == 3) {
    if (*param_2 < 10) {
      FUN_00120cd0(param_1,1,"libusb_get_ss_usb_device_capability_descriptor",
                   "short dev-cap descriptor read %d/%d",*param_2,10);
      uVar2 = 0xffffffff;
    }
    else {
      pvVar1 = malloc(10);
      if (pvVar1 == (void *)0x0) {
        uVar2 = 0xfffffff5;
      }
      else {
        FUN_00122b20(param_2,"bbbbwbbw",pvVar1,0);
        *param_3 = pvVar1;
        uVar2 = 0;
      }
    }
  }
  else {
    FUN_00120cd0(param_1,1,"libusb_get_ss_usb_device_capability_descriptor",
                 "unexpected bDevCapabilityType %x (expected %x)",param_2[2],3);
    uVar2 = 0xfffffffe;
  }
  return uVar2;
}


==================================================================

### FUNC 00124360 (5 bytes) name=libusb_free_ss_usb_device_capability_descriptor

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

void libusb_free_ss_usb_device_capability_descriptor(void *__ptr)

{
  (*(code *)PTR_free_0033f1e0)();
  return;
}


==================================================================

### FUNC 00124370 (165 bytes) name=libusb_get_container_id_descriptor

undefined8 libusb_get_container_id_descriptor(undefined8 param_1,byte *param_2,undefined8 *param_3)

{
  void *pvVar1;
  undefined8 uVar2;
  
  if (param_2[2] == 4) {
    if (*param_2 < 0x14) {
      FUN_00120cd0(param_1,1,"libusb_get_container_id_descriptor",
                   "short dev-cap descriptor read %d/%d",*param_2,0x14);
      uVar2 = 0xffffffff;
    }
    else {
      pvVar1 = malloc(0x14);
      if (pvVar1 == (void *)0x0) {
        uVar2 = 0xfffffff5;
      }
      else {
        FUN_00122b20(param_2,"bbbbu",pvVar1,0);
        *param_3 = pvVar1;
        uVar2 = 0;
      }
    }
  }
  else {
    FUN_00120cd0(param_1,1,"libusb_get_container_id_descriptor",
                 "unexpected bDevCapabilityType %x (expected %x)",param_2[2],4);
    uVar2 = 0xfffffffe;
  }
  return uVar2;
}


==================================================================

### FUNC 00124430 (5 bytes) name=libusb_free_container_id_descriptor

/* WARNING: Unknown calling convention -- yet parameter storage is locked */

void libusb_free_container_id_descriptor(void *__ptr)

{
  (*(code *)PTR_free_0033f1e0)();
  return;
}


==================================================================

### FUNC 00124440 (367 bytes) name=libusb_get_string_descriptor_ascii

ulong libusb_get_string_descriptor_ascii(undefined8 param_1,char param_2,long param_3,int param_4)

{
  uint uVar1;
  ulong uVar2;
  ulong uVar3;
  ulong uVar4;
  uint uVar5;
  long lVar6;
  long in_FS_OFFSET;
  byte local_138;
  char local_137;
  char local_136 [262];
  long local_30;
  
  local_30 = *(long *)(in_FS_OFFSET + 0x28);
  uVar2 = 0xfffffffe;
  if (param_2 != '\0') {
    uVar2 = libusb_control_transfer(param_1,0x80,6,0x300,0,&local_138,0xff,1000);
    if (-1 < (int)uVar2) {
      if (3 < (int)uVar2) {
        uVar2 = libusb_control_transfer
                          (param_1,0x80,6,CONCAT11(3,param_2),CONCAT11(local_136[1],local_136[0]),
                           &local_138,0xff,1000);
        if ((int)uVar2 < 0) goto LAB_0012457b;
        if (local_137 == '\x03') {
          if ((int)(uint)local_138 <= (int)uVar2) {
            if ((local_138 < 3) || (param_4 + -1 < 1)) {
              lVar6 = 0;
              uVar2 = 0;
            }
            else {
              uVar4 = 0;
              uVar3 = (ulong)(local_138 - 3 >> 1);
              uVar1 = 1;
              do {
                uVar5 = uVar1;
                uVar2 = (ulong)uVar5;
                if ((-1 < local_136[uVar4 * 2]) && (local_136[uVar4 * 2 + 1] == '\0')) {
                  *(char *)(param_3 + uVar4) = local_136[uVar4 * 2];
                  if (uVar4 != uVar3) goto LAB_0012454a;
LAB_00124573:
                  lVar6 = (long)(int)uVar5;
                  goto LAB_00124576;
                }
                *(undefined1 *)(param_3 + uVar4) = 0x3f;
                if (uVar4 == uVar3) goto LAB_00124573;
LAB_0012454a:
                uVar4 = uVar4 + 1;
                uVar1 = uVar5 + 1;
              } while ((int)uVar5 < param_4 + -1);
              lVar6 = (long)(int)uVar5;
            }
LAB_00124576:
            *(undefined1 *)(param_3 + lVar6) = 0;
            goto LAB_0012457b;
          }
        }
      }
      uVar2 = 0xffffffff;
    }
  }
LAB_0012457b:
  if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
    return uVar2;
  }
                    /* WARNING: Subroutine does not return */
  __stack_chk_fail();
}


==================================================================

### FUNC 001245c0 (93 bytes) name=FUN_001245c0

undefined8 FUN_001245c0(undefined8 param_1,long param_2,uint param_3,long param_4)

{
  undefined8 uVar1;
  
  if (*(int *)(param_4 + 0x38) != 0) {
    return 1;
  }
  if (((((*(uint *)(param_4 + 0x18) & param_3) != 0) &&
       ((*(uint *)(param_4 + 8) == 0xffffffff ||
        (*(uint *)(param_4 + 8) == (uint)*(ushort *)(param_2 + 0x70))))) &&
      ((*(uint *)(param_4 + 0xc) == 0xffffffff ||
       (*(uint *)(param_4 + 0xc) == (uint)*(ushort *)(param_2 + 0x72))))) &&
     ((*(uint *)(param_4 + 0x10) == 0xffffffff ||
      (*(uint *)(param_4 + 0x10) == (uint)*(byte *)(param_2 + 0x6c))))) {
                    /* WARNING: Could not recover jumptable at 0x0012461b. Too many branches */
                    /* WARNING: Treating indirect jump as call */
    uVar1 = (**(code **)(param_4 + 0x20))();
    return uVar1;
  }
  return 0;
}


==================================================================

### FUNC 00124630 (208 bytes) name=FUN_00124630

void FUN_00124630(long param_1,undefined8 param_2,undefined4 param_3)

{
  pthread_mutex_t *__mutex;
  long *plVar1;
  long *plVar2;
  long *plVar3;
  int iVar4;
  
  __mutex = (pthread_mutex_t *)(param_1 + 0x90);
  pthread_mutex_lock(__mutex);
  plVar2 = (long *)(*(long **)(param_1 + 0x88))[1];
  plVar1 = *(long **)(param_1 + 0x88);
  while (plVar3 = plVar2, (long *)(param_1 + 0x80) != plVar1) {
    pthread_mutex_unlock(__mutex);
    iVar4 = FUN_001245c0(param_1,param_2,param_3,plVar1 + -8);
    pthread_mutex_lock(__mutex);
    if (iVar4 != 0) {
      plVar2 = (long *)plVar1[1];
      *plVar2 = *plVar1;
      *(long **)(*plVar1 + 8) = plVar2;
      *plVar1 = 0;
      plVar1[1] = 0;
      free(plVar1 + -8);
    }
    plVar2 = (long *)plVar3[1];
    plVar1 = plVar3;
  }
  pthread_mutex_unlock(__mutex);
  return;
}


==================================================================

### FUNC 00124710 (261 bytes) name=FUN_00124710

void FUN_00124710(long param_1,undefined8 param_2,undefined4 param_3)

{
  undefined4 *puVar1;
  
  puVar1 = calloc(1,0x20);
  if (puVar1 != (undefined4 *)0x0) {
    *(undefined8 *)(puVar1 + 2) = param_2;
    *puVar1 = param_3;
    pthread_mutex_lock((pthread_mutex_t *)(param_1 + 400));
    if (((*(long *)(param_1 + 0x1b8) == 0) && (*(long *)(param_1 + 0x1e8) == param_1 + 0x1e0)) &&
       (*(long *)(param_1 + 0x1f8) == param_1 + 0x1f0)) {
      *(long *)(puVar1 + 6) = *(long *)(param_1 + 0x1e8);
      *(undefined8 *)(puVar1 + 4) = *(undefined8 *)(param_1 + 0x1e0);
      *(undefined4 **)(*(long *)(param_1 + 0x1e0) + 8) = puVar1 + 4;
      *(undefined4 **)(param_1 + 0x1e0) = puVar1 + 4;
      FUN_00121360(param_1);
    }
    else {
      *(long *)(puVar1 + 6) = param_1 + 0x1e0;
      *(undefined8 *)(puVar1 + 4) = *(undefined8 *)(param_1 + 0x1e0);
      *(undefined4 **)(*(long *)(param_1 + 0x1e0) + 8) = puVar1 + 4;
      *(undefined4 **)(param_1 + 0x1e0) = puVar1 + 4;
    }
    pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 400));
    return;
  }
  FUN_00120cd0(param_1,1,"usbi_hotplug_notification","error allocating hotplug message");
  return;
}


==================================================================

### FUNC 00124820 (150 bytes) name=libusb_hotplug_deregister_callback

void libusb_hotplug_deregister_callback(long param_1,int param_2)

{
  long lVar1;
  long lVar2;
  int iVar3;
  
  iVar3 = libusb_has_capability(1);
  if (iVar3 == 0) {
    return;
  }
  if (param_1 == 0) {
    param_1 = DAT_003665e8;
  }
  pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0x90));
  lVar1 = *(long *)(param_1 + 0x88);
  while (lVar2 = lVar1, param_1 + 0x80 != lVar1) {
    while (*(int *)(lVar2 + -0x18) != param_2) {
      lVar2 = *(long *)(lVar2 + 8);
      if (param_1 + 0x80 == lVar2) goto LAB_0012488e;
    }
    lVar1 = *(long *)(lVar2 + 8);
    *(undefined4 *)(lVar2 + -8) = 1;
  }
LAB_0012488e:
  pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0x90));
  FUN_00124710(param_1,0,0);
  return;
}


==================================================================

### FUNC 001248d0 (510 bytes) name=libusb_hotplug_register_callback

undefined8
libusb_hotplug_register_callback
          (long param_1,undefined4 param_2,uint param_3,uint param_4,uint param_5,uint param_6,
          long param_7,long param_8,undefined4 *param_9)

{
  undefined8 *puVar1;
  int iVar2;
  long *plVar3;
  undefined8 uVar4;
  long lVar5;
  long local_40 [2];
  
  iVar2 = libusb_has_capability(1);
  if (iVar2 == 0) {
    uVar4 = 0xfffffff4;
  }
  else if ((((param_4 == 0xffffffff) || ((param_4 & 0xffff0000) == 0)) &&
           ((param_5 == 0xffffffff || ((param_5 & 0xffff0000) == 0)))) &&
          (((param_6 == 0xffffffff || ((param_6 & 0xffffff00) == 0)) && (param_7 != 0)))) {
    if (param_1 == 0) {
      param_1 = DAT_003665e8;
    }
    plVar3 = calloc(1,0x50);
    if (plVar3 == (long *)0x0) {
      uVar4 = 0xfffffff5;
    }
    else {
      *(uint *)((long)plVar3 + 0xc) = param_5;
      *(uint *)((long)plVar3 + 0x14) = param_3;
      *plVar3 = param_1;
      *(uint *)(plVar3 + 1) = param_4;
      *(uint *)(plVar3 + 2) = param_6;
      *(undefined4 *)(plVar3 + 7) = 0;
      *(undefined4 *)(plVar3 + 3) = param_2;
      plVar3[4] = param_7;
      plVar3[6] = param_8;
      pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0x90));
      *(int *)(plVar3 + 5) = DAT_0033f5e8;
      DAT_0033f5e8 = DAT_0033f5e8 + 1;
      plVar3[9] = *(long *)(param_1 + 0x88);
      plVar3[8] = param_1 + 0x80;
      **(long **)(param_1 + 0x88) = (long)(plVar3 + 8);
      *(long **)(param_1 + 0x88) = plVar3 + 8;
      pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0x90));
      if ((param_3 & 1) != 0) {
        uVar4 = libusb_get_device_list(param_1,local_40);
        iVar2 = (int)uVar4;
        if (iVar2 < 0) {
          libusb_hotplug_deregister_callback(param_1,(int)plVar3[5]);
          return uVar4;
        }
        if (iVar2 != 0) {
          lVar5 = 0;
          do {
            puVar1 = (undefined8 *)(local_40[0] + lVar5);
            lVar5 = lVar5 + 8;
            FUN_001245c0(param_1,*puVar1,1,plVar3);
          } while (lVar5 != (ulong)(iVar2 - 1) * 8 + 8);
        }
        libusb_free_device_list(local_40[0],1);
      }
      if (param_9 == (undefined4 *)0x0) {
        uVar4 = 0;
      }
      else {
        *param_9 = (int)plVar3[5];
        uVar4 = 0;
      }
    }
  }
  else {
    uVar4 = 0xfffffffe;
  }
  return uVar4;
}


==================================================================

### FUNC 00124af0 (120 bytes) name=FUN_00124af0

void FUN_00124af0(long param_1)

{
  long *plVar1;
  long *plVar2;
  long *plVar3;
  
  pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0x90));
  plVar3 = (long *)(*(long **)(param_1 + 0x88))[1];
  plVar2 = *(long **)(param_1 + 0x88);
  while (plVar1 = plVar3, (long *)(param_1 + 0x80) != plVar2) {
    *plVar1 = *plVar2;
    *(long **)(*plVar2 + 8) = plVar1;
    *plVar2 = 0;
    plVar2[1] = 0;
    free(plVar2 + -8);
    plVar3 = (long *)plVar1[1];
    plVar2 = plVar1;
  }
  pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0x90));
  return;
}


==================================================================

### FUNC 00124b70 (62 bytes) name=FUN_00124b70

void FUN_00124b70(long param_1)

{
  if (((*(long *)(param_1 + 0x1b8) == 0) && (*(long *)(param_1 + 0x1e8) == param_1 + 0x1e0)) &&
     (*(long *)(param_1 + 0x1f8) == param_1 + 0x1f0)) {
    *(uint *)(param_1 + 0x1b8) = *(uint *)(param_1 + 0x1b8) | 1;
    FUN_00121360();
    return;
  }
  *(uint *)(param_1 + 0x1b8) = *(uint *)(param_1 + 0x1b8) | 1;
  return;
}


==================================================================

### FUNC 00124bc0 (271 bytes) name=FUN_00124bc0

uint FUN_00124bc0(long param_1)

{
  long lVar1;
  int iVar2;
  itimerspec local_28;
  
  for (lVar1 = *(long *)(param_1 + 0xc0);
      (param_1 + 0xb8 != lVar1 &&
      ((local_28.it_value.tv_sec = *(long *)(lVar1 + 0x20), local_28.it_value.tv_sec != 0 ||
       (*(long *)(lVar1 + 0x28) != 0)))); lVar1 = *(long *)(lVar1 + 8)) {
    if ((*(byte *)(lVar1 + 0x39) & 3) == 0) {
      local_28.it_interval.tv_sec = 0;
      local_28.it_interval.tv_nsec = 0;
      local_28.it_value.tv_nsec = *(long *)(lVar1 + 0x28) * 1000;
      FUN_00120cd0(0,4,"arm_timerfd_for_next_timeout","next timeout originally %dms",
                   *(undefined4 *)(lVar1 + 0x74));
      iVar2 = timerfd_settime(*(int *)(param_1 + 0x200),1,&local_28,(itimerspec *)0x0);
      return iVar2 >> 0x1f & 0xffffff9d;
    }
  }
  local_28.it_interval.tv_sec = 0;
  local_28.it_interval.tv_nsec = 0;
  local_28.it_value.tv_sec = 0;
  local_28.it_value.tv_nsec = 0;
  FUN_00120cd0(0,4,"disarm_timerfd");
  iVar2 = timerfd_settime(*(int *)(param_1 + 0x200),0,&local_28,(itimerspec *)0x0);
  return iVar2 >> 0x1f & 0xffffff9d;
}


==================================================================

### FUNC 00124ce0 (172 bytes) name=FUN_00124ce0

undefined4 FUN_00124ce0(long param_1)

{
  int iVar1;
  long lVar2;
  undefined8 *puVar3;
  undefined4 uVar4;
  
  lVar2 = *(long *)(*(long *)(*(long *)(param_1 + 0x70) + 0x40) + 0x30);
  pthread_mutex_lock((pthread_mutex_t *)(lVar2 + 200));
  if (((*(long *)(param_1 + 0x28) == 0) && (*(long *)(param_1 + 0x30) == 0)) ||
     (*(long *)(lVar2 + 0xc0) + -8 != param_1)) {
    puVar3 = *(undefined8 **)(param_1 + 0x10);
    *puVar3 = *(undefined8 *)(param_1 + 8);
    *(undefined8 **)(*(long *)(param_1 + 8) + 8) = puVar3;
    *(undefined8 *)(param_1 + 8) = 0;
    *(undefined8 *)(param_1 + 0x10) = 0;
  }
  else {
    puVar3 = *(undefined8 **)(param_1 + 0x10);
    iVar1 = *(int *)(lVar2 + 0x200);
    *puVar3 = *(undefined8 *)(param_1 + 8);
    *(undefined8 **)(*(long *)(param_1 + 8) + 8) = puVar3;
    *(undefined8 *)(param_1 + 8) = 0;
    *(undefined8 *)(param_1 + 0x10) = 0;
    if (-1 < iVar1) {
      uVar4 = FUN_00124bc0(lVar2);
      goto LAB_00124d7d;
    }
  }
  uVar4 = 0;
LAB_00124d7d:
  pthread_mutex_unlock((pthread_mutex_t *)(lVar2 + 200));
  return uVar4;
}


==================================================================

### FUNC 00124d90 (120 bytes) name=libusb_alloc_transfer

int * libusb_alloc_transfer(int param_1)

{
  int *piVar1;
  int *piVar2;
  
  piVar1 = calloc(1,*(long *)(PTR_PTR_0033ed80 + 0x128) + 0xb0 + (long)param_1 * 0xc);
  if (piVar1 == (int *)0x0) {
    piVar2 = (int *)0x0;
  }
  else {
    *piVar1 = param_1;
    piVar2 = piVar1 + 0x1c;
    pthread_mutex_init((pthread_mutex_t *)(piVar1 + 0x12),(pthread_mutexattr_t *)0x0);
    FUN_00120cd0(0,4,"libusb_alloc_transfer","transfer %p",piVar2);
  }
  return piVar2;
}


==================================================================

### FUNC 00124e10 (84 bytes) name=libusb_free_transfer

void libusb_free_transfer(long param_1)

{
  if (param_1 != 0) {
    FUN_00120cd0(0,4,"libusb_free_transfer","transfer %p",param_1);
    if (((*(byte *)(param_1 + 8) & 2) != 0) && (*(void **)(param_1 + 0x30) != (void *)0x0)) {
      free(*(void **)(param_1 + 0x30));
    }
    pthread_mutex_destroy((pthread_mutex_t *)(param_1 + -0x28));
    free((void *)(param_1 + -0x70));
    return;
  }
  return;
}


==================================================================

### FUNC 00124e70 (1050 bytes) name=libusb_submit_transfer

int libusb_submit_transfer(long *param_1)

{
  pthread_mutex_t *__mutex;
  long *plVar1;
  uint uVar2;
  long lVar3;
  long *plVar4;
  bool bVar5;
  int iVar6;
  long lVar7;
  int *piVar8;
  long lVar9;
  pthread_mutex_t *__mutex_00;
  itimerspec local_58;
  
  __mutex = (pthread_mutex_t *)(param_1 + -5);
  lVar3 = *(long *)(*(long *)(*param_1 + 0x40) + 0x30);
  FUN_00120cd0(0,4,"libusb_submit_transfer","transfer %p",param_1);
  __mutex_00 = (pthread_mutex_t *)(lVar3 + 200);
  pthread_mutex_lock(__mutex_00);
  pthread_mutex_lock(__mutex);
  if ((*(byte *)(param_1 + -6) & 1) != 0) {
    pthread_mutex_unlock(__mutex_00);
    pthread_mutex_unlock(__mutex);
    return -6;
  }
  uVar2 = *(uint *)((long)param_1 + 0xc);
  *(undefined1 *)(param_1 + -6) = 0;
  *(undefined1 *)((long)param_1 + -0x2f) = 0;
  *(undefined4 *)(param_1 + -7) = 0;
  lVar3 = *(long *)(*(long *)(*param_1 + 0x40) + 0x30);
  if (uVar2 != 0) {
    iVar6 = (**(code **)(PTR_PTR_0033ed80 + 0x108))(0,&local_58);
    if (iVar6 < 0) {
      piVar8 = __errno_location();
      FUN_00120cd0(*(undefined8 *)(*(long *)(*param_1 + 0x40) + 0x30),1,"calculate_timeout",
                   "failed to read monotonic clock, errno=%d",*piVar8);
      goto LAB_001250d4;
    }
    local_58.it_interval.tv_sec = (ulong)uVar2 / 1000 + local_58.it_interval.tv_sec;
    local_58.it_interval.tv_nsec =
         (ulong)((uVar2 + (int)((ulong)uVar2 / 1000) * -1000) * 1000000) +
         local_58.it_interval.tv_nsec;
    lVar7 = local_58.it_interval.tv_sec;
    for (lVar9 = local_58.it_interval.tv_nsec; 999999999 < lVar9; lVar9 = lVar9 + -1000000000) {
      lVar7 = lVar7 + 1;
    }
    param_1[-9] = lVar7;
    param_1[-8] = lVar9 / 1000;
  }
  plVar4 = *(long **)(lVar3 + 0xc0);
  plVar1 = (long *)(lVar3 + 0xb8);
  if (plVar4 == plVar1) {
    param_1[-0xc] = (long)plVar4;
    plVar1 = *(long **)(lVar3 + 0xc0);
    param_1[-0xd] = (long)plVar4;
    *plVar1 = (long)(param_1 + -0xd);
    *(long **)(lVar3 + 0xc0) = param_1 + -0xd;
  }
  else {
    lVar7 = param_1[-9];
    if ((lVar7 == 0) && (param_1[-8] == 0)) {
      lVar7 = *(long *)(lVar3 + 0xb8);
      param_1[-0xc] = (long)plVar1;
      param_1[-0xd] = lVar7;
      *(long **)(*(long *)(lVar3 + 0xb8) + 8) = param_1 + -0xd;
      *(long **)(lVar3 + 0xb8) = param_1 + -0xd;
    }
    else {
      bVar5 = true;
      for (; plVar1 != plVar4; plVar4 = (long *)plVar4[1]) {
        lVar9 = plVar4[4];
        if ((((lVar9 == 0) && (plVar4[5] == 0)) || (lVar7 < lVar9)) ||
           ((lVar7 == lVar9 && (param_1[-8] < plVar4[5])))) {
          param_1[-0xc] = (long)plVar4;
          param_1[-0xd] = *plVar4;
          *(long **)(*plVar4 + 8) = param_1 + -0xd;
          *plVar4 = (long)(param_1 + -0xd);
          goto LAB_00124f9c;
        }
        bVar5 = false;
      }
      lVar7 = *(long *)(lVar3 + 0xb8);
      param_1[-0xc] = (long)plVar1;
      param_1[-0xd] = lVar7;
      *(long **)(*(long *)(lVar3 + 0xb8) + 8) = param_1 + -0xd;
      *(long **)(lVar3 + 0xb8) = param_1 + -0xd;
LAB_00124f9c:
      if (!bVar5) goto LAB_00124fa1;
    }
  }
  if (-1 < *(int *)(lVar3 + 0x200)) {
    if ((param_1[-9] != 0) || (param_1[-8] != 0)) {
      local_58.it_value.tv_nsec = param_1[-8] * 1000;
      local_58.it_interval.tv_sec = 0;
      local_58.it_interval.tv_nsec = 0;
      local_58.it_value.tv_sec = param_1[-9];
      FUN_00120cd0(0,4,"add_to_flying_list","arm timerfd for timeout in %dms (first in line)",
                   *(undefined4 *)((long)param_1 + 0xc));
      iVar6 = timerfd_settime(*(int *)(lVar3 + 0x200),1,&local_58,(itimerspec *)0x0);
      if (iVar6 < 0) {
        piVar8 = __errno_location();
        FUN_00120cd0(lVar3,2,"add_to_flying_list","failed to arm first timerfd (errno %d)",*piVar8);
        iVar6 = -99;
      }
      else if (iVar6 == 0) goto LAB_00124fa1;
      plVar1 = (long *)param_1[-0xc];
      *plVar1 = param_1[-0xd];
      *(long **)(param_1[-0xd] + 8) = plVar1;
      param_1[-0xd] = 0;
      param_1[-0xc] = 0;
LAB_001250d4:
      pthread_mutex_unlock(__mutex_00);
      pthread_mutex_unlock(__mutex);
      return iVar6;
    }
  }
LAB_00124fa1:
  pthread_mutex_unlock(__mutex_00);
  iVar6 = (**(code **)(PTR_PTR_0033ed80 + 0xe0))(param_1 + -0xe);
  if (iVar6 != 0) {
    pthread_mutex_unlock(__mutex);
    FUN_00124ce0(param_1 + -0xe);
    return iVar6;
  }
  *(byte *)(param_1 + -6) = *(byte *)(param_1 + -6) | 1;
  libusb_ref_device(*(undefined8 *)(*param_1 + 0x40));
  pthread_mutex_unlock(__mutex);
  return 0;
}


==================================================================

### FUNC 001252b0 (227 bytes) name=libusb_cancel_transfer

int libusb_cancel_transfer(long *param_1)

{
  byte bVar1;
  int iVar2;
  
  iVar2 = -5;
  FUN_00120cd0(0,4,"libusb_cancel_transfer","transfer %p",param_1);
  pthread_mutex_lock((pthread_mutex_t *)(param_1 + -5));
  if ((*(byte *)(param_1 + -6) & 3) == 1) {
    iVar2 = (**(code **)(PTR_PTR_0033ed80 + 0xe8))(param_1 + -0xe);
    if (iVar2 < 0) {
      if (iVar2 + 5U < 2) {
        FUN_00120cd0(0,4,"libusb_cancel_transfer","cancel transfer failed error %d",iVar2);
      }
      else {
        FUN_00120cd0(*(undefined8 *)(*(long *)(*param_1 + 0x40) + 0x30),1,"libusb_cancel_transfer",
                     "cancel transfer failed error %d",iVar2);
      }
      bVar1 = *(byte *)(param_1 + -6);
      if (iVar2 == -4) {
        bVar1 = bVar1 | 4;
      }
    }
    else {
      bVar1 = *(byte *)(param_1 + -6);
    }
    *(byte *)(param_1 + -6) = bVar1 | 2;
  }
  pthread_mutex_unlock((pthread_mutex_t *)(param_1 + -5));
  return iVar2;
}


==================================================================

### FUNC 001253b0 (283 bytes) name=FUN_001253b0

undefined8 FUN_001253b0(long param_1)

{
  long lVar1;
  long lVar2;
  long lVar3;
  int iVar4;
  undefined8 uVar5;
  int *piVar6;
  long local_38;
  long local_30;
  
  lVar1 = param_1 + 0xb8;
  if (*(long *)(param_1 + 0xc0) != lVar1) {
    uVar5 = (**(code **)(PTR_PTR_0033ed80 + 0x108))(0,&local_38);
    if ((int)uVar5 < 0) {
      return uVar5;
    }
    for (lVar2 = *(long *)(param_1 + 0xc0); lVar1 != lVar2; lVar2 = *(long *)(lVar2 + 8)) {
      while( true ) {
        lVar3 = *(long *)(lVar2 + 0x20);
        if ((lVar3 == 0) && (*(long *)(lVar2 + 0x28) == 0)) {
          return 0;
        }
        if ((*(byte *)(lVar2 + 0x39) & 3) != 0) goto LAB_00125434;
        if (local_38 < lVar3) {
          return 0;
        }
        if ((local_38 == lVar3) && (local_30 / 1000 < *(long *)(lVar2 + 0x28))) {
          return 0;
        }
        *(byte *)(lVar2 + 0x39) = *(byte *)(lVar2 + 0x39) | 2;
        iVar4 = libusb_cancel_transfer(lVar2 + 0x68);
        if (iVar4 == 0) break;
        piVar6 = __errno_location();
        FUN_00120cd0(*(undefined8 *)(*(long *)(*(long *)(lVar2 + 0x68) + 0x40) + 0x30),2,
                     "handle_timeout","async cancel failed %d errno=%d",iVar4,*piVar6);
        lVar2 = *(long *)(lVar2 + 8);
        if (lVar1 == lVar2) {
          return 0;
        }
      }
      *(byte *)(lVar2 + 0x39) = *(byte *)(lVar2 + 0x39) | 4;
LAB_00125434:
    }
  }
  return 0;
}


==================================================================

### FUNC 001254d0 (68 bytes) name=FUN_001254d0

undefined4 FUN_001254d0(long param_1)

{
  undefined4 uVar1;
  
  if (param_1 == 0) {
    param_1 = DAT_003665e8;
  }
  pthread_mutex_lock((pthread_mutex_t *)(param_1 + 200));
  uVar1 = FUN_001253b0(param_1);
  pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 200));
  return uVar1;
}


==================================================================

### FUNC 00125520 (1684 bytes) name=FUN_00125520

int FUN_00125520(void *param_1,int *param_2)

{
  pthread_mutex_t *__mutex;
  pthread_mutex_t *__mutex_00;
  int iVar1;
  long lVar2;
  long *plVar3;
  long *plVar4;
  pollfd *ppVar5;
  undefined *puVar6;
  int iVar7;
  uint uVar8;
  int *piVar9;
  ulong uVar10;
  int iVar11;
  long *__ptr;
  bool bVar12;
  pollfd *local_78;
  nfds_t local_60;
  
  __mutex = (pthread_mutex_t *)((long)param_1 + 400);
  pthread_setspecific(*(pthread_key_t *)((long)param_1 + 0x134),param_1);
  iVar11 = *(int *)((long)param_1 + 0x200);
  pthread_mutex_lock(__mutex);
  uVar10 = ((long)iVar11 >> 0x3f) + 2;
  if ((*(byte *)((long)param_1 + 0x1b8) & 1) == 0) {
LAB_00125660:
    local_78 = *(pollfd **)((long)param_1 + 0x1d0);
    local_60 = *(nfds_t *)((long)param_1 + 0x1d8);
  }
  else {
    FUN_00120cd0(0,4,"handle_events","poll fds modified, reallocating");
    if (*(void **)((long)param_1 + 0x1d0) != (void *)0x0) {
      free(*(void **)((long)param_1 + 0x1d0));
      *(undefined8 *)((long)param_1 + 0x1d0) = 0;
    }
    local_60 = *(ulong *)((long)param_1 + 0x1d8);
    if (local_60 < uVar10) {
                    /* WARNING: Subroutine does not return */
      __assert_fail("ctx->pollfds_cnt >= internal_nfds","io.c",0x843,"handle_events");
    }
    local_78 = calloc(local_60,8);
    *(pollfd **)((long)param_1 + 0x1d0) = local_78;
    if (local_78 == (pollfd *)0x0) {
      iVar11 = -0xb;
      pthread_mutex_unlock(__mutex);
      goto LAB_001259f0;
    }
    ppVar5 = local_78;
    for (lVar2 = *(long *)((long)param_1 + 0x1c8); (long)param_1 + 0x1c0 != lVar2;
        lVar2 = *(long *)(lVar2 + 8)) {
      ppVar5->fd = *(int *)(lVar2 + -8);
      ppVar5->events = *(short *)(lVar2 + -4);
      ppVar5 = ppVar5 + 1;
    }
    *(uint *)((long)param_1 + 0x1b8) = *(uint *)((long)param_1 + 0x1b8) & 0xfffffffe;
    if (((*(long *)((long)param_1 + 0x1b8) == 0) &&
        (*(long *)((long)param_1 + 0x1e8) == (long)param_1 + 0x1e0)) &&
       (*(long *)((long)param_1 + 0x1f8) == (long)param_1 + 0x1f0)) {
      FUN_001213c0(param_1);
      goto LAB_00125660;
    }
  }
  pthread_mutex_unlock(__mutex);
  iVar11 = (*param_2 * 1000 + (int)(*(long *)(param_2 + 2) / 1000) + 1) -
           (uint)(*(long *)(param_2 + 2) % 1000 == 0);
  __mutex_00 = (pthread_mutex_t *)((long)param_1 + 200);
  lVar2 = (long)param_1 + 0x1e0;
  while( true ) {
    FUN_00120cd0(0,4,"handle_events","poll() %d fds with timeout in %dms",local_60,iVar11);
    iVar7 = poll(local_78,local_60,iVar11);
    FUN_00120cd0(0,4,"handle_events","poll() returned %d",iVar7);
    if (iVar7 == 0) break;
    if (iVar7 == -1) {
      piVar9 = __errno_location();
      iVar1 = *piVar9;
      if (iVar1 == 4) {
        iVar11 = -10;
      }
      else {
LAB_001259c2:
        iVar11 = -1;
        FUN_00120cd0(param_1,1,"handle_events","poll failed %d err=%d",iVar7,iVar1);
      }
      goto LAB_001259f0;
    }
    if (iVar7 < 0) {
      piVar9 = __errno_location();
      iVar1 = *piVar9;
      goto LAB_001259c2;
    }
    bVar12 = false;
    if (local_78->revents == 0) {
LAB_00125708:
      if ((*(int *)((long)param_1 + 0x200) < 0) || (local_78[1].revents == 0)) {
LAB_00125721:
        iVar11 = (**(code **)(PTR_PTR_0033ed80 + 0xf8))
                           (param_1,local_78 + uVar10,local_60 - uVar10,iVar7);
        if (iVar11 == 0) goto LAB_0012574b;
        FUN_00120cd0(param_1,1,"handle_events","backend handle_events failed with error %d",iVar11);
        goto LAB_001259f0;
      }
      FUN_00120cd0(0,4,"handle_events","timerfd triggered");
      pthread_mutex_lock(__mutex_00);
      iVar11 = FUN_001253b0(param_1);
      if (iVar11 < 0) {
        pthread_mutex_unlock(__mutex_00);
        goto LAB_001259f0;
      }
      iVar11 = FUN_00124bc0(param_1);
      pthread_mutex_unlock(__mutex_00);
      if (iVar11 < 0) goto LAB_001259f0;
      iVar7 = iVar7 + -1;
      if (iVar7 != 0) {
        bVar12 = true;
        goto LAB_00125721;
      }
    }
    else {
      FUN_00120cd0(0,4,"handle_events","caught a fish on the event pipe");
      pthread_mutex_lock(__mutex);
      uVar8 = *(uint *)((long)param_1 + 0x1b8);
      if ((uVar8 & 1) != 0) {
        FUN_00120cd0(0,4,"handle_events","someone updated the poll fds");
        uVar8 = *(uint *)((long)param_1 + 0x1b8);
      }
      if ((uVar8 & 2) == 0) {
        iVar11 = *(int *)((long)param_1 + 0x1bc);
      }
      else {
        FUN_00120cd0(0,4,"handle_events","someone purposely interrupted");
        iVar11 = *(int *)((long)param_1 + 0x1bc);
        *(uint *)((long)param_1 + 0x1b8) = *(uint *)((long)param_1 + 0x1b8) & 0xfffffffd;
      }
      if (iVar11 != 0) {
        FUN_00120cd0(0,4,"handle_events","someone is closing a device");
      }
      bVar12 = *(long *)((long)param_1 + 0x1e8) == lVar2;
      if (bVar12) {
        __ptr = (long *)0x0;
      }
      else {
        FUN_00120cd0(0,4,"handle_events","hotplug message received");
        plVar3 = *(long **)((long)param_1 + 0x1e8);
        __ptr = plVar3 + -2;
        plVar4 = (long *)plVar3[1];
        *plVar4 = *plVar3;
        *(long **)(*plVar3 + 8) = plVar4;
        *plVar3 = 0;
        plVar3[1] = 0;
      }
      puVar6 = PTR_PTR_0033ed80;
      bVar12 = !bVar12;
      plVar3 = *(long **)((long)param_1 + 0x1f8);
      while (plVar3 != (long *)((long)param_1 + 0x1f0)) {
        plVar4 = (long *)plVar3[1];
        *plVar4 = *plVar3;
        *(long **)(*plVar3 + 8) = plVar4;
        *plVar3 = 0;
        plVar3[1] = 0;
        pthread_mutex_unlock(__mutex);
        iVar11 = (**(code **)(puVar6 + 0x100))(plVar3 + -3);
        if (iVar11 != 0) {
          FUN_00120cd0(param_1,1,"handle_events",
                       "backend handle_transfer_completion failed with error %d",iVar11);
          pthread_mutex_lock(__mutex);
          goto LAB_00125910;
        }
        pthread_mutex_lock(__mutex);
        plVar3 = *(long **)((long)param_1 + 0x1f8);
      }
      iVar11 = 0;
LAB_00125910:
      if (((*(long *)((long)param_1 + 0x1b8) == 0) && (lVar2 == *(long *)((long)param_1 + 0x1e8)))
         && (*(long **)((long)param_1 + 0x1f8) == (long *)((long)param_1 + 0x1f0))) {
        FUN_001213c0(param_1);
      }
      pthread_mutex_unlock(__mutex);
      if (__ptr != (long *)0x0) {
        FUN_00124630(param_1,__ptr[1],(int)*__ptr);
        if ((int)*__ptr == 2) {
          libusb_unref_device(__ptr[1]);
        }
        free(__ptr);
      }
      if (iVar11 != 0) goto LAB_001259f0;
      iVar7 = iVar7 + -1;
      if (iVar7 != 0) goto LAB_00125708;
LAB_0012574b:
      if (!bVar12) {
        iVar11 = 0;
        goto LAB_001259f0;
      }
    }
    iVar11 = 0;
  }
  iVar11 = FUN_001254d0(param_1);
LAB_001259f0:
  pthread_setspecific(*(pthread_key_t *)((long)param_1 + 0x134),(void *)0x0);
  return iVar11;
}


==================================================================

### FUNC 00125bf0 (4 bytes) name=libusb_transfer_set_stream_id

void libusb_transfer_set_stream_id(long param_1,undefined4 param_2)

{
  *(undefined4 *)(param_1 + -0x34) = param_2;
  return;
}


==================================================================

### FUNC 00125c00 (4 bytes) name=libusb_transfer_get_stream_id

undefined4 libusb_transfer_get_stream_id(long param_1)

{
  return *(undefined4 *)(param_1 + -0x34);
}


==================================================================

### FUNC 00125c10 (317 bytes) name=FUN_00125c10

int FUN_00125c10(long param_1,int param_2)

{
  long lVar1;
  long lVar2;
  int iVar3;
  int iVar4;
  int iVar5;
  int *piVar6;
  byte bVar7;
  
  lVar1 = param_1 + 0x70;
  lVar2 = *(long *)(param_1 + 0x70);
  iVar4 = FUN_00124ce0();
  if (iVar4 < 0) {
    piVar6 = __errno_location();
    FUN_00120cd0(*(undefined8 *)(*(long *)(*(long *)(param_1 + 0x70) + 0x40) + 0x30),1,
                 "usbi_handle_transfer_completion","failed to set timer for next timeout, errno=%d",
                 *piVar6);
  }
  pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0x48));
  *(byte *)(param_1 + 0x40) = *(byte *)(param_1 + 0x40) & 0xfe;
  pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0x48));
  bVar7 = *(byte *)(param_1 + 0x78);
  if ((param_2 == 0) && ((bVar7 & 1) != 0)) {
    iVar3 = *(int *)(param_1 + 0x84);
    if (*(char *)(param_1 + 0x7a) == '\0') {
      iVar3 = *(int *)(param_1 + 0x84) + -8;
    }
    iVar5 = *(int *)(param_1 + 0x38);
    if (iVar5 != iVar3) {
      param_2 = 1;
      FUN_00120cd0(0,4,"usbi_handle_transfer_completion","interpreting short transfer as error");
      bVar7 = *(byte *)(param_1 + 0x78);
      iVar5 = *(int *)(param_1 + 0x38);
    }
  }
  else {
    iVar5 = *(int *)(param_1 + 0x38);
  }
  *(int *)(param_1 + 0x88) = iVar5;
  *(int *)(param_1 + 0x80) = param_2;
  FUN_00120cd0(0,4,"usbi_handle_transfer_completion","transfer %p has callback %p",lVar1,
               *(undefined8 *)(param_1 + 0x90));
  if (*(code **)(param_1 + 0x90) != (code *)0x0) {
    (**(code **)(param_1 + 0x90))(lVar1);
  }
  if ((bVar7 & 4) != 0) {
    libusb_free_transfer(lVar1);
  }
  libusb_unref_device(*(undefined8 *)(lVar2 + 0x40));
  return iVar4;
}


==================================================================

### FUNC 00125d60 (104 bytes) name=FUN_00125d60

void FUN_00125d60(long param_1)

{
  byte bVar1;
  undefined8 uVar2;
  pthread_mutex_t *__mutex;
  
  __mutex = (pthread_mutex_t *)(*(long *)(*(long *)(*(long *)(param_1 + 0x70) + 0x40) + 0x30) + 200)
  ;
  pthread_mutex_lock(__mutex);
  bVar1 = *(byte *)(param_1 + 0x41);
  pthread_mutex_unlock(__mutex);
  uVar2 = 3;
  if ((bVar1 & 4) != 0) {
    FUN_00120cd0(0,4,"usbi_handle_transfer_cancellation","detected timeout cancellation");
    uVar2 = 2;
  }
  FUN_00125c10(param_1,uVar2);
  return;
}


==================================================================

### FUNC 00125dd0 (182 bytes) name=FUN_00125dd0

void FUN_00125dd0(long param_1)

{
  long lVar1;
  
  lVar1 = *(long *)(*(long *)(*(long *)(param_1 + 0x70) + 0x40) + 0x30);
  pthread_mutex_lock((pthread_mutex_t *)(lVar1 + 400));
  if (((*(long *)(lVar1 + 0x1b8) == 0) && (*(long *)(lVar1 + 0x1e8) == lVar1 + 0x1e0)) &&
     (*(long *)(lVar1 + 0x1f8) == lVar1 + 0x1f0)) {
    *(long *)(param_1 + 0x20) = *(long *)(lVar1 + 0x1f8);
    *(undefined8 *)(param_1 + 0x18) = *(undefined8 *)(lVar1 + 0x1f0);
    *(long *)(*(long *)(lVar1 + 0x1f0) + 8) = param_1 + 0x18;
    *(long *)(lVar1 + 0x1f0) = param_1 + 0x18;
    FUN_00121360(lVar1);
  }
  else {
    *(long *)(param_1 + 0x20) = lVar1 + 0x1f0;
    *(undefined8 *)(param_1 + 0x18) = *(undefined8 *)(lVar1 + 0x1f0);
    *(long *)(*(long *)(lVar1 + 0x1f0) + 8) = param_1 + 0x18;
    *(long *)(lVar1 + 0x1f0) = param_1 + 0x18;
  }
  pthread_mutex_unlock((pthread_mutex_t *)(lVar1 + 400));
  return;
}


==================================================================

### FUNC 00125e90 (146 bytes) name=libusb_try_lock_events

bool libusb_try_lock_events(long param_1)

{
  int iVar1;
  
  if (param_1 == 0) {
    param_1 = DAT_003665e8;
  }
  pthread_mutex_lock((pthread_mutex_t *)(param_1 + 400));
  iVar1 = *(int *)(param_1 + 0x1bc);
  pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 400));
  if (iVar1 == 0) {
    iVar1 = pthread_mutex_trylock((pthread_mutex_t *)(param_1 + 0x108));
    if (iVar1 == 0) {
      *(undefined4 *)(param_1 + 0x130) = 1;
    }
    return iVar1 != 0;
  }
  FUN_00120cd0(0,4,"libusb_try_lock_events","someone else is closing a device");
  return true;
}


==================================================================

### FUNC 00125f30 (45 bytes) name=libusb_lock_events

void libusb_lock_events(long param_1)

{
  if (param_1 == 0) {
    param_1 = DAT_003665e8;
  }
  pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0x108));
  *(undefined4 *)(param_1 + 0x130) = 1;
  return;
}


==================================================================

### FUNC 00125f70 (89 bytes) name=libusb_unlock_events

void libusb_unlock_events(long param_1)

{
  if (param_1 == 0) {
    param_1 = DAT_003665e8;
  }
  *(undefined4 *)(param_1 + 0x130) = 0;
  pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0x108));
  pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0x138));
  pthread_cond_broadcast((pthread_cond_t *)(param_1 + 0x160));
  pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0x138));
  return;
}


==================================================================

### FUNC 00125fd0 (101 bytes) name=libusb_event_handling_ok

bool libusb_event_handling_ok(long param_1)

{
  int iVar1;
  bool bVar2;
  
  if (param_1 == 0) {
    param_1 = DAT_003665e8;
  }
  pthread_mutex_lock((pthread_mutex_t *)(param_1 + 400));
  iVar1 = *(int *)(param_1 + 0x1bc);
  pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 400));
  bVar2 = iVar1 == 0;
  if (!bVar2) {
    FUN_00120cd0(0,4,"libusb_event_handling_ok","someone else is closing a device");
  }
  return bVar2;
}


==================================================================

### FUNC 00126040 (108 bytes) name=libusb_event_handler_active

undefined4 libusb_event_handler_active(long param_1)

{
  int iVar1;
  
  if (param_1 == 0) {
    param_1 = DAT_003665e8;
  }
  pthread_mutex_lock((pthread_mutex_t *)(param_1 + 400));
  iVar1 = *(int *)(param_1 + 0x1bc);
  pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 400));
  if (iVar1 == 0) {
    return *(undefined4 *)(param_1 + 0x130);
  }
  FUN_00120cd0(0,4,"libusb_event_handler_active","someone else is closing a device");
  return 1;
}


==================================================================

### FUNC 001260c0 (149 bytes) name=libusb_interrupt_event_handler

void libusb_interrupt_event_handler(long param_1)

{
  if (param_1 == 0) {
    param_1 = DAT_003665e8;
  }
  FUN_00120cd0(0,4,"libusb_interrupt_event_handler",&DAT_00131fd1);
  pthread_mutex_lock((pthread_mutex_t *)(param_1 + 400));
  if (((*(long *)(param_1 + 0x1b8) == 0) && (*(long *)(param_1 + 0x1e8) == param_1 + 0x1e0)) &&
     (*(long *)(param_1 + 0x1f8) == param_1 + 0x1f0)) {
    *(uint *)(param_1 + 0x1b8) = *(uint *)(param_1 + 0x1b8) | 2;
    FUN_00121360(param_1);
  }
  pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 400));
  return;
}


==================================================================

### FUNC 00126160 (39 bytes) name=libusb_lock_event_waiters

void libusb_lock_event_waiters(long param_1)

{
  if (param_1 != 0) {
    pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0x138));
    return;
  }
  pthread_mutex_lock((pthread_mutex_t *)(DAT_003665e8 + 0x138));
  return;
}


==================================================================

### FUNC 00126190 (39 bytes) name=libusb_unlock_event_waiters

void libusb_unlock_event_waiters(long param_1)

{
  if (param_1 != 0) {
    pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0x138));
    return;
  }
  pthread_mutex_unlock((pthread_mutex_t *)(DAT_003665e8 + 0x138));
  return;
}


==================================================================

### FUNC 001261c0 (78 bytes) name=libusb_wait_for_event

ulong libusb_wait_for_event(long param_1,long param_2)

{
  ulong uVar1;
  
  if (param_1 == 0) {
    param_1 = DAT_003665e8;
  }
  if (param_2 != 0) {
    uVar1 = FUN_001274b0();
    if (-1 < (int)uVar1) {
      uVar1 = (ulong)((int)uVar1 == 0x6e);
    }
    return uVar1;
  }
  pthread_cond_wait((pthread_cond_t *)(param_1 + 0x160),(pthread_mutex_t *)(param_1 + 0x138));
  return 0;
}


==================================================================

### FUNC 00126220 (39 bytes) name=libusb_pollfds_handle_timeouts

uint libusb_pollfds_handle_timeouts(long param_1)

{
  if (param_1 != 0) {
    return ~*(uint *)(param_1 + 0x200) >> 0x1f;
  }
  return ~*(uint *)(DAT_003665e8 + 0x200) >> 0x1f;
}


==================================================================

### FUNC 00126250 (567 bytes) name=libusb_get_next_timeout

undefined8 libusb_get_next_timeout(long param_1,long *param_2)

{
  pthread_mutex_t *__mutex;
  long lVar1;
  byte bVar2;
  bool bVar3;
  int iVar4;
  int *piVar5;
  long lVar6;
  long local_38;
  long local_30;
  
  if (param_1 == 0) {
    param_1 = DAT_003665e8;
  }
  if (*(int *)(param_1 + 0x200) < 0) {
    __mutex = (pthread_mutex_t *)(param_1 + 200);
    pthread_mutex_lock(__mutex);
    lVar6 = *(long *)(param_1 + 0xc0);
    lVar1 = param_1 + 0xb8;
    if (lVar6 == lVar1) {
      pthread_mutex_unlock(__mutex);
      FUN_00120cd0(0,4,"libusb_get_next_timeout","no URBs, no timeout!");
    }
    else {
      if (lVar1 != lVar6) {
        bVar2 = *(byte *)(lVar6 + 0x39);
        while ((bVar2 & 3) != 0) {
          lVar6 = *(long *)(lVar6 + 8);
          if (lVar1 == lVar6) goto LAB_001263b0;
          bVar2 = *(byte *)(lVar6 + 0x39);
        }
        lVar1 = *(long *)(lVar6 + 0x20);
        lVar6 = *(long *)(lVar6 + 0x28);
        if ((lVar1 != 0) || (lVar6 != 0)) {
          pthread_mutex_unlock(__mutex);
          iVar4 = (**(code **)(PTR_PTR_0033ed80 + 0x108))(0,&local_38);
          if (iVar4 < 0) {
            piVar5 = __errno_location();
            FUN_00120cd0(param_1,1,"libusb_get_next_timeout",
                         "failed to read monotonic clock, errno=%d",*piVar5);
            return 0;
          }
          bVar3 = lVar1 <= local_38;
          if (lVar1 == local_38) {
            bVar3 = lVar6 <= local_30 / 1000;
          }
          if (bVar3) {
            FUN_00120cd0(0,4,"libusb_get_next_timeout","first timeout already expired");
            param_2[1] = 0;
            *param_2 = 0;
            return 1;
          }
          lVar6 = lVar6 - local_30 / 1000;
          *param_2 = lVar1 - local_38;
          param_2[1] = lVar6;
          if (lVar6 < 0) {
            *param_2 = (lVar1 - local_38) + -1;
            param_2[1] = lVar6 + 1000000;
          }
          FUN_00120cd0(0,4,"libusb_get_next_timeout","next timeout in %d.%06ds");
          return 1;
        }
      }
LAB_001263b0:
      pthread_mutex_unlock(__mutex);
      FUN_00120cd0(0,4,"libusb_get_next_timeout",
                   "no URB with timeout or all handled by OS; no timeout!");
    }
  }
  return 0;
}


==================================================================

### FUNC 001264b0 (142 bytes) name=FUN_001264b0

undefined8 FUN_001264b0(undefined8 param_1,long *param_2,long *param_3)

{
  long lVar1;
  bool bVar2;
  int iVar3;
  long local_28;
  long local_20;
  
  iVar3 = libusb_get_next_timeout(param_1,&local_28);
  if (iVar3 == 0) goto LAB_00126500;
  if (local_28 == 0) {
    if (local_20 == 0) {
      return 1;
    }
    bVar2 = 0 < *param_2;
    if (*param_2 == 0) goto LAB_0012653b;
  }
  else {
    bVar2 = local_28 < *param_2;
    if (local_28 == *param_2) {
LAB_0012653b:
      bVar2 = local_20 < param_2[1];
    }
  }
  if (bVar2) {
    *param_3 = local_28;
    param_3[1] = local_20;
    return 0;
  }
LAB_00126500:
  lVar1 = param_2[1];
  *param_3 = *param_2;
  param_3[1] = lVar1;
  return 0;
}


==================================================================

### FUNC 00126550 (351 bytes) name=libusb_handle_events_timeout_completed

ulong libusb_handle_events_timeout_completed(long param_1,undefined8 param_2,int *param_3)

{
  int iVar1;
  uint uVar2;
  void *pvVar3;
  ulong uVar4;
  undefined1 auStack_38 [24];
  
  if (param_1 == 0) {
    param_1 = DAT_003665e8;
  }
  iVar1 = FUN_001264b0(param_1,param_2,auStack_38);
  if (iVar1 == 0) {
    while( true ) {
      iVar1 = libusb_try_lock_events(param_1);
      if (iVar1 == 0) {
        if ((param_3 == (int *)0x0) || (uVar4 = 0, *param_3 == 0)) {
          uVar4 = 0xfffffffa;
          FUN_00120cd0(0,4,"libusb_handle_events_timeout_completed","doing our own event handling");
          pvVar3 = pthread_getspecific(*(pthread_key_t *)(param_1 + 0x134));
          if (pvVar3 == (void *)0x0) {
            uVar2 = FUN_00125520(param_1,auStack_38);
            uVar4 = (ulong)uVar2;
          }
        }
        libusb_unlock_events(param_1);
        return uVar4;
      }
      libusb_lock_event_waiters(param_1);
      if ((param_3 != (int *)0x0) && (*param_3 != 0)) {
        libusb_unlock_event_waiters(param_1);
        return 0;
      }
      iVar1 = libusb_event_handler_active();
      if (iVar1 != 0) break;
      libusb_unlock_event_waiters(param_1);
      FUN_00120cd0(0,4,"libusb_handle_events_timeout_completed",
                   "event handler was active but went away, retrying");
    }
    FUN_00120cd0(0,4,"libusb_handle_events_timeout_completed",
                 "another thread is doing event handling");
    uVar2 = libusb_wait_for_event(param_1,auStack_38);
    libusb_unlock_event_waiters(param_1);
    if ((int)uVar2 < 0) {
      return (ulong)uVar2;
    }
    if (uVar2 != 1) {
      return 0;
    }
  }
  uVar4 = FUN_001254d0(param_1);
  return uVar4;
}


==================================================================

### FUNC 001266d0 (7 bytes) name=libusb_handle_events_timeout

void libusb_handle_events_timeout(undefined8 param_1,undefined8 param_2)

{
  libusb_handle_events_timeout_completed(param_1,param_2,0);
  return;
}


==================================================================

### FUNC 001266e0 (36 bytes) name=libusb_handle_events

void libusb_handle_events(undefined8 param_1)

{
  undefined8 local_18;
  undefined8 local_10;
  
  local_18 = 0x3c;
  local_10 = 0;
  libusb_handle_events_timeout_completed(param_1,&local_18,0);
  return;
}


==================================================================

### FUNC 00126710 (37 bytes) name=libusb_handle_events_completed

void libusb_handle_events_completed(undefined8 param_1,undefined8 param_2)

{
  undefined8 local_18;
  undefined8 local_10;
  
  local_18 = 0x3c;
  local_10 = 0;
  libusb_handle_events_timeout_completed(param_1,&local_18,param_2);
  return;
}


==================================================================

### FUNC 00126740 (98 bytes) name=libusb_handle_events_locked

undefined8 libusb_handle_events_locked(long param_1,undefined8 param_2)

{
  int iVar1;
  void *pvVar2;
  undefined8 uVar3;
  undefined1 auStack_28 [24];
  
  if (param_1 == 0) {
    param_1 = DAT_003665e8;
  }
  iVar1 = FUN_001264b0(param_1,param_2,auStack_28);
  if (iVar1 == 0) {
    pvVar2 = pthread_getspecific(*(pthread_key_t *)(param_1 + 0x134));
    uVar3 = 0xfffffffa;
    if (pvVar2 == (void *)0x0) {
      uVar3 = FUN_00125520(param_1,auStack_28);
    }
    return uVar3;
  }
  uVar3 = FUN_001254d0(param_1);
  return uVar3;
}


==================================================================

### FUNC 001267b0 (39 bytes) name=libusb_set_pollfd_notifiers

void libusb_set_pollfd_notifiers
               (long param_1,undefined8 param_2,undefined8 param_3,undefined8 param_4)

{
  if (param_1 == 0) {
    param_1 = DAT_003665e8;
  }
  *(undefined8 *)(param_1 + 0xf0) = param_2;
  *(undefined8 *)(param_1 + 0xf8) = param_3;
  *(undefined8 *)(param_1 + 0x100) = param_4;
  return;
}


==================================================================

### FUNC 001267e0 (216 bytes) name=FUN_001267e0

undefined8 FUN_001267e0(long param_1,undefined4 param_2,short param_3)

{
  undefined4 *puVar1;
  undefined8 uVar2;
  
  puVar1 = malloc(0x18);
  if (puVar1 == (undefined4 *)0x0) {
    uVar2 = 0xfffffff5;
  }
  else {
    FUN_00120cd0(0,4,"usbi_add_pollfd","add fd %d events %d",param_2,(int)param_3);
    *(short *)(puVar1 + 1) = param_3;
    *puVar1 = param_2;
    pthread_mutex_lock((pthread_mutex_t *)(param_1 + 400));
    *(long *)(puVar1 + 4) = param_1 + 0x1c0;
    *(undefined8 *)(puVar1 + 2) = *(undefined8 *)(param_1 + 0x1c0);
    uVar2 = 0;
    *(undefined4 **)(*(long *)(param_1 + 0x1c0) + 8) = puVar1 + 2;
    *(long *)(param_1 + 0x1d8) = *(long *)(param_1 + 0x1d8) + 1;
    *(undefined4 **)(param_1 + 0x1c0) = puVar1 + 2;
    FUN_00124b70(param_1);
    pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 400));
    if (*(code **)(param_1 + 0xf0) != (code *)0x0) {
      (**(code **)(param_1 + 0xf0))(param_2,(int)param_3,*(undefined8 *)(param_1 + 0x100));
    }
  }
  return uVar2;
}


==================================================================

### FUNC 001268c0 (266 bytes) name=FUN_001268c0

void FUN_001268c0(long param_1,int param_2)

{
  pthread_mutex_t *__mutex;
  long *plVar1;
  long *plVar2;
  
  __mutex = (pthread_mutex_t *)(param_1 + 400);
  FUN_00120cd0(0,4,"usbi_remove_pollfd","remove fd %d",param_2);
  pthread_mutex_lock(__mutex);
  plVar1 = *(long **)(param_1 + 0x1c8);
  do {
    plVar2 = plVar1;
    if ((long *)(param_1 + 0x1c0) == plVar2) {
      FUN_00120cd0(0,4,"usbi_remove_pollfd","couldn\'t find fd %d to remove",param_2);
      pthread_mutex_unlock(__mutex);
      return;
    }
    plVar1 = (long *)plVar2[1];
  } while ((int)plVar2[-1] != param_2);
  *plVar1 = *plVar2;
  *(long **)(*plVar2 + 8) = plVar1;
  *plVar2 = 0;
  plVar2[1] = 0;
  *(long *)(param_1 + 0x1d8) = *(long *)(param_1 + 0x1d8) + -1;
  FUN_00124b70(param_1);
  pthread_mutex_unlock(__mutex);
  free(plVar2 + -1);
  if (*(code **)(param_1 + 0xf8) == (code *)0x0) {
    return;
  }
                    /* WARNING: Could not recover jumptable at 0x00126993. Too many branches */
                    /* WARNING: Treating indirect jump as call */
  (**(code **)(param_1 + 0xf8))(param_2,*(undefined8 *)(param_1 + 0x100));
  return;
}


==================================================================

### FUNC 001269e0 (550 bytes) name=FUN_001269e0

int FUN_001269e0(long param_1)

{
  int iVar1;
  clockid_t __clock_id;
  int *piVar2;
  
  pthread_mutex_init((pthread_mutex_t *)(param_1 + 200),(pthread_mutexattr_t *)0x0);
  pthread_mutex_init((pthread_mutex_t *)(param_1 + 0x108),(pthread_mutexattr_t *)0x0);
  pthread_mutex_init((pthread_mutex_t *)(param_1 + 0x138),(pthread_mutexattr_t *)0x0);
  pthread_cond_init((pthread_cond_t *)(param_1 + 0x160),(pthread_condattr_t *)0x0);
  pthread_mutex_init((pthread_mutex_t *)(param_1 + 400),(pthread_mutexattr_t *)0x0);
  pthread_key_create((pthread_key_t *)(param_1 + 0x134),(__destr_function *)0x0);
  *(long *)(param_1 + 0xc0) = param_1 + 0xb8;
  *(long *)(param_1 + 0xb8) = param_1 + 0xb8;
  *(long *)(param_1 + 0x1c8) = param_1 + 0x1c0;
  *(long *)(param_1 + 0x1c0) = param_1 + 0x1c0;
  *(long *)(param_1 + 0x1e8) = param_1 + 0x1e0;
  *(long *)(param_1 + 0x1e0) = param_1 + 0x1e0;
  *(long *)(param_1 + 0x1f8) = param_1 + 0x1f0;
  *(long *)(param_1 + 0x1f0) = param_1 + 0x1f0;
  iVar1 = FUN_00127400(param_1 + 8);
  if (iVar1 < 0) {
    iVar1 = -99;
  }
  else {
    iVar1 = FUN_001267e0(param_1,*(undefined4 *)(param_1 + 8),1);
    if (-1 < iVar1) {
      __clock_id = (**(code **)(PTR_PTR_0033ed80 + 0x110))();
      iVar1 = timerfd_create(__clock_id,0x800);
      *(int *)(param_1 + 0x200) = iVar1;
      if (iVar1 < 0) {
        piVar2 = __errno_location();
        FUN_00120cd0(0,4,"usbi_io_init","timerfd not available (code %d error %d)",iVar1,*piVar2);
        *(undefined4 *)(param_1 + 0x200) = 0xffffffff;
        return 0;
      }
      FUN_00120cd0(0,4,"usbi_io_init","using timerfd for timeouts");
      iVar1 = FUN_001267e0(param_1,*(undefined4 *)(param_1 + 0x200),1);
      if (-1 < iVar1) {
        return 0;
      }
      close(*(int *)(param_1 + 0x200));
      FUN_001268c0(param_1,*(undefined4 *)(param_1 + 8));
    }
    close(*(int *)(param_1 + 8));
    close(*(int *)(param_1 + 0xc));
  }
  pthread_mutex_destroy((pthread_mutex_t *)(param_1 + 200));
  pthread_mutex_destroy((pthread_mutex_t *)(param_1 + 0x108));
  pthread_mutex_destroy((pthread_mutex_t *)(param_1 + 0x138));
  pthread_cond_destroy((pthread_cond_t *)(param_1 + 0x160));
  pthread_mutex_destroy((pthread_mutex_t *)(param_1 + 400));
  pthread_key_delete(*(pthread_key_t *)(param_1 + 0x134));
  return iVar1;
}


==================================================================

### FUNC 00126c20 (148 bytes) name=FUN_00126c20

void FUN_00126c20(long param_1)

{
  FUN_001268c0(param_1,*(undefined4 *)(param_1 + 8));
  close(*(int *)(param_1 + 8));
  close(*(int *)(param_1 + 0xc));
  if (-1 < *(int *)(param_1 + 0x200)) {
    FUN_001268c0(param_1);
    close(*(int *)(param_1 + 0x200));
  }
  pthread_mutex_destroy((pthread_mutex_t *)(param_1 + 200));
  pthread_mutex_destroy((pthread_mutex_t *)(param_1 + 0x108));
  pthread_mutex_destroy((pthread_mutex_t *)(param_1 + 0x138));
  pthread_cond_destroy((pthread_cond_t *)(param_1 + 0x160));
  pthread_mutex_destroy((pthread_mutex_t *)(param_1 + 400));
  pthread_key_delete(*(pthread_key_t *)(param_1 + 0x134));
  if (*(void **)(param_1 + 0x1d0) != (void *)0x0) {
    free(*(void **)(param_1 + 0x1d0));
    return;
  }
  return;
}


==================================================================

### FUNC 00126cc0 (162 bytes) name=libusb_get_pollfds

long * libusb_get_pollfds(long param_1)

{
  long lVar1;
  long lVar2;
  long *plVar3;
  long *plVar4;
  
  if (param_1 == 0) {
    param_1 = DAT_003665e8;
  }
  pthread_mutex_lock((pthread_mutex_t *)(param_1 + 400));
  lVar1 = *(long *)(param_1 + 0x1d8);
  plVar3 = calloc(lVar1 + 1,8);
  if (plVar3 != (long *)0x0) {
    plVar4 = plVar3;
    for (lVar2 = *(long *)(param_1 + 0x1c8); param_1 + 0x1c0 != lVar2; lVar2 = *(long *)(lVar2 + 8))
    {
      *plVar4 = lVar2 + -8;
      plVar4 = plVar4 + 1;
    }
    plVar3[lVar1] = 0;
  }
  pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 400));
  return plVar3;
}


==================================================================

### FUNC 00126d70 (12 bytes) name=libusb_free_pollfds

void libusb_free_pollfds(void *param_1)

{
  if (param_1 != (void *)0x0) {
    free(param_1);
    return;
  }
  return;
}


==================================================================

### FUNC 00126d90 (314 bytes) name=FUN_00126d90

void FUN_00126d90(long param_1)

{
  pthread_mutex_t *__mutex;
  long lVar1;
  long lVar2;
  long lVar3;
  
  FUN_00120cd0(0,4,"usbi_handle_disconnect","device %d.%d",
               *(undefined1 *)(*(long *)(param_1 + 0x40) + 0x38),
               *(undefined1 *)(*(long *)(param_1 + 0x40) + 0x48));
LAB_00126dc8:
  pthread_mutex_lock((pthread_mutex_t *)(*(long *)(*(long *)(param_1 + 0x40) + 0x30) + 200));
  lVar3 = *(long *)(param_1 + 0x40);
  lVar2 = *(long *)(lVar3 + 0x30);
  lVar1 = *(long *)(lVar2 + 0xc0);
  if (lVar1 == lVar2 + 0xb8) {
LAB_00126eb0:
    pthread_mutex_unlock((pthread_mutex_t *)(lVar2 + 200));
    return;
  }
  do {
    if (*(long *)(lVar1 + 0x68) == param_1) {
      __mutex = (pthread_mutex_t *)(lVar1 + 0x40);
      pthread_mutex_lock(__mutex);
      if ((*(byte *)(lVar1 + 0x38) & 1) != 0) break;
      pthread_mutex_unlock(__mutex);
      lVar3 = *(long *)(param_1 + 0x40);
    }
    lVar2 = *(long *)(lVar3 + 0x30);
    lVar1 = *(long *)(lVar1 + 8);
    if (lVar1 == lVar2 + 0xb8) goto LAB_00126eb0;
  } while( true );
  pthread_mutex_unlock(__mutex);
  pthread_mutex_unlock((pthread_mutex_t *)(*(long *)(*(long *)(param_1 + 0x40) + 0x30) + 200));
  FUN_00120cd0(0,4,"usbi_handle_disconnect","cancelling transfer %p from disconnect",lVar1 + 0x68);
  pthread_mutex_lock(__mutex);
  (**(code **)(PTR_PTR_0033ed80 + 0xf0))(lVar1 + -8);
  pthread_mutex_unlock(__mutex);
  FUN_00125c10(lVar1 + -8,5);
  goto LAB_00126dc8;
}


==================================================================

### FUNC 00126ee0 (42 bytes) name=FUN_00126ee0

void FUN_00126ee0(long param_1)

{
  **(undefined4 **)(param_1 + 0x28) = 1;
  FUN_00120cd0(0,4,"sync_transfer_cb","actual_length=%d",*(undefined4 *)(param_1 + 0x18));
  return;
}


==================================================================

### FUNC 00126f10 (117 bytes) name=FUN_00126f10

void FUN_00126f10(long *param_1)

{
  int *piVar1;
  undefined8 uVar2;
  int iVar3;
  undefined8 uVar4;
  
  piVar1 = (int *)param_1[5];
  uVar2 = *(undefined8 *)(*(long *)(*param_1 + 0x40) + 0x30);
  do {
    if (*piVar1 != 0) {
      return;
    }
    while ((iVar3 = libusb_handle_events_completed(uVar2,piVar1), iVar3 < 0 && (iVar3 != -10))) {
      uVar4 = libusb_error_name(iVar3);
      FUN_00120cd0(uVar2,1,"sync_transfer_wait_for_completion",
                   "libusb_handle_events failed: %s, cancelling transfer and retrying",uVar4);
      libusb_cancel_transfer(param_1);
      if (*piVar1 != 0) {
        return;
      }
    }
  } while( true );
}


==================================================================

### FUNC 00126f90 (360 bytes) name=FUN_00126f90

int FUN_00126f90(long param_1,undefined1 param_2,long param_3,undefined4 param_4,undefined4 *param_5
                ,undefined4 param_6,undefined1 param_7)

{
  int iVar1;
  void *pvVar2;
  long *plVar3;
  undefined4 local_3c [3];
  
  local_3c[0] = 0;
  pvVar2 = pthread_getspecific(*(pthread_key_t *)
                                (*(long *)(*(long *)(param_1 + 0x40) + 0x30) + 0x134));
  iVar1 = -6;
  if (pvVar2 == (void *)0x0) {
    plVar3 = (long *)libusb_alloc_transfer(0);
    if (plVar3 == (long *)0x0) {
      iVar1 = -0xb;
    }
    else {
      *plVar3 = param_1;
      *(undefined1 *)((long)plVar3 + 9) = param_2;
      *(undefined4 *)((long)plVar3 + 0xc) = param_6;
      plVar3[6] = param_3;
      *(undefined4 *)((long)plVar3 + 0x14) = param_4;
      plVar3[4] = (long)FUN_00126ee0;
      plVar3[5] = (long)local_3c;
      *(undefined1 *)((long)plVar3 + 10) = param_7;
      iVar1 = libusb_submit_transfer(plVar3);
      if (iVar1 < 0) {
        libusb_free_transfer(plVar3);
      }
      else {
        FUN_00126f10(plVar3);
        if (param_5 != (undefined4 *)0x0) {
          *param_5 = (int)plVar3[3];
        }
        switch((int)plVar3[2]) {
        case 0:
          iVar1 = 0;
          break;
        case 1:
        case 3:
          iVar1 = -1;
          break;
        case 2:
          iVar1 = -7;
          break;
        case 4:
          iVar1 = -9;
          break;
        case 5:
          iVar1 = -4;
          break;
        case 6:
          iVar1 = -8;
          break;
        default:
          iVar1 = -99;
          FUN_00120cd0(*(undefined8 *)(*(long *)(param_1 + 0x40) + 0x30),2,"do_sync_bulk_transfer",
                       "unrecognised status code %d");
        }
        libusb_free_transfer(plVar3);
      }
    }
  }
  return iVar1;
}


==================================================================

### FUNC 00127130 (594 bytes) name=libusb_control_transfer

int libusb_control_transfer
              (long param_1,char param_2,char param_3,undefined2 param_4,undefined2 param_5,
              void *param_6,ushort param_7,undefined4 param_8)

{
  ushort uVar1;
  int iVar2;
  void *pvVar3;
  long *plVar4;
  char *pcVar5;
  undefined4 local_3c [3];
  
  local_3c[0] = 0;
  pvVar3 = pthread_getspecific(*(pthread_key_t *)
                                (*(long *)(*(long *)(param_1 + 0x40) + 0x30) + 0x134));
  iVar2 = -6;
  if (pvVar3 == (void *)0x0) {
    plVar4 = (long *)libusb_alloc_transfer(0);
    if (plVar4 == (long *)0x0) {
      iVar2 = -0xb;
    }
    else {
      pcVar5 = malloc((ulong)param_7 + 8);
      if (pcVar5 == (char *)0x0) {
        libusb_free_transfer(plVar4);
        iVar2 = -0xb;
      }
      else {
        pcVar5[1] = param_3;
        *pcVar5 = param_2;
        *(undefined2 *)(pcVar5 + 2) = param_4;
        *(undefined2 *)(pcVar5 + 4) = param_5;
        *(ushort *)(pcVar5 + 6) = param_7;
        if (-1 < param_2) {
          memcpy(pcVar5 + 8,param_6,(ulong)param_7);
        }
        *(undefined1 *)((long)plVar4 + 9) = 0;
        *(undefined1 *)((long)plVar4 + 10) = 0;
        uVar1 = *(ushort *)(pcVar5 + 6);
        plVar4[6] = (long)pcVar5;
        *plVar4 = param_1;
        *(undefined1 *)(plVar4 + 1) = 2;
        *(undefined4 *)((long)plVar4 + 0xc) = param_8;
        *(uint *)((long)plVar4 + 0x14) = uVar1 + 8;
        plVar4[5] = (long)local_3c;
        plVar4[4] = (long)FUN_00126ee0;
        iVar2 = libusb_submit_transfer(plVar4);
        if (iVar2 < 0) {
          libusb_free_transfer(plVar4);
        }
        else {
          FUN_00126f10(plVar4);
          if (param_2 < '\0') {
            memcpy(param_6,(void *)(plVar4[6] + 8),(long)(int)plVar4[3]);
          }
          switch((int)plVar4[2]) {
          case 0:
            iVar2 = (int)plVar4[3];
            break;
          case 1:
          case 3:
            iVar2 = -1;
            break;
          case 2:
            iVar2 = -7;
            break;
          case 4:
            iVar2 = -9;
            break;
          case 5:
            iVar2 = -4;
            break;
          case 6:
            iVar2 = -8;
            break;
          default:
            iVar2 = -99;
            FUN_00120cd0(*(undefined8 *)(*(long *)(param_1 + 0x40) + 0x30),2,
                         "libusb_control_transfer","unrecognised status code %d");
          }
          libusb_free_transfer(plVar4);
        }
      }
    }
  }
  return iVar2;
}


==================================================================

### FUNC 001273c0 (25 bytes) name=libusb_bulk_transfer

void libusb_bulk_transfer(undefined8 param_1,undefined1 param_2)

{
  FUN_00126f90(param_1,param_2);
  return;
}


==================================================================

### FUNC 001273e0 (25 bytes) name=libusb_interrupt_transfer

void libusb_interrupt_transfer(undefined8 param_1,undefined1 param_2)

{
  FUN_00126f90(param_1,param_2);
  return;
}


==================================================================

### FUNC 00127400 (153 bytes) name=FUN_00127400

int FUN_00127400(int *param_1)

{
  int iVar1;
  uint uVar2;
  int iVar3;
  int *piVar4;
  char *pcVar5;
  
  iVar1 = pipe(param_1);
  if (iVar1 != 0) {
    return iVar1;
  }
  uVar2 = fcntl(param_1[1],3);
  if (uVar2 == 0xffffffff) {
    piVar4 = __errno_location();
    pcVar5 = "Failed to get pipe fd flags: %d";
    iVar1 = *piVar4;
    iVar3 = -1;
  }
  else {
    iVar3 = fcntl(param_1[1],4,(ulong)uVar2 | 0x800);
    if (iVar3 == 0) {
      return 0;
    }
    piVar4 = __errno_location();
    iVar1 = *piVar4;
    pcVar5 = "Failed to set non-blocking on new pipe: %d";
  }
  FUN_00120cd0(0,4,"usbi_pipe",pcVar5,iVar1);
  close(*param_1);
  close(param_1[1]);
  return iVar3;
}


==================================================================

### FUNC 001274b0 (151 bytes) name=FUN_001274b0

void FUN_001274b0(pthread_cond_t *param_1,pthread_mutex_t *param_2,long *param_3)

{
  int iVar1;
  timespec local_38;
  
  iVar1 = (**(code **)(PTR_PTR_0033ed80 + 0x108))(1,&local_38);
  if (-1 < iVar1) {
    local_38.tv_sec = local_38.tv_sec + *param_3;
    for (local_38.tv_nsec = param_3[1] * 1000 + local_38.tv_nsec; 999999999 < local_38.tv_nsec;
        local_38.tv_nsec = local_38.tv_nsec + -1000000000) {
      local_38.tv_sec = local_38.tv_sec + 1;
    }
    pthread_cond_timedwait(param_1,param_2,&local_38);
  }
  return;
}


==================================================================

### FUNC 00127550 (21 bytes) name=FUN_00127550

void FUN_00127550(void)

{
  syscall(0xba);
  return;
}


==================================================================

### FUNC 00127570 (7 bytes) name=FUN_00127570

undefined4 FUN_00127570(void)

{
  return DAT_0033f5f4;
}


==================================================================

### FUNC 00127580 (364 bytes) name=FUN_00127580

int FUN_00127580(undefined8 param_1,undefined8 param_2,undefined8 param_3)

{
  int iVar1;
  FILE *__stream;
  int *piVar2;
  long in_FS_OFFSET;
  int local_103c;
  char local_1038 [4104];
  long local_30;
  
  local_30 = *(long *)(in_FS_OFFSET + 0x28);
  __snprintf_chk(local_1038,0x1000,1,0x1000,"%s/%s/%s","/sys/bus/usb/devices",param_2,param_3);
  __stream = fopen(local_1038,"r");
  if (__stream == (FILE *)0x0) {
    piVar2 = __errno_location();
    local_103c = -4;
    if (*piVar2 != 2) {
      FUN_00120cd0(param_1,1,"__read_sysfs_attr","open %s failed errno=%d",local_1038);
      local_103c = -1;
    }
  }
  else {
    iVar1 = fscanf(__stream,"%d",&local_103c);
    fclose(__stream);
    if (iVar1 == 1) {
      if (local_103c < 0) {
        FUN_00120cd0(param_1,1,"__read_sysfs_attr","%s contains a negative value",local_1038);
        local_103c = -1;
      }
    }
    else {
      piVar2 = __errno_location();
      FUN_00120cd0(param_1,1,"__read_sysfs_attr","fscanf %s returned %d, errno=%d",param_3,iVar1,
                   *piVar2);
      local_103c = -4;
    }
  }
  if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
    return local_103c;
  }
                    /* WARNING: Subroutine does not return */
  __stack_chk_fail();
}


==================================================================

### FUNC 00127700 (203 bytes) name=FUN_00127700

int FUN_00127700(long param_1,undefined8 param_2)

{
  int iVar1;
  int *piVar2;
  int iVar3;
  long in_FS_OFFSET;
  char local_1028 [4104];
  long local_20;
  
  local_20 = *(long *)(in_FS_OFFSET + 0x28);
  __snprintf_chk(local_1028,0x1000,1,0x1000,"%s/%s/%s","/sys/bus/usb/devices",
                 *(undefined8 *)(param_1 + 0x80),param_2);
  iVar1 = open(local_1028,0);
  iVar3 = iVar1;
  if (iVar1 < 0) {
    piVar2 = __errno_location();
    iVar3 = -1;
    FUN_00120cd0(*(undefined8 *)(param_1 + 0x30),1,"_open_sysfs_attr",
                 "open %s failed ret=%d errno=%d",local_1028,iVar1,*piVar2);
  }
  if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
    return iVar3;
  }
                    /* WARNING: Subroutine does not return */
  __stack_chk_fail();
}


==================================================================

### FUNC 001277d0 (41 bytes) name=FUN_001277d0

void FUN_001277d0(long param_1)

{
  if (*(void **)(param_1 + 0x88) != (void *)0x0) {
    free(*(void **)(param_1 + 0x88));
  }
  if (*(void **)(param_1 + 0x80) != (void *)0x0) {
    free(*(void **)(param_1 + 0x80));
    return;
  }
  return;
}


==================================================================

### FUNC 00127810 (447 bytes) name=FUN_00127810

int FUN_00127810(long param_1,int param_2,int param_3)

{
  undefined8 uVar1;
  int iVar2;
  int iVar3;
  int *piVar4;
  int __errnum;
  char *pcVar5;
  long in_FS_OFFSET;
  timespec local_1058;
  undefined1 local_1048 [4104];
  long local_40;
  
  uVar1 = *(undefined8 *)(param_1 + 0x30);
  local_40 = *(long *)(in_FS_OFFSET + 0x28);
  if (DAT_003666cc == 0) {
    pcVar5 = "%s/%03d/%03d";
  }
  else {
    pcVar5 = "%s/usbdev%d.%d";
  }
  __snprintf_chk(local_1048,0x1000,1,0x1000,pcVar5,DAT_003666d0,*(undefined1 *)(param_1 + 0x38),
                 *(undefined1 *)(param_1 + 0x48));
  iVar2 = __open_2(local_1048);
  iVar3 = iVar2;
  if (iVar2 != -1) goto LAB_00127895;
  piVar4 = __errno_location();
  __errnum = *piVar4;
  if (__errnum == 2) {
    if (param_3 == 0) {
      FUN_00120cd0(uVar1,1,"_get_usbfs_fd","File doesn\'t exist, wait %d ms and try again",10);
    }
    local_1058.tv_sec = 0;
    local_1058.tv_nsec = 10000000;
    nanosleep(&local_1058,(timespec *)0x0);
    iVar3 = __open_2(local_1048,param_2);
    if (iVar3 != -1) goto LAB_00127895;
    __errnum = *piVar4;
  }
  if (param_3 == 0) {
    pcVar5 = strerror(__errnum);
    FUN_00120cd0(uVar1,1,"_get_usbfs_fd","libusb couldn\'t open USB device %s: %s",local_1048,pcVar5
                );
    __errnum = *piVar4;
    if (__errnum == 0xd) {
      if (param_2 == 2) {
        FUN_00120cd0(uVar1,1,"_get_usbfs_fd","libusb requires write access to USB device nodes.");
        __errnum = *piVar4;
        goto LAB_001278e4;
      }
      goto LAB_0012797a;
    }
  }
  else {
LAB_001278e4:
    if (__errnum == 0xd) {
LAB_0012797a:
      iVar3 = -3;
      goto LAB_00127895;
    }
  }
  iVar3 = iVar2;
  if (__errnum == 2) {
    iVar3 = -4;
  }
LAB_00127895:
  if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
                    /* WARNING: Subroutine does not return */
    __stack_chk_fail();
  }
  return iVar3;
}


==================================================================

### FUNC 001279f0 (332 bytes) name=FUN_001279f0

undefined4 FUN_001279f0(int *param_1,int param_2,int param_3)

{
  int iVar1;
  long lVar2;
  undefined4 uVar3;
  int iVar4;
  int *piVar5;
  long lVar6;
  int iVar7;
  long lVar8;
  long lVar9;
  undefined4 local_40;
  
  iVar1 = *param_1;
  lVar2 = *(long *)(param_1 + 0x1c);
  param_3 = param_3 + -1;
  if (param_3 < param_2) {
    local_40 = 0;
  }
  else {
    local_40 = 0;
    lVar9 = (long)param_3 * 8;
    lVar8 = (long)param_3 * 0x38;
    iVar7 = param_3;
    do {
      if (*(char *)((long)param_1 + 0x7a) == '\x01') {
        lVar6 = *(long *)(*(long *)(param_1 + (long)iVar1 * 3 + 0x2c) + lVar9);
      }
      else {
        lVar6 = lVar8 + *(long *)(param_1 + (long)iVar1 * 3 + 0x2c);
      }
      iVar4 = ioctl(*(int *)(lVar2 + 0x4c),0x550b,lVar6);
      uVar3 = local_40;
      if (iVar4 != 0) {
        piVar5 = __errno_location();
        if (*piVar5 == 0x16) {
          FUN_00120cd0(0,4,"discard_urbs","URB not found --> assuming ready to be reaped");
          uVar3 = 0xfffffffb;
          if (iVar7 != param_3) {
            uVar3 = local_40;
          }
        }
        else if (*piVar5 == 0x13) {
          FUN_00120cd0(0,4,"discard_urbs","Device not found for URB --> assuming ready to be reaped"
                      );
          local_40 = 0xfffffffc;
          uVar3 = local_40;
        }
        else {
          FUN_00120cd0(*(undefined8 *)(*(long *)(*(long *)(param_1 + 0x1c) + 0x40) + 0x30),2,
                       "discard_urbs","unrecognised discard errno %d");
          local_40 = 0xffffff9d;
          uVar3 = local_40;
        }
      }
      local_40 = uVar3;
      iVar7 = iVar7 + -1;
      lVar9 = lVar9 + -8;
      lVar8 = lVar8 + -0x38;
    } while (param_2 <= iVar7);
  }
  return local_40;
}


==================================================================

### FUNC 00127b50 (90 bytes) name=FUN_00127b50

undefined8 FUN_00127b50(int *param_1)

{
  long *plVar1;
  undefined8 uVar2;
  
  plVar1 = (long *)(param_1 + (long)*param_1 * 3 + 0x2c);
  if (*plVar1 == 0) {
    uVar2 = 0xfffffffb;
  }
  else {
    uVar2 = FUN_001279f0(param_1,0,*(int *)((long)plVar1 + 0xc));
    if ((int)uVar2 == 0) {
      if (((*(char *)((long)param_1 + 0x7a) == '\x02') ||
          (*(char *)((long)param_1 + 0x7a) == '\x04')) && ((int)plVar1[1] == 4)) {
        uVar2 = 0;
      }
      else {
        *(int *)(plVar1 + 1) = 2;
        uVar2 = 0;
      }
    }
  }
  return uVar2;
}


==================================================================

### FUNC 00127bc0 (175 bytes) name=FUN_00127bc0

uint FUN_00127bc0(long param_1,undefined4 param_2)

{
  int iVar1;
  int iVar2;
  uint uVar3;
  int *piVar4;
  undefined4 local_28;
  undefined4 local_24;
  undefined8 local_20;
  
  local_24 = 0x5517;
  local_20 = 0;
  local_28 = param_2;
  iVar2 = ioctl(*(int *)(param_1 + 0x4c),0xc0105512,&local_28);
  if (iVar2 < 0) {
    piVar4 = __errno_location();
    iVar1 = *piVar4;
    if (iVar1 == 0x3d) {
      uVar3 = 0xfffffffb;
    }
    else if (iVar1 == 0x16) {
      uVar3 = 0xfffffffe;
    }
    else if (iVar1 == 0x13) {
      uVar3 = 0xfffffffc;
    }
    else {
      uVar3 = 0xfffffffa;
      if (iVar1 != 0x10) {
        FUN_00120cd0(*(undefined8 *)(*(long *)(param_1 + 0x40) + 0x30),1,"op_attach_kernel_driver",
                     "attach failed error %d errno %d",iVar2);
        return 0xffffff9d;
      }
    }
  }
  else {
    uVar3 = -(uint)(iVar2 == 0) & 0xfffffffb;
  }
  return uVar3;
}


==================================================================

### FUNC 00127c80 (109 bytes) name=FUN_00127c80

undefined8 FUN_00127c80(long param_1,undefined4 param_2)

{
  int iVar1;
  int *piVar2;
  undefined8 uVar3;
  undefined4 local_1c [3];
  
  local_1c[0] = param_2;
  iVar1 = ioctl(*(int *)(param_1 + 0x4c),0x80045510,local_1c);
  uVar3 = 0;
  if (iVar1 != 0) {
    piVar2 = __errno_location();
    uVar3 = 0xfffffffc;
    if (*piVar2 != 0x13) {
      FUN_00120cd0(*(undefined8 *)(*(long *)(param_1 + 0x40) + 0x30),1,"release_interface",
                   "release interface failed, error %d errno %d",iVar1);
      uVar3 = 0xffffff9d;
    }
  }
  return uVar3;
}


==================================================================

### FUNC 00127cf0 (135 bytes) name=FUN_00127cf0

undefined8 FUN_00127cf0(long param_1,undefined4 param_2)

{
  int iVar1;
  int iVar2;
  int *piVar3;
  undefined8 uVar4;
  undefined4 local_1c [3];
  
  local_1c[0] = param_2;
  iVar2 = ioctl(*(int *)(param_1 + 0x4c),0x8004550f,local_1c);
  uVar4 = 0;
  if (iVar2 != 0) {
    piVar3 = __errno_location();
    iVar1 = *piVar3;
    if (iVar1 == 2) {
      uVar4 = 0xfffffffb;
    }
    else if (iVar1 == 0x10) {
      uVar4 = 0xfffffffa;
    }
    else {
      uVar4 = 0xfffffffc;
      if (iVar1 != 0x13) {
        FUN_00120cd0(*(undefined8 *)(*(long *)(param_1 + 0x40) + 0x30),1,"claim_interface",
                     "claim interface failed, error %d errno %d",iVar2);
        uVar4 = 0xffffff9d;
      }
    }
  }
  return uVar4;
}


==================================================================

### FUNC 00127d80 (126 bytes) name=FUN_00127d80

undefined8 FUN_00127d80(long param_1,byte param_2)

{
  int iVar1;
  int *piVar2;
  undefined8 uVar3;
  uint local_1c [3];
  
  local_1c[0] = (uint)param_2;
  iVar1 = ioctl(*(int *)(param_1 + 0x4c),0x80045515,local_1c);
  uVar3 = 0;
  if (iVar1 != 0) {
    piVar2 = __errno_location();
    if (*piVar2 == 2) {
      uVar3 = 0xfffffffb;
    }
    else {
      uVar3 = 0xfffffffc;
      if (*piVar2 != 0x13) {
        FUN_00120cd0(*(undefined8 *)(*(long *)(param_1 + 0x40) + 0x30),1,"op_clear_halt",
                     "clear_halt failed error %d errno %d",iVar1);
        uVar3 = 0xffffff9d;
      }
    }
  }
  return uVar3;
}


==================================================================

### FUNC 00127e00 (123 bytes) name=FUN_00127e00

undefined8 FUN_00127e00(long param_1,undefined4 param_2,undefined4 param_3)

{
  int iVar1;
  int *piVar2;
  undefined8 uVar3;
  undefined4 local_28;
  undefined4 local_24;
  
  local_28 = param_2;
  local_24 = param_3;
  iVar1 = ioctl(*(int *)(param_1 + 0x4c),0x80085504,&local_28);
  uVar3 = 0;
  if (iVar1 != 0) {
    piVar2 = __errno_location();
    if (*piVar2 == 0x16) {
      uVar3 = 0xfffffffb;
    }
    else {
      uVar3 = 0xfffffffc;
      if (*piVar2 != 0x13) {
        FUN_00120cd0(*(undefined8 *)(*(long *)(param_1 + 0x40) + 0x30),1,"op_set_interface",
                     "setintf failed error %d errno %d",iVar1);
        uVar3 = 0xffffff9d;
      }
    }
  }
  return uVar3;
}


==================================================================

### FUNC 00127e80 (164 bytes) name=FUN_00127e80

undefined8 FUN_00127e80(long param_1,undefined4 param_2)

{
  int iVar1;
  long lVar2;
  int iVar3;
  int *piVar4;
  undefined8 uVar5;
  undefined4 local_1c;
  
  lVar2 = *(long *)(param_1 + 0x40);
  local_1c = param_2;
  iVar3 = ioctl(*(int *)(param_1 + 0x4c),0x80045505,&local_1c);
  if (iVar3 == 0) {
    *(undefined4 *)(lVar2 + 0x94) = local_1c;
    uVar5 = 0;
  }
  else {
    piVar4 = __errno_location();
    iVar1 = *piVar4;
    if (iVar1 == 0x16) {
      uVar5 = 0xfffffffb;
    }
    else if (iVar1 == 0x10) {
      uVar5 = 0xfffffffa;
    }
    else {
      uVar5 = 0xfffffffc;
      if (iVar1 != 0x13) {
        FUN_00120cd0(*(undefined8 *)(*(long *)(param_1 + 0x40) + 0x30),1,"op_set_configuration",
                     "failed, error %d errno %d",iVar3);
        return 0xffffff9d;
      }
    }
  }
  return uVar5;
}


==================================================================

### FUNC 00127f30 (257 bytes) name=FUN_00127f30

undefined8 FUN_00127f30(long param_1,undefined4 param_2)

{
  int iVar1;
  int iVar2;
  int *piVar3;
  undefined8 uVar4;
  long lVar5;
  char *pcVar6;
  char *pcVar7;
  long in_FS_OFFSET;
  bool bVar8;
  byte bVar9;
  undefined4 local_138;
  undefined4 local_134;
  undefined8 local_130;
  undefined4 local_128;
  char local_124 [260];
  long local_20;
  
  bVar9 = 0;
  iVar2 = *(int *)(param_1 + 0x4c);
  local_20 = *(long *)(in_FS_OFFSET + 0x28);
  local_134 = 0x5516;
  local_130 = 0;
  local_138 = param_2;
  local_128 = param_2;
  iVar1 = ioctl(iVar2,0x41045508,&local_128);
  bVar8 = iVar1 == 0;
  if (bVar8) {
    lVar5 = 6;
    pcVar6 = local_124;
    pcVar7 = "usbfs";
    do {
      if (lVar5 == 0) break;
      lVar5 = lVar5 + -1;
      bVar8 = *pcVar6 == *pcVar7;
      pcVar6 = pcVar6 + (ulong)bVar9 * -2 + 1;
      pcVar7 = pcVar7 + (ulong)bVar9 * -2 + 1;
    } while (bVar8);
    if (!bVar8) goto LAB_00127f9c;
  }
  else {
LAB_00127f9c:
    iVar2 = ioctl(iVar2,0xc0105512,&local_138);
    uVar4 = 0;
    if (iVar2 == 0) goto LAB_00127fff;
    piVar3 = __errno_location();
    iVar1 = *piVar3;
    if (iVar1 != 0x3d) {
      if (iVar1 == 0x16) {
        uVar4 = 0xfffffffe;
      }
      else {
        uVar4 = 0xfffffffc;
        if (iVar1 != 0x13) {
          FUN_00120cd0(*(undefined8 *)(*(long *)(param_1 + 0x40) + 0x30),1,"op_detach_kernel_driver"
                       ,"detach failed error %d errno %d",iVar2);
          uVar4 = 0xffffff9d;
        }
      }
      goto LAB_00127fff;
    }
  }
  uVar4 = 0xfffffffb;
LAB_00127fff:
  if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
    return uVar4;
  }
                    /* WARNING: Subroutine does not return */
  __stack_chk_fail();
}


==================================================================

### FUNC 00128040 (193 bytes) name=FUN_00128040

ulong FUN_00128040(long param_1,undefined4 param_2)

{
  int iVar1;
  int *piVar2;
  ulong uVar3;
  long lVar4;
  char *pcVar5;
  char *pcVar6;
  long in_FS_OFFSET;
  bool bVar7;
  byte bVar8;
  undefined4 local_128;
  char local_124 [260];
  long local_20;
  
  bVar8 = 0;
  local_20 = *(long *)(in_FS_OFFSET + 0x28);
  local_128 = param_2;
  iVar1 = ioctl(*(int *)(param_1 + 0x4c),0x41045508,&local_128);
  if (iVar1 == 0) {
    lVar4 = 6;
    bVar7 = true;
    pcVar5 = local_124;
    pcVar6 = "usbfs";
    do {
      if (lVar4 == 0) break;
      lVar4 = lVar4 + -1;
      bVar7 = *pcVar5 == *pcVar6;
      pcVar5 = pcVar5 + (ulong)bVar8 * -2 + 1;
      pcVar6 = pcVar6 + (ulong)bVar8 * -2 + 1;
    } while (bVar7);
    uVar3 = (ulong)!bVar7;
  }
  else {
    piVar2 = __errno_location();
    if (*piVar2 == 0x3d) {
      uVar3 = 0;
    }
    else {
      uVar3 = 0xfffffffc;
      if (*piVar2 != 0x13) {
        FUN_00120cd0(*(undefined8 *)(*(long *)(param_1 + 0x40) + 0x30),1,"op_kernel_driver_active",
                     "get driver failed error %d errno %d",iVar1);
        uVar3 = 0xffffff9d;
      }
    }
  }
  if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
    return uVar3;
  }
                    /* WARNING: Subroutine does not return */
  __stack_chk_fail();
}


==================================================================

### FUNC 00128110 (399 bytes) name=FUN_00128110

int FUN_00128110(long param_1,undefined4 *param_2)

{
  int __fd;
  ssize_t sVar1;
  long lVar2;
  int *piVar3;
  char *pcVar4;
  undefined8 uVar5;
  long in_FS_OFFSET;
  char *local_40;
  char local_38 [8];
  long local_30;
  
  local_30 = *(long *)(in_FS_OFFSET + 0x28);
  local_38[0] = '\0';
  local_38[1] = 0;
  local_38[2] = 0;
  local_38[3] = 0;
  local_38[4] = '\0';
  __fd = FUN_00127700(param_1,"bConfigurationValue");
  if (-1 < __fd) {
    sVar1 = read(__fd,local_38,5);
    close(__fd);
    if (sVar1 < 0) {
      piVar3 = __errno_location();
      __fd = -1;
      FUN_00120cd0(*(undefined8 *)(param_1 + 0x30),1,"sysfs_get_active_config",
                   "read bConfigurationValue failed ret=%d errno=%d",sVar1,*piVar3);
    }
    else if (sVar1 == 0) {
      __fd = 0;
      FUN_00120cd0(0,4,"sysfs_get_active_config","device unconfigured");
      *param_2 = 0xffffffff;
    }
    else {
      if (local_38[4] == '\0') {
        if (local_38[0] != '\0') {
          lVar2 = strtol(local_38,&local_40,10);
          if (local_40 == local_38) {
            __fd = -1;
            FUN_00120cd0(*(undefined8 *)(param_1 + 0x30),1,"sysfs_get_active_config",
                         "error converting \'%s\' to integer",local_38);
          }
          else {
            *param_2 = (int)lVar2;
            __fd = 0;
          }
          goto LAB_001281bb;
        }
        uVar5 = *(undefined8 *)(param_1 + 0x30);
        pcVar4 = "no configuration value?";
      }
      else {
        uVar5 = *(undefined8 *)(param_1 + 0x30);
        pcVar4 = "not null-terminated?";
      }
      __fd = -1;
      FUN_00120cd0(uVar5,1,"sysfs_get_active_config",pcVar4);
    }
  }
LAB_001281bb:
  if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
    return __fd;
  }
                    /* WARNING: Subroutine does not return */
  __stack_chk_fail();
}


==================================================================

### FUNC 001282b0 (47 bytes) name=FUN_001282b0

void FUN_001282b0(long param_1)

{
  if (*(int *)(param_1 + 0x50) == 0) {
    FUN_001268c0(*(undefined8 *)(*(long *)(param_1 + 0x40) + 0x30),*(undefined4 *)(param_1 + 0x4c));
  }
  if (*(int *)(param_1 + 0x54) != 0) {
    return;
  }
  close(*(int *)(param_1 + 0x4c));
  return;
}


==================================================================

### FUNC 001282f0 (1114 bytes) name=FUN_001282f0

undefined8 FUN_001282f0(int *param_1)

{
  int *piVar1;
  char cVar2;
  long lVar3;
  bool bVar4;
  uint uVar5;
  int iVar6;
  undefined1 *__ptr;
  int *piVar7;
  undefined1 *puVar8;
  size_t __nmemb;
  int iVar9;
  long lVar10;
  byte bVar11;
  undefined8 uVar12;
  byte bVar13;
  int iVar14;
  int local_64;
  int local_60;
  
  lVar3 = *(long *)(param_1 + 0x1c);
  bVar13 = -((char)~*(byte *)((long)param_1 + 0x79) >> 7);
  piVar1 = param_1 + (long)*param_1 * 3 + 0x2c;
  if (bVar13 == 0) {
    uVar5 = *(uint *)(lVar3 + 0x58);
  }
  else {
    uVar5 = *(uint *)(lVar3 + 0x58);
    if (((*(byte *)(param_1 + 0x1e) & 8) != 0) && ((uVar5 & 1) == 0)) {
      return 0xfffffff4;
    }
  }
  if ((uVar5 & 8) == 0) {
    if ((uVar5 & 2) == 0) {
      if ((uVar5 & 4) != 0) goto LAB_0012834d;
      bVar11 = 0;
    }
    else {
      bVar11 = 1;
    }
    iVar9 = param_1[0x21];
    if (iVar9 == 0) {
      __nmemb = 1;
      local_60 = 0x4000;
      bVar4 = false;
      local_64 = 1;
      goto LAB_00128382;
    }
    local_60 = 0x4000;
    local_64 = iVar9 + 0x3fff;
    if (-1 < iVar9) {
      local_64 = iVar9;
    }
    iVar14 = iVar9 % 0x4000;
    local_64 = local_64 >> 0xe;
  }
  else {
LAB_0012834d:
    iVar9 = param_1[0x21];
    if (iVar9 == 0) {
      __nmemb = 1;
      iVar9 = 0;
      bVar11 = 0;
      local_60 = 1;
      bVar4 = false;
      local_64 = 1;
      goto LAB_00128382;
    }
    bVar11 = 0;
    local_64 = iVar9 / iVar9;
    iVar14 = iVar9 % iVar9;
    local_60 = iVar9;
  }
  if (iVar14 < 1) {
    __nmemb = (size_t)local_64;
    bVar4 = false;
  }
  else {
    local_64 = local_64 + 1;
    bVar4 = true;
    __nmemb = (size_t)local_64;
  }
LAB_00128382:
  FUN_00120cd0(0,4,"submit_bulk_transfer","need %d urbs for new transfer with length %d",local_64,
               iVar9);
  __ptr = calloc(__nmemb,0x38);
  if (__ptr == (undefined1 *)0x0) {
    uVar12 = 0xfffffff5;
  }
  else {
    *(undefined1 **)piVar1 = __ptr;
    piVar1[3] = local_64;
    piVar1[4] = 0;
    piVar1[2] = 0;
    piVar1[5] = 0;
    if (0 < local_64) {
      iVar14 = 0;
      lVar10 = 0;
      iVar9 = local_64 + -1;
      puVar8 = __ptr;
      do {
        *(int **)(puVar8 + 0x30) = param_1;
        cVar2 = *(char *)((long)param_1 + 0x7a);
        if (cVar2 == '\x03') {
          *puVar8 = 1;
        }
        else if (cVar2 == '\x04') {
          *puVar8 = 3;
          *(int *)(puVar8 + 0x24) = param_1[0xf];
        }
        else if (cVar2 == '\x02') {
          *puVar8 = 3;
          *(undefined4 *)(puVar8 + 0x24) = 0;
        }
        puVar8[1] = *(undefined1 *)((long)param_1 + 0x79);
        *(long *)(puVar8 + 0x10) = lVar10 + *(long *)(param_1 + 0x28);
        if ((((bVar13 ^ 1) & bVar11) != 0) && (iVar14 < iVar9)) {
          *(undefined4 *)(puVar8 + 8) = 1;
        }
        if ((iVar14 == iVar9) && (bVar4)) {
          *(int *)(puVar8 + 0x18) = param_1[0x21] % local_60;
        }
        else {
          iVar6 = 0;
          if (param_1[0x21] != 0) {
            iVar6 = local_60;
          }
          *(int *)(puVar8 + 0x18) = iVar6;
        }
        if ((0 < iVar14) && (bVar11 != 0)) {
          *(uint *)(puVar8 + 8) = *(uint *)(puVar8 + 8) | 4;
        }
        if (((bVar13 != 0) && (iVar14 == iVar9)) && ((*(byte *)(param_1 + 0x1e) & 8) != 0)) {
          *(uint *)(puVar8 + 8) = *(uint *)(puVar8 + 8) | 0x40;
        }
        iVar6 = ioctl(*(int *)(lVar3 + 0x4c),0x8038550a,puVar8);
        if (iVar6 < 0) {
          piVar7 = __errno_location();
          uVar12 = 0xfffffffc;
          if (*piVar7 != 0x13) {
            uVar12 = 0xffffffff;
            FUN_00120cd0(*(undefined8 *)(*(long *)(*(long *)(param_1 + 0x1c) + 0x40) + 0x30),1,
                         "submit_bulk_transfer","submiturb failed error %d errno=%d",iVar6);
          }
          if (iVar14 == 0) {
            FUN_00120cd0(0,4,"submit_bulk_transfer","first URB failed, easy peasy");
            free(__ptr);
            piVar1[0] = 0;
            piVar1[1] = 0;
            return uVar12;
          }
          if (*piVar7 != 0x79) {
            piVar1[4] = piVar1[4] + (local_64 - iVar14);
            piVar1[2] = 1;
            FUN_001279f0(param_1,0,iVar14);
            FUN_00120cd0(0,4,"submit_bulk_transfer",
                         "reporting successful submission but waiting for %d discards before reporting error"
                         ,iVar14);
            return 0;
          }
          piVar1[4] = piVar1[4] + (local_64 - iVar14);
          piVar1[2] = 3;
          break;
        }
        iVar14 = iVar14 + 1;
        puVar8 = puVar8 + 0x38;
        lVar10 = lVar10 + local_60;
      } while (iVar14 != local_64);
    }
    uVar12 = 0;
  }
  return uVar12;
}


==================================================================

### FUNC 00128770 (64 bytes) name=FUN_00128770

undefined8 FUN_00128770(long param_1,undefined8 *param_2,uint *param_3)

{
  undefined8 *puVar1;
  uint uVar2;
  
  if (*(long *)(param_1 + 0x80) == 0) {
    uVar2 = 1;
  }
  else {
    uVar2 = (uint)(DAT_0033f5ec == 0);
  }
  *param_3 = uVar2;
  puVar1 = *(undefined8 **)(param_1 + 0x88);
  *param_2 = *puVar1;
  param_2[1] = puVar1[1];
  *(undefined2 *)(param_2 + 2) = *(undefined2 *)(puVar1 + 2);
  return 0;
}


==================================================================

### FUNC 001287c0 (262 bytes) name=FUN_001287c0

int FUN_001287c0(long param_1,ulong param_2,undefined4 param_3,void *param_4,int param_5)

{
  int iVar1;
  int iVar2;
  undefined4 *__ptr;
  int *piVar3;
  
  iVar2 = *(int *)(param_1 + 0x4c);
  if (param_5 < 0x1f) {
    __ptr = malloc((long)param_5 + 8);
    if (__ptr == (undefined4 *)0x0) {
      return -0xb;
    }
    __ptr[1] = param_5;
    *__ptr = param_3;
    memcpy(__ptr + 2,param_4,(long)param_5);
    iVar2 = ioctl(iVar2,param_2,__ptr);
    free(__ptr);
    if (-1 < iVar2) {
      return iVar2;
    }
    piVar3 = __errno_location();
    iVar1 = *piVar3;
    if (iVar1 == 0x19) {
      return -0xc;
    }
    if (iVar1 != 0x16) {
      if (iVar1 == 0x13) {
        return -4;
      }
      FUN_00120cd0(*(undefined8 *)(*(long *)(param_1 + 0x40) + 0x30),1,"do_streams_ioctl",
                   "streams-ioctl failed error %d errno %d",iVar2);
      return -99;
    }
  }
  return -2;
}


==================================================================

### FUNC 001288e0 (18 bytes) name=FUN_001288e0

void FUN_001288e0(undefined8 param_1,undefined8 param_2,undefined4 param_3)

{
  FUN_001287c0(param_1,0x8008551d,0,param_2,param_3);
  return;
}


==================================================================

### FUNC 00128900 (18 bytes) name=FUN_00128900

void FUN_00128900(undefined8 param_1,undefined4 param_2,undefined8 param_3,undefined4 param_4)

{
  FUN_001287c0(param_1,0x8008551c,param_2,param_3,param_4);
  return;
}


==================================================================

### FUNC 00128920 (171 bytes) name=FUN_00128920

void FUN_00128920(long param_1,int param_2)

{
  int iVar1;
  int *piVar2;
  
  *(int *)(param_1 + 0x4c) = param_2;
  iVar1 = ioctl(param_2,0x8004551a,param_1 + 0x58);
  if (iVar1 < 0) {
    piVar2 = __errno_location();
    if (*piVar2 == 0x19) {
      FUN_00120cd0(0,4,"initialize_handle","getcap not available");
    }
    else {
      FUN_00120cd0(*(undefined8 *)(*(long *)(param_1 + 0x40) + 0x30),1,"initialize_handle",
                   "getcap failed (%d)");
    }
    iVar1 = DAT_0033f5f8;
    *(undefined4 *)(param_1 + 0x58) = 0;
    if (iVar1 != 0) {
      *(undefined4 *)(param_1 + 0x58) = 1;
    }
    if (DAT_0033f5fc != 0) {
      *(uint *)(param_1 + 0x58) = *(uint *)(param_1 + 0x58) | 2;
    }
  }
  FUN_001267e0(*(undefined8 *)(*(long *)(param_1 + 0x40) + 0x30),*(undefined4 *)(param_1 + 0x4c),4);
  return;
}


==================================================================

### FUNC 001289e0 (5 bytes) name=thunk_FUN_0012c710

void thunk_FUN_0012c710(void)

{
  int iVar1;
  
  pthread_mutex_lock((pthread_mutex_t *)&DAT_00366660);
  do {
    iVar1 = FUN_0012bd00();
  } while (iVar1 == 0);
  pthread_mutex_unlock((pthread_mutex_t *)&DAT_00366660);
  return;
}


==================================================================

### FUNC 001289f0 (73 bytes) name=FUN_001289f0

undefined8 FUN_001289f0(char *param_1)

{
  DIR *__dirp;
  dirent *pdVar1;
  undefined8 uVar2;
  
  __dirp = opendir(param_1);
  if (__dirp == (DIR *)0x0) {
    return 0;
  }
  do {
    pdVar1 = readdir(__dirp);
    if (pdVar1 == (dirent *)0x0) {
      uVar2 = 0;
      goto LAB_00128a1b;
    }
  } while (pdVar1->d_name[0] == '.');
  uVar2 = 1;
LAB_00128a1b:
  closedir(__dirp);
  return uVar2;
}


==================================================================

### FUNC 00128a50 (100 bytes) name=FUN_00128a50

void FUN_00128a50(undefined8 *param_1,int *param_2)

{
  void *__ptr;
  int iVar1;
  long lVar2;
  long *__ptr_00;
  
  __ptr_00 = (long *)*param_1;
  if ((0 < *param_2) && (__ptr = (void *)*__ptr_00, __ptr != (void *)0x0)) {
    lVar2 = 8;
    iVar1 = 0;
    do {
      iVar1 = iVar1 + 1;
      free(__ptr);
      __ptr_00 = (long *)*param_1;
      if (*param_2 <= iVar1) break;
      __ptr = *(void **)((long)__ptr_00 + lVar2);
      lVar2 = lVar2 + 8;
    } while (__ptr != (void *)0x0);
  }
  free(__ptr_00);
  *param_1 = 0;
  return;
}


==================================================================

### FUNC 00128ac0 (123 bytes) name=FUN_00128ac0

void FUN_00128ac0(int *param_1)

{
  long *plVar1;
  byte bVar2;
  
  bVar2 = *(byte *)((long)param_1 + 0x7a);
  plVar1 = (long *)(param_1 + (long)*param_1 * 3 + 0x2c);
  if (bVar2 == 1) {
    if (*plVar1 != 0) {
      FUN_00128a50(plVar1,(int *)((long)plVar1 + 0xc));
      *plVar1 = 0;
      return;
    }
  }
  else {
    if ((bVar2 != 0) && (4 < bVar2)) {
      FUN_00120cd0(*(undefined8 *)(*(long *)(*(long *)(param_1 + 0x1c) + 0x40) + 0x30),1,
                   "op_clear_transfer_priv","unknown endpoint type %d");
      return;
    }
    if ((void *)*plVar1 != (void *)0x0) {
      free((void *)*plVar1);
      *plVar1 = 0;
    }
  }
  return;
}


==================================================================

### FUNC 00128b50 (1252 bytes) name=FUN_00128b50

undefined8 FUN_00128b50(int *param_1)

{
  undefined1 uVar1;
  long lVar2;
  undefined8 uVar3;
  uint uVar4;
  undefined8 uVar5;
  void *pvVar6;
  undefined1 *puVar7;
  int *piVar8;
  int *piVar9;
  uint uVar10;
  int iVar11;
  int iVar12;
  ulong uVar13;
  int iVar14;
  undefined1 *puVar15;
  long lVar16;
  long lVar17;
  long lVar18;
  size_t sVar19;
  int iVar20;
  long lVar21;
  
  switch(*(undefined1 *)((long)param_1 + 0x7a)) {
  case 0:
    lVar2 = *(long *)(param_1 + 0x1c);
    piVar8 = param_1 + (long)*param_1 * 3 + 0x2c;
    if (0x1000 < (long)param_1[0x21] - 8U) {
      return 0xfffffffe;
    }
    puVar7 = calloc(1,0x38);
    if (puVar7 != (undefined1 *)0x0) {
      *(undefined1 **)piVar8 = puVar7;
      piVar8[3] = 1;
      piVar8[2] = 0;
      *puVar7 = 2;
      *(int **)(puVar7 + 0x30) = param_1;
      puVar7[1] = *(undefined1 *)((long)param_1 + 0x79);
      iVar12 = *(int *)(lVar2 + 0x4c);
      *(undefined8 *)(puVar7 + 0x10) = *(undefined8 *)(param_1 + 0x28);
      *(int *)(puVar7 + 0x18) = param_1[0x21];
      iVar12 = ioctl(iVar12,0x8038550a,puVar7);
      if (-1 < iVar12) {
        return 0;
      }
      free(puVar7);
      piVar8[0] = 0;
      piVar8[1] = 0;
      piVar8 = __errno_location();
      if (*piVar8 == 0x13) {
        return 0xfffffffc;
      }
      FUN_00120cd0(*(undefined8 *)(*(long *)(*(long *)(param_1 + 0x1c) + 0x40) + 0x30),1,
                   "submit_control_transfer","submiturb failed error %d errno=%d",iVar12);
      return 0xffffffff;
    }
    break;
  case 1:
    lVar2 = *(long *)(param_1 + 0x1c);
    iVar12 = *param_1;
    lVar18 = *(long *)(param_1 + 0x28);
    if (param_1[0x2a] < 1) {
      sVar19 = 1;
      iVar14 = 1;
    }
    else {
      iVar14 = 1;
      piVar8 = param_1 + 0x1c;
      uVar10 = 0;
      do {
        while (uVar4 = *(uint *)((long)piVar8 + (-0x34 - (long)param_1) + (long)(param_1 + 0x1c)),
              uVar4 <= 0x600000 - uVar10) {
          piVar8 = piVar8 + 3;
          uVar10 = uVar10 + uVar4;
          if (piVar8 == param_1 + (ulong)(param_1[0x2a] - 1) * 3 + 0x1f) goto LAB_00128c18;
        }
        iVar14 = iVar14 + 1;
        if (0x600000 < (int)uVar4) {
          return 0xfffffffe;
        }
        piVar8 = piVar8 + 3;
        uVar10 = uVar4;
      } while (piVar8 != param_1 + (ulong)(param_1[0x2a] - 1) * 3 + 0x1f);
LAB_00128c18:
      sVar19 = (size_t)iVar14;
    }
    FUN_00120cd0(0,4,"submit_iso_transfer","need %d %dk URBs for transfer",iVar14,0x1800);
    pvVar6 = calloc(sVar19,8);
    if (pvVar6 != (void *)0x0) {
      lVar21 = 0;
      iVar20 = 0;
      piVar8 = param_1 + (long)iVar12 * 3 + 0x2c;
      *(void **)piVar8 = pvVar6;
      piVar8[3] = iVar14;
      piVar8[4] = 0;
      piVar8[2] = 0;
      piVar8[6] = 0;
      do {
        lVar17 = lVar18;
        if ((iVar20 < param_1[0x2a]) &&
           (uVar10 = param_1[(long)iVar20 * 3 + 0x2b], uVar10 < 0x600001)) {
          iVar12 = 0;
          uVar4 = 0x600000;
          do {
            iVar12 = iVar12 + 1;
            uVar4 = uVar4 - uVar10;
            lVar17 = lVar17 + (ulong)uVar10;
            if (iVar12 == param_1[0x2a] - iVar20) break;
            uVar10 = param_1[(long)(iVar20 + iVar12) * 3 + 0x2b];
          } while (uVar10 <= uVar4);
          sVar19 = (long)iVar12 * 0xc + 0x38;
          iVar20 = iVar20 + iVar12;
        }
        else {
          sVar19 = 0x38;
          iVar12 = 0;
        }
        puVar7 = calloc(1,sVar19);
        if (puVar7 == (undefined1 *)0x0) {
          FUN_00128a50(piVar8,piVar8 + 3);
          return 0xfffffff5;
        }
        *(undefined1 **)((long)pvVar6 + lVar21 * 8) = puVar7;
        iVar11 = iVar20 - iVar12;
        puVar15 = puVar7;
        if (iVar11 < iVar20) {
          do {
            lVar16 = (long)iVar11;
            iVar11 = iVar11 + 1;
            *(int *)(puVar15 + 0x38) = param_1[lVar16 * 3 + 0x2b];
            puVar15 = puVar15 + 0xc;
          } while (iVar11 != iVar20);
        }
        *(int **)(puVar7 + 0x30) = param_1;
        *puVar7 = 0;
        lVar21 = lVar21 + 1;
        *(undefined4 *)(puVar7 + 8) = 2;
        uVar1 = *(undefined1 *)((long)param_1 + 0x79);
        *(int *)(puVar7 + 0x24) = iVar12;
        *(long *)(puVar7 + 0x10) = lVar18;
        puVar7[1] = uVar1;
        lVar18 = lVar17;
        if (iVar14 <= (int)lVar21) {
          uVar13 = 0;
          while (iVar12 = ioctl(*(int *)(lVar2 + 0x4c),0x8038550a,
                                *(undefined8 *)((long)pvVar6 + uVar13 * 8)), -1 < iVar12) {
            uVar13 = uVar13 + 1;
            if (iVar14 <= (int)uVar13) {
              return 0;
            }
          }
          uVar5 = 0xfffffffc;
          piVar9 = __errno_location();
          if (*piVar9 != 0x13) {
            uVar3 = *(undefined8 *)(*(long *)(*(long *)(param_1 + 0x1c) + 0x40) + 0x30);
            if (*piVar9 == 0x16) {
              uVar5 = 0xfffffffe;
              FUN_00120cd0(uVar3,2,"submit_iso_transfer","submiturb failed, transfer too large",
                           iVar12);
            }
            else {
              uVar5 = 0xffffffff;
              FUN_00120cd0(uVar3,1,"submit_iso_transfer","submiturb failed error %d errno=%d",iVar12
                          );
            }
          }
          if ((int)uVar13 == 0) {
            FUN_00120cd0(0,4,"submit_iso_transfer","first URB failed, easy peasy");
            FUN_00128a50(piVar8,piVar8 + 3);
            return uVar5;
          }
          piVar8[2] = 1;
          piVar8[4] = iVar14 - (int)uVar13;
          FUN_001279f0(param_1,0,uVar13 & 0xffffffff);
          FUN_00120cd0(0,4,"submit_iso_transfer",
                       "reporting successful submission but waiting for %d discards before reporting error"
                       ,uVar13 & 0xffffffff);
          return 0;
        }
      } while( true );
    }
    break;
  case 2:
  case 3:
  case 4:
    uVar5 = FUN_001282f0();
    return uVar5;
  default:
    FUN_00120cd0(*(undefined8 *)(*(long *)(*(long *)(param_1 + 0x1c) + 0x40) + 0x30),1,
                 "op_submit_transfer","unknown endpoint type %d");
    return 0xfffffffe;
  }
  return 0xfffffff5;
}


==================================================================

### FUNC 00129050 (240 bytes) name=FUN_00129050

undefined8 FUN_00129050(long param_1,int param_2)

{
  int iVar1;
  int *piVar2;
  undefined8 uVar3;
  byte local_39 [17];
  byte *local_28;
  
  local_39[3] = 0;
  local_39[4] = 0;
  local_28 = local_39;
  local_39[5] = 0;
  local_39[6] = 0;
  local_39[0] = 0;
  local_39[1] = 0x80;
  local_39[2] = 8;
  local_39[7] = 1;
  local_39[8] = 0;
  local_39[9] = 0xe8;
  local_39[10] = 3;
  local_39[0xb] = 0;
  local_39[0xc] = 0;
  iVar1 = ioctl(param_2,0xc0185500,local_39 + 1);
  if (iVar1 < 0) {
    piVar2 = __errno_location();
    if (*piVar2 != 0x13) {
      FUN_00120cd0(*(undefined8 *)(param_1 + 0x30),2,"usbfs_get_active_config",
                   "get_configuration failed ret=%d errno=%d",iVar1);
      *(undefined4 *)(param_1 + 0x94) = 0xffffffff;
      return 0;
    }
    uVar3 = 0xfffffffc;
  }
  else {
    if (local_39[0] == 0) {
      FUN_00120cd0(*(undefined8 *)(param_1 + 0x30),2,"usbfs_get_active_config",
                   "active cfg 0? assuming unconfigured device");
      *(undefined4 *)(param_1 + 0x94) = 0xffffffff;
      return 0;
    }
    *(uint *)(param_1 + 0x94) = (uint)local_39[0];
    uVar3 = 0;
  }
  return uVar3;
}


==================================================================

### FUNC 00129160 (974 bytes) name=FUN_00129160

/* WARNING: Type propagation algorithm not settling */

int FUN_00129160(long param_1,undefined1 param_2,undefined1 param_3,long param_4,int param_5)

{
  undefined8 uVar1;
  void *__ptr;
  int iVar2;
  int iVar3;
  long lVar4;
  __off_t _Var5;
  ssize_t sVar6;
  void *pvVar7;
  int *piVar8;
  int iVar9;
  undefined1 local_68 [5];
  byte local_63;
  
  uVar1 = *(undefined8 *)(param_1 + 0x30);
  *(undefined1 *)(param_1 + 0x38) = param_2;
  *(undefined1 *)(param_1 + 0x48) = param_3;
  if (param_4 == 0) {
LAB_001291f7:
    if (-1 < param_5) {
      _Var5 = lseek(param_5,0,0);
      iVar3 = param_5;
      if (_Var5 < 0) {
        piVar8 = __errno_location();
        FUN_00120cd0(uVar1,1,"initialize_device","seek failed ret=%d errno=%d",_Var5,*piVar8);
        return -1;
      }
      goto LAB_0012921b;
    }
    iVar3 = FUN_00127810(param_1,0);
  }
  else {
    lVar4 = __strdup(param_4);
    *(long *)(param_1 + 0x80) = lVar4;
    if (lVar4 == 0) {
      return -0xb;
    }
    iVar2 = FUN_00127580(*(undefined8 *)(param_1 + 0x30),param_4,"speed");
    iVar3 = DAT_0033f5ec;
    if (-1 < iVar2) {
      if (iVar2 == 0xc) {
        *(undefined4 *)(param_1 + 0x4c) = 2;
      }
      else if (iVar2 < 0xd) {
        if (iVar2 == 1) {
          *(undefined4 *)(param_1 + 0x4c) = 1;
        }
        else {
LAB_00129420:
          FUN_00120cd0(*(undefined8 *)(param_1 + 0x30),2,"initialize_device",
                       "Unknown device speed: %d Mbps",iVar2);
          iVar3 = DAT_0033f5ec;
        }
      }
      else if (iVar2 == 0x1e0) {
        *(undefined4 *)(param_1 + 0x4c) = 3;
      }
      else {
        if (iVar2 != 5000) goto LAB_00129420;
        *(undefined4 *)(param_1 + 0x4c) = 4;
        iVar3 = DAT_0033f5ec;
      }
    }
    if (iVar3 == 0) goto LAB_001291f7;
    iVar3 = FUN_00127700(param_1,"descriptors");
  }
  if (iVar3 < 0) {
    return iVar3;
  }
LAB_0012921b:
  iVar2 = 0x200;
  while( true ) {
    __ptr = *(void **)(param_1 + 0x88);
    iVar2 = iVar2 * 2;
    pvVar7 = realloc(__ptr,(long)iVar2);
    if (pvVar7 == (void *)0x0) {
      free(__ptr);
      *(undefined8 *)(param_1 + 0x88) = 0;
      if (iVar3 != param_5) {
        close(iVar3);
      }
      return -0xb;
    }
    *(void **)(param_1 + 0x88) = pvVar7;
    if ((param_4 == 0) || (DAT_0033f5ec == 0)) {
      memset((void *)((long)*(int *)(param_1 + 0x90) + (long)pvVar7),0,
             (long)(iVar2 - *(int *)(param_1 + 0x90)));
      pvVar7 = *(void **)(param_1 + 0x88);
    }
    sVar6 = read(iVar3,(void *)((long)pvVar7 + (long)*(int *)(param_1 + 0x90)),
                 (long)(iVar2 - *(int *)(param_1 + 0x90)));
    if (sVar6 < 0) break;
    iVar9 = *(int *)(param_1 + 0x90) + (int)sVar6;
    *(int *)(param_1 + 0x90) = iVar9;
    if (iVar2 != iVar9) {
      if (iVar3 != param_5) {
        close(iVar3);
        iVar9 = *(int *)(param_1 + 0x90);
      }
      if (iVar9 < 0x12) {
        iVar3 = -1;
        FUN_00120cd0(uVar1,1,"initialize_device","short descriptor read (%d)");
      }
      else if ((param_4 == 0) || (iVar3 = 0, DAT_0033f5f0 == 0)) {
        if (param_5 < 0) {
          iVar2 = FUN_00127810(param_1,2,1);
          if (iVar2 < 0) {
            FUN_00120cd0(uVar1,2,"initialize_device",
                         "Missing rw usbfs access; cannot determine active configuration descriptor"
                        );
            if (*(int *)(param_1 + 0x90) < 0x1b) {
              *(undefined4 *)(param_1 + 0x94) = 0xffffffff;
              iVar3 = 0;
            }
            else {
              iVar3 = 0;
              FUN_00122b20(*(long *)(param_1 + 0x88) + 0x12,"bbwbbbbb",local_68,0);
              *(uint *)(param_1 + 0x94) = (uint)local_63;
            }
          }
          else {
            iVar3 = FUN_00129050(param_1,iVar2);
            close(iVar2);
          }
        }
        else {
          iVar3 = FUN_00129050(param_1,param_5);
        }
      }
      return iVar3;
    }
  }
  piVar8 = __errno_location();
  FUN_00120cd0(uVar1,1,"initialize_device","read descriptor failed ret=%d errno=%d",iVar3,*piVar8);
  if (iVar3 != param_5) {
    close(iVar3);
    return -1;
  }
  return -1;
}


==================================================================

### FUNC 00129560 (53 bytes) name=FUN_00129560

ulong FUN_00129560(long param_1,undefined4 param_2)

{
  ulong uVar1;
  
  uVar1 = FUN_00127c80();
  if (((int)uVar1 == 0) &&
     (uVar1 = (ulong)*(uint *)(param_1 + 0x48), *(uint *)(param_1 + 0x48) != 0)) {
    FUN_00127bc0(param_1,param_2);
    return 0;
  }
  return uVar1;
}


==================================================================

### FUNC 001295a0 (239 bytes) name=FUN_001295a0

int FUN_001295a0(long param_1,undefined4 param_2)

{
  int iVar1;
  int iVar2;
  int *piVar3;
  long in_FS_OFFSET;
  undefined4 local_128;
  undefined4 local_124;
  undefined4 local_120;
  undefined2 local_11c;
  long local_20;
  
  local_20 = *(long *)(in_FS_OFFSET + 0x28);
  local_120 = 0x66627375;
  local_11c = 0x73;
  local_124 = 2;
  local_128 = param_2;
  iVar1 = ioctl(*(int *)(param_1 + 0x4c),0x8108551b,&local_128);
  iVar2 = 0;
  if (iVar1 != 0) {
    piVar3 = __errno_location();
    iVar1 = *piVar3;
    if (iVar1 == 0x19) {
      iVar2 = FUN_00127f30(param_1,param_2);
      if ((iVar2 == -5) || (iVar2 == 0)) {
        iVar2 = FUN_00127cf0(param_1,param_2);
      }
    }
    else {
      iVar2 = -4;
      if (((iVar1 != 0x13) && (iVar2 = -2, iVar1 != 0x16)) && (iVar2 = -6, iVar1 != 0x10)) {
        FUN_00120cd0(*(undefined8 *)(*(long *)(param_1 + 0x40) + 0x30),1,
                     "detach_kernel_driver_and_claim","disconnect-and-claim failed errno %d");
        iVar2 = -99;
      }
    }
  }
  if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
    return iVar2;
  }
                    /* WARNING: Subroutine does not return */
  __stack_chk_fail();
}


==================================================================

### FUNC 001296a0 (17 bytes) name=FUN_001296a0

void FUN_001296a0(long param_1)

{
  if (*(int *)(param_1 + 0x48) == 0) {
    FUN_00127cf0();
    return;
  }
  FUN_001295a0();
  return;
}


==================================================================

### FUNC 001296c0 (287 bytes) name=FUN_001296c0

undefined8 FUN_001296c0(pthread_mutex_t *param_1)

{
  int iVar1;
  int iVar2;
  int *piVar3;
  undefined8 uVar4;
  int iVar5;
  ulong uVar6;
  undefined8 uVar7;
  
  iVar1 = *(int *)((long)param_1 + 0x4c);
  iVar2 = 0;
  do {
    while ((param_1[1].__align & 1L << ((byte)iVar2 & 0x3f)) != 0) {
      iVar5 = iVar2 + 1;
      FUN_00127c80(param_1,iVar2);
      iVar2 = iVar5;
      if (iVar5 == 0x20) goto LAB_00129708;
    }
    iVar2 = iVar2 + 1;
  } while (iVar2 != 0x20);
LAB_00129708:
  pthread_mutex_lock(param_1);
  iVar1 = ioctl(iVar1,0x5514,0);
  if (iVar1 == 0) {
    uVar7 = 0;
    iVar1 = 0;
    do {
      uVar6 = 1L << ((byte)iVar1 & 0x3f);
      if ((param_1[1].__align & uVar6) != 0) {
        iVar2 = FUN_001295a0(param_1,iVar1);
        if (iVar2 != 0) {
          uVar7 = 0xfffffffb;
          uVar4 = libusb_error_name(iVar2);
          FUN_00120cd0(*(undefined8 *)(*(long *)((long)param_1 + 0x40) + 0x30),2,"op_reset_device",
                       "failed to re-claim interface %d after reset: %s",iVar1,uVar4);
          param_1[1].__align = param_1[1].__align & ~uVar6;
        }
      }
      iVar1 = iVar1 + 1;
    } while (iVar1 != 0x20);
  }
  else {
    piVar3 = __errno_location();
    uVar7 = 0xfffffffb;
    if (*piVar3 != 0x13) {
      uVar7 = 0xffffff9d;
      FUN_00120cd0(*(undefined8 *)(*(long *)((long)param_1 + 0x40) + 0x30),1,"op_reset_device",
                   "reset failed error %d errno %d",iVar1);
    }
  }
  pthread_mutex_unlock(param_1);
  return uVar7;
}


==================================================================

### FUNC 00129800 (147 bytes) name=FUN_00129800

int FUN_00129800(long param_1,int *param_2)

{
  long lVar1;
  int iVar2;
  
  lVar1 = *(long *)(param_1 + 0x40);
  if ((*(long *)(lVar1 + 0x80) == 0) || (DAT_0033f5f0 == 0)) {
    iVar2 = FUN_00129050(lVar1,*(undefined4 *)(param_1 + 0x4c));
    if (iVar2 == 0) {
      iVar2 = *(int *)(lVar1 + 0x94);
      *param_2 = iVar2;
      goto joined_r0x00129867;
    }
  }
  else {
    iVar2 = FUN_00128110(lVar1);
  }
  if (iVar2 < 0) {
    return iVar2;
  }
  iVar2 = *param_2;
joined_r0x00129867:
  if (iVar2 != -1) {
    return 0;
  }
  FUN_00120cd0(*(undefined8 *)(*(long *)(param_1 + 0x40) + 0x30),1,"op_get_configuration",
               "device unconfigured");
  *param_2 = 0;
  return 0;
}


==================================================================

### FUNC 001298a0 (33 bytes) name=FUN_001298a0

int FUN_001298a0(int param_1,timespec *param_2)

{
  int iVar1;
  
  if (param_1 == 0) {
    iVar1 = clock_gettime(DAT_0033f5f4,param_2);
    return iVar1;
  }
  if (param_1 == 1) {
    iVar1 = clock_gettime(0,param_2);
    return iVar1;
  }
  return -2;
}


==================================================================

### FUNC 001298d0 (2646 bytes) name=FUN_001298d0

undefined8 FUN_001298d0(long param_1)

{
  int *piVar1;
  pthread_mutex_t *ppVar2;
  long *plVar3;
  int *piVar4;
  byte bVar5;
  int iVar6;
  uint uVar7;
  int iVar8;
  int iVar9;
  int *piVar10;
  long lVar11;
  undefined8 uVar12;
  undefined8 *puVar13;
  undefined4 uVar14;
  undefined1 *puVar15;
  void *__dest;
  int iVar16;
  int local_4c;
  undefined1 *local_40 [2];
  
  iVar8 = ioctl(*(int *)(param_1 + 0x4c),0x4008550d,local_40);
  if (iVar8 == -1) {
    piVar10 = __errno_location();
    iVar9 = *piVar10;
    if (iVar9 == 0xb) {
      return 1;
    }
LAB_00129a08:
    if (iVar9 == 0x13) {
      return 0xfffffffc;
    }
    FUN_00120cd0(*(undefined8 *)(*(long *)(param_1 + 0x40) + 0x30),1,"reap_for_handle",
                 "reap failed error %d errno=%d",iVar8);
    return 0xffffffff;
  }
  if (iVar8 < 0) {
    piVar10 = __errno_location();
    iVar9 = *piVar10;
    goto LAB_00129a08;
  }
  piVar10 = *(int **)(local_40[0] + 0x30);
  FUN_00120cd0(0,4,"reap_for_handle","urb type=%d status=%d transferred=%d",*local_40[0],
               *(undefined4 *)(local_40[0] + 4),*(undefined4 *)(local_40[0] + 0x1c));
  bVar5 = *(byte *)((long)piVar10 + 0x7a);
  if (bVar5 == 1) {
    piVar4 = piVar10 + (long)*piVar10 * 3 + 0x2c;
    iVar8 = piVar4[3];
    ppVar2 = (pthread_mutex_t *)(piVar10 + 0x12);
    pthread_mutex_lock(ppVar2);
    if (iVar8 < 1) {
LAB_00129b79:
      FUN_00120cd0(*(undefined8 *)(*(long *)(*(long *)(piVar10 + 0x1c) + 0x40) + 0x30),1,
                   "handle_iso_completion","could not locate urb!");
      pthread_mutex_unlock(ppVar2);
      return 0xfffffffb;
    }
    puVar13 = *(undefined8 **)piVar4;
    if (local_40[0] == (undefined1 *)*puVar13) {
      local_4c = 1;
    }
    else {
      iVar9 = 0;
      do {
        local_4c = iVar9;
        puVar13 = puVar13 + 1;
        iVar9 = local_4c + 1;
        if (iVar9 == iVar8) goto LAB_00129b79;
      } while (local_40[0] != (undefined1 *)*puVar13);
      local_4c = local_4c + 2;
    }
    FUN_00120cd0(0,4,"handle_iso_completion","handling completion status %d of iso urb %d/%d",
                 *(undefined4 *)(local_40[0] + 4),local_4c,iVar8);
    if (0 < *(int *)(local_40[0] + 0x24)) {
      iVar9 = 0;
      puVar15 = local_40[0];
      do {
        lVar11 = (long)piVar4[6];
        uVar7 = *(uint *)(puVar15 + 0x40);
        piVar4[6] = piVar4[6] + 1;
        piVar10[lVar11 * 3 + 0x2d] = 0;
        if (uVar7 < 0xffffffbb) {
          if (0xffffffb8 < uVar7) goto LAB_00129d8d;
          if (uVar7 != 0xffffff98) {
            if (uVar7 < 0xffffff99) {
              if (uVar7 != 0) {
                if (uVar7 == 0xffffff94) goto LAB_00129d1f;
LAB_00129cd2:
                FUN_00120cd0(*(undefined8 *)(*(long *)(*(long *)(piVar10 + 0x1c) + 0x40) + 0x30),2,
                             "handle_iso_completion","unrecognised urb status %d");
                piVar10[lVar11 * 3 + 0x2d] = 1;
              }
            }
            else {
              if (uVar7 == 0xffffffac) goto LAB_00129d8d;
              if (uVar7 != 0xffffffb5) goto LAB_00129cd2;
              FUN_00120cd0(0,4,"handle_iso_completion","overflow error");
              piVar10[lVar11 * 3 + 0x2d] = 6;
            }
          }
        }
        else if (uVar7 == 0xffffffe0) {
          FUN_00120cd0(0,4,"handle_iso_completion","detected endpoint stall");
          piVar10[lVar11 * 3 + 0x2d] = 4;
        }
        else {
          if (uVar7 < 0xffffffe1) {
            if (1 < uVar7 + 0x3f) goto LAB_00129cd2;
          }
          else if (uVar7 != 0xffffffee) {
            if (uVar7 != 0xfffffffe) {
              if (uVar7 != 0xffffffed) goto LAB_00129cd2;
LAB_00129d1f:
              FUN_00120cd0(0,4,"handle_iso_completion","device removed");
              piVar10[lVar11 * 3 + 0x2d] = 5;
            }
            goto LAB_00129c68;
          }
LAB_00129d8d:
          FUN_00120cd0(0,4,"handle_iso_completion","low-level USB error %d");
          piVar10[lVar11 * 3 + 0x2d] = 1;
        }
LAB_00129c68:
        piVar1 = (int *)(puVar15 + 0x3c);
        iVar9 = iVar9 + 1;
        puVar15 = puVar15 + 0xc;
        piVar10[lVar11 * 3 + 0x2c] = *piVar1;
      } while (iVar9 < *(int *)(local_40[0] + 0x24));
    }
    piVar4[4] = piVar4[4] + 1;
    if (piVar4[2] == 0) {
      iVar9 = *(int *)(local_40[0] + 4);
      if (iVar9 == -0x68) {
LAB_0012a2c0:
        uVar14 = 0;
      }
      else {
        if (iVar9 < -0x67) {
          if (iVar9 == -0x6c) {
            uVar14 = 5;
            FUN_00120cd0(0,4,"handle_iso_completion","device removed");
            goto LAB_00129e09;
          }
        }
        else if ((iVar9 == -2) || (iVar9 == 0)) goto LAB_0012a2c0;
        uVar14 = 1;
        FUN_00120cd0(*(undefined8 *)(*(long *)(*(long *)(piVar10 + 0x1c) + 0x40) + 0x30),2,
                     "handle_iso_completion","unrecognised urb status %d");
      }
LAB_00129e09:
      if (iVar8 == local_4c) {
        FUN_00120cd0(0,4,"handle_iso_completion","last URB in transfer --> complete!");
        FUN_00128a50(piVar4,piVar4 + 3);
        pthread_mutex_unlock(ppVar2);
        uVar12 = FUN_00125c10(piVar10,uVar14);
        return uVar12;
      }
LAB_00129e17:
      pthread_mutex_unlock(ppVar2);
      return 0;
    }
    FUN_00120cd0(0,4,"handle_iso_completion","CANCEL: urb status %d",
                 *(undefined4 *)(local_40[0] + 4));
    if (iVar8 != piVar4[4]) goto LAB_00129e17;
    FUN_00120cd0(0,4,"handle_iso_completion","CANCEL: last URB handled, reporting");
    FUN_00128a50(piVar4,piVar4 + 3);
    if (piVar4[2] != 2) {
      pthread_mutex_unlock(ppVar2);
      uVar12 = FUN_00125c10(piVar10,1);
      return uVar12;
    }
LAB_0012a13e:
    pthread_mutex_unlock((pthread_mutex_t *)(piVar10 + 0x12));
    goto LAB_0012a143;
  }
  if (bVar5 == 0) {
    piVar4 = piVar10 + (long)*piVar10 * 3 + 0x2c;
    pthread_mutex_lock((pthread_mutex_t *)(piVar10 + 0x12));
    FUN_00120cd0(0,4,"handle_control_completion","handling completion status %d",
                 *(undefined4 *)(local_40[0] + 4));
    piVar10[0xe] = piVar10[0xe] + *(int *)(local_40[0] + 0x1c);
    iVar8 = *(int *)(local_40[0] + 4);
    if (piVar4[2] != 2) {
      switch(iVar8) {
      case 0:
        uVar14 = 0;
        break;
      case -0x6c:
      case -0x13:
        uVar14 = 5;
        FUN_00120cd0(0,4,"handle_control_completion","device removed");
        break;
      default:
        uVar14 = 1;
        FUN_00120cd0(*(undefined8 *)(*(long *)(*(long *)(piVar10 + 0x1c) + 0x40) + 0x30),2,
                     "handle_control_completion","unrecognised urb status %d");
        break;
      case -0x54:
      case -0x47:
      case -0x46:
      case -0x3f:
      case -0x3e:
        uVar14 = 1;
        FUN_00120cd0(0,4,"handle_control_completion","low-level bus error occurred");
        break;
      case -0x4b:
        uVar14 = 6;
        FUN_00120cd0(0,4,"handle_control_completion","control overflow error");
        break;
      case -0x20:
        uVar14 = 4;
        FUN_00120cd0(0,4,"handle_control_completion","unsupported control request");
        break;
      case -2:
        uVar14 = 3;
      }
      free(*(void **)piVar4);
      piVar4[0] = 0;
      piVar4[1] = 0;
      pthread_mutex_unlock((pthread_mutex_t *)(piVar10 + 0x12));
      uVar12 = FUN_00125c10(piVar10,uVar14);
      return uVar12;
    }
    if ((iVar8 != -2) && (iVar8 != 0)) {
      FUN_00120cd0(*(undefined8 *)(*(long *)(*(long *)(piVar10 + 0x1c) + 0x40) + 0x30),2,
                   "handle_control_completion","cancel: unrecognised urb status %d");
    }
    free(*(void **)piVar4);
    piVar4[0] = 0;
    piVar4[1] = 0;
    goto LAB_0012a13e;
  }
  if (4 < bVar5) {
    FUN_00120cd0(*(undefined8 *)(*(long *)(param_1 + 0x40) + 0x30),1,"reap_for_handle",
                 "unrecognised endpoint type %x");
    return 0xffffff9d;
  }
  ppVar2 = (pthread_mutex_t *)(piVar10 + 0x12);
  plVar3 = (long *)(piVar10 + (long)*piVar10 * 3 + 0x2c);
  iVar9 = (int)((long)local_40[0] - *plVar3 >> 3) * -0x49249249;
  pthread_mutex_lock(ppVar2);
  iVar8 = *(int *)((long)plVar3 + 0xc);
  iVar16 = iVar9 + 1;
  FUN_00120cd0(0,4,"handle_bulk_completion","handling completion status %d of bulk urb %d/%d",
               *(undefined4 *)(local_40[0] + 4),iVar16,iVar8);
  *(int *)(plVar3 + 2) = (int)plVar3[2] + 1;
  if ((int)plVar3[1] != 0) {
    FUN_00120cd0(0,4,"handle_bulk_completion","abnormal reap: urb status %d",
                 *(undefined4 *)(local_40[0] + 4));
    if (0 < *(int *)(local_40[0] + 0x1c)) {
      __dest = (void *)((long)piVar10[0xe] + *(long *)(piVar10 + 0x28));
      FUN_00120cd0(0,4,"handle_bulk_completion","received %d bytes of surplus data");
      if (__dest != *(void **)(local_40[0] + 0x10)) {
        FUN_00120cd0(0,4,"handle_bulk_completion","moving surplus data from offset %d to offset %d",
                     (long)*(void **)(local_40[0] + 0x10) - *(long *)(piVar10 + 0x28),
                     (long)__dest - *(long *)(piVar10 + 0x28),iVar8);
        memmove(__dest,*(void **)(local_40[0] + 0x10),(long)*(int *)(local_40[0] + 0x1c));
      }
      piVar10[0xe] = piVar10[0xe] + *(int *)(local_40[0] + 0x1c);
    }
    if ((int)plVar3[2] == *(int *)((long)plVar3 + 0xc)) {
      FUN_00120cd0(0,4,"handle_bulk_completion","abnormal reap: last URB handled, reporting");
      if (((int)plVar3[1] != 3) && (*(int *)((long)plVar3 + 0x14) == 0)) {
        *(int *)((long)plVar3 + 0x14) = 1;
      }
      goto LAB_00129eb0;
    }
    goto LAB_00129f2b;
  }
  uVar14 = *(undefined4 *)(local_40[0] + 4);
  iVar6 = *(int *)(local_40[0] + 0x1c);
  piVar10[0xe] = piVar10[0xe] + iVar6;
  switch(uVar14) {
  case 0xffffff87:
  case 0xffffff98:
  case 0xfffffffe:
  case 0:
    if (iVar9 == *(int *)((long)plVar3 + 0xc) + -1) {
      FUN_00120cd0(0,4,"handle_bulk_completion","last URB in transfer --> complete!");
      goto LAB_00129eb0;
    }
    if (*(int *)(local_40[0] + 0x18) <= iVar6) goto LAB_00129f2b;
    FUN_00120cd0(0,4,"handle_bulk_completion","short transfer %d/%d --> complete!",iVar6,
                 *(int *)(local_40[0] + 0x18),iVar8);
    iVar8 = (int)plVar3[1];
    if (iVar8 != 0) goto LAB_00129f60;
    *(int *)(plVar3 + 1) = 3;
    goto LAB_00129f18;
  default:
    FUN_00120cd0(*(undefined8 *)(*(long *)(*(long *)(piVar10 + 0x1c) + 0x40) + 0x30),2,
                 "handle_bulk_completion","unrecognised urb status %d");
    *(int *)(plVar3 + 1) = 4;
    break;
  case 0xffffff94:
  case 0xffffffed:
    FUN_00120cd0(0,4,"handle_bulk_completion","device removed");
    iVar8 = (int)plVar3[1];
    *(int *)((long)plVar3 + 0x14) = 5;
    goto LAB_00129f60;
  case 0xffffffac:
  case 0xffffffb9:
  case 0xffffffba:
  case 0xffffffc1:
  case 0xffffffc2:
    FUN_00120cd0(0,4,"handle_bulk_completion","low level error %d");
    *(int *)(plVar3 + 1) = 4;
    break;
  case 0xffffffb5:
    FUN_00120cd0(0,4,"handle_bulk_completion","overflow, actual_length=%d",iVar6);
    if (*(int *)((long)plVar3 + 0x14) == 0) {
      *(int *)((long)plVar3 + 0x14) = 6;
    }
    goto LAB_00129eb0;
  case 0xffffffe0:
    FUN_00120cd0(0,4,"handle_bulk_completion","detected endpoint stall");
    if (*(int *)((long)plVar3 + 0x14) == 0) {
      *(int *)((long)plVar3 + 0x14) = 4;
      iVar8 = (int)plVar3[1];
    }
    else {
      iVar8 = (int)plVar3[1];
    }
LAB_00129f60:
    if (iVar8 == 4) break;
    goto LAB_00129f18;
  }
  if (*(int *)((long)plVar3 + 0x14) == 0) {
    *(int *)((long)plVar3 + 0x14) = 1;
  }
LAB_00129f18:
  if ((int)plVar3[2] == *(int *)((long)plVar3 + 0xc)) {
LAB_00129eb0:
    free((void *)*plVar3);
    *plVar3 = 0;
    pthread_mutex_unlock(ppVar2);
    if ((int)plVar3[1] == 2) {
LAB_0012a143:
      uVar12 = FUN_00125d60(piVar10);
    }
    else {
      uVar12 = FUN_00125c10(piVar10,*(int *)((long)plVar3 + 0x14));
    }
  }
  else {
    FUN_001279f0(piVar10,iVar16);
LAB_00129f2b:
    pthread_mutex_unlock(ppVar2);
    uVar12 = 0;
  }
  return uVar12;
}


==================================================================

### FUNC 0012a380 (70 bytes) name=FUN_0012a380

undefined4 FUN_0012a380(long param_1,void *param_2,size_t param_3)

{
  int iVar1;
  int *piVar2;
  
  iVar1 = munmap(param_2,param_3);
  if (iVar1 == 0) {
    return 0;
  }
  piVar2 = __errno_location();
  FUN_00120cd0(*(undefined8 *)(*(long *)(param_1 + 0x40) + 0x30),1,"op_dev_mem_free",
               "free dev mem failed errno %d",*piVar2);
  return 0xffffff9d;
}


==================================================================

### FUNC 0012a3d0 (82 bytes) name=FUN_0012a3d0

void * FUN_0012a3d0(long param_1,size_t param_2)

{
  void *pvVar1;
  int *piVar2;
  
  pvVar1 = mmap((void *)0x0,param_2,3,1,*(int *)(param_1 + 0x4c),0);
  if (pvVar1 != (void *)0xffffffffffffffff) {
    return pvVar1;
  }
  piVar2 = __errno_location();
  FUN_00120cd0(*(undefined8 *)(*(long *)(param_1 + 0x40) + 0x30),1,"op_dev_mem_alloc",
               "alloc dev mem failed errno %d",*piVar2);
  return (void *)0x0;
}


==================================================================

### FUNC 0012a430 (91 bytes) name=FUN_0012a430

void FUN_0012a430(void)

{
  pthread_mutex_lock((pthread_mutex_t *)&DAT_003666a0);
  if (DAT_003666c8 != 0) {
    DAT_003666c8 = DAT_003666c8 + -1;
    if (DAT_003666c8 == 0) {
      FUN_0012c640();
    }
    pthread_mutex_unlock((pthread_mutex_t *)&DAT_003666a0);
    return;
  }
                    /* WARNING: Subroutine does not return */
  __assert_fail("init_count != 0","os/linux_usbfs.c",0x1d8,"op_exit");
}


==================================================================

### FUNC 0012a490 (481 bytes) name=FUN_0012a490

uint FUN_0012a490(long param_1,long param_2,uint param_3)

{
  undefined8 uVar1;
  uint uVar2;
  char *pcVar3;
  uint uVar4;
  int iVar5;
  uint uVar6;
  byte local_78;
  char local_77;
  undefined1 local_68;
  char local_67;
  ushort local_66;
  
  uVar1 = *(undefined8 *)(param_1 + 0x30);
  if (param_3 == 0) {
    uVar4 = 0xfffffffb;
  }
  else if ((int)param_3 < 9) {
    FUN_00120cd0(uVar1,1,"seek_to_next_config","short descriptor read %d/%d",param_3,9);
    uVar4 = 0xffffffff;
  }
  else {
    FUN_00122b20(param_2,"bbwbbbbb",&local_68,0);
    pcVar3 = "descriptor is not a config desc (type 0x%02x)";
    if (local_67 != '\x02') {
LAB_0012a636:
      FUN_00120cd0(uVar1,1,"seek_to_next_config",pcVar3);
      return 0xffffffff;
    }
    if ((*(long *)(param_1 + 0x80) == 0) || (DAT_0033f5ec == 0)) {
      if (local_66 < 9) {
        pcVar3 = "invalid wTotalLength %d";
        goto LAB_0012a636;
      }
      uVar4 = (uint)local_66;
      if ((int)param_3 < (int)(uint)local_66) {
        pcVar3 = "short descriptor read %d/%d";
        uVar6 = param_3;
        uVar4 = (uint)local_66;
        goto LAB_0012a535;
      }
    }
    else {
      uVar6 = 0;
      FUN_00122b20(param_2,"bb",&local_78,0);
      uVar4 = param_3;
      do {
        uVar6 = uVar6 + local_78;
        uVar4 = uVar4 - local_78;
        if ((int)uVar4 < 0) {
          iVar5 = -uVar4;
          pcVar3 = "bLength overflow by %d bytes";
LAB_0012a5ec:
          FUN_00120cd0(uVar1,1,"seek_to_next_descriptor",pcVar3,iVar5);
          return 0xffffffff;
        }
        uVar2 = param_3;
        if (uVar4 == 0) break;
        if (uVar4 == 1) {
          iVar5 = 1;
          pcVar3 = "short descriptor read %d/2";
          goto LAB_0012a5ec;
        }
        FUN_00122b20((int)uVar6 + param_2,"bb",&local_78,0);
      } while ((uVar6 == 0) || (uVar2 = uVar6, local_77 != '\x02'));
      param_3 = uVar2;
      uVar4 = (uint)local_66;
      uVar6 = (uint)local_66;
      if (uVar6 != param_3) {
        pcVar3 = "config length mismatch wTotalLength %d real %d";
        uVar4 = param_3;
LAB_0012a535:
        FUN_00120cd0(uVar1,2,"seek_to_next_config",pcVar3,uVar6,uVar4);
        return param_3;
      }
    }
  }
  return uVar4;
}


==================================================================

### FUNC 0012a690 (103 bytes) name=FUN_0012a690

void FUN_0012a690(long param_1,char param_2,long *param_3,undefined4 *param_4)

{
  int iVar1;
  long lVar2;
  int iVar3;
  
  lVar2 = *(long *)(param_1 + 0x88);
  iVar3 = *(int *)(param_1 + 0x90);
  *param_3 = 0;
  *param_4 = 0;
  lVar2 = lVar2 + 0x12;
  iVar3 = iVar3 + -0x12;
  while( true ) {
    iVar1 = FUN_0012a490(param_1,lVar2,iVar3);
    if (iVar1 < 0) {
      return;
    }
    if (*(char *)(lVar2 + 5) == param_2) break;
    iVar3 = iVar3 - iVar1;
    lVar2 = lVar2 + iVar1;
  }
  *param_3 = lVar2;
  return;
}


==================================================================

### FUNC 0012a700 (150 bytes) name=FUN_0012a700

ulong FUN_0012a700(long param_1,void *param_2,ulong param_3,undefined8 param_4)

{
  int iVar1;
  ulong uVar2;
  uint local_24;
  void *local_20;
  
  if ((*(long *)(param_1 + 0x80) == 0) || (DAT_0033f5f0 == 0)) {
    local_24 = *(uint *)(param_1 + 0x94);
  }
  else {
    uVar2 = FUN_00128110(param_1,&local_24);
    if ((int)uVar2 < 0) {
      return uVar2;
    }
  }
  if (local_24 == 0xffffffff) {
    uVar2 = 0xfffffffb;
  }
  else {
    uVar2 = FUN_0012a690(param_1,local_24 & 0xff,&local_20,param_4);
    iVar1 = (int)uVar2;
    if (-1 < iVar1) {
      if ((ulong)(long)iVar1 <= param_3) {
        param_3 = (long)iVar1;
      }
      memcpy(param_2,local_20,param_3);
      uVar2 = param_3 & 0xffffffff;
    }
  }
  return uVar2;
}


==================================================================

### FUNC 0012a7a0 (156 bytes) name=FUN_0012a7a0

ulong FUN_0012a7a0(long param_1,byte param_2,void *param_3,ulong param_4,undefined4 *param_5)

{
  long lVar1;
  int iVar2;
  ulong uVar3;
  void *__src;
  uint uVar4;
  int iVar5;
  
  uVar4 = 0;
  lVar1 = *(long *)(param_1 + 0x88);
  iVar5 = *(int *)(param_1 + 0x90);
  *param_5 = 0;
  __src = (void *)(lVar1 + 0x12);
  iVar5 = iVar5 + -0x12;
  while( true ) {
    uVar3 = FUN_0012a490(param_1,__src,iVar5);
    iVar2 = (int)uVar3;
    if (iVar2 < 0) {
      return uVar3;
    }
    if (param_2 == uVar4) break;
    iVar5 = iVar5 - iVar2;
    uVar4 = uVar4 + 1;
    __src = (void *)((long)__src + (long)iVar2);
  }
  if ((ulong)(long)iVar2 <= param_4) {
    param_4 = (long)iVar2;
  }
  memcpy(param_3,__src,param_4);
  return param_4 & 0xffffffff;
}


==================================================================

### FUNC 0012a850 (196 bytes) name=FUN_0012a850

ulong FUN_0012a850(int param_1)

{
  int iVar1;
  ulong uVar2;
  long in_FS_OFFSET;
  int local_1b4;
  int local_1b0;
  int local_1ac;
  utsname local_1a8;
  long local_20;
  
  local_20 = *(long *)(in_FS_OFFSET + 0x28);
  iVar1 = uname(&local_1a8);
  if (-1 < iVar1) {
    iVar1 = sscanf(local_1a8.release,"%d.%d.%d",&local_1b4,&local_1b0,&local_1ac);
    if (0 < iVar1) {
      uVar2 = 1;
      if (((local_1b4 < 3) && (uVar2 = 0, local_1b4 == 2)) && (iVar1 != 1)) {
        uVar2 = 1;
        if ((local_1b0 < 7) && (uVar2 = 0, local_1b0 == 6)) {
          if (iVar1 == 2) {
            uVar2 = (ulong)(param_1 == 0);
          }
          else {
            uVar2 = (ulong)(param_1 <= local_1ac);
          }
        }
      }
      goto LAB_0012a8e0;
    }
  }
  uVar2 = 0xffffffff;
LAB_0012a8e0:
  if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
    return uVar2;
  }
                    /* WARNING: Subroutine does not return */
  __stack_chk_fail();
}


==================================================================

### FUNC 0012a920 (541 bytes) name=FUN_0012a920

int FUN_0012a920(undefined8 param_1,int param_2,undefined1 *param_3,undefined1 *param_4,
                byte *param_5,long param_6,int param_7)

{
  int iVar1;
  ssize_t sVar2;
  long lVar3;
  byte *pbVar4;
  byte *pbVar5;
  long in_FS_OFFSET;
  bool bVar6;
  bool bVar7;
  bool bVar8;
  byte bVar9;
  char acStack_2048 [4096];
  byte local_1048 [4104];
  long local_40;
  
  bVar9 = 0;
  local_40 = *(long *)(in_FS_OFFSET + 0x28);
  FUN_00120cd0(0,4,"linux_get_device_address","getting address for device: %s detached: %d",param_6,
               param_2);
  if (((DAT_0033f5f0 != 0) && (param_2 == 0)) && (param_6 != 0)) {
    FUN_00120cd0(0,4,"linux_get_device_address","scan %s",param_6);
    iVar1 = FUN_00127580(param_1,param_6,"busnum");
    if (iVar1 < 0) goto LAB_0012a9eb;
    if (iVar1 < 0x100) {
      *param_3 = (char)iVar1;
      iVar1 = FUN_00127580(param_1,param_6,"devnum");
      if (iVar1 < 0) goto LAB_0012a9eb;
      if (iVar1 < 0x100) {
        *param_4 = (char)iVar1;
        FUN_00120cd0(0,4,"linux_get_device_address","bus=%d dev=%d",*param_3,iVar1);
        iVar1 = 0;
        goto LAB_0012a9eb;
      }
    }
    iVar1 = -2;
    goto LAB_0012a9eb;
  }
  bVar8 = false;
  if (param_5 == (byte *)0x0) {
    if (-1 < param_7) {
      param_5 = local_1048;
      __snprintf_chk(acStack_2048,0x1000,1,0x1000,"/proc/self/fd/%d",param_7);
      sVar2 = readlink(acStack_2048,(char *)param_5,0x1000);
      bVar8 = sVar2 == 0;
      if (0 < sVar2) goto LAB_0012a990;
    }
  }
  else {
LAB_0012a990:
    bVar6 = false;
    lVar3 = 0xc;
    pbVar4 = param_5;
    pbVar5 = (byte *)"/dev/bus/usb";
    do {
      if (lVar3 == 0) break;
      lVar3 = lVar3 + -1;
      bVar6 = *pbVar4 < *pbVar5;
      bVar8 = *pbVar4 == *pbVar5;
      pbVar4 = pbVar4 + (ulong)bVar9 * -2 + 1;
      pbVar5 = pbVar5 + (ulong)bVar9 * -2 + 1;
    } while (bVar8);
    bVar7 = false;
    if ((!bVar6 && !bVar8) == bVar6) {
      sscanf((char *)param_5,"/dev/bus/usb/%hhu/%hhu",param_3,param_4);
      iVar1 = 0;
      goto LAB_0012a9eb;
    }
    lVar3 = 0xd;
    bVar8 = false;
    pbVar4 = param_5;
    pbVar5 = (byte *)"/proc/bus/usb";
    do {
      if (lVar3 == 0) break;
      lVar3 = lVar3 + -1;
      bVar7 = *pbVar4 < *pbVar5;
      bVar8 = *pbVar4 == *pbVar5;
      pbVar4 = pbVar4 + (ulong)bVar9 * -2 + 1;
      pbVar5 = pbVar5 + (ulong)bVar9 * -2 + 1;
    } while (bVar8);
    if ((!bVar7 && !bVar8) == bVar7) {
      sscanf((char *)param_5,"/proc/bus/usb/%hhu/%hhu",param_3,param_4);
      iVar1 = 0;
      goto LAB_0012a9eb;
    }
  }
  iVar1 = -99;
LAB_0012a9eb:
  if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
                    /* WARNING: Subroutine does not return */
    __stack_chk_fail();
  }
  return iVar1;
}


==================================================================

### FUNC 0012ab60 (309 bytes) name=FUN_0012ab60

ulong FUN_0012ab60(undefined8 param_1,long param_2,int param_3)

{
  int iVar1;
  long lVar2;
  ulong uVar3;
  int *piVar4;
  undefined1 local_2a;
  undefined1 local_29;
  undefined1 local_28 [16];
  
  iVar1 = FUN_0012a920(param_1,1,&local_2a,&local_29,0,0,param_3);
  if (iVar1 < 0) {
    iVar1 = ioctl(param_3,0x40085511,local_28);
    if (iVar1 < 0) {
      piVar4 = __errno_location();
      FUN_00120cd0(param_1,1,"op_wrap_fd","connectinfo failed (%d)",*piVar4);
      return 0xffffffff;
    }
    local_2a = 0;
    local_29 = local_28[0];
  }
  FUN_00120cd0(0,4,"op_wrap_fd","allocating new device for fd %d",param_3);
  lVar2 = FUN_00120870(param_1,0);
  if (lVar2 == 0) {
    return 0xfffffff5;
  }
  uVar3 = FUN_00129160(lVar2,local_2a,local_29,0,param_3);
  if ((-1 < (int)uVar3) && (uVar3 = FUN_00120d60(lVar2), -1 < (int)uVar3)) {
    *(undefined4 *)(lVar2 + 0x7c) = 1;
    *(long *)(param_2 + 0x40) = lVar2;
    uVar3 = FUN_00128920(param_2,param_3);
    *(undefined4 *)(param_2 + 0x54) = 1;
    if (-1 < (int)uVar3) {
      return uVar3;
    }
  }
  libusb_unref_device(lVar2);
  return uVar3 & 0xffffffff;
}


==================================================================

### FUNC 0012acb0 (814 bytes) name=FUN_0012acb0

int FUN_0012acb0(undefined8 param_1,undefined1 param_2,undefined1 param_3,char *param_4)

{
  long lVar1;
  undefined2 uVar2;
  int iVar3;
  long lVar4;
  char *pcVar5;
  char *pcVar6;
  undefined8 uVar7;
  long lVar8;
  bool bVar9;
  byte bVar10;
  char *local_40 [2];
  
  bVar10 = 0;
  uVar2 = CONCAT11(param_2,param_3);
  FUN_00120cd0(0,4,"linux_enumerate_device","busnum %d devaddr %d session_id %ld",param_2,param_3,
               uVar2);
  lVar4 = FUN_00120650(param_1,uVar2);
  if (lVar4 != 0) {
    FUN_00120cd0(0,4,"linux_enumerate_device","session_id %ld already exists",uVar2);
    libusb_unref_device(lVar4);
    return 0;
  }
  FUN_00120cd0(0,4,"linux_enumerate_device","allocating new device for %d/%d (session %ld)",param_2,
               param_3,uVar2);
  lVar4 = FUN_00120870(param_1,uVar2);
  if (lVar4 == 0) {
    return -0xb;
  }
  iVar3 = FUN_00129160(lVar4,param_2,param_3,param_4,0xffffffff);
  if ((iVar3 < 0) || (iVar3 = FUN_00120d60(lVar4), iVar3 < 0)) {
LAB_0012ae18:
    libusb_unref_device(lVar4);
    return iVar3;
  }
  bVar9 = param_4 == (char *)0x0;
  lVar1 = *(long *)(lVar4 + 0x30);
  if (!bVar9) {
    lVar8 = 3;
    pcVar5 = param_4;
    pcVar6 = "usb";
    do {
      if (lVar8 == 0) break;
      lVar8 = lVar8 + -1;
      bVar9 = *pcVar5 == *pcVar6;
      pcVar5 = pcVar5 + (ulong)bVar10 * -2 + 1;
      pcVar6 = pcVar6 + (ulong)bVar10 * -2 + 1;
    } while (bVar9);
    if (!bVar9) {
      pcVar5 = (char *)__strdup(param_4);
      local_40[0] = pcVar5;
      if (pcVar5 != (char *)0x0) {
        pcVar6 = strrchr(pcVar5,0x2e);
        if ((pcVar6 == (char *)0x0) && (pcVar6 = strrchr(pcVar5,0x2d), pcVar6 == (char *)0x0)) {
          FUN_00120cd0(lVar1,2,"linux_get_parent_info","Can not parse sysfs_dir: %s, no parent info"
                       ,pcVar5);
          free(local_40[0]);
          goto LAB_0012add0;
        }
        lVar8 = strtol(pcVar6 + 1,(char **)0x0,10);
        pcVar5 = local_40[0];
        *(char *)(lVar4 + 0x39) = (char)lVar8;
        *pcVar6 = '\0';
        pcVar6 = strchr(local_40[0],0x2d);
        if (pcVar6 != (char *)0x0) {
LAB_0012ae92:
          bVar9 = true;
          do {
            pthread_mutex_lock((pthread_mutex_t *)(lVar1 + 0x20));
            pcVar5 = local_40[0];
            for (lVar8 = *(long *)(lVar1 + 0x18); lVar1 + 0x10 != lVar8;
                lVar8 = *(long *)(lVar8 + 8)) {
              if ((*(char **)(lVar8 + 0x30) != (char *)0x0) &&
                 (iVar3 = strcmp(*(char **)(lVar8 + 0x30),pcVar5), iVar3 == 0)) {
                uVar7 = libusb_ref_device(lVar8 + -0x50);
                *(undefined8 *)(lVar4 + 0x40) = uVar7;
                break;
              }
            }
            pthread_mutex_unlock((pthread_mutex_t *)(lVar1 + 0x20));
            if ((*(long *)(lVar4 + 0x40) != 0) || (!bVar9)) goto LAB_0012af00;
            FUN_00120cd0(0,4,"linux_get_parent_info",
                         "parent_dev %s not enumerated yet, enumerating now",local_40[0]);
            FUN_0012aff0(lVar1,local_40[0]);
            bVar9 = false;
          } while( true );
        }
        iVar3 = __asprintf_chk(local_40,1,"usb%s",pcVar5);
        free(pcVar5);
        if (-1 < iVar3) goto LAB_0012ae92;
      }
      iVar3 = -0xb;
      goto LAB_0012ae18;
    }
  }
LAB_0012add0:
  FUN_001207e0(lVar4);
  return 0;
LAB_0012af00:
  FUN_00120cd0(0,4,"linux_get_parent_info","Dev %p (%s) has parent %p (%s) port %d",lVar4,param_4,
               *(long *)(lVar4 + 0x40),local_40[0],*(undefined1 *)(lVar4 + 0x39));
  free(local_40[0]);
  goto LAB_0012add0;
}


==================================================================

### FUNC 0012aff0 (74 bytes) name=FUN_0012aff0

void FUN_0012aff0(undefined8 param_1,undefined8 param_2)

{
  int iVar1;
  undefined1 local_1a;
  undefined1 local_19 [9];
  
  iVar1 = FUN_0012a920(param_1,0,&local_1a,local_19,0,param_2,0xffffffff);
  if (iVar1 == 0) {
    FUN_0012acb0(param_1,local_1a,local_19[0],param_2);
  }
  return;
}


==================================================================

### FUNC 0012b040 (398 bytes) name=FUN_0012b040

undefined8 FUN_0012b040(undefined8 param_1,undefined1 param_2)

{
  char *__nptr;
  int iVar1;
  DIR *__dirp;
  dirent *pdVar2;
  ulong uVar3;
  int *piVar4;
  undefined8 uVar5;
  long in_FS_OFFSET;
  char local_1038 [4104];
  long local_30;
  
  local_30 = *(long *)(in_FS_OFFSET + 0x28);
  __snprintf_chk(local_1038,0x1000,1,0x1000,"%s/%03d",DAT_003666d0,param_2);
  FUN_00120cd0(0,4,"usbfs_scan_busdir","%s",local_1038);
  __dirp = opendir(local_1038);
  if (__dirp == (DIR *)0x0) {
    piVar4 = __errno_location();
    uVar5 = 0xffffffff;
    FUN_00120cd0(param_1,1,"usbfs_scan_busdir","opendir \'%s\' failed, errno=%d",local_1038,*piVar4)
    ;
  }
  else {
    uVar5 = 0xffffffff;
LAB_0012b0d0:
    pdVar2 = readdir(__dirp);
    if (pdVar2 != (dirent *)0x0) {
      while (pdVar2->d_name[0] != '.') {
        __nptr = pdVar2->d_name;
        uVar3 = strtol(__nptr,(char **)0x0,10);
        if ((int)uVar3 != 0) {
          iVar1 = FUN_0012acb0(param_1,param_2,uVar3 & 0xff,0);
          if (iVar1 == 0) {
            uVar5 = 0;
          }
          else {
            FUN_00120cd0(0,4,"usbfs_scan_busdir","failed to enumerate dir entry %s",__nptr);
          }
          break;
        }
        FUN_00120cd0(0,4,"usbfs_scan_busdir","unknown dir entry %s",__nptr);
        pdVar2 = readdir(__dirp);
        if (pdVar2 == (dirent *)0x0) goto LAB_0012b124;
      }
      goto LAB_0012b0d0;
    }
LAB_0012b124:
    closedir(__dirp);
  }
  if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
    return uVar5;
  }
                    /* WARNING: Subroutine does not return */
  __stack_chk_fail();
}


==================================================================

### FUNC 0012b1e0 (1686 bytes) name=FUN_0012b1e0

int FUN_0012b1e0(undefined8 param_1)

{
  int iVar1;
  int iVar2;
  DIR *pDVar3;
  dirent *pdVar4;
  long lVar5;
  ushort **ppuVar6;
  int *piVar7;
  char *pcVar8;
  char *pcVar9;
  char *pcVar10;
  bool bVar11;
  byte bVar12;
  undefined1 local_d0 [4];
  undefined1 local_cc [4];
  stat local_c8;
  
  bVar12 = 0;
  pcVar9 = "/dev/bus/usb";
  iVar1 = FUN_001289f0("/dev/bus/usb");
  if (iVar1 == 0) {
    iVar1 = FUN_001289f0("/proc/bus/usb");
    if (iVar1 == 0) {
      pDVar3 = opendir("/dev");
      if (pDVar3 == (DIR *)0x0) {
LAB_0012b761:
        pcVar9 = "could not find usbfs";
        DAT_003666d0 = (char *)0x0;
        goto LAB_0012b773;
      }
      do {
        pdVar4 = readdir(pDVar3);
        if (pdVar4 == (dirent *)0x0) {
          closedir(pDVar3);
          goto LAB_0012b761;
        }
        iVar1 = sscanf(pdVar4->d_name,"usbdev%d.%d",local_cc,&local_c8);
      } while (iVar1 != 2);
      FUN_00120cd0(0,4,"_is_usbdev_entry","found: %s",pdVar4->d_name);
      DAT_003666cc = 1;
      pcVar9 = "/dev";
      closedir(pDVar3);
    }
    else {
      pcVar9 = "/proc/bus/usb";
    }
  }
  FUN_00120cd0(0,4,"find_usbfs_path","found usbfs at %s",pcVar9);
  DAT_003666d0 = pcVar9;
  if (DAT_0033f5f4 == 0xffffffff) {
    iVar1 = clock_gettime(1,(timespec *)&local_c8);
    if (iVar1 != 0) {
      piVar7 = __errno_location();
      FUN_00120cd0(0,4,"find_monotonic_clock","monotonic clock doesn\'t work, errno %d",*piVar7);
    }
    DAT_0033f5f4 = (uint)(iVar1 == 0);
  }
  if ((DAT_0033f5fc == -1) && (DAT_0033f5fc = FUN_0012a850(0x20), DAT_0033f5fc == -1)) {
    pcVar9 = "error checking for bulk continuation support";
LAB_0012b773:
    FUN_00120cd0(param_1,1,"op_init",pcVar9);
    return -99;
  }
  if (DAT_0033f5fc != 0) {
    FUN_00120cd0(0,4,"op_init","bulk continuation flag supported");
  }
  if ((DAT_0033f5f8 == -1) && (DAT_0033f5f8 = FUN_0012a850(0x1f), DAT_0033f5f8 == -1)) {
    pcVar9 = "error checking for zero length packet support";
    goto LAB_0012b773;
  }
  if (DAT_0033f5f8 != 0) {
    FUN_00120cd0(0,4,"op_init","zero length packet flag supported");
  }
  if ((DAT_0033f5ec == -1) && (DAT_0033f5ec = FUN_0012a850(0x1a), DAT_0033f5ec == -1)) {
    pcVar9 = "error checking for sysfs descriptors";
    goto LAB_0012b773;
  }
  if ((DAT_0033f5f0 == -1) && (DAT_0033f5f0 = FUN_0012a850(0x16), DAT_0033f5f0 == -1)) {
    pcVar9 = "error checking for sysfs busnum";
    DAT_0033f5f0 = -1;
    goto LAB_0012b773;
  }
  iVar1 = DAT_0033f5f0;
  if ((DAT_0033f5f0 != 0) || (DAT_0033f5ec != 0)) {
    iVar2 = __xstat(1,"/sys/bus/usb/devices",&local_c8);
    if ((iVar2 == 0) && ((local_c8.st_mode & 0xf000) == 0x4000)) {
      if (iVar1 != 0) {
        FUN_00120cd0(0,4,"op_init","sysfs can relate devices");
      }
    }
    else {
      FUN_00120cd0(param_1,2,"op_init","sysfs not mounted");
      DAT_0033f5f0 = 0;
      DAT_0033f5ec = 0;
    }
    if (DAT_0033f5ec != 0) {
      FUN_00120cd0(0,4,"op_init","sysfs has complete descriptors");
    }
  }
  pthread_mutex_lock((pthread_mutex_t *)&DAT_003666a0);
  if ((DAT_003666c8 == 0) && (iVar1 = FUN_0012c330(), iVar1 != 0)) {
    FUN_00120cd0(param_1,1,"op_init","error starting hotplug event monitor");
    goto LAB_0012b4ac;
  }
  pthread_mutex_lock((pthread_mutex_t *)&DAT_00366660);
  if (DAT_0033f5f0 == 0) {
    pDVar3 = opendir(DAT_003666d0);
    if (pDVar3 == (DIR *)0x0) {
      piVar7 = __errno_location();
      iVar1 = *piVar7;
      pcVar9 = "opendir buses failed errno=%d";
      pcVar8 = "usbfs_get_device_list";
LAB_0012b882:
      FUN_00120cd0(param_1,1,pcVar8,pcVar9,iVar1);
      iVar1 = -1;
    }
    else {
      iVar1 = 0;
LAB_0012b300:
      do {
        pdVar4 = readdir(pDVar3);
        while( true ) {
          if (pdVar4 == (dirent *)0x0) goto LAB_0012b488;
          if (pdVar4->d_name[0] == '.') goto LAB_0012b300;
          pcVar9 = pdVar4->d_name;
          if (DAT_003666cc != 0) {
            iVar2 = sscanf(pcVar9,"usbdev%d.%d",local_d0,local_cc);
            if (iVar2 == 2) {
              FUN_00120cd0(0,4,"_is_usbdev_entry","found: %s",pcVar9);
              iVar1 = FUN_0012acb0(param_1,local_d0[0],local_cc[0],0);
              if (iVar1 < 0) {
                FUN_00120cd0(0,4,"usbfs_get_device_list","failed to enumerate dir entry %s",pcVar9);
              }
            }
            goto LAB_0012b300;
          }
          lVar5 = strtol(pcVar9,(char **)0x0,10);
          if ((int)lVar5 != 0) break;
          FUN_00120cd0(0,4,"usbfs_get_device_list","unknown dir entry %s",pcVar9);
          pdVar4 = readdir(pDVar3);
        }
        iVar1 = FUN_0012b040(param_1);
      } while (-1 < iVar1);
LAB_0012b488:
      closedir(pDVar3);
    }
  }
  else {
    pDVar3 = opendir("/sys/bus/usb/devices");
    if (pDVar3 == (DIR *)0x0) {
      piVar7 = __errno_location();
      pcVar9 = "opendir devices failed errno=%d";
      iVar1 = *piVar7;
      pcVar8 = "sysfs_get_device_list";
      goto LAB_0012b882;
    }
    iVar1 = -1;
LAB_0012b6b8:
    pdVar4 = readdir(pDVar3);
    if (pdVar4 != (dirent *)0x0) {
      ppuVar6 = __ctype_b_loc();
      pcVar9 = pdVar4->d_name;
      if ((*(byte *)((long)*ppuVar6 + (long)pdVar4->d_name[0] * 2 + 1) & 8) == 0)
      goto code_r0x0012b6e4;
      goto LAB_0012b6f5;
    }
    closedir(pDVar3);
  }
  pthread_mutex_unlock((pthread_mutex_t *)&DAT_00366660);
  if (iVar1 == 0) {
    DAT_003666c8 = DAT_003666c8 + 1;
  }
  else if (DAT_003666c8 == 0) {
    FUN_0012c640();
  }
LAB_0012b4ac:
  pthread_mutex_unlock((pthread_mutex_t *)&DAT_003666a0);
  return iVar1;
code_r0x0012b6e4:
  lVar5 = 3;
  bVar11 = true;
  pcVar8 = pcVar9;
  pcVar10 = "usb";
  do {
    if (lVar5 == 0) break;
    lVar5 = lVar5 + -1;
    bVar11 = *pcVar8 == *pcVar10;
    pcVar8 = pcVar8 + (ulong)bVar12 * -2 + 1;
    pcVar10 = pcVar10 + (ulong)bVar12 * -2 + 1;
  } while (bVar11);
  if (bVar11) {
LAB_0012b6f5:
    pcVar8 = strchr(pcVar9,0x3a);
    if (pcVar8 == (char *)0x0) {
      iVar2 = FUN_0012aff0(param_1,pcVar9);
      if (iVar2 == 0) {
        iVar1 = 0;
      }
      else {
        FUN_00120cd0(0,4,"sysfs_get_device_list","failed to enumerate dir entry %s",pcVar9);
      }
    }
  }
  goto LAB_0012b6b8;
}


==================================================================

### FUNC 0012b8c0 (130 bytes) name=FUN_0012b8c0

void FUN_0012b8c0(undefined1 param_1,undefined1 param_2,undefined8 param_3)

{
  undefined8 *puVar1;
  
  pthread_mutex_lock((pthread_mutex_t *)&DAT_003665c0);
  for (puVar1 = DAT_003666e8; puVar1 != &DAT_003666e0; puVar1 = (undefined8 *)puVar1[1]) {
    FUN_0012acb0(puVar1 + -0x41,param_1,param_2,param_3);
  }
  pthread_mutex_unlock((pthread_mutex_t *)&DAT_003665c0);
  return;
}


==================================================================

### FUNC 0012b950 (170 bytes) name=FUN_0012b950

void FUN_0012b950(undefined1 param_1,undefined1 param_2)

{
  undefined8 *puVar1;
  long lVar2;
  
  pthread_mutex_lock((pthread_mutex_t *)&DAT_003665c0);
  puVar1 = DAT_003666e8;
  if (DAT_003666e8 != &DAT_003666e0) {
    do {
      lVar2 = FUN_00120650(puVar1 + -0x41,CONCAT11(param_1,param_2));
      if (lVar2 == 0) {
        FUN_00120cd0(0,4,"linux_device_disconnected","device not found for session %x",
                     CONCAT11(param_1,param_2));
      }
      else {
        FUN_00120910(lVar2);
        libusb_unref_device(lVar2);
      }
      puVar1 = (undefined8 *)puVar1[1];
    } while (puVar1 != &DAT_003666e0);
  }
  pthread_mutex_unlock((pthread_mutex_t *)&DAT_003665c0);
  return;
}


==================================================================

### FUNC 0012ba00 (435 bytes) name=FUN_0012ba00

int FUN_0012ba00(long param_1,long param_2,ulong param_3,int param_4)

{
  int *piVar1;
  int iVar2;
  long lVar3;
  int *piVar4;
  int iVar5;
  ulong uVar6;
  uint uVar7;
  long lVar8;
  
  pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0x58));
  if ((param_3 == 0) || (param_4 < 1)) {
LAB_0012bade:
    iVar5 = 0;
LAB_0012bae0:
    pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0x58));
    return iVar5;
  }
  uVar6 = 0;
  uVar7 = 0;
LAB_0012ba50:
  piVar1 = (int *)(param_2 + uVar6 * 8);
  if (*(ushort *)((long)piVar1 + 6) != 0) {
    lVar3 = *(long *)(param_1 + 0x50);
    param_4 = param_4 + -1;
    lVar8 = lVar3 + -0x30;
    if (param_1 + 0x48 == lVar3) {
      iVar5 = *piVar1;
    }
    else {
      iVar5 = *piVar1;
      iVar2 = *(int *)(lVar3 + 0x1c);
      while (piVar4 = (int *)(lVar3 + 0x1c), iVar2 != iVar5) {
        lVar3 = *(long *)(lVar8 + 0x38);
        lVar8 = lVar3 + -0x30;
        if (param_1 + 0x48 == lVar3) break;
        iVar2 = *(int *)(lVar3 + 0x1c);
      }
      if ((piVar4 != (int *)0x0) && (*piVar4 == iVar5)) {
        if ((*(ushort *)((long)piVar1 + 6) & 8) == 0) {
          do {
            iVar5 = FUN_001298d0(lVar8);
          } while (iVar5 == 0);
          if ((iVar5 == -4) || (-1 < iVar5)) goto LAB_0012baca;
          goto LAB_0012bae0;
        }
        FUN_001268c0(*(undefined8 *)(*(long *)(lVar8 + 0x40) + 0x30),iVar5);
        piVar4[1] = 1;
        pthread_mutex_lock((pthread_mutex_t *)&DAT_00366660);
        lVar3 = *(long *)(lVar8 + 0x40);
        if (*(int *)(lVar3 + 0x7c) != 0) {
          FUN_0012b950(*(undefined1 *)(lVar3 + 0x38),*(undefined1 *)(lVar3 + 0x48));
        }
        pthread_mutex_unlock((pthread_mutex_t *)&DAT_00366660);
        if ((*(byte *)(piVar4 + 3) & 0x10) != 0) {
          do {
            iVar5 = FUN_001298d0(lVar8);
          } while (iVar5 == 0);
        }
        FUN_00126d90(lVar8);
        goto LAB_0012baca;
      }
    }
    FUN_00120cd0(param_1,1,"op_handle_events","cannot find handle for fd %d",iVar5);
  }
LAB_0012baca:
  uVar7 = uVar7 + 1;
  uVar6 = (ulong)uVar7;
  if ((param_3 <= uVar6) || (param_4 < 1)) goto LAB_0012bade;
  goto LAB_0012ba50;
}


==================================================================

### FUNC 0012bbd0 (159 bytes) name=FUN_0012bbd0

int FUN_0012bbd0(long param_1)

{
  int __fd;
  int iVar1;
  
  __fd = FUN_00127810(*(undefined8 *)(param_1 + 0x40),2,0);
  if (__fd < 0) {
    iVar1 = __fd;
    if (__fd == -4) {
      pthread_mutex_lock((pthread_mutex_t *)&DAT_00366660);
      if (*(int *)(*(long *)(param_1 + 0x40) + 0x7c) != 0) {
        FUN_00120cd0(0,4,"op_open","open failed with no device, but device still attached");
        FUN_0012b950(*(undefined1 *)(*(long *)(param_1 + 0x40) + 0x38),
                     *(undefined1 *)(*(long *)(param_1 + 0x40) + 0x48));
      }
      iVar1 = -4;
      pthread_mutex_unlock((pthread_mutex_t *)&DAT_00366660);
    }
  }
  else {
    iVar1 = FUN_00128920(param_1,__fd);
    if (iVar1 < 0) {
      close(__fd);
    }
  }
  return iVar1;
}


==================================================================

### FUNC 0012bc80 (114 bytes) name=FUN_0012bc80

char * FUN_0012bc80(char *param_1,long param_2,char *param_3)

{
  char *pcVar1;
  int iVar2;
  size_t __n;
  size_t sVar3;
  
  pcVar1 = param_1 + param_2;
  __n = strlen(param_3);
  while( true ) {
    if ((pcVar1 <= param_1) || (*param_1 == '\0')) {
      return (char *)0x0;
    }
    iVar2 = strncmp(param_1,param_3,__n);
    if ((iVar2 == 0) && (param_1[__n] == '=')) break;
    sVar3 = strlen(param_1);
    param_1 = param_1 + sVar3 + 1;
  }
  return param_1 + __n + 1;
}


==================================================================

### FUNC 0012bd00 (1235 bytes) name=FUN_0012bd00

undefined4 FUN_0012bd00(void)

{
  ssize_t sVar1;
  int *piVar2;
  char *pcVar3;
  ulong uVar4;
  ulong uVar5;
  long lVar6;
  char *pcVar7;
  msghdr *pmVar8;
  char *pcVar9;
  undefined4 uVar10;
  long in_FS_OFFSET;
  bool bVar11;
  bool bVar12;
  byte bVar13;
  undefined1 local_8c9;
  undefined1 local_8c8 [4];
  int local_8c4;
  int local_8c0;
  iovec local_8b8;
  msghdr local_8a8;
  undefined1 local_868 [32];
  undefined1 local_848 [2056];
  long local_40;
  
  bVar13 = 0;
  local_40 = *(long *)(in_FS_OFFSET + 0x28);
  local_8b8.iov_len = 0x800;
  pmVar8 = &local_8a8;
  for (lVar6 = 7; lVar6 != 0; lVar6 = lVar6 + -1) {
    pmVar8->msg_name = (void *)0x0;
    pmVar8 = (msghdr *)&pmVar8->msg_namelen;
  }
  local_8a8.msg_name = local_8c8;
  local_8a8.msg_namelen = 0xc;
  local_8a8.msg_iovlen = 1;
  local_8a8.msg_iov = &local_8b8;
  local_8a8.msg_controllen = 0x20;
  local_8a8.msg_control = local_868;
  local_8b8.iov_base = local_848;
  sVar1 = recvmsg(DAT_0033f608,&local_8a8,0);
  if (sVar1 == -1) {
    piVar2 = __errno_location();
    if ((*piVar2 != 4) && (*piVar2 != 0xb)) {
      FUN_00120cd0(0,1,"linux_netlink_read_message","error receiving message from netlink (%d)");
      uVar10 = 0xffffffff;
      goto LAB_0012be7e;
    }
    goto LAB_0012be78;
  }
  if ((sVar1 < 0x20) || ((local_8a8.msg_flags & 0x20U) != 0)) {
    uVar10 = 0xffffffff;
    FUN_00120cd0(0,1,"linux_netlink_read_message","invalid netlink message length");
    goto LAB_0012be7e;
  }
  if ((local_8c0 != 1) || (local_8c4 != 0)) {
    uVar10 = 0xffffffff;
    FUN_00120cd0(0,4,"linux_netlink_read_message",
                 "ignoring netlink message from unknown group/PID (%u/%u)");
    goto LAB_0012be7e;
  }
  if (((local_8a8.msg_controllen < 0x10) || (local_8a8.msg_control == (undefined1 *)0x0)) ||
     (*(int *)((long)local_8a8.msg_control + 0xc) != 2)) {
    uVar10 = 0xffffffff;
    FUN_00120cd0(0,4,"linux_netlink_read_message",
                 "ignoring netlink message with no sender credentials");
    goto LAB_0012be7e;
  }
  if (*(int *)((long)local_8a8.msg_control + 0x14) != 0) {
    uVar10 = 0xffffffff;
    FUN_00120cd0(0,4,"linux_netlink_read_message",
                 "ignoring netlink message with non-zero sender UID %u");
    goto LAB_0012be7e;
  }
  piVar2 = __errno_location();
  *piVar2 = 0;
  pcVar3 = (char *)FUN_0012bc80(local_848,sVar1,"ACTION");
  bVar11 = pcVar3 == (char *)0x0;
  if (!bVar11) {
    lVar6 = 7;
    pcVar7 = pcVar3;
    pcVar9 = "remove";
    do {
      if (lVar6 == 0) break;
      lVar6 = lVar6 + -1;
      bVar11 = *pcVar7 == *pcVar9;
      pcVar7 = pcVar7 + (ulong)bVar13 * -2 + 1;
      pcVar9 = pcVar9 + (ulong)bVar13 * -2 + 1;
    } while (bVar11);
    if (bVar11) {
      bVar11 = true;
    }
    else {
      if (((*pcVar3 != 'a') || (pcVar3[1] != 'd')) || ((pcVar3[2] != 'd' || (pcVar3[3] != '\0')))) {
        FUN_00120cd0(0,4,"linux_netlink_parse","unknown device action %s",pcVar3);
        goto LAB_0012be78;
      }
      bVar11 = false;
    }
    pcVar3 = (char *)FUN_0012bc80(local_848,sVar1,"SUBSYSTEM");
    if (((pcVar3 != (char *)0x0) && (*pcVar3 == 'u')) &&
       ((pcVar3[1] == 's' && ((pcVar3[2] == 'b' && (pcVar3[3] == '\0')))))) {
      pcVar3 = (char *)FUN_0012bc80(local_848,sVar1,"DEVTYPE");
      bVar12 = pcVar3 == (char *)0x0;
      if (!bVar12) {
        lVar6 = 0xb;
        pcVar7 = "usb_device";
        do {
          if (lVar6 == 0) break;
          lVar6 = lVar6 + -1;
          bVar12 = *pcVar3 == *pcVar7;
          pcVar3 = pcVar3 + (ulong)bVar13 * -2 + 1;
          pcVar7 = pcVar7 + (ulong)bVar13 * -2 + 1;
        } while (bVar12);
        if (bVar12) {
          pcVar3 = (char *)FUN_0012bc80(local_848,sVar1,"BUSNUM");
          if (pcVar3 == (char *)0x0) {
            pcVar3 = (char *)FUN_0012bc80(local_848,sVar1,"DEVICE");
            if ((pcVar3 != (char *)0x0) && (pcVar3 = strrchr(pcVar3,0x2f), pcVar3 != (char *)0x0)) {
              uVar4 = strtoul(pcVar3 + -3,(char **)0x0,10);
              uVar4 = uVar4 & 0xff;
              if (*piVar2 == 0) {
                pcVar7 = (char *)0x0;
                uVar5 = strtoul(pcVar3 + 1,(char **)0x0,10);
                local_8c9 = (undefined1)uVar5;
                if (*piVar2 == 0) {
LAB_0012c00b:
                  uVar10 = 0;
                  if (bVar11) {
                    FUN_00120cd0(0,4,"linux_netlink_read_message",
                                 "netlink hotplug found device busnum: %hhu, devaddr: %hhu, sys_name: %s, removed: %s"
                                 ,uVar4,local_8c9,pcVar7,&DAT_00135ac3);
                    FUN_0012b950(uVar4,local_8c9);
                  }
                  else {
                    FUN_00120cd0(0,4,"linux_netlink_read_message",
                                 "netlink hotplug found device busnum: %hhu, devaddr: %hhu, sys_name: %s, removed: %s"
                                 ,uVar4,local_8c9,pcVar7,&DAT_00135ac7);
                    FUN_0012b8c0(uVar4,local_8c9,pcVar7);
                  }
                  goto LAB_0012be7e;
                }
              }
              goto LAB_0012c150;
            }
          }
          else {
            uVar4 = strtoul(pcVar3,(char **)0x0,10);
            uVar4 = uVar4 & 0xff;
            if (*piVar2 == 0) {
              pcVar3 = (char *)FUN_0012bc80(local_848,sVar1,"DEVNUM");
              if (pcVar3 != (char *)0x0) {
                uVar5 = strtoul(pcVar3,(char **)0x0,10);
                local_8c9 = (undefined1)uVar5;
                if (*piVar2 != 0) goto LAB_0012c150;
                pcVar3 = (char *)FUN_0012bc80(local_848,sVar1,"DEVPATH");
                if (pcVar3 != (char *)0x0) {
                  pcVar3 = strrchr(pcVar3,0x2f);
                  pcVar7 = (char *)0x0;
                  if (pcVar3 != (char *)0x0) {
                    pcVar7 = pcVar3 + 1;
                  }
                  goto LAB_0012c00b;
                }
              }
            }
            else {
LAB_0012c150:
              *piVar2 = 0;
            }
          }
        }
      }
    }
  }
LAB_0012be78:
  uVar10 = 0xffffffff;
LAB_0012be7e:
  if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
                    /* WARNING: Subroutine does not return */
    __stack_chk_fail();
  }
  return uVar10;
}


==================================================================

### FUNC 0012c210 (261 bytes) name=FUN_0012c210

undefined8 FUN_0012c210(void)

{
  int iVar1;
  ssize_t sVar2;
  undefined1 local_29;
  pollfd local_28;
  ulong local_20;
  
  local_28.events = 1;
  local_28.fd = DAT_0033f600;
  local_28.revents = 0;
  local_20 = (ulong)CONCAT24(1,DAT_0033f608);
  FUN_00120cd0(0,4,"linux_netlink_event_thread_main","netlink event thread entering");
  do {
    iVar1 = poll(&local_28,2,-1);
    if (iVar1 < 0) {
LAB_0012c29c:
      FUN_00120cd0(0,4,"linux_netlink_event_thread_main","netlink event thread exiting");
      return 0;
    }
    if (((ulong)local_28 & 0x1000000000000) != 0) {
      sVar2 = read(DAT_0033f600,&local_29,1);
      if (sVar2 < 1) {
        FUN_00120cd0(0,2,"linux_netlink_event_thread_main","netlink control pipe read failed");
      }
      goto LAB_0012c29c;
    }
    if ((local_20 & 0x1000000000000) != 0) {
      pthread_mutex_lock((pthread_mutex_t *)&DAT_00366660);
      FUN_0012bd00();
      pthread_mutex_unlock((pthread_mutex_t *)&DAT_00366660);
    }
  } while( true );
}


==================================================================

### FUNC 0012c330 (756 bytes) name=FUN_0012c330

undefined8 FUN_0012c330(void)

{
  int iVar1;
  uint uVar2;
  int iVar3;
  int *piVar4;
  char *pcVar5;
  undefined4 local_2c;
  sockaddr local_28;
  
  local_28.sa_data[6] = '\x01';
  local_28.sa_data[7] = '\0';
  local_28.sa_data[8] = '\0';
  local_28.sa_data[9] = '\0';
  local_28.sa_family = 0x10;
  local_28.sa_data[0] = '\0';
  local_28.sa_data[1] = '\0';
  local_28.sa_data[2] = '\0';
  local_28.sa_data[3] = '\0';
  local_28.sa_data[4] = '\0';
  local_28.sa_data[5] = '\0';
  local_2c = 1;
  iVar1 = socket(0x10,0x80803,0xf);
  if (iVar1 == -1) {
    DAT_0033f608 = iVar1;
    piVar4 = __errno_location();
    iVar1 = *piVar4;
    if (iVar1 != 0x16) {
LAB_0012c4e1:
      FUN_00120cd0(0,1,"linux_netlink_start_event_monitor","failed to create netlink socket (%d)",
                   iVar1);
      return 0xffffff9d;
    }
    FUN_00120cd0(0,4,"linux_netlink_start_event_monitor",
                 "failed to create netlink socket of type %d, attempting SOCK_RAW",0x80803);
    iVar1 = socket(0x10,3,0xf);
    if (iVar1 == -1) {
      iVar1 = *piVar4;
      DAT_0033f608 = -1;
      goto LAB_0012c4e1;
    }
  }
  DAT_0033f608 = iVar1;
  uVar2 = fcntl(iVar1,1);
  if (uVar2 == 0xffffffff) {
    piVar4 = __errno_location();
    pcVar5 = "failed to get netlink fd flags (%d)";
    iVar1 = *piVar4;
  }
  else if (((uVar2 & 1) == 0) && (iVar3 = fcntl(iVar1,2,(ulong)(uVar2 | 1)), iVar3 == -1)) {
    piVar4 = __errno_location();
    iVar1 = *piVar4;
    pcVar5 = "failed to set netlink fd flags (%d)";
  }
  else {
    uVar2 = fcntl(iVar1,3);
    if (uVar2 == 0xffffffff) {
      piVar4 = __errno_location();
      pcVar5 = "failed to get netlink fd status flags (%d)";
      iVar1 = *piVar4;
    }
    else {
      if (((uVar2 & 0x800) != 0) || (iVar1 = fcntl(iVar1,4,(ulong)(uVar2 | 0x800)), iVar1 != -1)) {
        iVar1 = DAT_0033f608;
        iVar3 = bind(DAT_0033f608,&local_28,0xc);
        if (iVar3 == -1) {
          piVar4 = __errno_location();
          iVar1 = *piVar4;
          pcVar5 = "failed to bind netlink socket (%d)";
        }
        else {
          iVar1 = setsockopt(iVar1,1,0x10,&local_2c,4);
          if (iVar1 != -1) {
            iVar1 = FUN_00127400(&DAT_0033f600);
            if (iVar1 == 0) {
              iVar1 = pthread_create(&DAT_003666d8,(pthread_attr_t *)0x0,FUN_0012c210,(void *)0x0);
              if (iVar1 == 0) {
                return 0;
              }
              FUN_00120cd0(0,1,"linux_netlink_start_event_monitor",
                           "failed to create netlink event thread (%d)",iVar1);
              close(DAT_0033f600);
              close(DAT_0033f604);
              DAT_0033f600 = -1;
              DAT_0033f604 = -1;
            }
            else {
              FUN_00120cd0(0,1,"linux_netlink_start_event_monitor",
                           "failed to create netlink control pipe");
            }
            goto LAB_0012c480;
          }
          piVar4 = __errno_location();
          pcVar5 = "failed to set netlink socket SO_PASSCRED option (%d)";
          iVar1 = *piVar4;
        }
        FUN_00120cd0(0,1,"linux_netlink_start_event_monitor",pcVar5,iVar1);
        goto LAB_0012c480;
      }
      piVar4 = __errno_location();
      pcVar5 = "failed to set netlink fd status flags (%d)";
      iVar1 = *piVar4;
    }
  }
  FUN_00120cd0(0,1,"set_fd_cloexec_nb",pcVar5,iVar1);
LAB_0012c480:
  close(DAT_0033f608);
  DAT_0033f608 = 0xffffffff;
  return 0xffffff9d;
}


==================================================================

### FUNC 0012c640 (193 bytes) name=FUN_0012c640

undefined8 FUN_0012c640(void)

{
  ssize_t sVar1;
  undefined1 local_9 [9];
  
  local_9[0] = 1;
  if (DAT_0033f608 != -1) {
    sVar1 = write(DAT_0033f604,local_9,1);
    if (sVar1 < 1) {
      FUN_00120cd0(0,2,"linux_netlink_stop_event_monitor","netlink control pipe signal failed");
    }
    pthread_join(DAT_003666d8,(void **)0x0);
    close(DAT_0033f608);
    DAT_0033f608 = 0xffffffff;
    close(DAT_0033f600);
    close(DAT_0033f604);
    DAT_0033f600 = 0xffffffff;
    DAT_0033f604 = 0xffffffff;
    return 0;
  }
                    /* WARNING: Subroutine does not return */
  __assert_fail("linux_netlink_socket != -1","os/linux_netlink.c",0xa1,
                "linux_netlink_stop_event_monitor");
}


==================================================================

### FUNC 0012c710 (34 bytes) name=FUN_0012c710

void FUN_0012c710(void)

{
  int iVar1;
  
  pthread_mutex_lock((pthread_mutex_t *)&DAT_00366660);
  do {
    iVar1 = FUN_0012bd00();
  } while (iVar1 == 0);
  pthread_mutex_unlock((pthread_mutex_t *)&DAT_00366660);
  return;
}


==================================================================

### FUNC 0012c734 (9 bytes) name=_fini

void _fini(void)

{
  return;
}


==================================================================

### FUNC 00367000 (1 bytes) name=exp

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

double exp(double __x)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367008 (1 bytes) name=pthread_getspecific

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

void * pthread_getspecific(pthread_key_t __key)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367010 (1 bytes) name=pthread_cond_destroy

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int pthread_cond_destroy(pthread_cond_t *__cond)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367018 (1 bytes) name=memset

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

void * memset(void *__s,int __c,size_t __n)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367020 (1 bytes) name=ftell

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

long ftell(FILE *__stream)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367028 (1 bytes) name=close

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int close(int __fd)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367030 (1 bytes) name=ioctl

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int ioctl(int __fd,ulong __request,...)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367038 (1 bytes) name=pthread_setspecific

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int pthread_setspecific(pthread_key_t __key,void *__pointer)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367040 (1 bytes) name=__gmon_start__

/* WARNING: Control flow encountered bad instruction data */

void __gmon_start__(void)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367048 (1 bytes) name=_Jv_RegisterClasses

/* WARNING: Control flow encountered bad instruction data */

void _Jv_RegisterClasses(void)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367050 (1 bytes) name=recvmsg

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

ssize_t recvmsg(int __fd,msghdr *__message,int __flags)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367058 (1 bytes) name=operator.new[]

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

void * operator_new__(ulong param_1)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367060 (1 bytes) name=uname

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int uname(utsname *__name)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367068 (1 bytes) name=fseek

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int fseek(FILE *__stream,long __off,int __whence)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367070 (1 bytes) name=pthread_cond_signal

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int pthread_cond_signal(pthread_cond_t *__cond)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367078 (1 bytes) name=operator.delete

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

void operator_delete(void *param_1)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367080 (1 bytes) name=_M_dispose

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

void std::string::_Rep::_M_dispose(allocator *param_1)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367088 (1 bytes) name=pthread_mutexattr_destroy

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int pthread_mutexattr_destroy(pthread_mutexattr_t *__attr)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367090 (1 bytes) name=__assert_fail

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

void __assert_fail(char *__assertion,char *__file,uint __line,char *__function)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367098 (1 bytes) name=__printf_chk

/* WARNING: Control flow encountered bad instruction data */

void __printf_chk(void)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 003670a0 (1 bytes) name=gettimeofday

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int gettimeofday(timeval *__tv,__timezone_ptr_t __tz)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 003670a8 (1 bytes) name=Init

/* WARNING: Control flow encountered bad instruction data */

void __thiscall std::ios_base::Init::Init(Init *this)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 003670b0 (1 bytes) name=read

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

ssize_t read(int __fd,void *__buf,size_t __nbytes)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 003670b8 (1 bytes) name=strncmp

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int strncmp(char *__s1,char *__s2,size_t __n)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 003670c0 (1 bytes) name=malloc

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

void * malloc(size_t __size)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 003670c8 (1 bytes) name=fopen

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

FILE * fopen(char *__filename,char *__modes)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 003670d0 (1 bytes) name=pthread_cond_timedwait

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int pthread_cond_timedwait(pthread_cond_t *__cond,pthread_mutex_t *__mutex,timespec *__abstime)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 003670d8 (1 bytes) name=__memcpy_chk

/* WARNING: Control flow encountered bad instruction data */

void __memcpy_chk(void)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 003670e0 (1 bytes) name=__cxa_atexit

/* WARNING: Control flow encountered bad instruction data */

void __cxa_atexit(void)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 003670e8 (1 bytes) name=setsockopt

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int setsockopt(int __fd,int __level,int __optname,void *__optval,socklen_t __optlen)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 003670f0 (1 bytes) name=pthread_mutex_init

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int pthread_mutex_init(pthread_mutex_t *__mutex,pthread_mutexattr_t *__mutexattr)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 003670f8 (1 bytes) name=fgets

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

char * fgets(char *__s,int __n,FILE *__stream)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367100 (1 bytes) name=__vsnprintf_chk

/* WARNING: Control flow encountered bad instruction data */

void __vsnprintf_chk(void)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367108 (1 bytes) name=~Init

/* WARNING: Control flow encountered bad instruction data */

void __thiscall std::ios_base::Init::~Init(Init *this)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367110 (1 bytes) name=pthread_attr_destroy

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int pthread_attr_destroy(pthread_attr_t *__attr)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367118 (1 bytes) name=getpwuid

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

passwd * getpwuid(__uid_t __uid)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367120 (1 bytes) name=_ITM_deregisterTMCloneTable

/* WARNING: Control flow encountered bad instruction data */

void _ITM_deregisterTMCloneTable(void)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367128 (1 bytes) name=operator<<

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

ostream * std::operator<<(ostream *param_1,char *param_2)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367130 (1 bytes) name=__strdup

/* WARNING: Control flow encountered bad instruction data */

void __strdup(void)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367138 (1 bytes) name=free

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

void free(void *__ptr)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367140 (1 bytes) name=strlen

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

size_t strlen(char *__s)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367148 (1 bytes) name=_ITM_registerTMCloneTable

/* WARNING: Control flow encountered bad instruction data */

void _ITM_registerTMCloneTable(void)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367150 (1 bytes) name=_M_destroy

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

void std::string::_Rep::_M_destroy(allocator *param_1)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367158 (1 bytes) name=__asprintf_chk

/* WARNING: Control flow encountered bad instruction data */

void __asprintf_chk(void)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367160 (1 bytes) name=pthread_create

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int pthread_create(pthread_t *__newthread,pthread_attr_t *__attr,__start_routine *__start_routine,
                  void *__arg)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367168 (1 bytes) name=opendir

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

DIR * opendir(char *__name)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367170 (1 bytes) name=__xstat

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int __xstat(int __ver,char *__filename,stat *__stat_buf)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367178 (1 bytes) name=pthread_cond_init

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int pthread_cond_init(pthread_cond_t *__cond,pthread_condattr_t *__cond_attr)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367180 (1 bytes) name=__ctype_b_loc

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

ushort ** __ctype_b_loc(void)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367188 (1 bytes) name=__cxa_finalize

/* WARNING: Control flow encountered bad instruction data */

void __cxa_finalize(void)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367190 (1 bytes) name=pthread_key_delete

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int pthread_key_delete(pthread_key_t __key)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 003671a0 (1 bytes) name=readdir

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

dirent * readdir(DIR *__dirp)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 003671a8 (1 bytes) name=strrchr

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

char * strrchr(char *__s,int __c)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 003671b0 (1 bytes) name=syscall

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

long syscall(long __sysno,...)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 003671b8 (1 bytes) name=sscanf

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int sscanf(char *__s,char *__format,...)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 003671c0 (1 bytes) name=pipe

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int pipe(int *__pipedes)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 003671c8 (1 bytes) name=pthread_join

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int pthread_join(pthread_t __th,void **__thread_return)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 003671d0 (1 bytes) name=poll

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int poll(pollfd *__fds,nfds_t __nfds,int __timeout)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 003671d8 (1 bytes) name=pthread_mutex_trylock

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int pthread_mutex_trylock(pthread_mutex_t *__mutex)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 003671e0 (1 bytes) name=pow

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

double pow(double __x,double __y)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 003671e8 (1 bytes) name=usleep

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int usleep(__useconds_t __useconds)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 003671f0 (1 bytes) name=strerror

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

char * strerror(int __errnum)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367200 (1 bytes) name=fputs

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int fputs(char *__s,FILE *__stream)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367208 (1 bytes) name=lseek

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

__off_t lseek(int __fd,__off_t __offset,int __whence)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367210 (1 bytes) name=strtol

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

long strtol(char *__nptr,char **__endptr,int __base)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367218 (1 bytes) name=readlink

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

ssize_t readlink(char *__path,char *__buf,size_t __len)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367220 (1 bytes) name=__cxa_pure_virtual

/* WARNING: Control flow encountered bad instruction data */

void __cxa_pure_virtual(void)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367228 (1 bytes) name=__strcpy_chk

/* WARNING: Control flow encountered bad instruction data */

void __strcpy_chk(void)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367230 (1 bytes) name=__ostream_insert<char,std::char_traits<char>>

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

ostream * std::__ostream_insert<char,std::char_traits<char>>
                    (ostream *param_1,char *param_2,long param_3)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367238 (1 bytes) name=memmove

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

void * memmove(void *__dest,void *__src,size_t __n)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367240 (1 bytes) name=strchr

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

char * strchr(char *__s,int __c)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367248 (1 bytes) name=socket

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int socket(int __domain,int __type,int __protocol)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367250 (1 bytes) name=fread

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

size_t fread(void *__ptr,size_t __size,size_t __n,FILE *__stream)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367258 (1 bytes) name=getenv

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

char * getenv(char *__name)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367260 (1 bytes) name=__errno_location

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int * __errno_location(void)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367270 (1 bytes) name=pthread_mutexattr_settype

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int pthread_mutexattr_settype(pthread_mutexattr_t *__attr,int __kind)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367278 (1 bytes) name=__stack_chk_fail

/* WARNING: Control flow encountered bad instruction data */

void __stack_chk_fail(void)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367280 (1 bytes) name=strcmp

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int strcmp(char *__s1,char *__s2)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367288 (1 bytes) name=__cxa_allocate_exception

/* WARNING: Control flow encountered bad instruction data */

void __cxa_allocate_exception(void)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367290 (1 bytes) name=assign

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

void std::string::assign(char *param_1,ulong param_2)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367298 (1 bytes) name=nanosleep

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int nanosleep(timespec *__requested_time,timespec *__remaining)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 003672a0 (1 bytes) name=getuid

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

__uid_t getuid(void)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 003672a8 (1 bytes) name=pthread_cond_wait

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int pthread_cond_wait(pthread_cond_t *__cond,pthread_mutex_t *__mutex)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 003672b0 (1 bytes) name=operator.delete[]

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

void operator_delete__(void *param_1)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 003672b8 (1 bytes) name=calloc

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

void * calloc(size_t __nmemb,size_t __size)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 003672c0 (1 bytes) name=munmap

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int munmap(void *__addr,size_t __len)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 003672c8 (1 bytes) name=feof

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int feof(FILE *__stream)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 003672d0 (1 bytes) name=__cxa_throw

/* WARNING: Control flow encountered bad instruction data */

void __cxa_throw(void)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 003672d8 (1 bytes) name=fclose

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int fclose(FILE *__stream)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 003672e0 (1 bytes) name=strncpy

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

char * strncpy(char *__dest,char *__src,size_t __n)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 003672e8 (1 bytes) name=pthread_attr_init

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int pthread_attr_init(pthread_attr_t *__attr)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 003672f0 (1 bytes) name=localtime_r

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

tm * localtime_r(time_t *__timer,tm *__tp)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 003672f8 (1 bytes) name=__cxa_end_catch

/* WARNING: Control flow encountered bad instruction data */

void __cxa_end_catch(void)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367300 (1 bytes) name=__throw_bad_alloc

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

void std::__throw_bad_alloc(void)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367310 (1 bytes) name=fscanf

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int fscanf(FILE *__stream,char *__format,...)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367318 (1 bytes) name=closedir

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int closedir(DIR *__dirp)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367320 (1 bytes) name=__sprintf_chk

/* WARNING: Control flow encountered bad instruction data */

void __sprintf_chk(void)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367330 (1 bytes) name=__snprintf_chk

/* WARNING: Control flow encountered bad instruction data */

void __snprintf_chk(void)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367338 (1 bytes) name=access

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int access(char *__name,int __type)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367340 (1 bytes) name=endl<char,std::char_traits<char>>

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

ostream * std::endl<char,std::char_traits<char>>(ostream *param_1)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367348 (1 bytes) name=__pthread_key_create

/* WARNING: Control flow encountered bad instruction data */

void __pthread_key_create(void)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367350 (1 bytes) name=__cxa_begin_catch

/* WARNING: Control flow encountered bad instruction data */

void __cxa_begin_catch(void)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367358 (1 bytes) name=bind

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int bind(int __fd,sockaddr *__addr,socklen_t __len)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367360 (1 bytes) name=fwrite

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

size_t fwrite(void *__ptr,size_t __size,size_t __n,FILE *__s)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367368 (1 bytes) name=pthread_mutex_lock

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int pthread_mutex_lock(pthread_mutex_t *__mutex)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367370 (1 bytes) name=realloc

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

void * realloc(void *__ptr,size_t __size)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367378 (1 bytes) name=timerfd_create

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int timerfd_create(clockid_t __clock_id,int __flags)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367380 (1 bytes) name=pthread_mutexattr_init

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int pthread_mutexattr_init(pthread_mutexattr_t *__attr)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367388 (1 bytes) name=pthread_key_create

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int pthread_key_create(pthread_key_t *__key,__destr_function *__destr_function)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367390 (1 bytes) name=__gxx_personality_v0

/* WARNING: Control flow encountered bad instruction data */

void __gxx_personality_v0(void)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367398 (1 bytes) name=timerfd_settime

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int timerfd_settime(int __ufd,int __flags,itimerspec *__utmr,itimerspec *__otmr)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 003673a0 (1 bytes) name=localtime

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

tm * localtime(time_t *__timer)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 003673a8 (1 bytes) name=pthread_mutex_destroy

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int pthread_mutex_destroy(pthread_mutex_t *__mutex)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 003673b0 (1 bytes) name=write

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

ssize_t write(int __fd,void *__buf,size_t __n)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 003673b8 (1 bytes) name=operator.new

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

void * operator_new(ulong param_1)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 003673c0 (1 bytes) name=_Unwind_Resume

/* WARNING: Control flow encountered bad instruction data */

void _Unwind_Resume(void)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 003673c8 (1 bytes) name=pthread_cond_broadcast

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int pthread_cond_broadcast(pthread_cond_t *__cond)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 003673d0 (1 bytes) name=clock_gettime

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int clock_gettime(clockid_t __clock_id,timespec *__tp)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 003673d8 (1 bytes) name=sqrt

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

double sqrt(double __x)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 003673e0 (1 bytes) name=strtoul

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

ulong strtoul(char *__nptr,char **__endptr,int __base)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 003673e8 (1 bytes) name=pthread_mutex_unlock

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int pthread_mutex_unlock(pthread_mutex_t *__mutex)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 003673f0 (1 bytes) name=memcpy

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

void * memcpy(void *__dest,void *__src,size_t __n)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 003673f8 (1 bytes) name=fcntl

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int fcntl(int __fd,int __cmd,...)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367400 (1 bytes) name=open

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int open(char *__file,int __oflag,...)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367408 (1 bytes) name=__open_2

/* WARNING: Control flow encountered bad instruction data */

void __open_2(void)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367410 (1 bytes) name=mmap

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

void * mmap(void *__addr,size_t __len,int __prot,int __flags,int __fd,__off_t __offset)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367420 (1 bytes) name=mkdir

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int mkdir(char *__path,__mode_t __mode)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367428 (1 bytes) name=time

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

time_t time(time_t *__timer)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367430 (1 bytes) name=fflush

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int fflush(FILE *__stream)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367438 (1 bytes) name=sqrtf

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

float sqrtf(float __x)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

### FUNC 00367440 (1 bytes) name=pthread_attr_setdetachstate

/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */

int pthread_attr_setdetachstate(pthread_attr_t *__attr,int __detachstate)

{
                    /* WARNING: Bad instruction - Truncating control flow here */
  halt_baddata();
}


==================================================================

