// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: get_obs_types(_IO_FILE*, char*, int, int*)
int get_obs_types(FILE *file, char *s, int system, int *obs_type)
{
int i;
int len;
char obs[5+1];
char *sys;
unsigned ti;
int num_obs;
int max_obs; // max observation types per line

   // parse list of observation types to output and build the RINEX file
   // observation type list

   // !!!!!!!!!! needs changes for RINEX v3 !!!!!!!!!!!!!!

   num_obs = 0;
   if(file == 0) return num_obs;

   if(s == 0) s = "";

   len = strlen(s);
   if(len) ++len;

   ti = 0;
   obs[0] = 0;
   for(i=0; i<len; i++) {  // build obs list from user specified measurments
      if(obs[0] && (s[i] == 0)) goto got_obs;  // null observation type list

      if(isalpha(s[i]) || isdigit(s[i])) {    // build the next obs type string
         if(ti >= (sizeof(obs)-1)) continue;  // obs name is too long, clip it
         obs[ti++] = s[i];
         obs[ti] = 0;
      }
      else if(obs[0]) {  // got the obs type string, parse it
         got_obs:
         strupr(obs);

         // RINEX v2.11
         if     (strstr(obs, "S1")) num_obs = add_obs_type(obs_type, num_obs, S1_OBS);  // signal strength
         else if(strstr(obs, "S2")) num_obs = add_obs_type(obs_type, num_obs, S2_OBS);
         else if(strstr(obs, "S5")) num_obs = add_obs_type(obs_type, num_obs, S5_OBS);
         else if(strstr(obs, "S6")) num_obs = add_obs_type(obs_type, num_obs, S6_OBS);
         else if(strstr(obs, "S7")) num_obs = add_obs_type(obs_type, num_obs, S7_OBS);
         else if(strstr(obs, "S8")) num_obs = add_obs_type(obs_type, num_obs, S8_OBS);
                                                                                     
         else if(strstr(obs, "D1")) num_obs = add_obs_type(obs_type, num_obs, D1_OBS);  // doppler
         else if(strstr(obs, "D2")) num_obs = add_obs_type(obs_type, num_obs, D2_OBS);
         else if(strstr(obs, "D5")) num_obs = add_obs_type(obs_type, num_obs, D5_OBS);
         else if(strstr(obs, "D6")) num_obs = add_obs_type(obs_type, num_obs, D6_OBS);
         else if(strstr(obs, "D7")) num_obs = add_obs_type(obs_type, num_obs, D7_OBS);
         else if(strstr(obs, "D8")) num_obs = add_obs_type(obs_type, num_obs, D8_OBS);
                                                                                     
         else if(strstr(obs, "C1")) num_obs = add_obs_type(obs_type, num_obs, C1_OBS);  // pseudorange
         else if(strstr(obs, "L1")) num_obs = add_obs_type(obs_type, num_obs, L1_OBS);
         else if(strstr(obs, "L2")) num_obs = add_obs_type(obs_type, num_obs, L2_OBS);
         else if(strstr(obs, "L5")) num_obs = add_obs_type(obs_type, num_obs, L5_OBS);
         else if(strstr(obs, "L6")) num_obs = add_obs_type(obs_type, num_obs, L6_OBS);
         else if(strstr(obs, "L7")) num_obs = add_obs_type(obs_type, num_obs, L7_OBS);
         else if(strstr(obs, "L8")) num_obs = add_obs_type(obs_type, num_obs, L8_OBS);
                                                                                     
         else if(strstr(obs, "P1")) num_obs = add_obs_type(obs_type, num_obs, P1_OBS);  // carrier phase
         else if(strstr(obs, "P2")) num_obs = add_obs_type(obs_type, num_obs, P2_OBS);
         else if(strstr(obs, "P5")) num_obs = add_obs_type(obs_type, num_obs, P5_OBS);
         else if(strstr(obs, "P6")) num_obs = add_obs_type(obs_type, num_obs, P6_OBS);
         else if(strstr(obs, "P7")) num_obs = add_obs_type(obs_type, num_obs, P7_OBS);
         else if(strstr(obs, "P8")) num_obs = add_obs_type(obs_type, num_obs, P8_OBS);

         // RINEX v3.03  - !!!!! These need work !!!!!
         else if(strstr(obs, "S1C")) num_obs = add_obs_type(obs_type, num_obs, S1_OBS);  // signal strength
         else if(strstr(obs, "S2C")) num_obs = add_obs_type(obs_type, num_obs, S2_OBS);
         else if(strstr(obs, "S5C")) num_obs = add_obs_type(obs_type, num_obs, S5_OBS);
         else if(strstr(obs, "S6C")) num_obs = add_obs_type(obs_type, num_obs, S6_OBS);
         else if(strstr(obs, "S7C")) num_obs = add_obs_type(obs_type, num_obs, S7_OBS);
         else if(strstr(obs, "S8C")) num_obs = add_obs_type(obs_type, num_obs, S8_OBS);
                                                                                       
         else if(strstr(obs, "D1C")) num_obs = add_obs_type(obs_type, num_obs, D1_OBS);  // doppler
         else if(strstr(obs, "D2C")) num_obs = add_obs_type(obs_type, num_obs, D2_OBS);
         else if(strstr(obs, "D5C")) num_obs = add_obs_type(obs_type, num_obs, D5_OBS);
         else if(strstr(obs, "D6C")) num_obs = add_obs_type(obs_type, num_obs, D6_OBS);
         else if(strstr(obs, "D7C")) num_obs = add_obs_type(obs_type, num_obs, D7_OBS);
         else if(strstr(obs, "D8C")) num_obs = add_obs_type(obs_type, num_obs, D8_OBS);
                                                                                       
         else if(strstr(obs, "C1C")) num_obs = add_obs_type(obs_type, num_obs, C1_OBS);  // pseudorange
         else if(strstr(obs, "C1P")) num_obs = add_obs_type(obs_type, num_obs, L1_OBS);
         else if(strstr(obs, "C2P")) num_obs = add_obs_type(obs_type, num_obs, L2_OBS);
         else if(strstr(obs, "C5P")) num_obs = add_obs_type(obs_type, num_obs, L5_OBS);
         else if(strstr(obs, "C6P")) num_obs = add_obs_type(obs_type, num_obs, L6_OBS);
         else if(strstr(obs, "C7P")) num_obs = add_obs_type(obs_type, num_obs, L7_OBS);
         else if(strstr(obs, "C8P")) num_obs = add_obs_type(obs_type, num_obs, L8_OBS);
                                                                                       
         else if(strstr(obs, "L1C")) num_obs = add_obs_type(obs_type, num_obs, P1_OBS);  // carrier phase
         else if(strstr(obs, "L2C")) num_obs = add_obs_type(obs_type, num_obs, P2_OBS);
         else if(strstr(obs, "L5C")) num_obs = add_obs_type(obs_type, num_obs, P5_OBS);
         else if(strstr(obs, "L6C")) num_obs = add_obs_type(obs_type, num_obs, P6_OBS);
         else if(strstr(obs, "L7C")) num_obs = add_obs_type(obs_type, num_obs, P7_OBS);
         else if(strstr(obs, "L8C")) num_obs = add_obs_type(obs_type, num_obs, P8_OBS);

         else continue;

         ++num_obs;
         ti = 0;
         obs[0] = 0;
         if(num_obs >= MAX_OBS) break;
      }
      else obs[0] = 0;  // skip whitespace

      if(s[i] == 0) break;
   }

   if(num_obs == 0) {  // build obs list from data type seen
      if(have_range & system)       obs_type[num_obs++] = C1_OBS;
      else if((have_phase & system) && use_rinex_cppr) {
         obs_type[num_obs++] = C1_OBS;
      }
      if(have_l1_range & system)    obs_type[num_obs++] = P1_OBS;
      if(have_l2_range & system)    obs_type[num_obs++] = P2_OBS;
      if(have_l5_range & system)    obs_type[num_obs++] = P5_OBS;
      if(have_l6_range & system)    obs_type[num_obs++] = P6_OBS;
      if(have_l7_range & system)    obs_type[num_obs++] = P7_OBS;
      if(have_l8_range & system)    obs_type[num_obs++] = P8_OBS;

      if((have_phase & system) || (have_l1_phase & system)) obs_type[num_obs++] = L1_OBS;
      if(have_l2_phase & system)    obs_type[num_obs++] = L2_OBS;
      if(have_l5_phase & system)    obs_type[num_obs++] = L5_OBS;
      if(have_l6_phase & system)    obs_type[num_obs++] = L6_OBS;
      if(have_l7_phase & system)    obs_type[num_obs++] = L7_OBS;
      if(have_l8_phase & system)    obs_type[num_obs++] = L8_OBS;

      if(rcvr_type == MOTO_RCVR) ;        // doppler value is unusable for RINEX 
      else if(rcvr_type == VENUS_RCVR) ;  // doppler value is unusable for RINEX
      else {
         if((have_doppler & system) || (have_l1_doppler & system)) {
            obs_type[num_obs++] = D1_OBS;
         }
         if(have_l2_doppler & system)  obs_type[num_obs++] = D2_OBS;
         if(have_l5_doppler & system)  obs_type[num_obs++] = D5_OBS;
         if(have_l6_doppler & system)  obs_type[num_obs++] = D6_OBS;
         if(have_l7_doppler & system)  obs_type[num_obs++] = D7_OBS;
         if(have_l8_doppler & system)  obs_type[num_obs++] = D8_OBS;
      }

      if(have_snr & system)         obs_type[num_obs++] = S1_OBS;
      else if(have_l1_snr & system) obs_type[num_obs++] = S1_OBS;
      if(have_l2_snr & system)      obs_type[num_obs++] = S2_OBS;
      if(have_l5_snr & system)      obs_type[num_obs++] = S5_OBS;
      if(have_l6_snr & system)      obs_type[num_obs++] = S6_OBS;
      if(have_l7_snr & system)      obs_type[num_obs++] = S7_OBS;
      if(have_l8_snr & system)      obs_type[num_obs++] = S8_OBS;
   }

   if(rinex_fmt >= 3.0) {
      if     (system & GPS)     sys = "G";
      else if(system & SBAS)    sys = "S";
      else if(system & GLONASS) sys = "R";
      else if(system & GALILEO) sys = "E";
      else if(system & BEIDOU)  sys = "C";
      else                      sys = "?";
      sprintf(out, "%s%5d", sys, num_obs);

      max_obs = 13;
      sys = "SYS / # / OBS TYPES";

      len = 0;
      for(i=0; i<num_obs; i++) {  // build the RINEX file observation list
         // !!!!!!!! THESE ARE TEMPORARY TEST VALUES... NEED TO BE UPDATED TO REAL ONES !!!!!!!!!
         if     (obs_type[i] == S1_OBS) { strcat(out, " S1C"); ++len; }  // sig level
         else if(obs_type[i] == S2_OBS) { strcat(out, " S2C"); ++len; } 
         else if(obs_type[i] == S5_OBS) { strcat(out, " S5C"); ++len; } 
         else if(obs_type[i] == S6_OBS) { strcat(out, " S6C"); ++len; } 
         else if(obs_type[i] == S7_OBS) { strcat(out, " S7C"); ++len; } 
         else if(obs_type[i] == S8_OBS) { strcat(out, " S8C"); ++len; } 

         else if(obs_type[i] == D1_OBS) { strcat(out, " D1C"); ++len; }  // dopple
         else if(obs_type[i] == D2_OBS) { strcat(out, " D2C"); ++len; } 
         else if(obs_type[i] == D5_OBS) { strcat(out, " D5C"); ++len; } 
         else if(obs_type[i] == D6_OBS) { strcat(out, " D6C"); ++len; } 
         else if(obs_type[i] == D7_OBS) { strcat(out, " D7C"); ++len; } 
         else if(obs_type[i] == D8_OBS) { strcat(out, " D8C"); ++len; } 

         else if(obs_type[i] == C1_OBS) { strcat(out, " C1C"); ++len; }  // pseudorange
         else if(obs_type[i] == P1_OBS) { strcat(out, " C1P"); ++len; } 
         else if(obs_type[i] == P2_OBS) { strcat(out, " C2P"); ++len; } 
         else if(obs_type[i] == P5_OBS) { strcat(out, " C5P"); ++len; } 
         else if(obs_type[i] == P6_OBS) { strcat(out, " C6P"); ++len; } 
         else if(obs_type[i] == P7_OBS) { strcat(out, " C7P"); ++len; } 
         else if(obs_type[i] == P8_OBS) { strcat(out, " C8P"); ++len; } 

         else if(obs_type[i] == L1_OBS) { strcat(out, " L1C"); ++len; }  // carrier phase
         else if(obs_type[i] == L2_OBS) { strcat(out, " L2C"); ++len; } 
         else if(obs_type[i] == L5_OBS) { strcat(out, " L5C"); ++len; } 
         else if(obs_type[i] == L6_OBS) { strcat(out, " L6C"); ++len; } 
         else if(obs_type[i] == L7_OBS) { strcat(out, " L7C"); ++len; } 
         else if(obs_type[i] == L8_OBS) { strcat(out, " L8C"); ++len; } 


         if(len >= max_obs) {  // time for continuation line
            write_rinex_line(file, out, sys); 
            strcpy(out,"      ");
            len = 0;
         }
      }

      if(len) {  // flush the last observation list line
         write_rinex_line(file, out, sys); 
      }
   }
   else {
      sprintf(out, "%6d", num_obs);

      max_obs = 9;
      sys = "# / TYPES OF OBSERV";

      len = 0;
      for(i=0; i<num_obs; i++) {  // build the RINEX file observation list
         if     (obs_type[i] == S1_OBS) { strcat(out, "    S1"); ++len; }
         else if(obs_type[i] == S2_OBS) { strcat(out, "    S2"); ++len; } 
         else if(obs_type[i] == S5_OBS) { strcat(out, "    S5"); ++len; } 
         else if(obs_type[i] == S6_OBS) { strcat(out, "    S6"); ++len; } 
         else if(obs_type[i] == S7_OBS) { strcat(out, "    S7"); ++len; } 
         else if(obs_type[i] == S8_OBS) { strcat(out, "    S8"); ++len; } 

         else if(obs_type[i] == D1_OBS) { strcat(out, "    D1"); ++len; } 
         else if(obs_type[i] == D2_OBS) { strcat(out, "    D2"); ++len; } 
         else if(obs_type[i] == D5_OBS) { strcat(out, "    D5"); ++len; } 
         else if(obs_type[i] == D6_OBS) { strcat(out, "    D6"); ++len; } 
         else if(obs_type[i] == D7_OBS) { strcat(out, "    D7"); ++len; } 
         else if(obs_type[i] == D8_OBS) { strcat(out, "    D8"); ++len; } 

         else if(obs_type[i] == C1_OBS) { strcat(out, "    C1"); ++len; } 
         else if(obs_type[i] == P1_OBS) { strcat(out, "    P1"); ++len; } 
         else if(obs_type[i] == P2_OBS) { strcat(out, "    P2"); ++len; } 
         else if(obs_type[i] == P5_OBS) { strcat(out, "    P5"); ++len; } 
         else if(obs_type[i] == P6_OBS) { strcat(out, "    P6"); ++len; } 
         else if(obs_type[i] == P7_OBS) { strcat(out, "    P7"); ++len; } 
         else if(obs_type[i] == P8_OBS) { strcat(out, "    P8"); ++len; } 


         else if(obs_type[i] == L1_OBS) { strcat(out, "    L1"); ++len; } 
         else if(obs_type[i] == L2_OBS) { strcat(out, "    L2"); ++len; } 
         else if(obs_type[i] == L5_OBS) { strcat(out, "    L5"); ++len; } 
         else if(obs_type[i] == L6_OBS) { strcat(out, "    L6"); ++len; } 
         else if(obs_type[i] == L7_OBS) { strcat(out, "    L7"); ++len; } 
         else if(obs_type[i] == L8_OBS) { strcat(out, "    L8"); ++len; } 


         if(len >= max_obs) {  // time for continuation line
            write_rinex_line(file, out, sys); 
            strcpy(out,"      ");
            len = 0;
         }
      }

      if(len) {  // flush the last observation list line
         write_rinex_line(file, out, sys); 
      }
   }

   return num_obs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, -0x30(%rbp)
movq %rdi, -0x60(%rbp)
testq %rdi, %rdi
je 0xcb0b4
movl %edx, -0x4c(%rbp)
testq %rsi, %rsi
leaq 0x5124a(%rip), %r13     # 0x11b9b6
cmovneq %rsi, %r13
movq %r13, %rdi
callq 0x9120
movq %rax, %rdx
leaq -0x3e(%rbp), %r12
movb $0x0, (%r12)
movslq %edx, %rax
movq %rax, -0x70(%rbp)
xorl %ecx, %ecx
movq $0x0, -0x68(%rbp)
xorl %ebx, %ebx
movq %rdx, -0x48(%rbp)
movq %r13, -0x58(%rbp)
testl %edx, %edx
je 0xcadc5
cmpq -0x70(%rbp), %rcx
jg 0xcadc5
movb -0x3e(%rbp), %r15b
testb %r15b, %r15b
setne %al
movq %rcx, -0x38(%rbp)
movb (%r13,%rcx), %r14b
testb %r14b, %r14b
sete %cl
testb %cl, %al
jne 0xca826
movl %ebx, %r13d
movsbl %r14b, %ebx
movl %ebx, %edi
callq 0x9640
testl %eax, %eax
setne %al
addl $-0x30, %ebx
cmpl $0xa, %ebx
setb %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0xca812
movq -0x68(%rbp), %rax
cmpl $0x4, %eax
movl %r13d, %ebx
jbe 0xcad8e
movq -0x58(%rbp), %r13
movq -0x48(%rbp), %rdx
movq -0x38(%rbp), %rcx
jmp 0xcadb3
testb %r15b, %r15b
movl %r13d, %ebx
movq -0x58(%rbp), %r13
movq -0x48(%rbp), %rdx
je 0xcadaa
movq %r12, %rdi
callq 0x988f
movq %r12, %rdi
leaq 0x52bd4(%rip), %rsi     # 0x11d40c
callq 0x9090
pushq $0x1
popq %rdx
testq %rax, %rax
jne 0xcad5c
movq %r12, %rdi
leaq 0x52bc0(%rip), %rsi     # 0x11d413
callq 0x9090
pushq $0x2
popq %rdx
testq %rax, %rax
jne 0xcad5c
movq %r12, %rdi
leaq 0x52bac(%rip), %rsi     # 0x11d41a
callq 0x9090
pushq $0x3
popq %rdx
testq %rax, %rax
jne 0xcad5c
movq %r12, %rdi
leaq 0x52b98(%rip), %rsi     # 0x11d421
callq 0x9090
pushq $0x4
popq %rdx
testq %rax, %rax
jne 0xcad5c
movq %r12, %rdi
leaq 0x52b84(%rip), %rsi     # 0x11d428
callq 0x9090
pushq $0x5
popq %rdx
testq %rax, %rax
jne 0xcad5c
movq %r12, %rdi
leaq 0x52b70(%rip), %rsi     # 0x11d42f
callq 0x9090
pushq $0x6
popq %rdx
testq %rax, %rax
jne 0xcad5c
movq %r12, %rdi
leaq 0x52b5c(%rip), %rsi     # 0x11d436
callq 0x9090
pushq $0x7
popq %rdx
testq %rax, %rax
jne 0xcad5c
movq %r12, %rdi
leaq 0x52b48(%rip), %rsi     # 0x11d43d
callq 0x9090
pushq $0x8
popq %rdx
testq %rax, %rax
jne 0xcad5c
movq %r12, %rdi
leaq 0x52b34(%rip), %rsi     # 0x11d444
callq 0x9090
pushq $0x9
popq %rdx
testq %rax, %rax
jne 0xcad5c
movq %r12, %rdi
leaq 0x52b20(%rip), %rsi     # 0x11d44b
callq 0x9090
pushq $0xa
popq %rdx
testq %rax, %rax
jne 0xcad5c
movq %r12, %rdi
leaq 0x52b0c(%rip), %rsi     # 0x11d452
callq 0x9090
pushq $0xb
popq %rdx
testq %rax, %rax
jne 0xcad5c
movq %r12, %rdi
leaq 0x52af8(%rip), %rsi     # 0x11d459
callq 0x9090
pushq $0xc
popq %rdx
testq %rax, %rax
jne 0xcad5c
movq %r12, %rdi
leaq 0x52ae4(%rip), %rsi     # 0x11d460
callq 0x9090
pushq $0xd
popq %rdx
testq %rax, %rax
jne 0xcad5c
movq %r12, %rdi
leaq 0x52afa(%rip), %rsi     # 0x11d491
callq 0x9090
pushq $0x14
popq %rdx
testq %rax, %rax
jne 0xcad5c
movq %r12, %rdi
leaq 0x52ae6(%rip), %rsi     # 0x11d498
callq 0x9090
pushq $0x15
popq %rdx
testq %rax, %rax
jne 0xcad5c
movq %r12, %rdi
leaq 0x52ad2(%rip), %rsi     # 0x11d49f
callq 0x9090
pushq $0x16
popq %rdx
testq %rax, %rax
jne 0xcad5c
movq %r12, %rdi
leaq 0x52abe(%rip), %rsi     # 0x11d4a6
callq 0x9090
pushq $0x17
popq %rdx
testq %rax, %rax
jne 0xcad5c
movq %r12, %rdi
leaq 0x52aaa(%rip), %rsi     # 0x11d4ad
callq 0x9090
pushq $0x18
popq %rdx
testq %rax, %rax
jne 0xcad5c
movq %r12, %rdi
leaq 0x52a96(%rip), %rsi     # 0x11d4b4
callq 0x9090
pushq $0x19
popq %rdx
testq %rax, %rax
jne 0xcad5c
movq %r12, %rdi
leaq 0x52a2e(%rip), %rsi     # 0x11d467
callq 0x9090
pushq $0xe
popq %rdx
testq %rax, %rax
jne 0xcad5c
movq %r12, %rdi
leaq 0x52a1a(%rip), %rsi     # 0x11d46e
callq 0x9090
pushq $0xf
popq %rdx
testq %rax, %rax
jne 0xcad5c
movq %r12, %rdi
leaq 0x52a06(%rip), %rsi     # 0x11d475
callq 0x9090
pushq $0x10
popq %rdx
testq %rax, %rax
jne 0xcad5c
movq %r12, %rdi
leaq 0x529f2(%rip), %rsi     # 0x11d47c
callq 0x9090
pushq $0x11
popq %rdx
testq %rax, %rax
jne 0xcad5c
movq %r12, %rdi
leaq 0x529de(%rip), %rsi     # 0x11d483
callq 0x9090
pushq $0x12
popq %rdx
testq %rax, %rax
jne 0xcad5c
movq %r12, %rdi
leaq 0x529ca(%rip), %rsi     # 0x11d48a
callq 0x9090
pushq $0x13
popq %rdx
testq %rax, %rax
jne 0xcad5c
movq %r12, %rdi
leaq 0x5289d(%rip), %rsi     # 0x11d378
callq 0x9090
pushq $0x1
popq %rdx
testq %rax, %rax
jne 0xcad5c
movq %r12, %rdi
leaq 0x52887(%rip), %rsi     # 0x11d37d
callq 0x9090
pushq $0x2
popq %rdx
testq %rax, %rax
jne 0xcad5c
movq %r12, %rdi
leaq 0x52871(%rip), %rsi     # 0x11d382
callq 0x9090
pushq $0x3
popq %rdx
testq %rax, %rax
jne 0xcad5c
movq %r12, %rdi
leaq 0x5285b(%rip), %rsi     # 0x11d387
callq 0x9090
pushq $0x4
popq %rdx
testq %rax, %rax
jne 0xcad5c
movq %r12, %rdi
leaq 0x52845(%rip), %rsi     # 0x11d38c
callq 0x9090
pushq $0x5
popq %rdx
testq %rax, %rax
jne 0xcad5c
movq %r12, %rdi
leaq 0x5282f(%rip), %rsi     # 0x11d391
callq 0x9090
pushq $0x6
popq %rdx
testq %rax, %rax
jne 0xcad5c
movq %r12, %rdi
leaq 0x52819(%rip), %rsi     # 0x11d396
callq 0x9090
pushq $0x7
popq %rdx
testq %rax, %rax
jne 0xcad5c
movq %r12, %rdi
leaq 0x52803(%rip), %rsi     # 0x11d39b
callq 0x9090
pushq $0x8
popq %rdx
testq %rax, %rax
jne 0xcad5c
movq %r12, %rdi
leaq 0x527ed(%rip), %rsi     # 0x11d3a0
callq 0x9090
pushq $0x9
popq %rdx
testq %rax, %rax
jne 0xcad5c
movq %r12, %rdi
leaq 0x527d7(%rip), %rsi     # 0x11d3a5
callq 0x9090
pushq $0xa
popq %rdx
testq %rax, %rax
jne 0xcad5c
movq %r12, %rdi
leaq 0x527c1(%rip), %rsi     # 0x11d3aa
callq 0x9090
pushq $0xb
popq %rdx
testq %rax, %rax
jne 0xcad5c
movq %r12, %rdi
leaq 0x527ab(%rip), %rsi     # 0x11d3af
callq 0x9090
pushq $0xc
popq %rdx
testq %rax, %rax
jne 0xcad5c
movq %r12, %rdi
leaq 0x52795(%rip), %rsi     # 0x11d3b4
callq 0x9090
pushq $0xd
popq %rdx
testq %rax, %rax
jne 0xcad5c
movq %r12, %rdi
leaq 0x5277f(%rip), %rsi     # 0x11d3b9
callq 0x9090
pushq $0x14
popq %rdx
testq %rax, %rax
jne 0xcad5c
movq %r12, %rdi
leaq 0x52769(%rip), %rsi     # 0x11d3be
callq 0x9090
pushq $0x15
popq %rdx
testq %rax, %rax
jne 0xcad5c
movq %r12, %rdi
leaq 0x52753(%rip), %rsi     # 0x11d3c3
callq 0x9090
pushq $0x16
popq %rdx
testq %rax, %rax
jne 0xcad5c
movq %r12, %rdi
leaq 0x5273d(%rip), %rsi     # 0x11d3c8
callq 0x9090
pushq $0x17
popq %rdx
testq %rax, %rax
jne 0xcad5c
movq %r12, %rdi
leaq 0x52727(%rip), %rsi     # 0x11d3cd
callq 0x9090
pushq $0x18
popq %rdx
testq %rax, %rax
jne 0xcad5c
movq %r12, %rdi
leaq 0x52711(%rip), %rsi     # 0x11d3d2
callq 0x9090
pushq $0x19
popq %rdx
testq %rax, %rax
jne 0xcad5c
movq %r12, %rdi
leaq 0x526fb(%rip), %rsi     # 0x11d3d7
callq 0x9090
pushq $0xe
popq %rdx
testq %rax, %rax
jne 0xcad5c
movq %r12, %rdi
leaq 0x526e9(%rip), %rsi     # 0x11d3dc
callq 0x9090
pushq $0xf
popq %rdx
testq %rax, %rax
jne 0xcad5c
movq %r12, %rdi
leaq 0x526d7(%rip), %rsi     # 0x11d3e1
callq 0x9090
pushq $0x10
popq %rdx
testq %rax, %rax
jne 0xcad5c
movq %r12, %rdi
leaq 0x526c5(%rip), %rsi     # 0x11d3e6
callq 0x9090
pushq $0x11
popq %rdx
testq %rax, %rax
jne 0xcad5c
movq %r12, %rdi
leaq 0x526b3(%rip), %rsi     # 0x11d3eb
callq 0x9090
pushq $0x12
popq %rdx
testq %rax, %rax
jne 0xcad5c
movq %r12, %rdi
leaq 0x526a1(%rip), %rsi     # 0x11d3f0
callq 0x9090
pushq $0x13
popq %rdx
testq %rax, %rax
je 0xcadbb
movq -0x30(%rbp), %rdi
movl %ebx, %esi
callq 0xca6fe
leal 0x1(%rax), %ebx
movb $0x0, -0x3e(%rbp)
cmpl $0x19, %eax
jg 0xcb0bb
movq -0x38(%rbp), %rcx
movb (%r13,%rcx), %r14b
movq $0x0, -0x68(%rbp)
movq -0x48(%rbp), %rdx
jmp 0xcadae
movl %eax, %eax
leaq 0x1(%rax), %rcx
movq %rcx, -0x68(%rbp)
movb %r14b, -0x3e(%rbp,%rax)
movb $0x0, -0x3d(%rbp,%rax)
movq -0x58(%rbp), %r13
movq -0x48(%rbp), %rdx
movq -0x38(%rbp), %rcx
testb %r14b, %r14b
je 0xcadc5
incq %rcx
jmp 0xca79f
movq -0x38(%rbp), %rcx
movq -0x48(%rbp), %rdx
jmp 0xcadb3
testl %ebx, %ebx
movl -0x4c(%rbp), %edx
jne 0xcb0be
leaq 0x22c571(%rip), %rax    # 0x2f7348
testl %edx, (%rax)
jne 0xcadf4
leaq 0x22c562(%rip), %rax    # 0x2f7344
xorl %ebx, %ebx
testl %edx, (%rax)
je 0xcae01
leaq 0x15d79d(%rip), %rax    # 0x22858c
cmpl $0x0, (%rax)
je 0xcae01
movq -0x30(%rbp), %rax
movl $0xd, (%rax)
pushq $0x1
popq %rbx
leaq 0x22c550(%rip), %rax    # 0x2f7358
testl %edx, (%rax)
je 0xcae1b
movl %ebx, %eax
incl %ebx
movq -0x30(%rbp), %rcx
movl $0xe, (%rcx,%rax,4)
leaq 0x22c546(%rip), %rax    # 0x2f7368
testl %edx, (%rax)
je 0xcae35
movl %ebx, %eax
incl %ebx
movq -0x30(%rbp), %rcx
movl $0xf, (%rcx,%rax,4)
leaq 0x22c53c(%rip), %rax    # 0x2f7378
testl %edx, (%rax)
je 0xcae4f
movl %ebx, %eax
incl %ebx
movq -0x30(%rbp), %rcx
movl $0x10, (%rcx,%rax,4)
leaq 0x22c532(%rip), %rax    # 0x2f7388
testl %edx, (%rax)
je 0xcae69
movl %ebx, %eax
incl %ebx
movq -0x30(%rbp), %rcx
movl $0x11, (%rcx,%rax,4)
leaq 0x22c528(%rip), %rax    # 0x2f7398
testl %edx, (%rax)
je 0xcae83
movl %ebx, %eax
incl %ebx
movq -0x30(%rbp), %rcx
movl $0x12, (%rcx,%rax,4)
leaq 0x22c51e(%rip), %rax    # 0x2f73a8
testl %edx, (%rax)
je 0xcae9d
movl %ebx, %eax
incl %ebx
movq -0x30(%rbp), %rcx
movl $0x13, (%rcx,%rax,4)
leaq 0x22c4a0(%rip), %rax    # 0x2f7344
testl %edx, (%rax)
jne 0xcaeb3
leaq 0x22c4a5(%rip), %rax    # 0x2f7354
testl %edx, (%rax)
je 0xcaec2
movl %ebx, %eax
incl %ebx
movq -0x30(%rbp), %rcx
movl $0x14, (%rcx,%rax,4)
leaq 0x22c49b(%rip), %rax    # 0x2f7364
testl %edx, (%rax)
je 0xcaedc
movl %ebx, %eax
incl %ebx
movq -0x30(%rbp), %rcx
movl $0x15, (%rcx,%rax,4)
leaq 0x22c491(%rip), %rax    # 0x2f7374
testl %edx, (%rax)
je 0xcaef6
movl %ebx, %eax
incl %ebx
movq -0x30(%rbp), %rcx
movl $0x16, (%rcx,%rax,4)
leaq 0x22c487(%rip), %rax    # 0x2f7384
testl %edx, (%rax)
je 0xcaf10
movl %ebx, %eax
incl %ebx
movq -0x30(%rbp), %rcx
movl $0x17, (%rcx,%rax,4)
leaq 0x22c47d(%rip), %rax    # 0x2f7394
testl %edx, (%rax)
je 0xcaf2a
movl %ebx, %eax
incl %ebx
movq -0x30(%rbp), %rcx
movl $0x18, (%rcx,%rax,4)
leaq 0x22c473(%rip), %rax    # 0x2f73a4
testl %edx, (%rax)
je 0xcaf44
movl %ebx, %eax
incl %ebx
movq -0x30(%rbp), %rcx
movl $0x19, (%rcx,%rax,4)
leaq 0x137985(%rip), %rax    # 0x2028d0
movq (%rax), %rax
cmpq $0x20, %rax
je 0xcb00b
cmpq $0x80, %rax
je 0xcb00b
leaq 0x22c3d5(%rip), %rax    # 0x2f7340
testl %edx, (%rax)
jne 0xcaf7a
leaq 0x22c3da(%rip), %rax    # 0x2f7350
testl %edx, (%rax)
je 0xcaf89
movl %ebx, %eax
incl %ebx
movq -0x30(%rbp), %rcx
movl $0x7, (%rcx,%rax,4)
leaq 0x22c3d0(%rip), %rax    # 0x2f7360
testl %edx, (%rax)
je 0xcafa3
movl %ebx, %eax
incl %ebx
movq -0x30(%rbp), %rcx
movl $0x8, (%rcx,%rax,4)
leaq 0x22c3c6(%rip), %rax    # 0x2f7370
testl %edx, (%rax)
je 0xcafbd
movl %ebx, %eax
incl %ebx
movq -0x30(%rbp), %rcx
movl $0x9, (%rcx,%rax,4)
leaq 0x22c3bc(%rip), %rax    # 0x2f7380
testl %edx, (%rax)
je 0xcafd7
movl %ebx, %eax
incl %ebx
movq -0x30(%rbp), %rcx
movl $0xa, (%rcx,%rax,4)
leaq 0x22c3b2(%rip), %rax    # 0x2f7390
testl %edx, (%rax)
je 0xcaff1
movl %ebx, %eax
incl %ebx
movq -0x30(%rbp), %rcx
movl $0xb, (%rcx,%rax,4)
leaq 0x22c3a8(%rip), %rax    # 0x2f73a0
testl %edx, (%rax)
je 0xcb00b
movl %ebx, %eax
incl %ebx
movq -0x30(%rbp), %rcx
movl $0xc, (%rcx,%rax,4)
leaq 0x22c33a(%rip), %rax    # 0x2f734c
testl %edx, (%rax)
jne 0xcb021
leaq 0x22c33f(%rip), %rax    # 0x2f735c
testl %edx, (%rax)
je 0xcb030
movl %ebx, %eax
incl %ebx
movq -0x30(%rbp), %rcx
movl $0x1, (%rcx,%rax,4)
leaq 0x22c335(%rip), %rax    # 0x2f736c
testl %edx, (%rax)
je 0xcb04a
movl %ebx, %eax
incl %ebx
movq -0x30(%rbp), %rcx
movl $0x2, (%rcx,%rax,4)
leaq 0x22c32b(%rip), %rax    # 0x2f737c
testl %edx, (%rax)
je 0xcb064
movl %ebx, %eax
incl %ebx
movq -0x30(%rbp), %rcx
movl $0x3, (%rcx,%rax,4)
leaq 0x22c321(%rip), %rax    # 0x2f738c
testl %edx, (%rax)
je 0xcb07e
movl %ebx, %eax
incl %ebx
movq -0x30(%rbp), %rcx
movl $0x4, (%rcx,%rax,4)
leaq 0x22c317(%rip), %rax    # 0x2f739c
testl %edx, (%rax)
je 0xcb098
movl %ebx, %eax
incl %ebx
movq -0x30(%rbp), %rcx
movl $0x5, (%rcx,%rax,4)
leaq 0x22c30d(%rip), %rax    # 0x2f73ac
testl %edx, (%rax)
je 0xcb0be
movl %ebx, %eax
incl %ebx
movq -0x30(%rbp), %rcx
movl $0x6, (%rcx,%rax,4)
jmp 0xcb0be
xorl %ebx, %ebx
jmp 0xcb70e
movl -0x4c(%rbp), %edx
leaq 0x15d4bb(%rip), %rax    # 0x228580
movsd (%rax), %xmm0
ucomisd 0x2a9af(%rip), %xmm0    # 0xf5a80
movl %ebx, -0x38(%rbp)
jae 0xcb415
movl %ebx, %r14d
leaq 0x25b13c(%rip), %rbx    # 0x326220
leaq 0x46c7e(%rip), %rsi     # 0x111d69
xorl %r12d, %r12d
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x9060
testl %r14d, %r14d
movl $0x0, %r13d
cmovgl %r14d, %r13d
leaq 0x49f8d(%rip), %r14     # 0x11509c
xorl %r15d, %r15d
cmpq %r12, %r13
je 0xcb440
movq -0x30(%rbp), %rax
movl (%rax,%r12,4), %eax
decl %eax
cmpl $0x18, %eax
ja 0xcb40d
movslq (%r14,%rax,4), %rax
addq %r14, %rax
jmpq *%rax
movq %rbx, %rdi
callq 0x9120
movl $0x20202020, (%rbx,%rax) # imm = 0x20202020
movl $0x315320, 0x3(%rbx,%rax) # imm = 0x315320
jmp 0xcb3df
movq %rbx, %rdi
callq 0x9120
movl $0x20202020, (%rbx,%rax) # imm = 0x20202020
movl $0x365020, 0x3(%rbx,%rax) # imm = 0x365020
jmp 0xcb3df
movq %rbx, %rdi
callq 0x9120
movl $0x20202020, (%rbx,%rax) # imm = 0x20202020
movl $0x325020, 0x3(%rbx,%rax) # imm = 0x325020
jmp 0xcb3df
movq %rbx, %rdi
callq 0x9120
movl $0x20202020, (%rbx,%rax) # imm = 0x20202020
movl $0x384420, 0x3(%rbx,%rax) # imm = 0x384420
jmp 0xcb3df
movq %rbx, %rdi
callq 0x9120
movl $0x20202020, (%rbx,%rax) # imm = 0x20202020
movl $0x375320, 0x3(%rbx,%rax) # imm = 0x375320
jmp 0xcb3df
movq %rbx, %rdi
callq 0x9120
movl $0x20202020, (%rbx,%rax) # imm = 0x20202020
movl $0x314320, 0x3(%rbx,%rax) # imm = 0x314320
jmp 0xcb3df
movq %rbx, %rdi
callq 0x9120
movl $0x20202020, (%rbx,%rax) # imm = 0x20202020
movl $0x364420, 0x3(%rbx,%rax) # imm = 0x364420
jmp 0xcb3df
movq %rbx, %rdi
callq 0x9120
movl $0x20202020, (%rbx,%rax) # imm = 0x20202020
movl $0x384c20, 0x3(%rbx,%rax) # imm = 0x384C20
jmp 0xcb3df
movq %rbx, %rdi
callq 0x9120
movl $0x20202020, (%rbx,%rax) # imm = 0x20202020
movl $0x355320, 0x3(%rbx,%rax) # imm = 0x355320
jmp 0xcb3df
movq %rbx, %rdi
callq 0x9120
movl $0x20202020, (%rbx,%rax) # imm = 0x20202020
movl $0x355020, 0x3(%rbx,%rax) # imm = 0x355020
jmp 0xcb3df
movq %rbx, %rdi
callq 0x9120
movl $0x20202020, (%rbx,%rax) # imm = 0x20202020
movl $0x365320, 0x3(%rbx,%rax) # imm = 0x365320
jmp 0xcb3df
movq %rbx, %rdi
callq 0x9120
movl $0x20202020, (%rbx,%rax) # imm = 0x20202020
movl $0x324420, 0x3(%rbx,%rax) # imm = 0x324420
jmp 0xcb3df
movq %rbx, %rdi
callq 0x9120
movl $0x20202020, (%rbx,%rax) # imm = 0x20202020
movl $0x325320, 0x3(%rbx,%rax) # imm = 0x325320
jmp 0xcb3df
movq %rbx, %rdi
callq 0x9120
movl $0x20202020, (%rbx,%rax) # imm = 0x20202020
movl $0x375020, 0x3(%rbx,%rax) # imm = 0x375020
jmp 0xcb3df
movq %rbx, %rdi
callq 0x9120
movl $0x20202020, (%rbx,%rax) # imm = 0x20202020
movl $0x324c20, 0x3(%rbx,%rax) # imm = 0x324C20
jmp 0xcb3df
movq %rbx, %rdi
callq 0x9120
movl $0x20202020, (%rbx,%rax) # imm = 0x20202020
movl $0x385320, 0x3(%rbx,%rax) # imm = 0x385320
jmp 0xcb3df
movq %rbx, %rdi
callq 0x9120
movl $0x20202020, (%rbx,%rax) # imm = 0x20202020
movl $0x354c20, 0x3(%rbx,%rax) # imm = 0x354C20
jmp 0xcb3df
movq %rbx, %rdi
callq 0x9120
movl $0x20202020, (%rbx,%rax) # imm = 0x20202020
movl $0x315020, 0x3(%rbx,%rax) # imm = 0x315020
jmp 0xcb3df
movq %rbx, %rdi
callq 0x9120
movl $0x20202020, (%rbx,%rax) # imm = 0x20202020
movl $0x314420, 0x3(%rbx,%rax) # imm = 0x314420
jmp 0xcb3df
movq %rbx, %rdi
callq 0x9120
movl $0x20202020, (%rbx,%rax) # imm = 0x20202020
movl $0x385020, 0x3(%rbx,%rax) # imm = 0x385020
jmp 0xcb3df
movq %rbx, %rdi
callq 0x9120
movl $0x20202020, (%rbx,%rax) # imm = 0x20202020
movl $0x374420, 0x3(%rbx,%rax) # imm = 0x374420
jmp 0xcb3df
movq %rbx, %rdi
callq 0x9120
movl $0x20202020, (%rbx,%rax) # imm = 0x20202020
movl $0x354420, 0x3(%rbx,%rax) # imm = 0x354420
jmp 0xcb3df
movq %rbx, %rdi
callq 0x9120
movl $0x20202020, (%rbx,%rax) # imm = 0x20202020
movl $0x364c20, 0x3(%rbx,%rax) # imm = 0x364C20
jmp 0xcb3df
movq %rbx, %rdi
callq 0x9120
movl $0x20202020, (%rbx,%rax) # imm = 0x20202020
movl $0x314c20, 0x3(%rbx,%rax) # imm = 0x314C20
jmp 0xcb3df
movq %rbx, %rdi
callq 0x9120
movl $0x20202020, (%rbx,%rax) # imm = 0x20202020
movl $0x374c20, 0x3(%rbx,%rax) # imm = 0x374C20
cmpl $0x8, %r15d
jge 0xcb3ea
incl %r15d
jmp 0xcb40d
leaq 0x52003(%rip), %rdx     # 0x11d3f4
movq -0x60(%rbp), %rdi
movq %rbx, %rsi
callq 0xb2e38
movl $0x202020, 0x3(%rbx)    # imm = 0x202020
movl $0x20202020, (%rbx)     # imm = 0x20202020
xorl %r15d, %r15d
incq %r12
jmp 0xcb112
testb $0x1, %dl
jne 0xcb455
testw %dx, %dx
js 0xcb45e
testb $0x2, %dl
jne 0xcb467
testb $0x4, %dl
jne 0xcb470
testb $0x8, %dl
leaq 0x425da(%rip), %rax     # 0x10da0d
leaq 0x4dbff(%rip), %rdx     # 0x119039
cmoveq %rax, %rdx
jmp 0xcb477
testl %r15d, %r15d
je 0xcb70b
leaq 0x51fa4(%rip), %rdx     # 0x11d3f4
jmp 0xcb6f6
leaq 0x44d7f(%rip), %rdx     # 0x1101db
jmp 0xcb477
leaq 0x40f08(%rip), %rdx     # 0x10c36d
jmp 0xcb477
leaq 0x336b9(%rip), %rdx     # 0xfeb27
jmp 0xcb477
leaq 0x45e0e(%rip), %rdx     # 0x111285
leaq 0x25ada2(%rip), %rbx    # 0x326220
leaq 0x51ed8(%rip), %rsi     # 0x11d35d
xorl %r12d, %r12d
movq %rbx, %rdi
movl -0x38(%rbp), %r14d
movl %r14d, %ecx
xorl %eax, %eax
callq 0x9060
testl %r14d, %r14d
movl $0x0, %r13d
cmovgl %r14d, %r13d
leaq 0x49b8b(%rip), %r14     # 0x115038
xorl %r15d, %r15d
cmpq %r12, %r13
je 0xcb6ea
movq -0x30(%rbp), %rax
movl (%rax,%r12,4), %eax
decl %eax
cmpl $0x18, %eax
ja 0xcb6e2
movslq (%r14,%rax,4), %rax
addq %r14, %rax
jmpq *%rax
movq %rbx, %rdi
callq 0x9120
movl $0x43315320, (%rbx,%rax) # imm = 0x43315320
jmp 0xcb6af
movq %rbx, %rdi
callq 0x9120
movl $0x50364320, (%rbx,%rax) # imm = 0x50364320
jmp 0xcb6af
movq %rbx, %rdi
callq 0x9120
movl $0x50324320, (%rbx,%rax) # imm = 0x50324320
jmp 0xcb6af
movq %rbx, %rdi
callq 0x9120
movl $0x43384420, (%rbx,%rax) # imm = 0x43384420
jmp 0xcb6af
movq %rbx, %rdi
callq 0x9120
movl $0x43375320, (%rbx,%rax) # imm = 0x43375320
jmp 0xcb6af
movq %rbx, %rdi
callq 0x9120
movl $0x43314320, (%rbx,%rax) # imm = 0x43314320
jmp 0xcb6af
movq %rbx, %rdi
callq 0x9120
movl $0x43364420, (%rbx,%rax) # imm = 0x43364420
jmp 0xcb6af
movq %rbx, %rdi
callq 0x9120
movl $0x43384c20, (%rbx,%rax) # imm = 0x43384C20
jmp 0xcb6af
movq %rbx, %rdi
callq 0x9120
movl $0x43355320, (%rbx,%rax) # imm = 0x43355320
jmp 0xcb6af
movq %rbx, %rdi
callq 0x9120
movl $0x50354320, (%rbx,%rax) # imm = 0x50354320
jmp 0xcb6af
movq %rbx, %rdi
callq 0x9120
movl $0x43365320, (%rbx,%rax) # imm = 0x43365320
jmp 0xcb6af
movq %rbx, %rdi
callq 0x9120
movl $0x43324420, (%rbx,%rax) # imm = 0x43324420
jmp 0xcb6af
movq %rbx, %rdi
callq 0x9120
movl $0x43325320, (%rbx,%rax) # imm = 0x43325320
jmp 0xcb6af
movq %rbx, %rdi
callq 0x9120
movl $0x50374320, (%rbx,%rax) # imm = 0x50374320
jmp 0xcb6af
movq %rbx, %rdi
callq 0x9120
movl $0x43324c20, (%rbx,%rax) # imm = 0x43324C20
jmp 0xcb6af
movq %rbx, %rdi
callq 0x9120
movl $0x43385320, (%rbx,%rax) # imm = 0x43385320
jmp 0xcb6af
movq %rbx, %rdi
callq 0x9120
movl $0x43354c20, (%rbx,%rax) # imm = 0x43354C20
jmp 0xcb6af
movq %rbx, %rdi
callq 0x9120
movl $0x50314320, (%rbx,%rax) # imm = 0x50314320
jmp 0xcb6af
movq %rbx, %rdi
callq 0x9120
movl $0x43314420, (%rbx,%rax) # imm = 0x43314420
jmp 0xcb6af
movq %rbx, %rdi
callq 0x9120
movl $0x50384320, (%rbx,%rax) # imm = 0x50384320
jmp 0xcb6af
movq %rbx, %rdi
callq 0x9120
movl $0x43374420, (%rbx,%rax) # imm = 0x43374420
jmp 0xcb6af
movq %rbx, %rdi
callq 0x9120
movl $0x43354420, (%rbx,%rax) # imm = 0x43354420
jmp 0xcb6af
movq %rbx, %rdi
callq 0x9120
movl $0x43364c20, (%rbx,%rax) # imm = 0x43364C20
jmp 0xcb6af
movq %rbx, %rdi
callq 0x9120
movl $0x43314c20, (%rbx,%rax) # imm = 0x43314C20
jmp 0xcb6af
movq %rbx, %rdi
callq 0x9120
movl $0x43374c20, (%rbx,%rax) # imm = 0x43374C20
movb $0x0, 0x4(%rbx,%rax)
cmpl $0xc, %r15d
jge 0xcb6bf
incl %r15d
jmp 0xcb6e2
leaq 0x51c9d(%rip), %rdx     # 0x11d363
movq -0x60(%rbp), %rdi
movq %rbx, %rsi
callq 0xb2e38
movl $0x202020, 0x3(%rbx)    # imm = 0x202020
movl $0x20202020, (%rbx)     # imm = 0x20202020
xorl %r15d, %r15d
incq %r12
jmp 0xcb4b0
testl %r15d, %r15d
je 0xcb70b
leaq 0x51c6d(%rip), %rdx     # 0x11d363
movl -0x38(%rbp), %ebx
leaq 0x25ab20(%rip), %rsi    # 0x326220
movq -0x60(%rbp), %rdi
callq 0xb2e38
jmp 0xcb70e
movl -0x38(%rbp), %ebx
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq