// File: /workspace/github_c_makefile_star2_O3/Nico01[P]obj2asm/rec_coment.c
// Function: coment
void coment(size_t length)
{
  char            junk[3];
  char            *comment;
  char            text[80];
  char            temp[80];
  int             type;
  int             class;
  char            cksum;
  uchar           *prt_char;
  int             i;
  int             w;
  char            *p;
  LOCAL_VAR       *local_var;
  static word     scope_type = VT_VAR;
  static NODE_T **ppScope_tree;
  static SCOPE_T *pScope;
  static SCOPE_T **ppScope;
  static SCOPE_T *arg_scope;
  static SCOPE_T *loc_scope;

  type = get_byte();
  class = get_byte();
  length -= 3;
  if (length)
    comment = o_malloc(length);
  else
    comment = junk;
  get_str( length, comment);
  switch( class ) {
  case MSLANG:
       out_line( "", "; Compiler:", comment, "" );
       break;
  case MSMODL:
       processor_type_comment_occurred = TRUE;
       switch( comment[0] ) {
       case '3':
            out_line( "", ".386p", "", "" );
            out_line( "", ".387", "", "" );
            processor_mode = 386;
            break;
       case '2':
            out_line( "", ".286p", "", "" );
            out_line( "", ".287", "", "" );
            processor_mode = 286;
            break;
       case '1':
            out_line( "", ".186", "", "" );
            out_line( "", ".187", "", "" );
            processor_mode = 186;
            break;
       case '0':
            out_line( "", ".8086", "", "" );
            out_line( "", ".8087", "", "" );
            processor_mode = 8086;
            break;
       default:
            fmt_error( "Unknown Processor Type" );
            break;
       }
       switch( comment[1] ) {
       case 'c':
            out_line( "", "; Compact Memory Model", "", "" );
            break;
       case 's':
            out_line( "", "; Small Memory Model", "", "" );
            break;
       case 'm':
            out_line( "", "; Medium Memory Model", "", "" );
            break;
       case 'l':
            out_line( "", "; Large Memory Model", "", "" );
            break;
       case 'h':
            out_line( "", "; Huge Memory Model", "", "" );
            break;
       default:
            fmt_error( "Unknown Model" );
            break;
       }
       if ( comment[2] == 'O' )
           out_line( "", "; Optimizations Enabled", "", "" );
       break;
  case MSDSEG:
       out_line( "", "; Force DOSSEG linker option", "", "" );
       break;
  case MSILIB:
       out_line( "", "includelib", comment, "" );
       break;
  case MSEXTN:
       if (length) {
         if ( !strcmp( comment, "\001CV" ) ) {
             out_line( "", "; CodeView Enabled", "", "" );
         } else {
             fmt_error( "Unknown CodeView Option" );
         }
       }
       break;
  case UNKNWN:
       out_line( "", "; Linker - Pass two marker","","");
       break;
  case PATIME:
       if ( comment[0] != 16 )
         fmt_error( "Unknown Phoenix Time Stamp Prefix" );
       out_line( "", "; Time: ", &comment[1], "" );
       break;
  case PACMNT:
       out_line( "", ";", comment, "" );
       break;

/*
   Extensions to COMENT record defined by Borland.

   Note that these have been deduced using TDUMP (and lots of examples)
   and consequently may be completely wrong.
                                                                   [rh]
*/

  case TCXSYMTYPIX:
       sprintf(text, "; External symbol type index %02X", *comment, comment[1]&1);
       out_line(text,"","","");
       break;

  case TCPUBSYMTYP:
       sprintf(text, "; Public symbol type %02X, function return offset %02X", *comment, comment[1]&1);
       out_line(text,"","","");
       break;

  case TCSTRUCT:
       out_line("; typedef struct:","","","");
       i = 1;
       while (i<length) {
         out_newline();
         sprintf(text, "; \"%.*s\"",comment[i],&comment[i+1]);
         i+=comment[i]+1;
         sprintf(temp, "type %02X",comment[i]); /* ;* */
         i+=2;
         out_line(text,"","",temp);
       }
       break;

  case TCDEPFIL:
       if (length<=3) {
         out_line("; End of dependency list","","","");
       } else {
         sprintf(text,"%.*s",(int)comment[4],&comment[5]);
         out_line("; Dependent file: ",text,"","");
       }
       break;

  case TCENDSCP:
       pScope = o_malloc(sizeof(SCOPE_T));
       pScope->hex_offset = *(int*)comment;
       pScope = insert(pScope, end_scope_tree,TC scope_compare)->data;
       sprintf(text, "; End of scope at offset %04X",*(int*)comment);
       out_line(text,"","","");
       break;

  case TCBEGSCP:
       if (scope_type==VT_ARG)
         scope_type = VT_VAR;
       else
         scope_type = VT_ARG;
       if (scope_type==VT_ARG) {
         ppScope_tree = &arg_scope_tree;
         ppScope      = &arg_scope;
       } else {
         ppScope_tree = &loc_scope_tree;
         ppScope      = &loc_scope;
       }
       *ppScope = o_malloc(sizeof(SCOPE_T));
       (*ppScope)->hex_offset = *(int*)&comment[1];
       *ppScope = insert(*ppScope,*ppScope_tree, TC scope_compare)->data;
       sprintf(text,"; Begin scope segment %04X, offset %04X",(int)*comment,*(int*)&comment[1]);
       out_line(text,"","","");
       break;

  case TCLOCDEF:
       out_line("; Local definitions:","","","");
       i = 0;
       local_var = (*ppScope)->head = o_malloc(sizeof(LOCAL_VAR));
       while (i+1<length) {
         if (i!=0)
           local_var=local_var->next = o_malloc(sizeof(LOCAL_VAR));
         out_newline();
         sprintf(text,"; \"%.*s\"",comment[i],&comment[i+1]);
         sprintf(local_var->vname,"%.*s",comment[i],&comment[i+1]);
         i+=comment[i]+1;
         sprintf(temp,", type %02X, class %02X",comment[i],comment[i+1]&7);
         strcat(text,temp);
         *temp = 0;
         i++;
         local_var->class = comment[i]&7;
         switch (comment[i]&7) {
         case 7:
              sprintf(temp, " (instance of typed variable)");
              local_var->bInfo1 = comment[i+1];
              i++;
              break;
         case 6:                           /* local typedef ? */
              sprintf(temp, " (local typedef)");
              local_var->bInfo1 = comment[i+1];
              i++;
              break;
         case 4:                          /* register variable */
              i++;
              switch (comment[i]) {
              case 0x06: p = "si"; break;
              case 0x07: p = "di"; break;
              default  : p = "[unknown]"; break;
              }
              local_var->bInfo1 = comment[i];
              sprintf(temp," variable in register %s",p);
              i++;
              local_var->bInfo2 = comment[i];
              break;
         case 2:                        /* variable */
              local_var->bInfo1 = comment[i]; /* argument or local */
              sprintf(temp," (var) %s stored in ",comment[i]&8?"argument":"local");
              strcat(text,temp);
              switch (comment[i++]&7) {
              case 2 :                          /* stored on stack */
                   local_var->bInfo2 = (comment[i-1]&7)==2; /* stored on stack */
                   local_var->wInfo1 = *(int*)&comment[i]; /* address */
                   w = *(int*)&comment[i++];
                   if (w<0)
                     sprintf(temp,"[bp-%04X]",-w);
                   else
                     sprintf(temp,"[bp+%04X]",w);
                   break;
              default :
                   strcpy(temp,"[unknown]");
                   break;
              }
              i++;
              break;
         case 0:                  /* static function */
              sprintf(temp, " (static func) index %04X, word %04X", *(int*)&comment[i+1],*(int*)&comment[i+3]);
              i+=5;
         }
         strcat(text,temp);
         out_line(text,"","","");
       }
       break;

  case TCTYPDEF:
       sprintf(text, "; Type definition: index %02X ",*(int*)&comment[0]);
       i = 1;
       if (comment[1]) {
         sprintf(temp, "\"%.*s\", ",comment[1],&comment[2]); /* name */
         strcat(text,temp);
       }
       i+=comment[i]+1;
       sprintf(temp, "size %04X, TID %02X",*(int*)&comment[i],comment[i+2]);
       strcat(text,temp);
       out_line(text,"","","");
       break;

  case TCSOURCE :
       if (!*comment) {
         i = 1;
         sprintf(text, "; Source file %.*s",comment[1],&comment[2]);
         i+=comment[1]+1;
         sprint_date(temp,&comment[i]);
         out_line(text,temp,"","");
       } else {
         out_line("; Source file","","","");
       }
       break;

  case TCXLATOR :
       strcpy(text, "; Compiler: ");
       switch (*comment) {
       case 0x01: strcat(text,"'C'");       break;
       case 0x04: strcat(text,"Assembler"); break;
       default :  strcat(text,"[unknown]"); break;
       }
       sprintf(temp, " using %s model with underscores %s",
               models[comment[1]&7],comment[1]&8?"on":"off");
       strcat(text,temp);
       out_line(text,"","","");
       break;

  case TCENUM :
       i = 1;
       out_line("; ENUM member list","","","");
       while (i<length) {
         sprintf(text,"; %.*s",comment[i],&comment[i+1]);
         i+=comment[i]+1;
         sprintf(temp, " = %04X",*(word*)&comment[i]);
         i+=3;
         strcat(text,temp);
         out_line(text,"","","");
         out_newline();
       }
       break;

  case TCMANGLE:
       sprintf(temp, "; Mangled name \"%.*s\"",*comment, &comment[1]);
       out_line(temp,"","","");
       break;

  default:
       text[0] = '\0';
       prt_char = comment;
       while ( length ) {
           if ( isprint(*prt_char) ) {
               sprintf( temp, "%c", *prt_char );
           } else {
               sprintf( temp, "[%02X]", *prt_char );
           }
           strcat( text, temp );
           prt_char++;
           --length;
       }
       sprintf( temp, "; Unknown COMENT Record (Class %d): '%s'", class, text );
       out_line("", temp, "", "" );
       break;
  }
  out_newline();
  cksum = get_byte();
  cksum = cksum;
  type = type;
  if (comment!=junk)
    free(comment);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %r14
callq 0xf4b4
callq 0xf4b4
movzbl %al, %r15d
addq $-0x3, %r14
je 0x10583
movq %r14, %rdi
callq 0x128e2
movq %rax, %rbx
jmp 0x10588
leaq 0x9(%rsp), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xf53b
leal -0xdd(%r15), %eax
cmpl $0x22, %eax
ja 0x105da
leaq 0x3f02(%rip), %rcx      # 0x144a8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpb $0x10, (%rbx)
je 0x105c0
leaq 0x413c(%rip), %rdi      # 0x146f7
callq 0x128bc
leaq 0x1(%rbx), %rdx
leaq 0x414e(%rip), %rsi      # 0x14719
leaq 0x3b3a(%rip), %rcx      # 0x1410c
movq %rcx, %rdi
jmp 0x1104a
leal -0x9d(%r15), %eax
cmpl $0x5, %eax
ja 0x10665
leaq 0x3ea3(%rip), %rcx      # 0x14490
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xc8f3(%rip), %rax      # 0x1cef0
movl $0x1, (%rax)
movzbl (%rbx), %eax
addl $-0x30, %eax
cmpl $0x3, %eax
ja 0x10fbd
leaq 0x3f3b(%rip), %rcx      # 0x14554
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x3fa8(%rip), %rsi      # 0x145d1
leaq 0x3adc(%rip), %r14      # 0x1410c
movq %r14, %rdi
movq %r14, %rdx
movq %r14, %rcx
callq 0xcb44
leaq 0x3f92(%rip), %rsi      # 0x145d7
movq %r14, %rdi
movq %r14, %rdx
movq %r14, %rcx
callq 0xcb44
leaq 0xc88a(%rip), %rax      # 0x1cee4
movl $0x1f96, (%rax)         # imm = 0x1F96
jmp 0x10fc9
testl %r15d, %r15d
jne 0x10676
leaq 0x3f3f(%rip), %rsi      # 0x145b0
jmp 0x10dab
movb $0x0, 0x60(%rsp)
testq %r14, %r14
je 0x106d3
callq 0x91f0
movq %rax, %r12
leaq 0x10(%rsp), %rbp
xorl %r13d, %r13d
movq (%r12), %rcx
movb (%rbx,%r13), %al
movzbl %al, %edx
testb $0x40, 0x1(%rcx,%rdx,2)
jne 0x106b5
movq %rbp, %rdi
leaq 0x428c(%rip), %rsi      # 0x14938
xorl %eax, %eax
callq 0x91b0
jmp 0x106be
movb %al, 0x10(%rsp)
movb $0x0, 0x11(%rsp)
leaq 0x60(%rsp), %rdi
movq %rbp, %rsi
callq 0x91a0
incq %r13
cmpq %r13, %r14
jne 0x10690
leaq 0x4265(%rip), %rsi      # 0x1493f
leaq 0x10(%rsp), %r14
leaq 0x60(%rsp), %rcx
movq %r14, %rdi
movl %r15d, %edx
xorl %eax, %eax
callq 0x91b0
leaq 0x3a14(%rip), %rcx      # 0x1410c
movq %rcx, %rdi
jmp 0x10de9
cmpq $0x3, %r14
ja 0x10dbd
leaq 0x408f(%rip), %rdi      # 0x147a0
jmp 0x108a0
leaq 0x41e3(%rip), %rdi      # 0x14900
leaq 0x39e8(%rip), %rcx      # 0x1410c
movq %rcx, %rsi
movq %rcx, %rdx
callq 0xcb44
cmpq $0x2, %r14
jb 0x1104f
movl $0x1, %r13d
movl $0x1, %ebp
movsbl (%rbx,%rbp), %edx
leal 0x1(%r13), %eax
movslq %eax, %rcx
addq %rbx, %rcx
leaq 0x60(%rsp), %r15
movq %r15, %rdi
leaq 0x41b2(%rip), %rsi      # 0x14913
xorl %eax, %eax
callq 0x91b0
movsbl (%rbx,%rbp), %ebp
leal 0x1(%r13,%rbp), %eax
cltq
movl (%rbx,%rax), %edx
leaq 0x10(%rsp), %r12
movq %r12, %rdi
leaq 0x4195(%rip), %rsi      # 0x1491a
xorl %eax, %eax
callq 0x91b0
addl %ebp, %r13d
addl $0x4, %r13d
movq %r15, %rdi
movq %r12, %rsi
callq 0x91a0
movq %r15, %rdi
leaq 0x3964(%rip), %rcx      # 0x1410c
movq %rcx, %rsi
movq %rcx, %rdx
callq 0xcb44
callq 0xcad9
movslq %r13d, %rbp
cmpq %rbp, %r14
ja 0x10744
jmp 0x1104f
movsbl (%rbx), %edx
leaq 0x1(%rbx), %rcx
leaq 0x414f(%rip), %rsi      # 0x14922
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x91b0
jmp 0x10a6f
leaq 0x3f8d(%rip), %rdi      # 0x1477b
leaq 0x3917(%rip), %rcx      # 0x1410c
movq %rcx, %rsi
movq %rcx, %rdx
callq 0xcb44
cmpq $0x2, %r14
jb 0x1104f
movl $0x1, %r13d
movl $0x1, %r12d
callq 0xcad9
movsbl (%rbx,%r12), %edx
leal 0x1(%r13), %eax
movslq %eax, %rcx
addq %rbx, %rcx
leaq 0x60(%rsp), %rbp
movq %rbp, %rdi
leaq 0x3f54(%rip), %rsi      # 0x1478d
xorl %eax, %eax
callq 0x91b0
movsbl (%rbx,%r12), %r12d
leal (%r12,%r13), %eax
incl %eax
cltq
movsbl (%rbx,%rax), %edx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
leaq 0x3f36(%rip), %rsi      # 0x14796
xorl %eax, %eax
callq 0x91b0
addl %r12d, %r13d
addl $0x3, %r13d
movq %rbp, %rdi
leaq 0x3894(%rip), %rdx      # 0x1410c
movq %rdx, %rsi
movq %r15, %rcx
callq 0xcb44
movslq %r13d, %r12
cmpq %r12, %r14
ja 0x10816
jmp 0x1104f
cmpb $0x0, (%rbx)
je 0x10df1
leaq 0x4013(%rip), %rdi      # 0x148b3
leaq 0x3865(%rip), %rcx      # 0x1410c
jmp 0x10ee6
movabsq $0x203a72656c6970, %rax # imm = 0x203A72656C6970
leaq 0x60(%rsp), %rdi
movq %rax, 0x5(%rdi)
movabsq $0x6c69706d6f43203b, %rax # imm = 0x6C69706D6F43203B
movq %rax, (%rdi)
movzbl (%rbx), %ebp
callq 0x90b0
addq %rsp, %rax
addq $0x60, %rax
cmpl $0x4, %ebp
je 0x10e63
cmpl $0x1, %ebp
jne 0x10e78
movl $0x274327, (%rax)       # imm = 0x274327
jmp 0x10e8b
movsbl (%rbx), %edx
movzbl 0x1(%rbx), %ecx
andl $0x1, %ecx
leaq 0x3e19(%rip), %rsi      # 0x14722
jmp 0x10a0b
movsbl (%rbx), %edx
movzbl 0x1(%rbx), %ecx
andl $0x1, %ecx
leaq 0x3e25(%rip), %rsi      # 0x14744
jmp 0x10a0b
movl (%rbx), %edx
leaq 0x3f37(%rip), %rsi      # 0x14864
leaq 0x60(%rsp), %rdi
xorl %eax, %eax
callq 0x91b0
movsbl 0x1(%rbx), %edx
testl %edx, %edx
je 0x10e3b
leaq 0x2(%rbx), %rcx
leaq 0x3f33(%rip), %rsi      # 0x14883
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x91b0
leaq 0x60(%rsp), %rdi
movq %r14, %rsi
callq 0x91a0
movsbq 0x1(%rbx), %rax
addq $0x2, %rax
jmp 0x10e40
movb 0xdc68(%rip), %al       # 0x1e5e8
movl %eax, %ecx
xorb $0x1, %cl
leaq 0xc5ec(%rip), %rdx      # 0x1cf78
testb %al, %al
cmovneq 0x864a(%rip), %rdx      # 0x18fe0
movb %cl, 0xdc4c(%rip)       # 0x1e5e8
leaq 0xdc6d(%rip), %rax      # 0x1e610
leaq 0xdc5e(%rip), %rcx      # 0x1e608
cmovneq %rax, %rcx
movq %rdx, 0xdc3b(%rip)      # 0x1e5f0
movq %rcx, 0xdc44(%rip)      # 0x1e600
movl $0x10, %edi
callq 0x128e2
movq 0xdc33(%rip), %rcx      # 0x1e600
movq %rax, (%rcx)
movslq 0x1(%rbx), %rcx
movq %rcx, (%rax)
movq 0xdc12(%rip), %rcx      # 0x1e5f0
movq (%rcx), %rsi
leaq -0x4b4(%rip), %rdx      # 0x10534
movq %rax, %rdi
callq 0x125e8
movq 0x20(%rax), %rax
movq 0xdc05(%rip), %rcx      # 0x1e600
movq %rax, (%rcx)
movsbl (%rbx), %edx
movl 0x1(%rbx), %ecx
leaq 0x3ddf(%rip), %rsi      # 0x147ea
leaq 0x60(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x91b0
jmp 0x10a6f
movl $0x10, %edi
callq 0x128e2
movq %rax, 0xdbcb(%rip)      # 0x1e5f8
movslq (%rbx), %rcx
movq %rcx, (%rax)
leaq 0xc54e(%rip), %rcx      # 0x1cf88
movq (%rcx), %rsi
leaq -0x510(%rip), %rdx      # 0x10534
movq %rax, %rdi
callq 0x125e8
movq 0x20(%rax), %rax
movq %rax, 0xdba1(%rip)      # 0x1e5f8
movl (%rbx), %edx
leaq 0x3d6c(%rip), %rsi      # 0x147cc
leaq 0x60(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x91b0
leaq 0x3696(%rip), %rcx      # 0x1410c
movq %r14, %rdi
jmp 0x10ee6
leaq 0x3d8d(%rip), %rdi      # 0x14812
leaq 0x3680(%rip), %rcx      # 0x1410c
movq %rcx, %rsi
movq %rcx, %rdx
callq 0xcb44
movl $0x38, %edi
callq 0x128e2
movq %rax, %r15
movq 0xdb55(%rip), %rax      # 0x1e600
movq (%rax), %rax
movq %r15, 0x8(%rax)
cmpq $0x2, %r14
jb 0x1104f
movl $0x1, %r12d
xorl %ebp, %ebp
movq %r14, 0xb0(%rsp)
testl %ebp, %ebp
je 0x10ae3
movl $0x38, %edi
callq 0x128e2
movq %rax, %r14
movq %rax, 0x30(%r15)
jmp 0x10ae6
movq %r15, %r14
callq 0xcad9
movslq %ebp, %r13
movsbl (%rbx,%r13), %edx
addq %rbx, %r12
leaq 0x60(%rsp), %r15
movq %r15, %rdi
leaq 0x3c88(%rip), %rsi      # 0x1478d
movq %r12, %rcx
xorl %eax, %eax
callq 0x91b0
leaq 0xc(%r14), %rdi
movsbl (%rbx,%r13), %edx
leaq 0x3df6(%rip), %rsi      # 0x14915
movq %r12, %rcx
xorl %eax, %eax
callq 0x91b0
movsbl (%rbx,%r13), %eax
addl %ebp, %eax
incl %eax
movl %eax, 0xc(%rsp)
movslq %eax, %r12
movsbl (%rbx,%r12), %edx
leaq 0x1(%r12), %rbp
movzbl 0x1(%rbx,%r12), %ecx
andl $0x7, %ecx
movq %rbx, %r13
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
leaq 0x3cc9(%rip), %rsi      # 0x14827
xorl %eax, %eax
callq 0x91b0
movq %r15, %rdi
movq %rbx, %rsi
movq %r13, %rbx
callq 0x91a0
movb $0x0, 0x10(%rsp)
movzbl 0x1(%r13,%r12), %eax
andl $0x7, %eax
movl %eax, (%r14)
movzbl 0x1(%r13,%r12), %eax
movl %eax, %ecx
andl $0x7, %ecx
cmpl $0x7, %ecx
ja 0x10cd8
leaq 0x3995(%rip), %rdx      # 0x14534
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl 0x2(%r12,%rbx), %edx
movl 0x4(%r12,%rbx), %ecx
leaq 0x10(%rsp), %rdi
leaq 0x3c81(%rip), %rsi      # 0x1483f
xorl %eax, %eax
callq 0x91b0
addl $0x6, %r12d
jmp 0x10cd5
movb 0x2(%r12,%rbx), %al
cmpb $0x7, %al
leaq 0x32cc(%rip), %rdx      # 0x13ea8
leaq 0x252f(%rip), %rcx      # 0x13112
cmoveq %rcx, %rdx
cmpb $0x6, %al
leaq 0x251b(%rip), %rcx      # 0x1310b
cmoveq %rcx, %rdx
movb %al, 0x4(%r14)
leaq 0x10(%rsp), %rdi
leaq 0x32af(%rip), %rsi      # 0x13eb3
xorl %eax, %eax
callq 0x91b0
movb 0x3(%rbx,%r12), %al
addq $0x3, %r12
movb %al, 0x5(%r14)
jmp 0x10cd5
movb %al, 0x4(%r14)
testb $0x8, (%rbx,%rbp)
leaq 0x32a2(%rip), %rdx      # 0x13ece
leaq 0x32a4(%rip), %rax      # 0x13ed7
cmoveq %rax, %rdx
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
leaq 0x3298(%rip), %rsi      # 0x13ede
xorl %eax, %eax
callq 0x91b0
leaq 0x60(%rsp), %rdi
movq %rbx, %rsi
movq %r13, %rbx
callq 0x91a0
addq $0x2, %r12
movb (%r13,%rbp), %al
andb $0x7, %al
cmpb $0x2, %al
jne 0x10d1e
movb $0x1, 0x5(%r14)
movl (%rbx,%r12), %edx
movl %edx, 0x8(%r14)
movl 0xc(%rsp), %ebp
addl $0x3, %ebp
testl %edx, %edx
js 0x10d39
leaq 0x10(%rsp), %rdi
leaq 0x3265(%rip), %rsi      # 0x13efd
jmp 0x10d47
movups 0x31f3(%rip), %xmm0     # 0x13e97
movaps %xmm0, 0x10(%rsp)
movb $0x0, 0x20(%rsp)
jmp 0x10cc8
movups 0x31cf(%rip), %xmm0     # 0x13e86
movups %xmm0, 0x1e(%rsp)
movups 0x31b5(%rip), %xmm0     # 0x13e78
movaps %xmm0, 0x10(%rsp)
movb 0x2(%rbx,%r12), %al
addq $0x2, %r12
movb %al, 0x4(%r14)
movl %r12d, %ebp
leaq 0x60(%rsp), %r15
movq %r15, %rdi
leaq 0x10(%rsp), %rsi
callq 0x91a0
movq %r15, %rdi
movq %r14, %r15
leaq 0x3415(%rip), %rcx      # 0x1410c
movq %rcx, %rsi
movq %rcx, %rdx
callq 0xcb44
leal 0x1(%rbp), %eax
movslq %eax, %r12
movq 0xb0(%rsp), %r14
cmpq %r12, %r14
ja 0x10acc
jmp 0x1104f
movabsq $0x6e776f6e6b6e755b, %rax # imm = 0x6E776F6E6B6E755B
movq %rax, 0x10(%rsp)
movw $0x5d, 0x18(%rsp)
movl %r12d, %ebp
jmp 0x10d4e
negl %edx
leaq 0x10(%rsp), %rdi
leaq 0x31ac(%rip), %rsi      # 0x13ef3
xorl %eax, %eax
callq 0x91b0
incl %ebp
jmp 0x10cd8
leaq 0x3173(%rip), %rsi      # 0x13ecc
jmp 0x10dab
leaq 0x397a(%rip), %rsi      # 0x146dc
jmp 0x1103d
testq %r14, %r14
je 0x1104f
leaq 0x3936(%rip), %rsi      # 0x146ad
movq %rbx, %rdi
callq 0x9120
testl %eax, %eax
je 0x10eee
leaq 0x3936(%rip), %rdi      # 0x146c4
callq 0x128bc
jmp 0x1104f
leaq 0x38e6(%rip), %rsi      # 0x14685
jmp 0x1103d
leaq 0x38f7(%rip), %rsi      # 0x146a2
leaq 0x335a(%rip), %rcx      # 0x1410c
movq %rcx, %rdi
movq %rbx, %rdx
jmp 0x1104a
movsbl 0x4(%rbx), %edx
leaq 0x5(%rbx), %rcx
leaq 0x3b49(%rip), %rsi      # 0x14915
leaq 0x60(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x91b0
leaq 0x39d7(%rip), %rdi      # 0x147b9
leaq 0x3323(%rip), %rcx      # 0x1410c
movq %r14, %rsi
jmp 0x11047
movsbl 0x1(%rbx), %edx
leaq 0x2(%rbx), %rcx
leaq 0x3aa0(%rip), %rsi      # 0x148a0
leaq 0x60(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x91b0
movsbq 0x1(%rbx), %rax
movl 0x2(%rbx,%rax), %esi
movl 0x4(%rbx,%rax), %edx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x1108b
leaq 0x32dc(%rip), %rcx      # 0x1410c
movq %r14, %rdi
movq %r15, %rsi
jmp 0x11047
movl $0x2, %eax
movl (%rbx,%rax), %edx
movl %edx, %eax
shrl $0x10, %eax
movsbl %al, %ecx
leaq 0x3a3a(%rip), %rsi      # 0x1488c
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x91b0
jmp 0x10ecc
movabsq $0x656c626d65737341, %rcx # imm = 0x656C626D65737341
movq %rcx, (%rax)
movw $0x72, 0x8(%rax)
jmp 0x10e8b
movabsq $0x6e776f6e6b6e755b, %rcx # imm = 0x6E776F6E6B6E755B
movq %rcx, (%rax)
movw $0x5d, 0x8(%rax)
movzbl 0x1(%rbx), %eax
movl %eax, %ecx
andl $0x7, %ecx
leaq 0x36c9(%rip), %rsi      # 0x14564
movslq (%rsi,%rcx,4), %rdx
addq %rsi, %rdx
testb $0x8, %al
leaq 0x3a51(%rip), %rax      # 0x148fc
leaq 0x3827(%rip), %rcx      # 0x146d9
cmoveq %rax, %rcx
leaq 0x3a1b(%rip), %rsi      # 0x148d8
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x91b0
leaq 0x60(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x91a0
leaq 0x3229(%rip), %rcx      # 0x1410c
movq %r15, %rdi
movq %rcx, %rsi
jmp 0x11047
leaq 0x37bc(%rip), %rsi      # 0x146b1
jmp 0x1103d
leaq 0x2f4a(%rip), %rsi      # 0x13e4b
leaq 0x3204(%rip), %r14      # 0x1410c
movq %r14, %rdi
movq %r14, %rdx
movq %r14, %rcx
callq 0xcb44
leaq 0x2f34(%rip), %rsi      # 0x13e51
movq %r14, %rdi
movq %r14, %rdx
movq %r14, %rcx
callq 0xcb44
leaq 0xbfb2(%rip), %rax      # 0x1cee4
movl $0x11e, (%rax)          # imm = 0x11E
jmp 0x10fc9
leaq 0x3678(%rip), %rsi      # 0x145bc
leaq 0x31c1(%rip), %r14      # 0x1410c
movq %r14, %rdi
movq %r14, %rdx
movq %r14, %rcx
callq 0xcb44
leaq 0x3662(%rip), %rsi      # 0x145c2
movq %r14, %rdi
movq %r14, %rdx
movq %r14, %rcx
callq 0xcb44
leaq 0xbf6f(%rip), %rax      # 0x1cee4
movl $0x182, (%rax)          # imm = 0x182
jmp 0x10fc9
leaq 0x3643(%rip), %rsi      # 0x145c7
leaq 0x3181(%rip), %r14      # 0x1410c
movq %r14, %rdi
movq %r14, %rdx
movq %r14, %rcx
callq 0xcb44
leaq 0x362c(%rip), %rsi      # 0x145cc
movq %r14, %rdi
movq %r14, %rdx
movq %r14, %rcx
callq 0xcb44
leaq 0xbf2f(%rip), %rax      # 0x1cee4
movl $0xba, (%rax)
jmp 0x10fc9
leaq 0x3619(%rip), %rdi      # 0x145dd
callq 0x128bc
movzbl 0x1(%rbx), %eax
cmpl $0x6b, %eax
jle 0x10fee
cmpl $0x6c, %eax
je 0x11005
cmpl $0x6d, %eax
je 0x1100e
cmpl $0x73, %eax
jne 0x1107d
leaq 0x361f(%rip), %rsi      # 0x1460b
jmp 0x1101e
cmpl $0x63, %eax
je 0x11017
cmpl $0x68, %eax
jne 0x1107d
leaq 0x3648(%rip), %rsi      # 0x1464b
jmp 0x1101e
leaq 0x362a(%rip), %rsi      # 0x14636
jmp 0x1101e
leaq 0x360b(%rip), %rsi      # 0x14620
jmp 0x1101e
leaq 0x35d6(%rip), %rsi      # 0x145f4
leaq 0x30e7(%rip), %rcx      # 0x1410c
movq %rcx, %rdi
movq %rcx, %rdx
callq 0xcb44
cmpb $0x4f, 0x2(%rbx)
jne 0x1104f
leaq 0x3630(%rip), %rsi      # 0x1466d
leaq 0x30c8(%rip), %rcx      # 0x1410c
movq %rcx, %rdi
movq %rcx, %rdx
callq 0xcb44
callq 0xcad9
callq 0xf4b4
leaq 0x9(%rsp), %rax
cmpq %rax, %rbx
je 0x1106b
movq %rbx, %rdi
callq 0x9040
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x35db(%rip), %rdi      # 0x1465f
callq 0x128bc
jmp 0x11030