// File: /workspace/github_cpp_makefile_star2_O2/nicklausw[P]snesasm/snesasm.cpp
// Function: pass()
int pass()
{  
  for (pass_counter = 0; pass_counter < (tokens.size())/sizeof(token); pass_counter++) {
    if (tokens[pass_counter].token_type == tkDIR) {
      // directive
      if (tokens[pass_counter].token_i == "compcheck") {
        compcheck_flag = true;
      } else if (tokens[pass_counter].token_i == "autoromsize") {
        autoromsize_flag = true;
      } else if (tokens[pass_counter].token_i == "romsize") {
        directive_arg("romsize", r8); romsize = tr;
      } else if (tokens[pass_counter].token_i == "carttype") {
        directive_arg("carttype", r8); carttype = tr;
      } else if (tokens[pass_counter].token_i == "licenseecode") {
        directive_arg("licenseecode", r8); licenseecode = tr;
      } else if (tokens[pass_counter].token_i == "version") {
        directive_arg("version", r8); version = tr;
      } else if (tokens[pass_counter].token_i == "org") {
        directive_arg("org", r16); org = tr;
        
        if (banksize_defined == false || rombanks_defined == false) {
          cerr << "error: rombanks and banksize need to be defined before org\n";
          return fail;
        }
      } else if (tokens[pass_counter].token_i == "banksize") {
        directive_arg("banksize", r16); banksize = tr;
        banksize_defined = true;
        
        if (rombanks != 0) {
          // go ahead and set size of output
          rom.resize(rombanks*banksize);
        }
      } else if (tokens[pass_counter].token_i == "rombanks") {
        // not sure about rombanks limit
        directive_arg("rombanks", rNONE); rombanks = tr;
        rombanks_defined = true;
        
        if (banksize != 0) {
          // go ahead and set size of output
          rom.resize(rombanks*banksize);
        }
      } else if (tokens[pass_counter].token_i == "bank") {
       directive_arg("bank", rNONE); cur_bank = tr;
        
        // reset org
        org = base*(cur_bank+1);
        
        if (rombanks_defined == false) {
          cerr << "error: rombanks needs to be defined before .bank\n";
          return fail;
        } else if (banksize_defined == false) {
          cerr << "error: banksize needs to be defined before .bank\n";
          return fail;
        }
        
        if (cur_bank >= rombanks) {
          cerr << "error: can't go to bank higher than maximum banks\n";
          return fail;
        } else {
          org = (banksize*cur_bank)+base;
        }
      } else if (tokens[pass_counter].token_i == "name") {
        if (hint_next_token().token_type != tkQUOTE) {
          cerr << "error: name expects string value\n";
          return fail;
        }
        
        name_flag = true;
        
        string name_quote_raw = hint_next_token().token_i;
        
        for (unsigned int name_counter = 0; name_quote_raw[name_counter] != '\"'; name_counter++) {
          name.append(string(1, name_quote_raw[name_counter]));
          if (name_counter == 21) {
            cerr << "error: name can have only up to 21 characters\n";
            return fail;
          }
        }
      } else if (tokens[pass_counter].token_i == "db") {
          raw_data(r8, "db");
      } else if (tokens[pass_counter].token_i == "dw") {
          raw_data(r16, "dw");
      } else if (tokens[pass_counter].token_i == "lorom") {
        lohirom = lorom;
      } else if (tokens[pass_counter].token_i == "hirom") {
        lohirom = hirom;
      } else if (tokens[pass_counter].token_i == "slowrom") {
        sfrom = slowrom;
      } else if (tokens[pass_counter].token_i == "fastrom") {
        sfrom = fastrom;
      } else {
        cout << "error: unknown directive " << tokens[pass_counter].token_i << "\n";
        return fail;
      }
    } else if (tokens[pass_counter].token_type == tkNUM || tokens[pass_counter].token_type == tkARG) {
      cerr << "error: loose phrase " << tokens[pass_counter].token_i << "\n";
      return fail;
    } else if (tokens[pass_counter].token_type == tkOP) {
      // opcode
      int match_count = 0;
      token next_tok = hint_next_token();
      
      if (banksize_defined == false || rombanks_defined == false) {
        cerr << "error: rombanks and banksize need to be defined before opcodes\n";
        return fail;
      }
      
      
      for (unsigned int opcounter = 0; opcounter < sizeof(opcodes)/sizeof(opcode); opcounter++) {
        if (tokens[pass_counter].token_i == opcodes[opcounter].name) {
          match_count++;
        } else continue;
        
        // it's a match
        if (next_tok.token_type == tkNL || next_tok.token_type == tkUNDEF) {
          if (opcodes[opcounter].no_arg != -1) {
            write_byte(opcodes[opcounter].no_arg);
            continue;
          } else {
            cerr << "error: opcode " << opcodes[opcounter].name << " expects args\n";
            return fail;
          }
        } else if (next_tok.token_i[0] == '#') {
          // it's a literal!
          next_tok.token_i.erase(0, 1);
          if (opcodes[opcounter].lit != -1) {
            if (parse_num(next_tok.token_i) < 256) {
              // in range
              write_byte(opcodes[opcounter].lit);
              write_byte(parse_num(next_tok.token_i));
              pass_counter++; continue;
            } else {
              cerr << "error: opcode " << opcodes[opcounter].name << " takes only 8-bit literals\n";
              return fail;
            }
          } else {
            // this thing doesn't like literals!?
            cerr << "error: opcode " << opcodes[opcounter].name << " doesn't take literals\n";
            return fail;
          }
        } else if (next_tok.token_type == tkNUM || next_tok.token_type == tkOP) {
          // it's a number!
          // this could go multiple ways.
          
          // ", x"?
          if ((pass_counter+3) >= tokens.size()) {
          } else {
            if (tokens[pass_counter+2].token_type == tkCOMMA) {
              if (tokens[pass_counter+3].token_i == "x") {
                if (opcodes[opcounter].x8 != -1) {
                  // yay, x8
                  if (parse_num(tokens[pass_counter+1].token_i) < 256) {
                    write_byte(opcodes[opcounter].x8);
                    write_byte(parse_num(tokens[pass_counter+1].token_i));
                    pass_counter += 3; continue;
                  }
                } else if (opcodes[opcounter].x16 != -1) {
                  if (parse_num(tokens[pass_counter+1].token_i) < 65536) {
                    write_byte(opcodes[opcounter].x16);
                    write_byte((parse_num(tokens[pass_counter+1].token_i) & 0xFF));
                    write_byte((parse_num(tokens[pass_counter+1].token_i) >> 8));
                    pass_counter += 3; continue;
                  }
                } else if (opcodes[opcounter].x24 != -1) {
                  if (parse_num(tokens[pass_counter+1].token_i) < 0xFFFFFF+1) {
                    write_byte(opcodes[opcounter].x24);
                    write_byte((parse_num(tokens[pass_counter+1].token_i) & 0xFF));
                    write_byte(((parse_num(tokens[pass_counter+1].token_i) >> 8) & 0xFF));
                    write_byte((parse_num(tokens[pass_counter+1].token_i) >> 16));
                    pass_counter += 3; continue;
                  }
                  
                  cerr << "error: number out of range\n";
                  return fail;
                }
              } else {
                cerr << "error: xxx $XX, x only for now\n";
                return fail;
              }
            }
          }
          
          
          // is it relative?
          if (opcodes[opcounter].relative8 != -1 && org-parse_num(next_tok.token_i) < 256) {
            // it is!
            unsigned char relative_temp;
            if (next_tok.token_i[0] == '-' || ((signed)org-parse_num(next_tok.token_i)) < 0) {
              relative_temp = org-parse_num(next_tok.token_i);
            } else {
              relative_temp = 254-(org-parse_num(next_tok.token_i));
            }
            
            write_byte(opcodes[opcounter].relative8);
            write_byte(relative_temp);
            pass_counter++; continue;
          }
          
          // what about 16 bit relative?
          if (opcodes[opcounter].relative16 != -1 && org-parse_num(next_tok.token_i) < 65536) {
            // yay!
            unsigned int relative_temp;
            if (next_tok.token_i[0] == '-' || ((signed)org-parse_num(next_tok.token_i)) < 0) {
              relative_temp = org-parse_num(next_tok.token_i);
            } else {
              relative_temp = 65534-(org-parse_num(next_tok.token_i));
            }
            
            write_byte(opcodes[opcounter].relative16);
            write_byte(relative_temp & 0xFF);
            write_byte(relative_temp >> 8);
            pass_counter++; continue;
          }
          
          
          if (parse_num(next_tok.token_i) < 256) {
            // 8-bit!
            if (opcodes[opcounter].one8 != -1) {
              write_byte(opcodes[opcounter].one8);
              write_byte(parse_num(next_tok.token_i));
              pass_counter++; continue;
            } else {
              cerr << "error: opcode " << opcodes[opcounter].name << " can't take 8-bit args\n";
              return fail; 
            }
          } else if (parse_num(next_tok.token_i) < 65536) {
            // 16-bit!
            if (opcodes[opcounter].one16 != -1) {
              write_byte(opcodes[opcounter].one16);
              write_byte(parse_num(next_tok.token_i) & 0xFF);
              write_byte(parse_num(next_tok.token_i) >> 8);
              pass_counter++; continue;
            } else {
              cerr << "error: opcode " << opcodes[opcounter].name << " can't take 16-bit args\n";
              return fail; 
            }
          } else if (parse_num(next_tok.token_i) < 0xFFFFFF+1) {
            // 24-bit!
            if (opcodes[opcounter].one24 != -1) {
              write_byte(opcodes[opcounter].one24);
              write_byte(parse_num(next_tok.token_i) & 0xFF);
              write_byte((parse_num(next_tok.token_i) >> 8) & 0xFF); // crazy middle byte
              write_byte(parse_num(next_tok.token_i) >> 16);
              pass_counter++; continue;
            } else {
              cerr << "error: opcode " << opcodes[opcounter].name << " can't take 24-bit args\n";
              return fail; 
            }
          }
        }
      }
      
      if (!match_count) {
        // no matches
        cerr << "error: unknown opcode " << tokens[pass_counter].token_i << "\n";
        return fail;
      }
    } else if (tokens[pass_counter].token_type == tkLB) {
      tokens[pass_counter].token_i.pop_back();
      new_label(tokens[pass_counter].token_i, org);
    } else if (tokens[pass_counter].token_type == tkNL) {
      continue;
    } else {
      // probably a blank line
      continue;
    }
  }
  
  return success;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x538, %rsp            # imm = 0x538
leaq 0x3c4b(%rip), %r15      # 0x845a
leaq 0x3c4e(%rip), %r12      # 0x8464
leaq 0x3c4b(%rip), %r14      # 0x8468
leaq 0x3c4c(%rip), %r13      # 0x8470
leaq 0x30(%rsp), %rbx
xorl %ecx, %ecx
movq %rcx, 0x7a8e(%rip)      # 0xc2c0
movq 0x79a7(%rip), %rax      # 0xc1e0
movq 0x7998(%rip), %rsi      # 0xc1d8
subq %rsi, %rax
cqto
pushq $0x28
popq %rdi
idivq %rdi
xorl %edx, %edx
divq %rdi
cmpq %rax, %rcx
jae 0x5998
imulq $0x28, %rcx, %rax
leaq (%rsi,%rax), %rdi
movl (%rsi,%rax), %eax
cmpl 0x790a(%rip), %eax      # 0xc174
jne 0x488c
addq $0x8, %rdi
movq %r15, %rsi
callq 0x6a1f
testb %al, %al
je 0x51ff
movb $0x1, 0x7991(%rip)      # 0xc218
jmp 0x5440
cmpl 0x78de(%rip), %eax      # 0xc170
je 0x5a12
cmpl 0x78e2(%rip), %eax      # 0xc180
je 0x5a12
cmpl 0x78ce(%rip), %eax      # 0xc178
jne 0x5232
leaq 0x8(%rsp), %rdi
callq 0x6493
cmpb $0x0, 0x7998(%rip)      # 0xc259
je 0x5a55
cmpb $0x0, 0x798a(%rip)      # 0xc258
je 0x5a55
xorl %ebp, %ebp
xorl %r15d, %r15d
cmpq $0x1b80, %rbp           # imm = 0x1B80
je 0x5282
movq 0x78eb(%rip), %rax      # 0xc1d8
imulq $0x28, 0x79cb(%rip), %rcx # 0xc2c0
leaq (%rax,%rcx), %rdi
addq $0x8, %rdi
leaq 0x79cc(%rip), %rax      # 0xc2d0
leaq (%rax,%rbp), %r12
movq %r12, %rsi
callq 0x6a58
testb %al, %al
je 0x4a1f
incl %r15d
movl 0x8(%rsp), %eax
cmpl 0x785f(%rip), %eax      # 0xc184
je 0x49f1
cmpl 0x78bf(%rip), %eax      # 0xc1f0
je 0x49f1
movq 0x10(%rsp), %rcx
cmpb $0x23, (%rcx)
jne 0x4a0f
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
pushq $0x1
popq %rdx
callq 0x2030
leaq 0x7975(%rip), %rax      # 0xc2d0
cmpl $-0x1, 0x34(%rbp,%rax)
je 0x599c
leaq 0x3d8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x21d0
leaq 0x3d8(%rsp), %r14
movq %r14, %rdi
callq 0x6700
movq %rax, %rbx
movq %r14, %rdi
callq 0x22c8
cmpq $0xff, %rbx
jg 0x59c6
leaq 0x7929(%rip), %rax      # 0xc2d0
movzbl 0x34(%rbp,%rax), %edi
callq 0x65dd
leaq 0x1f8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x21d0
leaq 0x1f8(%rsp), %rdi
callq 0x6700
movzbl %al, %edi
callq 0x65dd
leaq 0x1f8(%rsp), %rdi
pushq $0x1
popq %rbx
callq 0x22c8
addq %rbx, 0x78d1(%rip)      # 0xc2c0
jmp 0x4a1f
leaq 0x78d8(%rip), %rax      # 0xc2d0
movl 0x20(%rbp,%rax), %eax
cmpl $-0x1, %eax
je 0x596e
movzbl %al, %edi
callq 0x65dd
jmp 0x4a1f
cmpl 0x775b(%rip), %eax      # 0xc170
je 0x4a28
cmpl 0x775b(%rip), %eax      # 0xc178
je 0x4a28
addq $0x50, %rbp
jmp 0x48d9
movq 0x7891(%rip), %rdi      # 0xc2c0
leaq 0x3(%rdi), %rcx
movq 0x77a6(%rip), %rax      # 0xc1e0
movq 0x7797(%rip), %rsi      # 0xc1d8
subq %rsi, %rax
cqto
pushq $0x28
popq %r8
idivq %r8
cmpq %rax, %rcx
jae 0x4d79
imulq $0x28, %rdi, %rax
movl 0x50(%rsi,%rax), %eax
cmpl 0x7724(%rip), %eax      # 0xc188
jne 0x4d79
imulq $0x28, %rcx, %rax
leaq (%rsi,%rax), %rdi
addq $0x8, %rdi
leaq 0x392d(%rip), %rsi      # 0x83aa
callq 0x6a1f
testb %al, %al
je 0x5aab
leaq 0x783f(%rip), %rax      # 0xc2d0
cmpl $-0x1, 0x38(%rbp,%rax)
je 0x4b42
movq 0x7735(%rip), %rax      # 0xc1d8
imulq $0x28, 0x7815(%rip), %rcx # 0xc2c0
leaq (%rax,%rcx), %rsi
addq $0x30, %rsi
leaq 0x3b8(%rsp), %rdi
callq 0x21d0
leaq 0x3b8(%rsp), %r14
movq %r14, %rdi
callq 0x6700
movq %rax, %rbx
movq %r14, %rdi
callq 0x22c8
cmpq $0xff, %rbx
jg 0x4d79
leaq 0x77e1(%rip), %rax      # 0xc2d0
movzbl 0x38(%rbp,%rax), %edi
callq 0x65dd
movq 0x76d8(%rip), %rax      # 0xc1d8
imulq $0x28, 0x77b8(%rip), %rcx # 0xc2c0
leaq (%rax,%rcx), %rsi
addq $0x30, %rsi
leaq 0x1d8(%rsp), %rdi
callq 0x21d0
leaq 0x1d8(%rsp), %rdi
callq 0x6700
movzbl %al, %edi
callq 0x65dd
leaq 0x1d8(%rsp), %rdi
pushq $0x3
popq %rbx
jmp 0x49e3
cmpl $-0x1, 0x3c(%rbp,%rax)
je 0x4c39
movq 0x7684(%rip), %rax      # 0xc1d8
imulq $0x28, 0x7764(%rip), %rcx # 0xc2c0
leaq (%rax,%rcx), %rsi
addq $0x30, %rsi
leaq 0x398(%rsp), %rdi
callq 0x21d0
leaq 0x398(%rsp), %r14
movq %r14, %rdi
callq 0x6700
movq %rax, %rbx
movq %r14, %rdi
callq 0x22c8
cmpq $0xffff, %rbx           # imm = 0xFFFF
jg 0x4d79
leaq 0x7730(%rip), %rax      # 0xc2d0
movzbl 0x3c(%rbp,%rax), %edi
callq 0x65dd
movq 0x7627(%rip), %rax      # 0xc1d8
imulq $0x28, 0x7707(%rip), %rcx # 0xc2c0
leaq (%rax,%rcx), %rsi
addq $0x30, %rsi
leaq 0x1b8(%rsp), %rdi
callq 0x21d0
leaq 0x1b8(%rsp), %rdi
callq 0x6700
movzbl %al, %edi
callq 0x65dd
leaq 0x1b8(%rsp), %rdi
callq 0x22c8
movq 0x75e1(%rip), %rax      # 0xc1d8
imulq $0x28, 0x76c1(%rip), %rcx # 0xc2c0
leaq (%rax,%rcx), %rsi
addq $0x30, %rsi
leaq 0x198(%rsp), %rdi
callq 0x21d0
leaq 0x198(%rsp), %rdi
callq 0x6700
movzbl %ah, %edi
callq 0x65dd
leaq 0x198(%rsp), %rdi
pushq $0x3
popq %rbx
jmp 0x49e3
cmpl $-0x1, 0x40(%rbp,%rax)
je 0x4d79
movq 0x758d(%rip), %rax      # 0xc1d8
imulq $0x28, 0x766d(%rip), %rcx # 0xc2c0
leaq (%rax,%rcx), %rsi
addq $0x30, %rsi
leaq 0x378(%rsp), %rdi
callq 0x21d0
leaq 0x378(%rsp), %r14
movq %r14, %rdi
callq 0x6700
movq %rax, %rbx
movq %r14, %rdi
callq 0x22c8
cmpq $0xffffff, %rbx         # imm = 0xFFFFFF
jg 0x5b45
leaq 0x7639(%rip), %rax      # 0xc2d0
movzbl 0x40(%rbp,%rax), %edi
callq 0x65dd
movq 0x7530(%rip), %rax      # 0xc1d8
imulq $0x28, 0x7610(%rip), %rcx # 0xc2c0
leaq (%rax,%rcx), %rsi
addq $0x30, %rsi
leaq 0x178(%rsp), %rdi
callq 0x21d0
leaq 0x178(%rsp), %rdi
callq 0x6700
movzbl %al, %edi
callq 0x65dd
leaq 0x178(%rsp), %rdi
callq 0x22c8
movq 0x74ea(%rip), %rax      # 0xc1d8
imulq $0x28, 0x75ca(%rip), %rcx # 0xc2c0
leaq (%rax,%rcx), %rsi
addq $0x30, %rsi
leaq 0x158(%rsp), %rdi
callq 0x21d0
leaq 0x158(%rsp), %rdi
callq 0x6700
movzbl %ah, %edi
callq 0x65dd
leaq 0x158(%rsp), %rdi
callq 0x22c8
movq 0x74a4(%rip), %rax      # 0xc1d8
imulq $0x28, 0x7584(%rip), %rcx # 0xc2c0
leaq (%rax,%rcx), %rsi
addq $0x30, %rsi
leaq 0x138(%rsp), %rdi
callq 0x21d0
leaq 0x138(%rsp), %rdi
callq 0x6700
shrl $0x10, %eax
movzbl %al, %edi
callq 0x65dd
leaq 0x138(%rsp), %rdi
pushq $0x3
popq %rbx
jmp 0x49e3
leaq 0x7550(%rip), %rax      # 0xc2d0
cmpl $-0x1, 0x44(%rbp,%rax)
je 0x4e3f
movq 0x7416(%rip), %rbx      # 0xc1a8
leaq 0x358(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x21d0
leaq 0x358(%rsp), %r14
movq %r14, %rdi
callq 0x6700
subq %rax, %rbx
movq %r14, %rdi
callq 0x22c8
cmpq $0xff, %rbx
ja 0x4e3f
movq 0x10(%rsp), %rax
cmpb $0x2d, (%rax)
je 0x4e0f
movslq 0x73cf(%rip), %r12      # 0xc1a8
leaq 0x338(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x21d0
leaq 0x338(%rsp), %r14
movq %r14, %rdi
callq 0x6700
movq %rax, %rbx
movq %r14, %rdi
callq 0x22c8
cmpq %rbx, %r12
jge 0x513e
movq 0x7392(%rip), %rbx      # 0xc1a8
leaq 0x318(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x21d0
leaq 0x318(%rsp), %r14
movq %r14, %rdi
callq 0x6700
subl %eax, %ebx
jmp 0x5170
leaq 0x748a(%rip), %rax      # 0xc2d0
cmpl $-0x1, 0x48(%rbp,%rax)
je 0x4f05
movq 0x7350(%rip), %rbx      # 0xc1a8
leaq 0x2d8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x21d0
leaq 0x2d8(%rsp), %r14
movq %r14, %rdi
callq 0x6700
subq %rax, %rbx
movq %r14, %rdi
callq 0x22c8
cmpq $0xffff, %rbx           # imm = 0xFFFF
ja 0x4f05
movq 0x10(%rsp), %rax
cmpb $0x2d, (%rax)
je 0x4ed5
movslq 0x7309(%rip), %r12      # 0xc1a8
leaq 0x2b8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x21d0
leaq 0x2b8(%rsp), %r14
movq %r14, %rdi
callq 0x6700
movq %rax, %rbx
movq %r14, %rdi
callq 0x22c8
cmpq %rbx, %r12
jge 0x5199
movq 0x72cc(%rip), %rbx      # 0xc1a8
leaq 0x298(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x21d0
leaq 0x298(%rsp), %r14
movq %r14, %rdi
callq 0x6700
subl %eax, %ebx
jmp 0x51ce
leaq 0x258(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x21d0
leaq 0x258(%rsp), %r14
movq %r14, %rdi
callq 0x6700
movq %rax, %rbx
movq %r14, %rdi
callq 0x22c8
cmpq $0xff, %rbx
jg 0x4f8e
leaq 0x738e(%rip), %rax      # 0xc2d0
movl 0x24(%rbp,%rax), %eax
cmpl $-0x1, %eax
je 0x5abe
movzbl %al, %edi
callq 0x65dd
leaq 0x118(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x21d0
leaq 0x118(%rsp), %rdi
callq 0x6700
movzbl %al, %edi
callq 0x65dd
leaq 0x118(%rsp), %rdi
pushq $0x1
popq %rbx
jmp 0x49e3
leaq 0x238(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x21d0
leaq 0x238(%rsp), %r14
movq %r14, %rdi
callq 0x6700
movq %rax, %rbx
movq %r14, %rdi
callq 0x22c8
cmpq $0xffff, %rbx           # imm = 0xFFFF
jg 0x504f
leaq 0x7301(%rip), %rax      # 0xc2d0
movl 0x28(%rbp,%rax), %eax
cmpl $-0x1, %eax
je 0x5aeb
movzbl %al, %edi
callq 0x65dd
leaq 0xf8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x21d0
leaq 0xf8(%rsp), %rdi
callq 0x6700
movzbl %al, %edi
callq 0x65dd
leaq 0xf8(%rsp), %rdi
callq 0x22c8
leaq 0xd8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x21d0
leaq 0xd8(%rsp), %rdi
callq 0x6700
movzbl %ah, %edi
callq 0x65dd
leaq 0xd8(%rsp), %rdi
pushq $0x1
popq %rbx
jmp 0x49e3
leaq 0x218(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x21d0
leaq 0x218(%rsp), %r14
movq %r14, %rdi
callq 0x6700
movq %rax, %rbx
movq %r14, %rdi
callq 0x22c8
cmpq $0xffffff, %rbx         # imm = 0xFFFFFF
jg 0x4a1f
leaq 0x7240(%rip), %rax      # 0xc2d0
movl 0x2c(%rbp,%rax), %eax
cmpl $-0x1, %eax
je 0x5b18
movzbl %al, %edi
callq 0x65dd
leaq 0xb8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x21d0
leaq 0xb8(%rsp), %rdi
callq 0x6700
movzbl %al, %edi
callq 0x65dd
leaq 0xb8(%rsp), %rdi
callq 0x22c8
leaq 0x98(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x21d0
leaq 0x98(%rsp), %rdi
callq 0x6700
movzbl %ah, %edi
callq 0x65dd
leaq 0x98(%rsp), %rdi
callq 0x22c8
leaq 0x78(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x21d0
leaq 0x78(%rsp), %rdi
callq 0x6700
shrl $0x10, %eax
movzbl %al, %edi
callq 0x65dd
leaq 0x78(%rsp), %rdi
pushq $0x1
popq %rbx
jmp 0x49e3
movq 0x7063(%rip), %r12      # 0xc1a8
leaq 0x2f8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x21d0
leaq 0x2f8(%rsp), %r14
movq %r14, %rdi
callq 0x6700
movq %rax, %rbx
subl %r12d, %ebx
addb $-0x2, %bl
movq %r14, %rdi
callq 0x22c8
leaq 0x7151(%rip), %rax      # 0xc2d0
movzbl 0x44(%rbp,%rax), %edi
callq 0x65dd
movzbl %bl, %edi
callq 0x65dd
pushq $0x1
popq %rbx
jmp 0x49e8
movq 0x7008(%rip), %r12      # 0xc1a8
leaq 0x278(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x21d0
leaq 0x278(%rsp), %r14
movq %r14, %rdi
callq 0x6700
movq %rax, %rbx
subl %r12d, %ebx
addl $0xfffe, %ebx           # imm = 0xFFFE
movq %r14, %rdi
callq 0x22c8
leaq 0x70f3(%rip), %rax      # 0xc2d0
movzbl 0x48(%rbp,%rax), %edi
callq 0x65dd
movzbl %bl, %edi
callq 0x65dd
movzbl %bh, %edi
callq 0x65dd
pushq $0x1
popq %rbx
jmp 0x49e8
movq 0x6fd2(%rip), %rax      # 0xc1d8
imulq $0x28, 0x70b2(%rip), %rcx # 0xc2c0
leaq (%rax,%rcx), %rdi
addq $0x8, %rdi
movq %r12, %rsi
callq 0x6a1f
testb %al, %al
je 0x52af
movb $0x1, 0x6fec(%rip)      # 0xc219
jmp 0x5440
cmpl 0x6f44(%rip), %eax      # 0xc17c
jne 0x5445
addq $0x8, %rdi
callq 0x2190
movq 0x6f8a(%rip), %rax      # 0xc1d8
imulq $0x28, 0x706a(%rip), %rcx # 0xc2c0
leaq (%rax,%rcx), %rsi
addq $0x8, %rsi
movq %rbx, %rdi
callq 0x21d0
movq 0x6f3b(%rip), %rsi      # 0xc1a8
movq %rbx, %rdi
callq 0x6843
movq %rbx, %rdi
callq 0x22c8
jmp 0x5445
testl %r15d, %r15d
je 0x5a65
leaq 0x10(%rsp), %rdi
callq 0x22c8
leaq 0x31be(%rip), %r15      # 0x845a
leaq 0x31c1(%rip), %r12      # 0x8464
leaq 0x31be(%rip), %r14      # 0x8468
jmp 0x5440
movq 0x6f22(%rip), %rax      # 0xc1d8
imulq $0x28, 0x7002(%rip), %rcx # 0xc2c0
leaq (%rax,%rcx), %rdi
addq $0x8, %rdi
movq %r14, %rsi
callq 0x6a1f
testb %al, %al
je 0x5311
leaq 0x518(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
leaq 0x8(%rsp), %rdx
callq 0x2080
movl 0x6ea0(%rip), %esi      # 0xc190
movq %rbx, %rdi
callq 0x62a7
movq %rbx, %rdi
callq 0x22c8
movb 0x6f5a(%rip), %al       # 0xc260
movb %al, 0x6f34(%rip)       # 0xc240
jmp 0x5440
movq 0x6ec0(%rip), %rax      # 0xc1d8
imulq $0x28, 0x6fa0(%rip), %rcx # 0xc2c0
leaq (%rax,%rcx), %rdi
addq $0x8, %rdi
movq %r13, %rbx
movq %r13, %rsi
callq 0x6a1f
testb %al, %al
je 0x5376
leaq 0x4f8(%rsp), %rbp
movq %rbp, %rdi
movq %rbx, %rsi
leaq 0x8(%rsp), %rdx
callq 0x2080
movl 0x6e3b(%rip), %esi      # 0xc190
movq %rbp, %rdi
callq 0x62a7
movq %rbp, %rdi
callq 0x22c8
movb 0x6ef5(%rip), %al       # 0xc260
movb %al, 0x6ed0(%rip)       # 0xc241
jmp 0x5440
movq 0x6e5b(%rip), %rax      # 0xc1d8
imulq $0x28, 0x6f3b(%rip), %rcx # 0xc2c0
leaq (%rax,%rcx), %rdi
addq $0x8, %rdi
leaq 0x30e5(%rip), %rbx      # 0x8479
movq %rbx, %rsi
callq 0x6a1f
testb %al, %al
je 0x53dc
leaq 0x4d8(%rsp), %rbp
movq %rbp, %rdi
movq %rbx, %rsi
leaq 0x8(%rsp), %rdx
callq 0x2080
movl 0x6dd2(%rip), %esi      # 0xc190
movq %rbp, %rdi
callq 0x62a7
movq %rbp, %rdi
callq 0x22c8
movb 0x6e8c(%rip), %al       # 0xc260
movb %al, 0x6e68(%rip)       # 0xc242
jmp 0x5440
movq 0x6df5(%rip), %rax      # 0xc1d8
imulq $0x28, 0x6ed5(%rip), %rcx # 0xc2c0
leaq (%rax,%rcx), %rdi
addq $0x8, %rdi
leaq 0x308c(%rip), %rbx      # 0x8486
movq %rbx, %rsi
callq 0x6a1f
testb %al, %al
je 0x5454
leaq 0x4b8(%rsp), %rbp
movq %rbp, %rdi
movq %rbx, %rsi
leaq 0x8(%rsp), %rdx
callq 0x2080
movl 0x6d6c(%rip), %esi      # 0xc190
movq %rbp, %rdi
callq 0x62a7
movq %rbp, %rdi
callq 0x22c8
movb 0x6e26(%rip), %al       # 0xc260
movb %al, 0x6e03(%rip)       # 0xc243
leaq 0x30(%rsp), %rbx
movq 0x6e74(%rip), %rcx      # 0xc2c0
incq %rcx
jmp 0x482b
movq 0x6d7d(%rip), %rax      # 0xc1d8
imulq $0x28, 0x6e5d(%rip), %rcx # 0xc2c0
leaq (%rax,%rcx), %rdi
addq $0x8, %rdi
leaq 0x301c(%rip), %rbx      # 0x848e
movq %rbx, %rsi
callq 0x6a1f
testb %al, %al
je 0x54de
leaq 0x498(%rsp), %rbp
movq %rbp, %rdi
movq %rbx, %rsi
leaq 0x8(%rsp), %rdx
callq 0x2080
movl 0x6cf8(%rip), %esi      # 0xc194
movq %rbp, %rdi
callq 0x62a7
movq %rbp, %rdi
callq 0x22c8
movq 0x6dad(%rip), %rax      # 0xc260
movq %rax, 0x6cee(%rip)      # 0xc1a8
cmpb $0x0, 0x6d98(%rip)      # 0xc259
leaq 0x30(%rsp), %rbx
je 0x5b58
cmpb $0x0, 0x6d85(%rip)      # 0xc258
jne 0x5445
jmp 0x5b58
movq 0x6cf3(%rip), %rax      # 0xc1d8
imulq $0x28, 0x6dd3(%rip), %rcx # 0xc2c0
leaq (%rax,%rcx), %rdi
addq $0x8, %rdi
leaq 0x2fd2(%rip), %rbx      # 0x84ce
movq %rbx, %rsi
callq 0x6a1f
testb %al, %al
je 0x5565
leaq 0x478(%rsp), %rbp
movq %rbp, %rdi
movq %rbx, %rsi
leaq 0x8(%rsp), %rdx
callq 0x2080
movl 0x6c6e(%rip), %esi      # 0xc194
movq %rbp, %rdi
callq 0x62a7
movq %rbp, %rdi
callq 0x22c8
movq 0x6d23(%rip), %rsi      # 0xc260
movq %rsi, 0x6d04(%rip)      # 0xc248
movb $0x1, 0x6d0e(%rip)      # 0xc259
movzbl 0x6cf4(%rip), %eax      # 0xc246
testq %rax, %rax
leaq 0x30(%rsp), %rbx
jne 0x55e9
jmp 0x5445
movq 0x6c6c(%rip), %rax      # 0xc1d8
imulq $0x28, 0x6d4c(%rip), %rcx # 0xc2c0
leaq (%rax,%rcx), %rdi
addq $0x8, %rdi
leaq 0x2f54(%rip), %rbx      # 0x84d7
movq %rbx, %rsi
callq 0x6a1f
testb %al, %al
je 0x55fe
leaq 0x458(%rsp), %rbp
movq %rbp, %rdi
movq %rbx, %rsi
leaq 0x8(%rsp), %rdx
callq 0x2080
movl 0x6c47(%rip), %esi      # 0xc1f4
movq %rbp, %rdi
callq 0x62a7
movq %rbp, %rdi
callq 0x22c8
movq 0x6c9c(%rip), %rax      # 0xc260
movb %al, 0x6c7c(%rip)       # 0xc246
movb $0x1, 0x6c87(%rip)      # 0xc258
movq 0x6c70(%rip), %rsi      # 0xc248
testq %rsi, %rsi
leaq 0x30(%rsp), %rbx
je 0x5445
movzbl %al, %eax
imulq %rax, %rsi
leaq 0x6c74(%rip), %rdi      # 0xc268
callq 0x6a2c
jmp 0x5440
movq 0x6bd3(%rip), %rax      # 0xc1d8
imulq $0x28, 0x6cb3(%rip), %rcx # 0xc2c0
leaq (%rax,%rcx), %rdi
addq $0x8, %rdi
leaq 0x2ec4(%rip), %rbx      # 0x84e0
movq %rbx, %rsi
callq 0x6a1f
testb %al, %al
je 0x56c4
leaq 0x438(%rsp), %rbp
movq %rbp, %rdi
movq %rbx, %rsi
leaq 0x8(%rsp), %rdx
callq 0x2080
movl 0x6baa(%rip), %esi      # 0xc1f4
movq %rbp, %rdi
callq 0x62a7
movq %rbp, %rdi
callq 0x22c8
movq 0x6bff(%rip), %rax      # 0xc260
movq %rax, 0x6be8(%rip)      # 0xc250
movq 0x6b31(%rip), %rcx      # 0xc1a0
leaq 0x1(%rax), %rdx
imulq %rcx, %rdx
movq %rdx, 0x6b2a(%rip)      # 0xc1a8
cmpb $0x0, 0x6bd3(%rip)      # 0xc258
je 0x5b88
cmpb $0x0, 0x6bc7(%rip)      # 0xc259
leaq 0x30(%rsp), %rbx
je 0x5b9b
movzbl 0x6ba2(%rip), %edx      # 0xc246
cmpq %rdx, %rax
jae 0x5bae
imulq 0x6b93(%rip), %rax      # 0xc248
addq %rcx, %rax
movq %rax, 0x6ae9(%rip)      # 0xc1a8
jmp 0x5445
movq 0x6b0d(%rip), %rax      # 0xc1d8
imulq $0x28, 0x6bed(%rip), %rcx # 0xc2c0
leaq (%rax,%rcx), %rdi
addq $0x8, %rdi
leaq 0x2e9a(%rip), %rsi      # 0x857c
callq 0x6a1f
testb %al, %al
je 0x5760
movq %r14, %rbp
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x6493
movl 0x8(%rsp), %eax
movl %eax, 0x54(%rsp)
movl 0x6a83(%rip), %ebx      # 0xc18c
leaq 0x10(%rsp), %rdi
callq 0x22c8
cmpl %ebx, 0x54(%rsp)
jne 0x5bc1
movb $0x1, 0x6af6(%rip)      # 0xc21a
movq %r14, %rdi
callq 0x6493
leaq 0x68(%rsp), %rcx
movq %rcx, 0x58(%rsp)
movq 0x10(%rsp), %rax
leaq 0x20(%rsp), %rdx
cmpq %rdx, %rax
movq %rbp, %r14
je 0x580f
movq %rax, 0x58(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x68(%rsp)
jmp 0x5815
movq 0x6a71(%rip), %rax      # 0xc1d8
imulq $0x28, 0x6b51(%rip), %rcx # 0xc2c0
leaq (%rax,%rcx), %rdi
addq $0x8, %rdi
leaq 0x2e54(%rip), %rbp      # 0x85d2
movq %rbp, %rsi
callq 0x6a1f
testb %al, %al
je 0x57b4
movq %rbp, %rsi
movl 0x69fd(%rip), %ebx      # 0xc190
leaq 0x418(%rsp), %rbp
movq %rbp, %rdi
leaq 0x8(%rsp), %rdx
callq 0x2080
movl %ebx, %edi
movq %rbp, %rsi
callq 0x64fe
jmp 0x580a
movq 0x6a1d(%rip), %rax      # 0xc1d8
imulq $0x28, 0x6afd(%rip), %rcx # 0xc2c0
leaq (%rax,%rcx), %rdi
addq $0x8, %rdi
leaq 0x2e03(%rip), %rbp      # 0x85d5
movq %rbp, %rsi
callq 0x6a1f
testb %al, %al
je 0x5897
movq %rbp, %rsi
movl 0x69a9(%rip), %ebx      # 0xc194
leaq 0x3f8(%rsp), %rbp
movq %rbp, %rdi
leaq 0x8(%rsp), %rdx
callq 0x2080
movl %ebx, %edi
movq %rbp, %rsi
callq 0x64fe
movq %rbp, %rdi
jmp 0x588d
movups (%rdx), %xmm0
movups %xmm0, (%rcx)
movq 0x18(%rsp), %rax
movq %rax, 0x60(%rsp)
movq %rdx, 0x10(%rsp)
andq $0x0, 0x18(%rsp)
movb $0x0, 0x20(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x22c8
xorl %ebx, %ebx
movq 0x58(%rsp), %rax
movb (%rax,%rbx), %al
cmpb $0x22, %al
je 0x5888
leaq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movsbl %al, %edx
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
pushq $0x1
popq %rsi
callq 0x2160
leaq 0x69b5(%rip), %rdi      # 0xc220
movq %rbp, %rsi
callq 0x22b0
movq %rbp, %rdi
callq 0x22c8
incq %rbx
cmpl $0x16, %ebx
jne 0x583b
jmp 0x5b6b
leaq 0x58(%rsp), %rdi
callq 0x22c8
jmp 0x5440
movq 0x693a(%rip), %rax      # 0xc1d8
imulq $0x28, 0x6a1a(%rip), %rcx # 0xc2c0
leaq (%rax,%rcx), %rdi
addq $0x8, %rdi
leaq 0x2d23(%rip), %rsi      # 0x85d8
callq 0x6a1f
testb %al, %al
je 0x58ca
movb $0x0, 0x697f(%rip)      # 0xc244
jmp 0x5440
movq 0x6907(%rip), %rax      # 0xc1d8
imulq $0x28, 0x69e7(%rip), %rcx # 0xc2c0
leaq (%rax,%rcx), %rdi
addq $0x8, %rdi
leaq 0x2cf6(%rip), %rsi      # 0x85de
callq 0x6a1f
testb %al, %al
je 0x58fd
movb $0x1, 0x694c(%rip)      # 0xc244
jmp 0x5440
movq 0x68d4(%rip), %rax      # 0xc1d8
imulq $0x28, 0x69b4(%rip), %rcx # 0xc2c0
leaq (%rax,%rcx), %rdi
addq $0x8, %rdi
leaq 0x2cc9(%rip), %rsi      # 0x85e4
callq 0x6a1f
testb %al, %al
je 0x5930
movb $0x0, 0x691a(%rip)      # 0xc245
jmp 0x5440
movq 0x68a1(%rip), %rax      # 0xc1d8
imulq $0x28, 0x6981(%rip), %rcx # 0xc2c0
leaq (%rax,%rcx), %rdi
addq $0x8, %rdi
leaq 0x2c9e(%rip), %rsi      # 0x85ec
callq 0x6a1f
testb %al, %al
je 0x5bd4
movb $0x1, 0x68e3(%rip)      # 0xc245
leaq 0x2af1(%rip), %r15      # 0x845a
jmp 0x5440
movq 0x667b(%rip), %rdi      # 0xbff0
leaq 0x2ce7(%rip), %rsi      # 0x8663
callq 0x2140
movq %rax, %rdi
movq %r12, %rsi
callq 0x2120
movq %rax, %rdi
leaq 0x2cdc(%rip), %rsi      # 0x8672
jmp 0x59ee
xorl %eax, %eax
jmp 0x5a00
movq 0x664d(%rip), %rdi      # 0xbff0
leaq 0x2cb9(%rip), %rsi      # 0x8663
callq 0x2140
movq %rax, %rdi
movq %r12, %rsi
callq 0x2120
movq %rax, %rdi
leaq 0x2cd9(%rip), %rsi      # 0x869d
jmp 0x59ee
movq 0x6623(%rip), %rdi      # 0xbff0
leaq 0x2c8f(%rip), %rsi      # 0x8663
callq 0x2140
movq %rax, %rdi
movq %r12, %rsi
callq 0x2120
movq %rax, %rdi
leaq 0x2c93(%rip), %rsi      # 0x8681
callq 0x2140
leaq 0x10(%rsp), %rdi
callq 0x22c8
pushq $0x1
popq %rax
addq $0x538, %rsp            # imm = 0x538
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x65d7(%rip), %rdi      # 0xbff0
leaq 0x2bee(%rip), %rsi      # 0x860e
callq 0x2140
movq 0x67ac(%rip), %rcx      # 0xc1d8
imulq $0x28, 0x688c(%rip), %rdx # 0xc2c0
leaq (%rcx,%rdx), %rsi
addq $0x8, %rsi
movq %rax, %rdi
callq 0x2120
leaq 0x29d7(%rip), %rsi      # 0x8422
movq %rax, %rdi
callq 0x2140
jmp 0x59fd
movq 0x6594(%rip), %rdi      # 0xbff0
leaq 0x2bc0(%rip), %rsi      # 0x8623
jmp 0x5aa1
movq 0x6584(%rip), %rdi      # 0xbff0
leaq 0x2cc8(%rip), %rsi      # 0x873b
callq 0x2140
movq 0x6759(%rip), %rcx      # 0xc1d8
imulq $0x28, 0x6839(%rip), %rdx # 0xc2c0
leaq (%rcx,%rdx), %rsi
addq $0x8, %rsi
movq %rax, %rdi
callq 0x2120
movq %rax, %rdi
leaq 0x2981(%rip), %rsi      # 0x8422
callq 0x2140
jmp 0x59f3
movq 0x653e(%rip), %rdi      # 0xbff0
leaq 0x2c18(%rip), %rsi      # 0x86d1
jmp 0x59ee
movq 0x652b(%rip), %rdi      # 0xbff0
leaq 0x2b97(%rip), %rsi      # 0x8663
callq 0x2140
movq %rax, %rdi
movq %r12, %rsi
callq 0x2120
movq %rax, %rdi
leaq 0x2c0b(%rip), %rsi      # 0x86f1
jmp 0x59ee
movq 0x64fe(%rip), %rdi      # 0xbff0
leaq 0x2b6a(%rip), %rsi      # 0x8663
callq 0x2140
movq %rax, %rdi
movq %r12, %rsi
callq 0x2120
movq %rax, %rdi
leaq 0x2bf6(%rip), %rsi      # 0x8709
jmp 0x59ee
movq 0x64d1(%rip), %rdi      # 0xbff0
leaq 0x2b3d(%rip), %rsi      # 0x8663
callq 0x2140
movq %rax, %rdi
movq %r12, %rsi
callq 0x2120
movq %rax, %rdi
leaq 0x2be2(%rip), %rsi      # 0x8722
jmp 0x59ee
leaq 0x2b69(%rip), %rsi      # 0x86b5
movq 0x649d(%rip), %rdi      # 0xbff0
jmp 0x59ee
movq 0x6491(%rip), %rdi      # 0xbff0
leaq 0x292c(%rip), %rsi      # 0x8492
jmp 0x5a4e
movq 0x647e(%rip), %rdi      # 0xbff0
leaq 0x2a2a(%rip), %rsi      # 0x85a3
callq 0x2140
leaq 0x58(%rsp), %rdi
jmp 0x59f8
movq 0x6461(%rip), %rdi      # 0xbff0
leaq 0x294f(%rip), %rsi      # 0x84e5
jmp 0x5a4e
movq 0x644e(%rip), %rdi      # 0xbff0
leaq 0x296e(%rip), %rsi      # 0x8517
jmp 0x5a4e
movq 0x643b(%rip), %rdi      # 0xbff0
leaq 0x298d(%rip), %rsi      # 0x8549
jmp 0x5a4e
movq 0x6428(%rip), %rdi      # 0xbff0
leaq 0x29b2(%rip), %rsi      # 0x8581
jmp 0x5a4e
movq 0x63f5(%rip), %rdi      # 0xbfd0
leaq 0x2a12(%rip), %rsi      # 0x85f4
jmp 0x5a20
jmp 0x5c61
movq %rax, %r14
leaq 0x418(%rsp), %rdi
jmp 0x5e9b
movq %rax, %r14
leaq 0x3f8(%rsp), %rdi
jmp 0x5e9b
jmp 0x5e2b
jmp 0x5e2b
jmp 0x5e2b
movq %rax, %r14
leaq 0x438(%rsp), %rdi
jmp 0x5e9b
movq %rax, %r14
leaq 0x458(%rsp), %rdi
jmp 0x5e9b
jmp 0x5e2b
movq %rax, %r14
leaq 0x478(%rsp), %rdi
jmp 0x5e9b
jmp 0x5e2b
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x22c8
jmp 0x5c64
movq %rax, %r14
leaq 0x58(%rsp), %rdi
jmp 0x5e9b
jmp 0x5e2b
movq %rax, %r14
leaq 0x498(%rsp), %rdi
jmp 0x5e9b
movq %rax, %r14
leaq 0x378(%rsp), %rdi
jmp 0x5e8c
movq %rax, %r14
leaq 0x4b8(%rsp), %rdi
jmp 0x5e9b
jmp 0x5e2b
movq %rax, %r14
leaq 0x138(%rsp), %rdi
jmp 0x5e8c
movq %rax, %r14
leaq 0x158(%rsp), %rdi
jmp 0x5e8c
movq %rax, %r14
leaq 0x178(%rsp), %rdi
jmp 0x5e8c
movq %rax, %r14
leaq 0x278(%rsp), %rdi
jmp 0x5e8c
movq %rax, %r14
leaq 0x4d8(%rsp), %rdi
jmp 0x5e9b
jmp 0x5e2b
movq %rax, %r14
leaq 0x198(%rsp), %rdi
jmp 0x5e8c
movq %rax, %r14
leaq 0x1b8(%rsp), %rdi
jmp 0x5e8c
movq %rax, %r14
leaq 0x398(%rsp), %rdi
jmp 0x5e8c
movq %rax, %r14
leaq 0x2f8(%rsp), %rdi
jmp 0x5e8c
jmp 0x5e93
movq %rax, %r14
leaq 0x2b8(%rsp), %rdi
jmp 0x5e8c
movq %rax, %r14
leaq 0x78(%rsp), %rdi
jmp 0x5e8c
movq %rax, %r14
leaq 0x98(%rsp), %rdi
jmp 0x5e8c
movq %rax, %r14
leaq 0xb8(%rsp), %rdi
jmp 0x5e8c
movq %rax, %r14
leaq 0x218(%rsp), %rdi
jmp 0x5e8c
movq %rax, %r14
leaq 0x4f8(%rsp), %rdi
jmp 0x5e9b
jmp 0x5e2b
movq %rax, %r14
leaq 0x338(%rsp), %rdi
jmp 0x5e8c
movq %rax, %r14
leaq 0x298(%rsp), %rdi
jmp 0x5e8c
movq %rax, %r14
leaq 0x1d8(%rsp), %rdi
jmp 0x5e8c
movq %rax, %r14
leaq 0x3b8(%rsp), %rdi
jmp 0x5e8c
movq %rax, %r14
leaq 0xd8(%rsp), %rdi
jmp 0x5e8c
movq %rax, %r14
leaq 0xf8(%rsp), %rdi
jmp 0x5e8c
movq %rax, %r14
leaq 0x318(%rsp), %rdi
jmp 0x5e8c
movq %rax, %r14
leaq 0x238(%rsp), %rdi
jmp 0x5e8c
movq %rax, %r14
leaq 0x518(%rsp), %rdi
jmp 0x5e9b
movq %rax, %r14
jmp 0x5ea0
movq %rax, %r14
leaq 0x2d8(%rsp), %rdi
jmp 0x5e8c
movq %rax, %r14
leaq 0x118(%rsp), %rdi
jmp 0x5e8c
movq %rax, %r14
leaq 0x30(%rsp), %rdi
jmp 0x5e9b
movq %rax, %r14
leaq 0x258(%rsp), %rdi
jmp 0x5e8c
movq %rax, %r14
leaq 0x358(%rsp), %rdi
jmp 0x5e8c
jmp 0x5e93
jmp 0x5e93
jmp 0x5e93
movq %rax, %r14
leaq 0x3d8(%rsp), %rdi
jmp 0x5e8c
movq %rax, %r14
leaq 0x1f8(%rsp), %rdi
callq 0x22c8
jmp 0x5e96
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x22c8
movq %r14, %rdi
callq 0x2270