// File: /workspace/github_c_makefile_star2_O1/radekh[P]palbart/palbart-2.5.c
// Function: pseudoOperators
BOOL pseudoOperators( PSEUDO_T val )
{
  int     count;
  int     delim;
  int     index;
  int     ix;
  int     lexstartsave;
  WORD16  newfield;
  WORD16  oldclc;
  int     pack;
  BOOL    status;
  SYM_T  *sym;
  FILE   *temp;
  int     term;
  WORD16  value;
  int	  leaderlen;

  status = TRUE;
  switch( (PSEUDO_T) val )
  {
  case BANK:
    errorSymbol( &no_pseudo_op, "BANK", lexstartprev );
    /* should select a different 32K out of 128K                              */
    break;

  case BINPUNCH:
    /* If there has been data output and this is a mode switch, set up to     */
    /* output data in BIN mode.                                               */
    if( binary_data_output && rim_mode )
    {
      lexstartsave = lexstartprev;
      if( isdone( line[lexstart] ))
        {
	  leaderlen = 8; /* If not specified, the short leader/trailer will be 8. */
	}
      else	
	{
	  leaderlen = (getExpr())->val;      /* BINPUN leaderlen              */
	}


      cp.loc = 00200;           /* Clear the literal tables.                  */
      cp.error = FALSE;
      pz.loc = 00200;
      pz.error = FALSE;
      punchLeader( leaderlen ); /* Generate a short leader/trailer.           */
      checksum = 0;
      binary_data_output = FALSE;
    }
    rim_mode = FALSE;
    break;

  case DECIMAL:
    radix = 10;
    break;

  case DUBL:
    inputDubl();
    break;

  case EJECT:
    page_lineno = LIST_LINES_PER_PAGE;  /* This will force a page break.      */
    status = FALSE;             /* This will force reading of next line       */
    break;

  case ENPUNCH:
    if( pass == 2 )
    {
      objectfile = objectsave;
    }
    break;

  case EXPUNGE:                 /* Erase symbol table                         */
    if( pass == 1 )
    {
      symtab[0] = sym_undefined;
      symbol_top = 0;
      number_of_fixed_symbols = symbol_top;
      fixed_symbols = &symtab[symbol_top - 1];

      /* Enter the pseudo-ops into the symbol table.                          */
      for( ix = 0; ix < DIM( pseudo ); ix++ )
      {
        defineSymbol( pseudo[ix].name, pseudo[ix].val, pseudo[ix].type, 0 );
      }
      number_of_fixed_symbols = symbol_top;
      fixed_symbols = &symtab[symbol_top - 1];
    }
    break;

  case FIELD:
    punchLiteralPool( &cp, clc - 1 );
    punchLiteralPool( &pz, 0 );
    newfield = field >> 12;
    lexstartsave = lexstartprev;
    if( isdone( line[lexstart] ))
    {
      newfield += 1;            /* Blank FIELD directive.                     */
    }
    else
    {
      newfield = (getExpr())->val;      /* FIELD with argument.               */
    }

    if( rim_mode )
    {
      errorMessage( &in_rim_mode, lexstartsave ); /* Can't change fields.     */
    }
    else if( newfield > 7 || newfield < 0 )
    {
      errorMessage( &illegal_field_value, lexstartprev );
    }
    else
    {
      value = (( newfield & 0007 ) << 3 ) | 00300;
      punchObject( value );
      checksum -= value;        /* Field punches are not added to checksum.   */
      field = newfield << 12;
    }

    clc = 0200 | field;
    fieldlc = clc & 07777;

    if( !rim_mode )
    {
      punchOrigin( clc );
    }
    break;

  case FIXMRI:
    if( line[lexterm] == '=' && isalpha( line[lexstart] ))
    {
      lexstartsave = lexstart;
      term = lexterm;
      nextLexeme();           /* Skip symbol.                                 */
      nextLexeme();           /* Skip trailing =                              */
      defineLexeme( lexstartsave, term, getExprs(), MRI );
    }
    else
    {
      errorLexeme( &symbol_syntax, lexstart );
      nextLexeme();           /* Skip symbol.                                 */
      nextLexeme();           /* Skip trailing =                              */
      (void) getExprs();      /* Skip expression.                             */
    }
    break;

  case FIXTAB:
    /* Mark all current symbols as permanent symbols.                         */
    for( ix = 0; ix < symbol_top; ix++ )
    {
      symtab[ix].type = symtab[ix].type | FIXED;
    }
    number_of_fixed_symbols = symbol_top;
    fixed_symbols = &symtab[symbol_top - 1];

    /* Re-sort the symbol table                                               */
    qsort( symtab, symbol_top, sizeof(symtab[0]), compareSymbols );
    break;

  case FLTG:
    inputFltg();
    /* errorSymbol( &no_pseudo_op, "FLTG", lexstartprev ); */
    break;

  case IFDEF:
    if( isalpha( line[lexstart] ))
    {
      sym = evalSymbol();
      nextLexeme();
      if( M_DEFINED_CONDITIONALLY( sym->type ))
      {
        conditionTrue();
      }
      else
      {
        conditionFalse();
      }
    }
    else
    {
      errorLexeme( &label_syntax, lexstart );
    }
    break;

  case IFNDEF:
    if( isalpha( line[lexstart] ))
    {
      sym = evalSymbol();
      nextLexeme();
      if( M_DEFINED_CONDITIONALLY( sym->type ))
      {
        conditionFalse();
      }
      else
      {
        conditionTrue();
      }
    }
    else
    {
      errorLexeme( &label_syntax, lexstart );
    }
    break;

  case IFNZERO:
    if( (getExpr())->val == 0 )
    {
      conditionFalse();
    }
    else
    {
      conditionTrue();
    }
    break;

  case IFZERO:
    if( (getExpr())->val == 0 )
    {
      conditionTrue();
    }
    else
    {
      conditionFalse();
    }
    break;

  case NOPUNCH:
    if( pass == 2 )
    {
      objectfile = NULL;
    }
    break;

  case OCTAL:
    radix = 8;
    break;

  case PAGE:
    punchLiteralPool( &cp, clc - 1 );
    oldclc = clc;
    if( isdone( line[lexstart] ))
    {
      clc = ( clc + 0177 ) & 077600;            /* No argumnet.               */
      fieldlc = clc & 07777;
    }
    else
    {
      value = (getExpr())->val;
      clc = ( field << 12 ) + (( value & 037 ) << 7 );
      fieldlc = clc & 07777;
    }
    testForLiteralCollision( clc );

    if( !rim_mode && clc != oldclc )
    {
      punchOrigin( clc );
    }
    break;

  case PAUSE:
    break;

  case RELOC:
    if( isdone( line[lexstart] ))
    {
       reloc = 0;               /* Blank RELOC directive.                     */
    }
    else
    {
      value = (getExpr())->val; /* RELOC with argument.                       */
      reloc = value - ( clc + reloc );
    }
    break;

  case RIMPUNCH:
    /* If the assembler has output any BIN data, output the literal tables    */
    /* and the checksum for what has been assembled and setup for RIM mode.   */
    if( binary_data_output && !rim_mode )
    {
      lexstartsave = lexstartprev;
      if( isdone( line[lexstart] ))
      {
	leaderlen = 8; /* If not specified, the short leader/trailer will be 8. */
      }
      else	
      {
	leaderlen = (getExpr())->val;      /* BINPUN leaderlen              */
      }

      endOfBinary();
      if (leaderlen != -1)
      {
	punchChecksum();
      }
      punchLeader( leaderlen );         /* Generate a short leader/trailer.           */
    }
    rim_mode = TRUE;
    break;

  case SEGMNT:
    punchLiteralPool( &cp, clc - 1 );
    if( isdone( line[lexstart] ))
    {                           /* No argument.                               */
      clc = ( clc & 06000 ) + 02000;
      fieldlc = clc & 07777;
    }
    else
    {
      getExpr();
      clc = ( val & 003 ) << 10;
      fieldlc = clc & 07777;
    }
    if( !rim_mode )
    {
      punchOrigin( clc );
    }
    testForLiteralCollision( clc );
    break;

  case TEXT:
    delim = line[lexstart];
    pack = 0;
    count = 0;
    index = lexstart + 1;
    while( line[index] != delim && !isend( line[index] ))
    {
      pack = ( pack << 6 ) | ( line[index] & 077 );
      count++;
      if( count > 1 )
      {
        punchOutObject( clc, pack );
        incrementClc();
        count = 0;
        pack = 0;
      }
      index++;
    }

    if( count != 0 )
    {
      punchOutObject( clc, pack << 6 );
      incrementClc();
    }
    else
    {
      punchOutObject( clc, 0 );
      incrementClc();
    }

    if( isend( line[index] ))
    {
      cc = index;
      lexterm = cc;
      errorMessage( &text_string, cc );
    }
    else
    {
      cc = index + 1;
      lexterm = cc;
    }
    nextLexeme();
    break;

  case TITLE:
    delim = line[lexstart];
    ix = lexstart + 1;
    /* Find string delimiter.                                                 */
    do
    {
      if( list_title[ix] == delim && list_title[ix + 1] == delim )
      {
        ix++;
      }
      ix++;
    } while( line[ix] != delim && !isend(line[ix]) );

    if( line[ix] == delim )
    {
      count = 0;
      ix = lexstart + 1;
      do
      {
        if( list_title[ix] == delim && list_title[ix + 1] == delim )
        {
          ix++;
        }
        list_title[count] = line[ix];
        count++;
        ix++;
        list_title[count] = '\0';
      } while( line[ix] != delim && !isend(line[ix]) );

      if( strlen( list_title ) > TITLELEN )
      {
        list_title[TITLELEN] = '\0';
      }

      cc = ix + 1;
      lexterm = cc;
      page_lineno = LIST_LINES_PER_PAGE;/* Force top of page for new titles.  */
      list_title_set = TRUE;
    }
    else
    {
      cc = ix;
      lexterm = cc;
      errorMessage( &text_string, cc );
    }

    nextLexeme();
    break;

  case XLIST:
    if( isdone( line[lexstart] ))
    {
      temp = listfile;          /* Blank XLIST directive.                     */
      listfile = listsave;
      listsave = temp;
    }
    else
    {
      if( (getExpr())->val == 0 )
      {
        if( listfile == NULL )
        {
          listfile = listsave;
          listsave = NULL;
        }
      }
      else
      {
        if( listfile != NULL )
        {
          listsave = listfile;
          listfile = NULL;
        }
      }
    }
    break;

  case ZBLOCK:
    value = (getExpr())->val;
    if( value < 0 )
    {
      errorMessage( &zblock_too_small, lexstartprev );
    }
    else if( value + ( clc & 07777 ) - 1 > 07777 )
    {
      errorMessage( &zblock_too_large, lexstartprev );
    }
    else
    {
      for( ; value > 0; value-- )
      {
        punchOutObject( clc, 0 );
        incrementClc();
      }
    }

    break;

  default:
    break;
  } /* end switch for pseudo-ops                                              */
  return( status );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movb $0x1, %bl
cmpl $0x19, %edi
ja 0x4aad
movl %edi, %eax
leaq 0x2f8f(%rip), %rcx      # 0x7078
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x7618(%rip), %edx      # 0xb710
leaq 0x6f81(%rip), %rdi      # 0xb080
leaq 0x3744(%rip), %rsi      # 0x784a
callq 0x3d8a
jmp 0x4aad
movslq 0x75e9(%rip), %rax      # 0xb700
leaq 0x7582(%rip), %rcx      # 0xb6a0
movzbl (%rax,%rcx), %eax
cmpq $0x3b, %rax
ja 0x4b62
movabsq $0x800800000000401, %rcx # imm = 0x800800000000401
btq %rax, %rcx
jae 0x4b62
movw $0x0, 0x732d(%rip)      # 0xb476
jmp 0x4aad
movl 0x75ab(%rip), %r13d     # 0xb700
movslq %r13d, %r15
leaq 0x7541(%rip), %rbx      # 0xb6a0
movb (%r15,%rbx), %r12b
movb 0x1(%r15,%rbx), %dl
xorl %ecx, %ecx
cmpb %r12b, %dl
jne 0x485d
incq %r15
movb $0x1, %cl
movq %r15, %r12
xorl %eax, %eax
movl %r15d, %ebp
jmp 0x49c9
callq 0x37cc
cmpw $0x0, 0x6f92(%rip)      # 0xb124
jne 0x493d
jmp 0x4627
movslq 0x755c(%rip), %rax      # 0xb700
leaq 0x74f5(%rip), %rcx      # 0xb6a0
movzbl (%rax,%rcx), %eax
cmpq $0x3b, %rax
ja 0x4b89
movabsq $0x800800000000401, %rcx # imm = 0x800800000000401
btq %rax, %rcx
jae 0x4b89
movq 0x717c(%rip), %rax      # 0xb350
movq 0x717d(%rip), %rcx      # 0xb358
movq %rcx, 0x716e(%rip)      # 0xb350
movq %rax, 0x716f(%rip)      # 0xb358
jmp 0x4aad
callq 0x55c2
jmp 0x4aad
movw $0xa, 0x7499(%rip)      # 0xb69a
jmp 0x4aad
movl $0x37, 0x7014(%rip)     # 0xb224
xorl %ebx, %ebx
jmp 0x4aad
movslq 0x74e2(%rip), %rdx      # 0xb700
leaq 0x747b(%rip), %rax      # 0xb6a0
movb (%rdx,%rax), %cl
leal 0x1(%rdx), %edi
leaq 0x750e(%rip), %rdx      # 0xb740
movl %edi, %esi
movslq %esi, %r8
cmpb %cl, (%r8,%rdx)
jne 0x424d
cmpb %cl, 0x1(%r8,%rdx)
leaq 0x1(%r8), %rsi
cmovel %esi, %r8d
movl %r8d, %esi
movslq %esi, %rsi
movzbl 0x1(%rsi,%rax), %r8d
cmpb %cl, %r8b
je 0x4272
incq %rsi
cmpl $0xa, %r8d
je 0x4269
testl %r8d, %r8d
jne 0x4234
cmpb %cl, %r8b
jne 0x4a90
leaq 0x74c8(%rip), %rsi      # 0xb741
movslq %edi, %r8
movl %edi, %ebp
cmpb %cl, (%r8,%rdx)
jne 0x4294
cmpb %cl, 0x1(%r8,%rdx)
leaq 0x1(%r8), %rdi
cmovel %edi, %r8d
movl %r8d, %ebp
movslq %ebp, %rdi
movb (%rdi,%rax), %r8b
movb %r8b, -0x1(%rsi)
movb $0x0, (%rsi)
movzbl 0x1(%rdi,%rax), %r8d
cmpb %cl, %r8b
je 0x42be
cmpl $0xa, %r8d
je 0x42be
incq %rdi
incq %rsi
testl %r8d, %r8d
jne 0x4279
leaq 0x747b(%rip), %rdi      # 0xb740
callq 0x2090
cmpq $0x40, %rax
jb 0x42d7
movb $0x0, 0x74a8(%rip)      # 0xb77f
addl $0x2, %ebp
movl %ebp, 0x7438(%rip)      # 0xb718
movl %ebp, 0x7422(%rip)      # 0xb708
movl $0x37, 0x6f34(%rip)     # 0xb224
movb $0x1, 0x73a1(%rip)      # 0xb698
jmp 0x4aa8
callq 0x2180
movq (%rax), %rax
movslq 0x73f5(%rip), %rsi      # 0xb700
leaq 0x738e(%rip), %rcx      # 0xb6a0
movsbq (%rsi,%rcx), %rcx
testb $0x4, 0x1(%rax,%rcx,2)
je 0x4408
callq 0x4042
movq %rax, %r14
callq 0x3640
movl (%r14), %eax
movl 0x6ec8(%rip), %ecx      # 0xb200
cmpl $0x1, %ecx
sete %dl
testb %dl, %al
jne 0x4627
andl $0x1, %eax
xorl $0x2, %ecx
orl %eax, %ecx
je 0x4627
jmp 0x493d
cmpb $0x0, 0x6df8(%rip)      # 0xb158
je 0x43b6
cmpb $0x0, 0x6df3(%rip)      # 0xb15c
jne 0x43b6
movslq 0x738e(%rip), %rax      # 0xb700
leaq 0x7327(%rip), %rcx      # 0xb6a0
movzbl (%rax,%rcx), %eax
cmpq $0x3b, %rax
ja 0x4c3e
movl $0x8, %ebp
movabsq $0x800800000000401, %rcx # imm = 0x800800000000401
btq %rax, %rcx
jae 0x4c3e
callq 0x3738
cmpl $-0x1, %ebp
je 0x43af
callq 0x3056
movl %ebp, %edi
callq 0x3020
movb $0x1, 0x6d9f(%rip)      # 0xb15c
jmp 0x4aad
cmpl $0x2, 0x6e37(%rip)      # 0xb200
jne 0x4aad
movq 0x6ef2(%rip), %rax      # 0xb2c8
movq %rax, 0x6ee3(%rip)      # 0xb2c0
jmp 0x4aad
callq 0x2180
movq (%rax), %rax
movslq 0x730f(%rip), %rsi      # 0xb700
leaq 0x72a8(%rip), %rcx      # 0xb6a0
movsbq (%rsi,%rcx), %rcx
testb $0x4, 0x1(%rax,%rcx,2)
jne 0x490f
leaq 0x6b71(%rip), %rdi      # 0xaf80
callq 0x3e62
jmp 0x4aad
callq 0x5143
jmp 0x4aad
cmpb $0x0, 0x6d2e(%rip)      # 0xb158
je 0x44a1
cmpb $0x0, 0x6d29(%rip)      # 0xb15c
je 0x44a1
movslq 0x72c4(%rip), %rax      # 0xb700
leaq 0x725d(%rip), %rcx      # 0xb6a0
movzbl (%rax,%rcx), %eax
cmpq $0x3b, %rax
ja 0x4c4f
movl $0x8, %edi
movabsq $0x800800000000401, %rcx # imm = 0x800800000000401
btq %rax, %rcx
jae 0x4c4f
movw $0x80, %ax
movw %ax, 0x7005(%rip)       # 0xb47a
xorl %ebp, %ebp
movb %bpl, 0x6ffa(%rip)      # 0xb478
movw %ax, 0x70f9(%rip)       # 0xb57e
movb %bpl, 0x70f0(%rip)      # 0xb57c
callq 0x3020
movw $0x0, 0x6d86(%rip)      # 0xb220
movb %bpl, 0x6cb7(%rip)      # 0xb158
movb $0x0, 0x6cb4(%rip)      # 0xb15c
jmp 0x4aad
callq 0x37cc
movzwl 0x6c6a(%rip), %r15d     # 0xb124
testw %r15w, %r15w
js 0x4947
movzwl 0x6fa5(%rip), %eax      # 0xb470
andl $0xfff, %eax            # imm = 0xFFF
addl %r15d, %eax
movzwl %ax, %eax
cmpl $0x1000, %eax           # imm = 0x1000
jbe 0x4abe
movl 0x7229(%rip), %esi      # 0xb710
leaq 0x6b72(%rip), %rdi      # 0xb060
jmp 0x4954
cmpl $0x1, 0x6d06(%rip)      # 0xb200
jne 0x4aad
movq 0x6d01(%rip), %rax      # 0xb208
movq 0x6c42(%rip), %rcx      # 0xb150
movq %rcx, 0x10(%rax)
movups 0x6c27(%rip), %xmm0     # 0xb140
movups %xmm0, (%rax)
xorl %r14d, %r14d
movl %r14d, 0x6cea(%rip)     # 0xb210
movl %r14d, 0x6ce7(%rip)     # 0xb214
addq $-0x18, %rax
movq %rax, 0x6ce0(%rip)      # 0xb218
leaq 0x5bb1(%rip), %r15      # 0xa0f0
leaq (%r14,%r15), %rdi
addq $0x4, %rdi
movswl 0x8(%rdi), %esi
movl -0x4(%rdi), %edx
xorl %ecx, %ecx
callq 0x2b83
addq $0x18, %r14
cmpq $0x270, %r14            # imm = 0x270
jne 0x453f
movslq 0x6ca7(%rip), %rax      # 0xb210
movl %eax, 0x6ca5(%rip)      # 0xb214
movq 0x6c92(%rip), %rcx      # 0xb208
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rax
addq $-0x18, %rax
movq %rax, 0x6c8f(%rip)      # 0xb218
jmp 0x4aad
movzwl 0x6edb(%rip), %eax      # 0xb470
decl %eax
movswl %ax, %esi
leaq 0x6ed7(%rip), %rdi      # 0xb478
callq 0x3a09
leaq 0x6fcf(%rip), %rdi      # 0xb57c
xorl %esi, %esi
callq 0x3a09
movl 0x7156(%rip), %ebp      # 0xb710
movslq 0x713f(%rip), %rax      # 0xb700
leaq 0x70d8(%rip), %rcx      # 0xb6a0
movzbl (%rax,%rcx), %eax
cmpq $0x3b, %rax
ja 0x4bc3
movabsq $0x800800000000401, %rcx # imm = 0x800800000000401
btq %rax, %rcx
jae 0x4bc3
movswl 0x6e80(%rip), %r14d     # 0xb472
sarl $0xc, %r14d
incl %r14d
cmpb $0x0, 0x6b5c(%rip)      # 0xb15c
je 0x495e
leaq 0x6ac3(%rip), %rdi      # 0xb0d0
movl %ebp, %esi
jmp 0x4976
callq 0x37cc
cmpw $0x0, 0x6b03(%rip)      # 0xb124
je 0x493d
callq 0x60b4
jmp 0x4aad
cmpl $0x2, 0x6bc8(%rip)      # 0xb200
jne 0x4aad
movq $0x0, 0x6c77(%rip) # 0xb2c0
jmp 0x4aad
movl 0x6bbc(%rip), %eax      # 0xb210
testl %eax, %eax
jle 0x4677
movq 0x6ba9(%rip), %rcx      # 0xb208
xorl %edx, %edx
orb $0x2, (%rcx)
incq %rdx
movslq 0x6ba2(%rip), %rax      # 0xb210
addq $0x18, %rcx
cmpq %rax, %rdx
jl 0x4661
movl %eax, 0x6b97(%rip)      # 0xb214
movq 0x6b84(%rip), %rdi      # 0xb208
movslq %eax, %rsi
leaq (%rsi,%rsi,2), %rax
leaq (%rdi,%rax,8), %rax
addq $-0x18, %rax
movq %rax, 0x6b7e(%rip)      # 0xb218
leaq 0x19e1(%rip), %rcx      # 0x6082
movl $0x18, %edx
callq 0x2070
jmp 0x4aad
movslq 0x7051(%rip), %r14      # 0xb708
leaq 0x6fe2(%rip), %r12      # 0xb6a0
cmpb $0x3d, (%r14,%r12)
jne 0x46e4
callq 0x2180
movq (%rax), %rax
movslq 0x702c(%rip), %r15      # 0xb700
movsbq (%r15,%r12), %rcx
testb $0x4, 0x1(%rax,%rcx,2)
jne 0x4b3b
movl 0x7016(%rip), %ebp      # 0xb700
leaq 0x1(%rsp), %r15
movq %r15, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x3d15
leaq 0x68ad(%rip), %rdi      # 0xafb0
movq %r15, %rsi
movl %ebp, %edx
callq 0x3d8a
callq 0x3640
callq 0x3640
callq 0x3ef0
jmp 0x4aad
movzwl 0x6d48(%rip), %eax      # 0xb470
decl %eax
movswl %ax, %esi
leaq 0x6d44(%rip), %rdi      # 0xb478
callq 0x3a09
movzwl 0x6d2f(%rip), %r14d     # 0xb470
movslq 0x6fb8(%rip), %rax      # 0xb700
leaq 0x6f51(%rip), %rcx      # 0xb6a0
movzbl (%rax,%rcx), %eax
cmpq $0x3b, %rax
ja 0x4bd5
movabsq $0x800800000000401, %rcx # imm = 0x800800000000401
btq %rax, %rcx
jae 0x4bd5
leal 0x7f(%r14), %eax
movl %eax, %ecx
andl $0x7f80, %ecx           # imm = 0x7F80
movw %cx, 0x6cec(%rip)       # 0xb470
andl $0xf80, %eax            # imm = 0xF80
movw %ax, 0x6ce4(%rip)       # 0xb474
movswl %cx, %edi
callq 0x5ce4
cmpb $0x0, 0x69bd(%rip)      # 0xb15c
jne 0x4aad
movzwl 0x6cc4(%rip), %eax      # 0xb470
cmpw %r14w, %ax
je 0x4aad
movswl %ax, %edi
jmp 0x49ad
movw $0x8, 0x6ed3(%rip)      # 0xb69a
jmp 0x4aad
movzwl 0x6c9d(%rip), %eax      # 0xb470
decl %eax
movswl %ax, %esi
leaq 0x6c99(%rip), %rdi      # 0xb478
callq 0x3a09
movslq 0x6f15(%rip), %rax      # 0xb700
leaq 0x6eae(%rip), %rcx      # 0xb6a0
movzbl (%rax,%rcx), %eax
cmpq $0x3b, %rax
ja 0x4bfc
movabsq $0x800800000000401, %rcx # imm = 0x800800000000401
btq %rax, %rcx
jae 0x4bfc
movzwl 0x6c55(%rip), %eax      # 0xb470
movl $0xc00, %ecx            # imm = 0xC00
andl %ecx, %eax
addl $0x400, %eax            # imm = 0x400
movw %ax, 0x6c42(%rip)       # 0xb470
andl %ecx, %eax
movw %ax, 0x6c3d(%rip)       # 0xb474
cmpb $0x0, 0x691e(%rip)      # 0xb15c
jne 0x484c
movswl 0x6c29(%rip), %edi      # 0xb470
callq 0x3abf
movswl 0x6c1d(%rip), %edi      # 0xb470
callq 0x5ce4
jmp 0x4aad
xorl %eax, %eax
testb %dl, %dl
je 0x49b7
movzbl %dl, %esi
cmpl $0xa, %esi
je 0x49b7
movl %eax, %esi
shll $0x6, %esi
andb $0x3f, %dl
movzbl %dl, %eax
orl %esi, %eax
testl %ecx, %ecx
jne 0x488b
movl $0x1, %ecx
jmp 0x48f3
movswl 0x6bde(%rip), %ebp      # 0xb470
movzwl 0x6bd9(%rip), %ecx      # 0xb472
orw %bp, %cx
movswl %ax, %r14d
movswl %cx, %esi
movq %rbx, %rdi
movl %r14d, %edx
movl $0x2, %ecx
callq 0x3adb
movl %ebp, %edi
movl %r14d, %esi
callq 0x5fad
movswl 0x6bac(%rip), %edi      # 0xb470
callq 0x5ce4
movzwl 0x6ba0(%rip), %eax      # 0xb470
movl %eax, %ecx
andl $0x7000, %ecx           # imm = 0x7000
incl %eax
andl $0xfff, %eax            # imm = 0xFFF
movw %ax, 0x6b8e(%rip)       # 0xb474
orl %ecx, %eax
movw %ax, 0x6b81(%rip)       # 0xb470
xorl %eax, %eax
xorl %ecx, %ecx
movb 0x2(%r15,%rbx), %dl
incq %r15
cmpb %r12b, %dl
jne 0x485f
movq %r15, %r12
incq %r12
jmp 0x49bb
callq 0x4042
movq %rax, %r14
callq 0x3640
movl (%r14), %eax
movl 0x68db(%rip), %ecx      # 0xb200
cmpl $0x1, %ecx
sete %dl
testb %dl, %al
jne 0x493d
andl $0x1, %eax
xorl $0x2, %ecx
orl %eax, %ecx
jne 0x4627
callq 0x608f
jmp 0x4aad
movl 0x6dc3(%rip), %esi      # 0xb710
leaq 0x66fc(%rip), %rdi      # 0xb050
callq 0x5084
jmp 0x4aad
cmpw $0x8, %r14w
jb 0x4c13
movl 0x6da1(%rip), %esi      # 0xb710
leaq 0x671a(%rip), %rdi      # 0xb090
callq 0x5084
movzwl 0x6af0(%rip), %eax      # 0xb472
orl $0x80, %eax
movw %ax, 0x6ae2(%rip)       # 0xb470
movl %eax, %ecx
andl $0xfff, %ecx            # imm = 0xFFF
movw %cx, 0x6ad7(%rip)       # 0xb474
cmpb $0x0, 0x67b8(%rip)      # 0xb15c
jne 0x4aad
movswl %ax, %edi
callq 0x3abf
jmp 0x4aad
leaq 0x1(%r15), %r12
movl %r12d, %ebp
testl %ecx, %ecx
sete %cl
shll $0x6, %eax
movl %r15d, %r13d
movzwl 0x6a9f(%rip), %r15d     # 0xb470
testb %cl, %cl
je 0x49e7
movswl %r15w, %edi
xorl %esi, %esi
callq 0x4c87
callq 0x4cbd
jmp 0x4a4b
movzwl 0x6a84(%rip), %ecx      # 0xb472
orw %r15w, %cx
movswl %ax, %r14d
movswl %cx, %esi
leaq 0x6ca0(%rip), %rdi      # 0xb6a0
movl %r14d, %edx
movl $0x2, %ecx
callq 0x3adb
movswl %r15w, %edi
movl %r14d, %esi
callq 0x5fad
movswl 0x6a50(%rip), %edi      # 0xb470
callq 0x5ce4
movzwl 0x6a44(%rip), %eax      # 0xb470
movl %eax, %ecx
andl $0x7000, %ecx           # imm = 0x7000
incl %eax
andl $0xfff, %eax            # imm = 0xFFF
movw %ax, 0x6a32(%rip)       # 0xb474
orl %ecx, %eax
movw %ax, 0x6a25(%rip)       # 0xb470
movzbl (%r12,%rbx), %eax
cmpl $0xa, %eax
je 0x4a59
testl %eax, %eax
jne 0x4a75
movl %ebp, 0x6cb9(%rip)      # 0xb718
movl %ebp, 0x6ca3(%rip)      # 0xb708
leaq 0x6654(%rip), %rdi      # 0xb0c0
movl %ebp, %esi
callq 0x5084
jmp 0x4a87
addl $0x2, %r13d
movl %r13d, 0x6c98(%rip)     # 0xb718
movl %r13d, 0x6c81(%rip)     # 0xb708
callq 0x3640
movb $0x1, %bl
jmp 0x4aad
movl %esi, 0x6c82(%rip)      # 0xb718
movl %esi, 0x6c6c(%rip)      # 0xb708
leaq 0x661d(%rip), %rdi      # 0xb0c0
callq 0x5084
callq 0x3640
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testw %r15w, %r15w
je 0x4aad
incl %r15d
leaq 0x6bd2(%rip), %r14      # 0xb6a0
movswl 0x699b(%rip), %ebp      # 0xb470
movzwl 0x6996(%rip), %eax      # 0xb472
orw %bp, %ax
movswl %ax, %esi
movq %r14, %rdi
xorl %edx, %edx
movl $0x2, %ecx
callq 0x3adb
movl %ebp, %edi
xorl %esi, %esi
callq 0x5fad
movswl 0x696f(%rip), %edi      # 0xb470
callq 0x5ce4
movzwl 0x6963(%rip), %eax      # 0xb470
movl %eax, %ecx
andl $0x7000, %ecx           # imm = 0x7000
incl %eax
andl $0xfff, %eax            # imm = 0xFFF
movw %ax, 0x6951(%rip)       # 0xb474
orl %ecx, %eax
movw %ax, 0x6944(%rip)       # 0xb470
decl %r15d
cmpw $0x1, %r15w
jg 0x4ace
jmp 0x4aad
callq 0x3640
callq 0x3640
callq 0x3ef0
movswl %ax, %edx
movl %r15d, %edi
movl %r14d, %esi
movl $0x5, %ecx
callq 0x3e27
jmp 0x4aad
callq 0x37cc
movl 0x65b7(%rip), %eax      # 0xb124
movzwl 0x68fc(%rip), %ecx      # 0xb470
addw 0x68fb(%rip), %cx       # 0xb476
subl %ecx, %eax
movw %ax, 0x68f2(%rip)       # 0xb476
jmp 0x4aad
callq 0x37cc
cmpw $0x0, 0x658e(%rip)      # 0xb124
movq 0x67b3(%rip), %rax      # 0xb350
je 0x4c60
testq %rax, %rax
je 0x4aad
movq %rax, 0x67a5(%rip)      # 0xb358
movq $0x0, 0x6792(%rip) # 0xb350
jmp 0x4aad
callq 0x37cc
movzwl 0x6554(%rip), %r14d     # 0xb124
jmp 0x45f9
callq 0x37cc
movl 0x6544(%rip), %eax      # 0xb124
movzwl 0x688b(%rip), %edx      # 0xb472
shll $0xc, %edx
shll $0x7, %eax
movl %eax, %ecx
andl $0xf80, %ecx            # imm = 0xF80
orl %edx, %ecx
jmp 0x477d
callq 0x37cc
movw $0x400, 0x6866(%rip)    # imm = 0x400
movw $0x400, %ax             # imm = 0x400
jmp 0x4830
movl %r14d, %eax
orl $0x18, %eax
shll $0x3, %eax
movzwl %ax, %ebp
movl %ebp, %edi
callq 0x5ff2
subw %bp, 0x65f3(%rip)       # 0xb220
shll $0xc, %r14d
movw %r14w, 0x6839(%rip)     # 0xb472
jmp 0x497b
callq 0x37cc
movswl 0x64da(%rip), %ebp      # 0xb124
jmp 0x43a0
callq 0x37cc
movswl 0x64c9(%rip), %edi      # 0xb124
jmp 0x446a
testq %rax, %rax
jne 0x4aad
movq 0x66e8(%rip), %rax      # 0xb358
movq %rax, 0x66d9(%rip)      # 0xb350
movq $0x0, 0x66d6(%rip) # 0xb358
jmp 0x4aad