// File: /workspace/github_c_makefile_star2_O2/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 0xed18
callq 0xed18
movzbl %al, %r15d
addq $-0x3, %r14
je 0xfddb
movq %r14, %rdi
callq 0x11f10
movq %rax, %rbx
jmp 0xfde0
leaq 0xd(%rsp), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xedbe
leal -0xdd(%r15), %eax
cmpl $0x22, %eax
ja 0xfe32
leaq 0x36aa(%rip), %rcx      # 0x134a8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpb $0x10, (%rbx)
je 0xfe18
leaq 0x38e4(%rip), %rdi      # 0x136f7
callq 0x11eec
leaq 0x1(%rbx), %rdx
leaq 0x38f6(%rip), %rsi      # 0x13719
leaq 0x32e2(%rip), %rcx      # 0x1310c
movq %rcx, %rdi
jmp 0x108a6
leal -0x9d(%r15), %eax
cmpl $0x5, %eax
ja 0xfebd
leaq 0x364b(%rip), %rcx      # 0x13490
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xc09b(%rip), %rax      # 0x1bef0
movl $0x1, (%rax)
movzbl (%rbx), %eax
addl $-0x30, %eax
cmpl $0x3, %eax
ja 0x10818
leaq 0x36e3(%rip), %rcx      # 0x13554
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x3750(%rip), %rsi      # 0x135d1
leaq 0x3284(%rip), %r14      # 0x1310c
movq %r14, %rdi
movq %r14, %rdx
movq %r14, %rcx
callq 0xc585
leaq 0x373a(%rip), %rsi      # 0x135d7
movq %r14, %rdi
movq %r14, %rdx
movq %r14, %rcx
callq 0xc585
leaq 0xc032(%rip), %rax      # 0x1bee4
movl $0x1f96, (%rax)         # imm = 0x1F96
jmp 0x10824
testl %r15d, %r15d
jne 0xfece
leaq 0x36e7(%rip), %rsi      # 0x135b0
jmp 0x105b9
leaq 0x60(%rsp), %r12
movb $0x0, (%r12)
leaq 0x10(%rsp), %rbp
xorl %r13d, %r13d
cmpq %r13, %r14
je 0xff27
callq 0x91f0
movq (%rax), %rcx
movb (%rbx,%r13), %al
movzbl %al, %edx
testb $0x40, 0x1(%rcx,%rdx,2)
jne 0xff0e
movq %rbp, %rdi
leaq 0x3a33(%rip), %rsi      # 0x13938
xorl %eax, %eax
callq 0x91b0
jmp 0xff17
movb %al, 0x10(%rsp)
movb $0x0, 0x11(%rsp)
movq %r12, %rdi
movq %rbp, %rsi
callq 0x91a0
incq %r13
jmp 0xfee0
leaq 0x3a11(%rip), %rsi      # 0x1393f
leaq 0x10(%rsp), %r14
leaq 0x60(%rsp), %rcx
movq %r14, %rdi
movl %r15d, %edx
xorl %eax, %eax
callq 0x91b0
leaq 0x31c0(%rip), %rcx      # 0x1310c
movq %rcx, %rdi
jmp 0x105f7
cmpq $0x3, %r14
ja 0x105cb
leaq 0x383b(%rip), %rdi      # 0x137a0
jmp 0x100ce
leaq 0x398f(%rip), %rdi      # 0x13900
leaq 0x3194(%rip), %rcx      # 0x1310c
movq %rcx, %rsi
movq %rcx, %rdx
callq 0xc585
pushq $0x1
popq %rbp
leaq 0x60(%rsp), %r13
movslq %ebp, %rbp
cmpq %rbp, %r14
jbe 0x108ab
movsbl (%rbx,%rbp), %edx
leal 0x1(%rbp), %eax
movslq %eax, %rcx
addq %rbx, %rcx
movq %r13, %rdi
leaq 0x3965(%rip), %rsi      # 0x13913
xorl %eax, %eax
callq 0x91b0
movsbl (%rbx,%rbp), %r12d
leal (%r12,%rbp), %eax
incl %eax
cltq
movl (%rbx,%rax), %edx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
leaq 0x3946(%rip), %rsi      # 0x1391a
xorl %eax, %eax
callq 0x91b0
addl %r12d, %ebp
addl $0x4, %ebp
movq %r13, %rdi
movq %r15, %rsi
callq 0x91a0
movq %r13, %rdi
leaq 0x3116(%rip), %rcx      # 0x1310c
movq %rcx, %rsi
movq %rcx, %rdx
callq 0xc585
callq 0xc54f
jmp 0xff8b
movsbl (%rbx), %edx
leaq 0x1(%rbx), %rcx
leaq 0x390c(%rip), %rsi      # 0x13922
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x91b0
jmp 0x10299
leaq 0x374a(%rip), %rdi      # 0x1377b
leaq 0x30d4(%rip), %rcx      # 0x1310c
movq %rcx, %rsi
movq %rcx, %rdx
callq 0xc585
pushq $0x1
popq %rbp
leaq 0x60(%rsp), %r13
leaq 0x10(%rsp), %r12
movslq %ebp, %rbp
cmpq %rbp, %r14
jbe 0x108ab
callq 0xc54f
movsbl (%rbx,%rbp), %edx
leal 0x1(%rbp), %eax
movslq %eax, %rcx
addq %rbx, %rcx
movq %r13, %rdi
leaq 0x3715(%rip), %rsi      # 0x1378d
xorl %eax, %eax
callq 0x91b0
movsbl (%rbx,%rbp), %r15d
leal (%r15,%rbp), %eax
incl %eax
cltq
movsbl (%rbx,%rax), %edx
movq %r12, %rdi
leaq 0x36fc(%rip), %rsi      # 0x13796
xorl %eax, %eax
callq 0x91b0
addl %r15d, %ebp
addl $0x3, %ebp
movq %r13, %rdi
leaq 0x305b(%rip), %rdx      # 0x1310c
movq %rdx, %rsi
movq %r12, %rcx
callq 0xc585
jmp 0x10050
cmpb $0x0, (%rbx)
je 0x105ff
leaq 0x37e5(%rip), %rdi      # 0x138b3
leaq 0x3037(%rip), %rcx      # 0x1310c
jmp 0x10741
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 0x106be
cmpl $0x1, %ebp
jne 0x106d3
movl $0x274327, (%rax)       # imm = 0x274327
jmp 0x106e6
movsbl (%rbx), %edx
movzbl 0x1(%rbx), %ecx
andl $0x1, %ecx
leaq 0x35eb(%rip), %rsi      # 0x13722
jmp 0x10237
movsbl (%rbx), %edx
movzbl 0x1(%rbx), %ecx
andl $0x1, %ecx
leaq 0x35f7(%rip), %rsi      # 0x13744
jmp 0x10237
movl (%rbx), %edx
leaq 0x3709(%rip), %rsi      # 0x13864
leaq 0x60(%rsp), %rdi
xorl %eax, %eax
callq 0x91b0
movsbl 0x1(%rbx), %edx
testl %edx, %edx
je 0x10698
leaq 0x2(%rbx), %rcx
leaq 0x3705(%rip), %rsi      # 0x13883
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 0x1069b
movb 0xd43a(%rip), %al       # 0x1d5e8
movl %eax, %ecx
xorb $0x1, %cl
leaq 0xbdbe(%rip), %rdx      # 0x1bf78
testb %al, %al
cmovneq 0x7e1c(%rip), %rdx      # 0x17fe0
movb %cl, 0xd41e(%rip)       # 0x1d5e8
leaq 0xd43f(%rip), %rax      # 0x1d610
leaq 0xd430(%rip), %rcx      # 0x1d608
cmovneq %rax, %rcx
movq %rdx, 0xd40d(%rip)      # 0x1d5f0
movq %rcx, 0xd416(%rip)      # 0x1d600
pushq $0x10
popq %rdi
callq 0x11f10
movq 0xd407(%rip), %rcx      # 0x1d600
movq %rax, (%rcx)
movslq 0x1(%rbx), %rcx
movq %rcx, (%rax)
movq 0xd3e6(%rip), %rcx      # 0x1d5f0
movq (%rcx), %rsi
leaq -0x488(%rip), %rdx      # 0xfd8c
movq %rax, %rdi
callq 0x11c41
movq 0x20(%rax), %rax
movq 0xd3d9(%rip), %rcx      # 0x1d600
movq %rax, (%rcx)
movsbl (%rbx), %edx
movl 0x1(%rbx), %ecx
leaq 0x35b3(%rip), %rsi      # 0x137ea
leaq 0x60(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x91b0
jmp 0x10299
pushq $0x10
popq %rdi
callq 0x11f10
movq %rax, 0xd3a1(%rip)      # 0x1d5f8
movslq (%rbx), %rcx
movq %rcx, (%rax)
leaq 0xbd24(%rip), %rcx      # 0x1bf88
movq (%rcx), %rsi
leaq -0x4e2(%rip), %rdx      # 0xfd8c
movq %rax, %rdi
callq 0x11c41
movq 0x20(%rax), %rax
movq %rax, 0xd377(%rip)      # 0x1d5f8
movl (%rbx), %edx
leaq 0x3542(%rip), %rsi      # 0x137cc
leaq 0x60(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x91b0
leaq 0x2e6c(%rip), %rcx      # 0x1310c
movq %r14, %rdi
jmp 0x10741
leaq 0x3563(%rip), %rdi      # 0x13812
leaq 0x2e56(%rip), %rcx      # 0x1310c
movq %rcx, %rsi
movq %rcx, %rdx
callq 0xc585
pushq $0x38
popq %rdi
callq 0x11f10
movq %rax, %r13
movq 0xd32d(%rip), %rax      # 0x1d600
movq (%rax), %rax
movq %r13, 0x8(%rax)
xorl %r12d, %r12d
movq %r14, 0xb0(%rsp)
leal 0x1(%r12), %eax
movslq %eax, %rbp
cmpq %rbp, %r14
jbe 0x108ab
testl %r12d, %r12d
je 0x1030a
pushq $0x38
popq %rdi
callq 0x11f10
movq %rax, 0x30(%r13)
movq %rax, %r13
callq 0xc54f
movslq %r12d, %r12
movsbl (%rbx,%r12), %edx
leaq (%rbx,%rbp), %r15
leaq 0x60(%rsp), %rdi
leaq 0x3466(%rip), %rsi      # 0x1378d
movq %r15, %rcx
xorl %eax, %eax
callq 0x91b0
leaq 0xc(%r13), %rdi
movsbl (%rbx,%r12), %edx
leaq 0x35d4(%rip), %rsi      # 0x13915
movq %r15, %rcx
xorl %eax, %eax
callq 0x91b0
movsbl (%rbx,%r12), %eax
addl %eax, %ebp
movslq %ebp, %r15
movsbl (%rbx,%r15), %edx
leaq 0x1(%r15), %r12
movzbl 0x1(%rbx,%r15), %ecx
andl $0x7, %ecx
movq %rbx, %r14
movq %r13, %rbx
leaq 0x10(%rsp), %r13
movq %r13, %rdi
leaq 0x34ab(%rip), %rsi      # 0x13827
xorl %eax, %eax
callq 0x91b0
leaq 0x60(%rsp), %rdi
movq %r13, %rsi
movq %rbx, %r13
movq %r14, %rbx
callq 0x91a0
movb $0x0, 0x10(%rsp)
movzbl 0x1(%r14,%r15), %eax
andl $0x7, %eax
movl %eax, (%r13)
movzbl 0x1(%r14,%r15), %eax
movl %eax, %ecx
andl $0x7, %ecx
cmpl $0x7, %ecx
ja 0x104f5
leaq 0x3171(%rip), %rdx      # 0x13534
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl 0x2(%r15,%rbx), %edx
movl 0x4(%r15,%rbx), %ecx
leaq 0x10(%rsp), %rdi
leaq 0x345d(%rip), %rsi      # 0x1383f
xorl %eax, %eax
callq 0x91b0
addl $0x6, %r15d
jmp 0x104f2
movb 0x2(%r15,%rbx), %al
cmpb $0x7, %al
leaq 0x2aa8(%rip), %rdx      # 0x12ea8
leaq 0x1d0b(%rip), %rcx      # 0x12112
cmoveq %rcx, %rdx
cmpb $0x6, %al
leaq 0x1cf7(%rip), %rcx      # 0x1210b
cmoveq %rcx, %rdx
movb %al, 0x4(%r13)
leaq 0x10(%rsp), %rdi
leaq 0x2a8b(%rip), %rsi      # 0x12eb3
xorl %eax, %eax
callq 0x91b0
movb 0x3(%rbx,%r15), %al
addq $0x3, %r15
movb %al, 0x5(%r13)
jmp 0x104f2
movb %al, 0x4(%r13)
testb $0x8, (%rbx,%r12)
leaq 0x2a7d(%rip), %rdx      # 0x12ece
leaq 0x2a7f(%rip), %rax      # 0x12ed7
cmoveq %rax, %rdx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
leaq 0x2a73(%rip), %rsi      # 0x12ede
xorl %eax, %eax
callq 0x91b0
leaq 0x60(%rsp), %rdi
movq %r14, %rsi
callq 0x91a0
addq $0x2, %r15
movb (%rbx,%r12), %al
andb $0x7, %al
cmpb $0x2, %al
jne 0x10529
movb $0x1, 0x5(%r13)
movl (%rbx,%r15), %edx
movl %edx, 0x8(%r13)
addl $0x3, %ebp
testl %edx, %edx
js 0x10544
leaq 0x10(%rsp), %rdi
leaq 0x2a48(%rip), %rsi      # 0x12efd
jmp 0x10552
movups 0x29d6(%rip), %xmm0     # 0x12e97
movaps %xmm0, 0x10(%rsp)
movb $0x0, 0x20(%rsp)
jmp 0x104e5
movups 0x29b2(%rip), %xmm0     # 0x12e86
movups %xmm0, 0x1e(%rsp)
movups 0x2998(%rip), %xmm0     # 0x12e78
movaps %xmm0, 0x10(%rsp)
movb 0x2(%rbx,%r15), %al
addq $0x2, %r15
movb %al, 0x4(%r13)
movl %r15d, %r12d
leaq 0x60(%rsp), %r14
movq %r14, %rdi
leaq 0x10(%rsp), %rsi
callq 0x91a0
movq %r14, %rdi
leaq 0x2bfb(%rip), %rcx      # 0x1310c
movq %rcx, %rsi
movq %rcx, %rdx
callq 0xc585
movq 0xb0(%rsp), %r14
jmp 0x102e5
movabsq $0x6e776f6e6b6e755b, %rax # imm = 0x6E776F6E6B6E755B
movq %rax, 0x10(%rsp)
movw $0x5d, 0x18(%rsp)
movl %r15d, %ebp
jmp 0x10559
negl %edx
leaq 0x10(%rsp), %rdi
leaq 0x29a1(%rip), %rsi      # 0x12ef3
xorl %eax, %eax
callq 0x91b0
incl %ebp
movl %ebp, %r12d
jmp 0x104f5
leaq 0x2965(%rip), %rsi      # 0x12ecc
jmp 0x105b9
leaq 0x316c(%rip), %rsi      # 0x136dc
jmp 0x10899
testq %r14, %r14
je 0x108ab
leaq 0x3128(%rip), %rsi      # 0x136ad
movq %rbx, %rdi
callq 0x9120
testl %eax, %eax
je 0x10749
leaq 0x3128(%rip), %rdi      # 0x136c4
callq 0x11eec
jmp 0x108ab
leaq 0x30d8(%rip), %rsi      # 0x13685
jmp 0x10899
leaq 0x30e9(%rip), %rsi      # 0x136a2
leaq 0x2b4c(%rip), %rcx      # 0x1310c
movq %rcx, %rdi
movq %rbx, %rdx
jmp 0x108a6
movsbl 0x4(%rbx), %edx
leaq 0x5(%rbx), %rcx
leaq 0x333b(%rip), %rsi      # 0x13915
leaq 0x60(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x91b0
leaq 0x31c9(%rip), %rdi      # 0x137b9
leaq 0x2b15(%rip), %rcx      # 0x1310c
movq %r14, %rsi
jmp 0x108a3
movsbl 0x1(%rbx), %edx
leaq 0x2(%rbx), %rcx
leaq 0x3292(%rip), %rsi      # 0x138a0
leaq 0x60(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x91b0
movsbq 0x1(%rbx), %rax
movzwl 0x2(%rbx,%rax), %r8d
movzwl 0x4(%rbx,%rax), %r10d
movl %r8d, %edx
shrl $0xb, %edx
movl %r8d, %ecx
shrl $0x5, %ecx
andl $0x3f, %ecx
andl $0x1f, %r8d
movl %r10d, %eax
shrl $0x3, %eax
andl $0x3c, %eax
leaq 0x2f2b(%rip), %rsi      # 0x1357c
movslq (%rax,%rsi), %r9
addq %rsi, %r9
movl %r10d, %r11d
andl $0x1f, %r11d
shrl $0x9, %r10d
addl $0x7bc, %r10d           # imm = 0x7BC
leaq 0x32f7(%rip), %rsi      # 0x13968
leaq 0x10(%rsp), %r15
movq %r15, %rdi
xorl %eax, %eax
pushq %r10
pushq %r11
callq 0x91b0
popq %rcx
popq %rdx
leaq 0x2a7f(%rip), %rcx      # 0x1310c
movq %r14, %rdi
movq %r15, %rsi
jmp 0x108a3
pushq $0x2
popq %rax
movl (%rbx,%rax), %edx
movl %edx, %eax
shrl $0x10, %eax
movsbl %al, %ecx
leaq 0x31df(%rip), %rsi      # 0x1388c
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x91b0
jmp 0x10727
movabsq $0x656c626d65737341, %rcx # imm = 0x656C626D65737341
movq %rcx, (%rax)
movw $0x72, 0x8(%rax)
jmp 0x106e6
movabsq $0x6e776f6e6b6e755b, %rcx # imm = 0x6E776F6E6B6E755B
movq %rcx, (%rax)
movw $0x5d, 0x8(%rax)
movzbl 0x1(%rbx), %eax
movl %eax, %ecx
andl $0x7, %ecx
leaq 0x2e6e(%rip), %rsi      # 0x13564
movslq (%rsi,%rcx,4), %rdx
addq %rsi, %rdx
testb $0x8, %al
leaq 0x31f6(%rip), %rax      # 0x138fc
leaq 0x2fcc(%rip), %rcx      # 0x136d9
cmoveq %rax, %rcx
leaq 0x31c0(%rip), %rsi      # 0x138d8
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 0x29ce(%rip), %rcx      # 0x1310c
movq %r15, %rdi
movq %rcx, %rsi
jmp 0x108a3
leaq 0x2f61(%rip), %rsi      # 0x136b1
jmp 0x10899
leaq 0x26ef(%rip), %rsi      # 0x12e4b
leaq 0x29a9(%rip), %r14      # 0x1310c
movq %r14, %rdi
movq %r14, %rdx
movq %r14, %rcx
callq 0xc585
leaq 0x26d9(%rip), %rsi      # 0x12e51
movq %r14, %rdi
movq %r14, %rdx
movq %r14, %rcx
callq 0xc585
leaq 0xb757(%rip), %rax      # 0x1bee4
movl $0x11e, (%rax)          # imm = 0x11E
jmp 0x10824
leaq 0x2e1d(%rip), %rsi      # 0x135bc
leaq 0x2966(%rip), %r14      # 0x1310c
movq %r14, %rdi
movq %r14, %rdx
movq %r14, %rcx
callq 0xc585
leaq 0x2e07(%rip), %rsi      # 0x135c2
movq %r14, %rdi
movq %r14, %rdx
movq %r14, %rcx
callq 0xc585
leaq 0xb714(%rip), %rax      # 0x1bee4
movl $0x182, (%rax)          # imm = 0x182
jmp 0x10824
leaq 0x2de8(%rip), %rsi      # 0x135c7
leaq 0x2926(%rip), %r14      # 0x1310c
movq %r14, %rdi
movq %r14, %rdx
movq %r14, %rcx
callq 0xc585
leaq 0x2dd1(%rip), %rsi      # 0x135cc
movq %r14, %rdi
movq %r14, %rdx
movq %r14, %rcx
callq 0xc585
leaq 0xb6d4(%rip), %rax      # 0x1bee4
movl $0xba, (%rax)
jmp 0x10824
leaq 0x2dbe(%rip), %rdi      # 0x135dd
callq 0x11eec
movzbl 0x1(%rbx), %eax
cmpl $0x73, %eax
je 0x10873
cmpl $0x68, %eax
je 0x1084a
cmpl $0x6c, %eax
je 0x1085c
cmpl $0x6d, %eax
je 0x10853
cmpl $0x63, %eax
jne 0x10865
leaq 0x2dac(%rip), %rsi      # 0x135f4
jmp 0x1087a
leaq 0x2dfa(%rip), %rsi      # 0x1364b
jmp 0x1087a
leaq 0x2dc6(%rip), %rsi      # 0x13620
jmp 0x1087a
leaq 0x2dd3(%rip), %rsi      # 0x13636
jmp 0x1087a
leaq 0x2df3(%rip), %rdi      # 0x1365f
callq 0x11eec
jmp 0x1088c
leaq 0x2d91(%rip), %rsi      # 0x1360b
leaq 0x288b(%rip), %rcx      # 0x1310c
movq %rcx, %rdi
movq %rcx, %rdx
callq 0xc585
cmpb $0x4f, 0x2(%rbx)
jne 0x108ab
leaq 0x2dd4(%rip), %rsi      # 0x1366d
leaq 0x286c(%rip), %rcx      # 0x1310c
movq %rcx, %rdi
movq %rcx, %rdx
callq 0xc585
callq 0xc54f
callq 0xed18
leaq 0xd(%rsp), %rax
cmpq %rax, %rbx
je 0x108c7
movq %rbx, %rdi
callq 0x9040
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)