// File: /workspace/github_c_makefile_star2_O1/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 0xf478
callq 0xf478
movzbl %al, %r15d
addq $-0x3, %r14
je 0x10507
movq %r14, %rdi
callq 0x1282e
movq %rax, %rbx
jmp 0x1050c
leaq 0x9(%rsp), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xf4ff
leal -0xdd(%r15), %eax
cmpl $0x22, %eax
ja 0x1055e
leaq 0x3f7e(%rip), %rcx      # 0x144a8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpb $0x10, (%rbx)
je 0x10544
leaq 0x41b8(%rip), %rdi      # 0x146f7
callq 0x12808
leaq 0x1(%rbx), %rdx
leaq 0x41ca(%rip), %rsi      # 0x14719
leaq 0x3bb6(%rip), %rcx      # 0x1410c
movq %rcx, %rdi
jmp 0x10fc1
leal -0x9d(%r15), %eax
cmpl $0x5, %eax
ja 0x105e9
leaq 0x3f1f(%rip), %rcx      # 0x14490
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xc96f(%rip), %rax      # 0x1cef0
movl $0x1, (%rax)
movzbl (%rbx), %eax
addl $-0x30, %eax
cmpl $0x3, %eax
ja 0x10f34
leaq 0x3fb7(%rip), %rcx      # 0x14554
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x4024(%rip), %rsi      # 0x145d1
leaq 0x3b58(%rip), %r14      # 0x1410c
movq %r14, %rdi
movq %r14, %rdx
movq %r14, %rcx
callq 0xcad8
leaq 0x400e(%rip), %rsi      # 0x145d7
movq %r14, %rdi
movq %r14, %rdx
movq %r14, %rcx
callq 0xcad8
leaq 0xc906(%rip), %rax      # 0x1cee4
movl $0x1f96, (%rax)         # imm = 0x1F96
jmp 0x10f40
testl %r15d, %r15d
jne 0x105fa
leaq 0x3fbb(%rip), %rsi      # 0x145b0
jmp 0x10d4a
movb $0x0, 0x60(%rsp)
testq %r14, %r14
je 0x10657
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 0x10639
movq %rbp, %rdi
leaq 0x4308(%rip), %rsi      # 0x14938
xorl %eax, %eax
callq 0x91b0
jmp 0x10642
movb %al, 0x10(%rsp)
movb $0x0, 0x11(%rsp)
leaq 0x60(%rsp), %rdi
movq %rbp, %rsi
callq 0x91a0
incq %r13
cmpq %r13, %r14
jne 0x10614
leaq 0x42e1(%rip), %rsi      # 0x1493f
leaq 0x10(%rsp), %r14
leaq 0x60(%rsp), %rcx
movq %r14, %rdi
movl %r15d, %edx
xorl %eax, %eax
callq 0x91b0
leaq 0x3a90(%rip), %rcx      # 0x1410c
movq %rcx, %rdi
jmp 0x10d88
cmpq $0x3, %r14
ja 0x10d5c
leaq 0x410b(%rip), %rdi      # 0x147a0
jmp 0x10824
leaq 0x425f(%rip), %rdi      # 0x14900
leaq 0x3a64(%rip), %rcx      # 0x1410c
movq %rcx, %rsi
movq %rcx, %rdx
callq 0xcad8
cmpq $0x2, %r14
jb 0x10fc6
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 0x422e(%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 0x4211(%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 0x39e0(%rip), %rcx      # 0x1410c
movq %rcx, %rsi
movq %rcx, %rdx
callq 0xcad8
callq 0xca6d
movslq %r13d, %rbp
cmpq %rbp, %r14
ja 0x106c8
jmp 0x10fc6
movsbl (%rbx), %edx
leaq 0x1(%rbx), %rcx
leaq 0x41cb(%rip), %rsi      # 0x14922
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x91b0
jmp 0x10a0a
leaq 0x4009(%rip), %rdi      # 0x1477b
leaq 0x3993(%rip), %rcx      # 0x1410c
movq %rcx, %rsi
movq %rcx, %rdx
callq 0xcad8
cmpq $0x2, %r14
jb 0x10fc6
movl $0x1, %r13d
movl $0x1, %r12d
callq 0xca6d
movsbl (%rbx,%r12), %edx
leal 0x1(%r13), %eax
movslq %eax, %rcx
addq %rbx, %rcx
leaq 0x60(%rsp), %rbp
movq %rbp, %rdi
leaq 0x3fd0(%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 0x3fb2(%rip), %rsi      # 0x14796
xorl %eax, %eax
callq 0x91b0
addl %r12d, %r13d
addl $0x3, %r13d
movq %rbp, %rdi
leaq 0x3910(%rip), %rdx      # 0x1410c
movq %rdx, %rsi
movq %r15, %rcx
callq 0xcad8
movslq %r13d, %r12
cmpq %r12, %r14
ja 0x1079a
jmp 0x10fc6
cmpb $0x0, (%rbx)
je 0x10d90
leaq 0x408f(%rip), %rdi      # 0x148b3
leaq 0x38e1(%rip), %rcx      # 0x1410c
jmp 0x10e5d
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 0x10dda
cmpl $0x1, %ebp
jne 0x10def
movl $0x274327, (%rax)       # imm = 0x274327
jmp 0x10e02
movsbl (%rbx), %edx
movzbl 0x1(%rbx), %ecx
andl $0x1, %ecx
leaq 0x3e95(%rip), %rsi      # 0x14722
jmp 0x109a6
movsbl (%rbx), %edx
movzbl 0x1(%rbx), %ecx
andl $0x1, %ecx
leaq 0x3ea1(%rip), %rsi      # 0x14744
jmp 0x109a6
movl (%rbx), %edx
leaq 0x3fb3(%rip), %rsi      # 0x14864
leaq 0x60(%rsp), %rdi
xorl %eax, %eax
callq 0x91b0
movsbl 0x1(%rbx), %edx
testl %edx, %edx
je 0x108ec
leaq 0x2(%rbx), %rcx
leaq 0x3fb3(%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
movl 0x2(%rax,%rbx), %edx
movsbl 0x4(%rax,%rbx), %ecx
leaq 0x3f8b(%rip), %rsi      # 0x1488c
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x91b0
jmp 0x10e43
movb 0xdccd(%rip), %al       # 0x1e5e8
movl %eax, %ecx
xorb $0x1, %cl
leaq 0xc651(%rip), %rdx      # 0x1cf78
testb %al, %al
cmovneq 0x86af(%rip), %rdx      # 0x18fe0
movb %cl, 0xdcb1(%rip)       # 0x1e5e8
leaq 0xdcd2(%rip), %rax      # 0x1e610
leaq 0xdcc3(%rip), %rcx      # 0x1e608
cmovneq %rax, %rcx
movq %rdx, 0xdca0(%rip)      # 0x1e5f0
movq %rcx, 0xdca9(%rip)      # 0x1e600
movl $0x10, %edi
callq 0x1282e
movq 0xdc98(%rip), %rcx      # 0x1e600
movq %rax, (%rcx)
movslq 0x1(%rbx), %rcx
movq %rcx, (%rax)
movq 0xdc77(%rip), %rcx      # 0x1e5f0
movq (%rcx), %rsi
leaq -0x4cb(%rip), %rdx      # 0x104b8
movq %rax, %rdi
callq 0x12538
movq 0x20(%rax), %rax
movq 0xdc6a(%rip), %rcx      # 0x1e600
movq %rax, (%rcx)
movsbl (%rbx), %edx
movl 0x1(%rbx), %ecx
leaq 0x3e44(%rip), %rsi      # 0x147ea
leaq 0x60(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x91b0
jmp 0x10a0a
movl $0x10, %edi
callq 0x1282e
movq %rax, 0xdc30(%rip)      # 0x1e5f8
movslq (%rbx), %rcx
movq %rcx, (%rax)
leaq 0xc5b3(%rip), %rcx      # 0x1cf88
movq (%rcx), %rsi
leaq -0x527(%rip), %rdx      # 0x104b8
movq %rax, %rdi
callq 0x12538
movq 0x20(%rax), %rax
movq %rax, 0xdc06(%rip)      # 0x1e5f8
movl (%rbx), %edx
leaq 0x3dd1(%rip), %rsi      # 0x147cc
leaq 0x60(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x91b0
leaq 0x36fb(%rip), %rcx      # 0x1410c
movq %r14, %rdi
jmp 0x10e5d
leaq 0x3df2(%rip), %rdi      # 0x14812
leaq 0x36e5(%rip), %rcx      # 0x1410c
movq %rcx, %rsi
movq %rcx, %rdx
callq 0xcad8
movl $0x38, %edi
callq 0x1282e
movq %rax, %r15
movq 0xdbba(%rip), %rax      # 0x1e600
movq (%rax), %rax
movq %r15, 0x8(%rax)
cmpq $0x2, %r14
jb 0x10fc6
movl $0x1, %r12d
xorl %ebp, %ebp
movq %r14, 0xb0(%rsp)
testl %ebp, %ebp
je 0x10a7e
movl $0x38, %edi
callq 0x1282e
movq %rax, %r14
movq %rax, 0x30(%r15)
jmp 0x10a81
movq %r15, %r14
callq 0xca6d
movslq %ebp, %r13
movsbl (%rbx,%r13), %edx
addq %rbx, %r12
leaq 0x60(%rsp), %r15
movq %r15, %rdi
leaq 0x3ced(%rip), %rsi      # 0x1478d
movq %r12, %rcx
xorl %eax, %eax
callq 0x91b0
leaq 0xc(%r14), %rdi
movsbl (%rbx,%r13), %edx
leaq 0x3e5b(%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 0x3d2e(%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 0x10c77
leaq 0x39fa(%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 0x3ce6(%rip), %rsi      # 0x1483f
xorl %eax, %eax
callq 0x91b0
addl $0x6, %r12d
jmp 0x10c74
movb 0x2(%r12,%rbx), %al
cmpb $0x7, %al
leaq 0x3331(%rip), %rdx      # 0x13ea8
leaq 0x2594(%rip), %rcx      # 0x13112
cmoveq %rcx, %rdx
cmpb $0x6, %al
leaq 0x2580(%rip), %rcx      # 0x1310b
cmoveq %rcx, %rdx
movb %al, 0x4(%r14)
leaq 0x10(%rsp), %rdi
leaq 0x3314(%rip), %rsi      # 0x13eb3
xorl %eax, %eax
callq 0x91b0
movb 0x3(%rbx,%r12), %al
addq $0x3, %r12
movb %al, 0x5(%r14)
jmp 0x10c74
movb %al, 0x4(%r14)
testb $0x8, (%rbx,%rbp)
leaq 0x3307(%rip), %rdx      # 0x13ece
leaq 0x3309(%rip), %rax      # 0x13ed7
cmoveq %rax, %rdx
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
leaq 0x32fd(%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 0x10cbd
movb $0x1, 0x5(%r14)
movl (%rbx,%r12), %eax
movl %eax, 0x8(%r14)
movl 0xc(%rsp), %ebp
addl $0x3, %ebp
movl (%rbx,%r12), %edx
testl %edx, %edx
js 0x10cd8
leaq 0x10(%rsp), %rdi
leaq 0x32c6(%rip), %rsi      # 0x13efd
jmp 0x10ce6
movups 0x3254(%rip), %xmm0     # 0x13e97
movaps %xmm0, 0x10(%rsp)
movb $0x0, 0x20(%rsp)
jmp 0x10c67
movups 0x3230(%rip), %xmm0     # 0x13e86
movups %xmm0, 0x1e(%rsp)
movups 0x3216(%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 0x3476(%rip), %rcx      # 0x1410c
movq %rcx, %rsi
movq %rcx, %rdx
callq 0xcad8
leal 0x1(%rbp), %eax
movslq %eax, %r12
movq 0xb0(%rsp), %r14
cmpq %r12, %r14
ja 0x10a67
jmp 0x10fc6
movabsq $0x6e776f6e6b6e755b, %rax # imm = 0x6E776F6E6B6E755B
movq %rax, 0x10(%rsp)
movw $0x5d, 0x18(%rsp)
movl %r12d, %ebp
jmp 0x10ced
negl %edx
leaq 0x10(%rsp), %rdi
leaq 0x320d(%rip), %rsi      # 0x13ef3
xorl %eax, %eax
callq 0x91b0
incl %ebp
jmp 0x10c77
leaq 0x31d4(%rip), %rsi      # 0x13ecc
jmp 0x10d4a
leaq 0x39db(%rip), %rsi      # 0x146dc
jmp 0x10fb4
testq %r14, %r14
je 0x10fc6
leaq 0x3997(%rip), %rsi      # 0x146ad
movq %rbx, %rdi
callq 0x9120
testl %eax, %eax
je 0x10e65
leaq 0x3997(%rip), %rdi      # 0x146c4
callq 0x12808
jmp 0x10fc6
leaq 0x3947(%rip), %rsi      # 0x14685
jmp 0x10fb4
leaq 0x3958(%rip), %rsi      # 0x146a2
leaq 0x33bb(%rip), %rcx      # 0x1410c
movq %rcx, %rdi
movq %rbx, %rdx
jmp 0x10fc1
movsbl 0x4(%rbx), %edx
leaq 0x5(%rbx), %rcx
leaq 0x3baa(%rip), %rsi      # 0x14915
leaq 0x60(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x91b0
leaq 0x3a38(%rip), %rdi      # 0x147b9
leaq 0x3384(%rip), %rcx      # 0x1410c
movq %r14, %rsi
jmp 0x10fbe
movsbl 0x1(%rbx), %edx
leaq 0x2(%rbx), %rcx
leaq 0x3b01(%rip), %rsi      # 0x148a0
leaq 0x60(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x91b0
movsbq 0x1(%rbx), %rax
leaq (%rbx,%rax), %rsi
addq $0x2, %rsi
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x11002
leaq 0x333d(%rip), %rcx      # 0x1410c
movq %r14, %rdi
movq %r15, %rsi
jmp 0x10fbe
movabsq $0x656c626d65737341, %rcx # imm = 0x656C626D65737341
movq %rcx, (%rax)
movw $0x72, 0x8(%rax)
jmp 0x10e02
movabsq $0x6e776f6e6b6e755b, %rcx # imm = 0x6E776F6E6B6E755B
movq %rcx, (%rax)
movw $0x5d, 0x8(%rax)
movzbl 0x1(%rbx), %eax
movl %eax, %ecx
andl $0x7, %ecx
leaq 0x3752(%rip), %rsi      # 0x14564
movslq (%rsi,%rcx,4), %rdx
addq %rsi, %rdx
testb $0x8, %al
leaq 0x3ada(%rip), %rax      # 0x148fc
leaq 0x38b0(%rip), %rcx      # 0x146d9
cmoveq %rax, %rcx
leaq 0x3aa4(%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 0x32b2(%rip), %rcx      # 0x1410c
movq %r15, %rdi
movq %rcx, %rsi
jmp 0x10fbe
leaq 0x3845(%rip), %rsi      # 0x146b1
jmp 0x10fb4
leaq 0x2fd3(%rip), %rsi      # 0x13e4b
leaq 0x328d(%rip), %r14      # 0x1410c
movq %r14, %rdi
movq %r14, %rdx
movq %r14, %rcx
callq 0xcad8
leaq 0x2fbd(%rip), %rsi      # 0x13e51
movq %r14, %rdi
movq %r14, %rdx
movq %r14, %rcx
callq 0xcad8
leaq 0xc03b(%rip), %rax      # 0x1cee4
movl $0x11e, (%rax)          # imm = 0x11E
jmp 0x10f40
leaq 0x3701(%rip), %rsi      # 0x145bc
leaq 0x324a(%rip), %r14      # 0x1410c
movq %r14, %rdi
movq %r14, %rdx
movq %r14, %rcx
callq 0xcad8
leaq 0x36eb(%rip), %rsi      # 0x145c2
movq %r14, %rdi
movq %r14, %rdx
movq %r14, %rcx
callq 0xcad8
leaq 0xbff8(%rip), %rax      # 0x1cee4
movl $0x182, (%rax)          # imm = 0x182
jmp 0x10f40
leaq 0x36cc(%rip), %rsi      # 0x145c7
leaq 0x320a(%rip), %r14      # 0x1410c
movq %r14, %rdi
movq %r14, %rdx
movq %r14, %rcx
callq 0xcad8
leaq 0x36b5(%rip), %rsi      # 0x145cc
movq %r14, %rdi
movq %r14, %rdx
movq %r14, %rcx
callq 0xcad8
leaq 0xbfb8(%rip), %rax      # 0x1cee4
movl $0xba, (%rax)
jmp 0x10f40
leaq 0x36a2(%rip), %rdi      # 0x145dd
callq 0x12808
movzbl 0x1(%rbx), %eax
cmpl $0x6b, %eax
jle 0x10f65
cmpl $0x6c, %eax
je 0x10f7c
cmpl $0x6d, %eax
je 0x10f85
cmpl $0x73, %eax
jne 0x10ff4
leaq 0x36a8(%rip), %rsi      # 0x1460b
jmp 0x10f95
cmpl $0x63, %eax
je 0x10f8e
cmpl $0x68, %eax
jne 0x10ff4
leaq 0x36d1(%rip), %rsi      # 0x1464b
jmp 0x10f95
leaq 0x36b3(%rip), %rsi      # 0x14636
jmp 0x10f95
leaq 0x3694(%rip), %rsi      # 0x14620
jmp 0x10f95
leaq 0x365f(%rip), %rsi      # 0x145f4
leaq 0x3170(%rip), %rcx      # 0x1410c
movq %rcx, %rdi
movq %rcx, %rdx
callq 0xcad8
cmpb $0x4f, 0x2(%rbx)
jne 0x10fc6
leaq 0x36b9(%rip), %rsi      # 0x1466d
leaq 0x3151(%rip), %rcx      # 0x1410c
movq %rcx, %rdi
movq %rcx, %rdx
callq 0xcad8
callq 0xca6d
callq 0xf478
leaq 0x9(%rsp), %rax
cmpq %rax, %rbx
je 0x10fe2
movq %rbx, %rdi
callq 0x9040
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3664(%rip), %rdi      # 0x1465f
callq 0x12808
jmp 0x10fa7