// File: /workspace/github_cpp_makefile_star2_O3/adamnovak[P]rlcsa/document_graph.cpp
// Function: main
int
main(int argc, char** argv)
{
  std::cout << "Document graph extractor" << std::endl;
  if(argc < 2)
  {
    std::cout << "Usage:" << std::endl;
    std::cout << "document_graph basename block_size storing_factor" << std::endl;
    std::cout << "  to build the document graph and sparse suffix tree" << std::endl;
    std::cout << "document_graph basename prefix" << std::endl;
    std::cout << "  to compress the grammar and build the index" << std::endl;
    std::cout << "document_graph basename" << std::endl;
    std::cout << "  to test the document array" << std::endl;
    return 1;
  }
  std::cout << std::endl;

  std::string base_name = argv[1];
  std::cout << "Base name: " << base_name << std::endl;

  // Load the index.
  if(argc == 2)
  {
    std::cout << std::endl;
    return testDocarray(base_name);
  }

  // Load the index and compress
  if(argc == 3)
  {
    std::string prefix = argv[2];
    std::cout << "Prefix: " << prefix << std::endl;
    std::cout << std::endl;
    return buildIndex(base_name, prefix);
  }

  usint block_size = atoi(argv[2]);
  std::cout << "Block size: " << block_size << std::endl;
  usint storing_factor = atoi(argv[3]);
  std::cout << "Storing factor: " << storing_factor << std::endl;
  std::cout << std::endl;

  RLCSA rlcsa(argv[1]);
  if(!rlcsa.isOk() || !rlcsa.supportsLocate())
  {
    std::cerr << "Error: Locate is not supported!" << std::endl;
    return 2;
  }
  rlcsa.printInfo();
  rlcsa.reportSize(true);
  if(block_size == 0 || storing_factor == 0) { return 0; }


  double start = readTimer();

  // Get the suffix array from RLCSA.
  usint size = rlcsa.getSize();
  uint docs = rlcsa.getNumberOfSequences();
  usint* documents = new usint[size];
  #pragma omp parallel for schedule(static)
  for(usint i = 0; i < size; i += MEGABYTE)
  {
    rlcsa.locate(pair_type(i, std::min(i + MEGABYTE, size - 1)), documents + i);
  }
  double locate = readTimer();
  std::cout << "Locate: " << (locate - start) << " seconds" << std::endl;

  // Get the LCP array.
  uint* lcp = new uint[size + 1]; lcp[size] = 0;
/*  #ifdef MULTITHREAD_SUPPORT
  usint threads = omp_get_max_threads();
  PLCPVector* plcpvec = rlcsa.buildPLCP(16, threads);
  std::cout << "Total: " << plcpvec->getNumberOfItems() << " / " << plcpvec->getSize() << std::endl;
  PLCPVector::Iterator* iters[threads];
  for(usint i = 0; i < threads; i++) { iters[i] = new PLCPVector::Iterator(*plcpvec); }
  #pragma omp parallel for schedule(static, MEGABYTE)
  for(usint i = 0; i < size; i++)
  {
    lcp[i] = iters[omp_get_thread_num()]->select(documents[i]) - 2 * documents[i];
  }
  for(usint i = 0; i < threads; i++) { delete iters[i]; iters[i] = 0; }
  #else*/
  PLCPVector* plcpvec = rlcsa.buildPLCP(16);
  PLCPVector::Iterator iter(*plcpvec);
  for(usint i = 0; i < size; i++)
  {
    lcp[i] = iter.select(documents[i]) - 2 * documents[i];
  }
//  #endif
  delete plcpvec;
  double lcparray = readTimer();
  std::cout << "LCP: " << (lcparray - locate) << " seconds" << std::endl;

  // Convert SA to document array.
  #pragma omp parallel for schedule(static)
  for(usint i = 0; i < size; i += MEGABYTE)
  {
    rlcsa.getSequenceForPosition(documents + i, std::min(MEGABYTE, size - i));
  }
  // Change document array to be 1-based.
  #pragma omp parallel for schedule(static, MEGABYTE)
  for(usint i = 0; i < size; i++) { documents[i]++; }
  double find = readTimer();
  std::cout << "Documents: " << (find - lcparray) << " seconds" << std::endl;

  // Build a truncated suffix tree.
  // A node with at most block_size suffixes should not have any children.
  std::stack<STNode*> nodestack; nodestack.push(new STNode(0, pair_type(0, 0)));
  STNode* prev = 0; STNode* root = 0;
  for(usint i = 1; i <= size; i++)
  {
    usint left = i - 1;
    while(lcp[i] < nodestack.top()->string_depth)
    {
      nodestack.top()->range.second = i - 1;
      prev = nodestack.top(); nodestack.pop();
      if(length(prev->range) <= block_size) { prev->deleteChildren(); }
      root = prev;  // Last processed node.
      left = prev->range.first;
      if(lcp[i] <= nodestack.top()->string_depth) { nodestack.top()->addChild(prev); prev = 0; }
    }
    if(lcp[i] > nodestack.top()->string_depth)
    {
      STNode* curr = new STNode(lcp[i], pair_type(left, left));
      if(prev != 0) { curr->addChild(prev); prev = 0; }
      nodestack.push(curr);
    }
  }
  while(root->parent != 0) { root = root->parent; }  // Find the actual root.
  root->range.second = size - 1; root->containsAllDocuments();
  delete[] lcp; lcp = 0;
  uint st_nodes = 0, leaf_nodes = 0;
  root->addLeaves();
  root->verifyTree();
  root->determineSize(st_nodes, leaf_nodes);
  double st = readTimer();
  std::cout << "Suffix tree: " << (st - find) << " seconds" << std::endl;
  std::cout << "Total " << size << " positions, " << docs << " documents" << std::endl;
  std::cout << "Truncated suffix tree has " << st_nodes << " nodes" << std::endl;
  std::cout << std::endl;


  // Start processing.
  uint tree_leaves = 0, tree_nodes = leaf_nodes, graph_nodes = 0, edges = 0;
  std::string graph_name = base_name + ".graph";
  std::ofstream output(graph_name.c_str(), std::ios_base::binary);
  if(!output)
  {
    std::cerr << "Error: Cannot open output file " << graph_name << "!" << std::endl;
    delete[] documents;
    return 3;
  }
  std::string singleton_name = base_name + ".singletons";
  std::ofstream singletons(singleton_name.c_str(), std::ios_base::binary);
  if(!singletons)
  {
    std::cerr << "Error: Cannot open output file " << singleton_name << "!" << std::endl;
    delete[] documents;
    output.close();
    return 3;
  }
  output.write((char*)&tree_nodes, sizeof(tree_nodes)); // Placeholder for nodes/subsets.
  output.write((char*)&edges, sizeof(edges)); // Placeholder for edges.

  // For each suffix tree node, produce the corresponding subset if necessary.
  double sets = readTimer();
  while(!nodestack.empty()) { nodestack.pop(); }
  for(prev = root; prev != 0; prev = prev->child) { nodestack.push(prev); }
  while(nodestack.top() != root)
  {
    STNode* curr = nodestack.top(); nodestack.pop();
    for(STNode* temp = curr->sibling; temp != 0; temp = temp->child) { nodestack.push(temp); }
    if(curr->contains_all)
    {
      curr->id = tree_nodes; tree_nodes++;
      continue;
    }

    curr->computeStoredDocuments(documents);
    if(curr->docs->size() >= docs) { curr->containsAllDocuments(); }

    if(curr->child == 0 || curr->contains_all || curr->stored_documents > storing_factor * curr->docs->size())
    {
      curr->storeThisSet();
      int curr_node = -1 * docs;
      if(curr->child == 0) { curr->id = tree_leaves; tree_leaves++; curr_node -= tree_leaves; }
      else                 { curr->id = tree_nodes; tree_nodes++; curr_node -= tree_nodes; }
      if(!(curr->contains_all))
      {
        // Store singletons in a separate file. The presence of singletons greatly slows down the
        // search for bicliques.
        if(curr->docs->size() == 1)
        {
          singletons << (-curr_node) << ": " << curr->docs->at(0) << std::endl;
        }
        else
        {
          output.write((char*)&curr_node, sizeof(curr_node));
          for(std::vector<uint>::iterator iter = curr->docs->begin(); iter != curr->docs->end(); ++iter)
          {
            uint temp = *iter;
            output.write((char*)&temp, sizeof(temp));
          }
          graph_nodes++;
          edges += curr->docs->size();
        }
      }
    }
    else
    {
      curr->remove();
      delete curr;
    }
  }
  root->id = tree_nodes; tree_nodes++;
  double block_stop = readTimer();
  std::cout << "Blocks: " << (block_stop - sets) << " seconds" << std::endl;
  std::cout << std::endl;

  // Write the number of nodes & edges.
  output.seekp(0, std::ios::beg);
  output.write((char*)&graph_nodes, sizeof(graph_nodes));
  output.write((char*)&edges, sizeof(edges));
  std::cout << "Graph has " << graph_nodes << " nodes, " << edges << " edges" << std::endl;
  std::cout << std::endl;
  output.close();
  singletons.close();
  delete[] documents;

  // Write the tree structure.
  DocArray docarray(root, rlcsa);
  if(docarray.isOk())
  {
    std::cout << "Final tree has " << docarray.getNumberOfNodes() << " nodes, " << tree_leaves << " leaves" << std::endl;
    std::cout << std::endl;
    docarray.reportSize(true);
    docarray.writeTo(base_name);
  }

  delete root;
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe08, %rsp            # imm = 0xE08
movq %rsi, %rbx
movl %edi, %ebp
movq 0x234a7(%rip), %r14     # 0x27fd0
leaq 0x19575(%rip), %rsi     # 0x1e0a5
movl $0x18, %edx
movq %r14, %rdi
callq 0x32b0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3240
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3190
cmpl $0x1, %ebp
jg 0x4d14
leaq 0x1954a(%rip), %rsi     # 0x1e0be
movl $0x6, %edx
movq %r14, %rdi
callq 0x32b0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3240
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3190
leaq 0x19516(%rip), %rsi     # 0x1e0c5
movl $0x31, %edx
movq %r14, %rdi
callq 0x32b0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3240
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3190
leaq 0x1950d(%rip), %rsi     # 0x1e0f7
movl $0x34, %edx
movq %r14, %rdi
callq 0x32b0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3240
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3190
leaq 0x19507(%rip), %rsi     # 0x1e12c
movl $0x1e, %edx
movq %r14, %rdi
callq 0x32b0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3240
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3190
leaq 0x194eb(%rip), %rsi     # 0x1e14b
movl $0x2d, %edx
movq %r14, %rdi
callq 0x32b0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3240
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3190
leaq 0x194de(%rip), %rsi     # 0x1e179
movl $0x17, %edx
movq %r14, %rdi
callq 0x32b0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3240
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3190
leaq 0x194bb(%rip), %rsi     # 0x1e191
movl $0x1c, %edx
movq %r14, %rdi
callq 0x32b0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3240
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3190
movl $0x1, %ebx
jmp 0x517b
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3240
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3190
movq 0x8(%rbx), %rsi
leaq 0x98(%rsp), %rdi
leaq 0x5d8(%rsp), %rdx
callq 0x6390
leaq 0x19453(%rip), %rsi     # 0x1e1ae
movl $0xb, %edx
movq %r14, %rdi
callq 0x32b0
movq 0x98(%rsp), %rsi
movq 0xa0(%rsp), %rdx
movq 0x23251(%rip), %r14     # 0x27fd0
movq %r14, %rdi
callq 0x32b0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x3240
movsbl %al, %esi
movq %r15, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3190
cmpl $0x3, %ebp
je 0x4dfe
cmpl $0x2, %ebp
jne 0x4ee4
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x3240
movsbl %al, %esi
movq 0x231f3(%rip), %rdi     # 0x27fd0
callq 0x3040
movq %rax, %rdi
callq 0x3190
leaq 0x98(%rsp), %rdi
callq 0x61eb
movl %eax, %ebx
jmp 0x515a
movq 0x10(%rbx), %rsi
leaq 0x5d8(%rsp), %rdi
leaq 0x160(%rsp), %rdx
callq 0x6390
movq 0x231b2(%rip), %rdi     # 0x27fd0
leaq 0x19395(%rip), %rsi     # 0x1e1ba
movl $0x8, %edx
callq 0x32b0
movq 0x5d8(%rsp), %rsi
movq 0x5e0(%rsp), %rdx
movq 0x2318a(%rip), %rbx     # 0x27fd0
movq %rbx, %rdi
callq 0x32b0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3240
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3190
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x3240
movsbl %al, %esi
movq 0x2313a(%rip), %rdi     # 0x27fd0
callq 0x3040
movq %rax, %rdi
callq 0x3190
leaq 0x98(%rsp), %rdi
leaq 0x5d8(%rsp), %rsi
callq 0x62a3
movl %eax, %ebx
leaq 0x5e8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x515a
movq 0x5e8(%rsp), %rsi
incq %rsi
callq 0x3270
jmp 0x515a
movq 0x10(%rbx), %rdi
callq 0x33a0
movl %eax, 0x18(%rsp)
movq 0x230d8(%rip), %rdi     # 0x27fd0
leaq 0x192c4(%rip), %rsi     # 0x1e1c3
movl $0xc, %edx
callq 0x32b0
movl 0x18(%rsp), %esi
movq 0x230bc(%rip), %rdi     # 0x27fd0
callq 0x3180
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3240
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3190
movq 0x18(%rbx), %rdi
callq 0x33a0
movl %eax, %r14d
movq 0x2307a(%rip), %rdi     # 0x27fd0
leaq 0x19273(%rip), %rsi     # 0x1e1d0
movl $0x10, %edx
callq 0x32b0
movl %r14d, %r13d
movq 0x2305f(%rip), %r15     # 0x27fd0
movq %r15, %rdi
movq %r13, %rsi
callq 0x3180
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x3240
movsbl %al, %esi
movq %r12, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3190
movq (%r15), %rax
addq -0x18(%rax), %r15
movq %r15, %rdi
movl $0xa, %esi
callq 0x3240
movsbl %al, %esi
movq 0x2300c(%rip), %rdi     # 0x27fd0
callq 0x3040
movq %rax, %rdi
callq 0x3190
movq 0x8(%rbx), %rsi
leaq 0x160(%rsp), %rdi
leaq 0x3d8(%rsp), %rdx
callq 0x6390
leaq 0x5d8(%rsp), %rdi
leaq 0x160(%rsp), %rsi
xorl %edx, %edx
callq 0x6a70
leaq 0x170(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5022
movq 0x170(%rsp), %rsi
incq %rsi
callq 0x3270
cmpb $0x1, 0x5d8(%rsp)
jne 0x5102
cmpb $0x0, 0xdf0(%rsp)
je 0x5102
leaq 0x5d8(%rsp), %rdi
callq 0xa19a
leaq 0x5d8(%rsp), %rdi
movl $0x1, %esi
callq 0x9ef2
cmpl $0x0, 0x18(%rsp)
sete %al
testl %r14d, %r14d
sete %cl
xorl %ebx, %ebx
orb %al, %cl
jne 0x514d
movq %r13, 0xe8(%rsp)
callq 0x1c2cf
movsd %xmm0, 0x8(%rsp)
movl 0x5dc(%rsp), %r12d
movl 0xdf8(%rsp), %eax
movq %rax, 0x30(%rsp)
leaq (,%r12,4), %rdi
callq 0x3030
movq %rax, %r13
leal -0x1(%r12), %ebp
movl $0x100000, %r14d        # imm = 0x100000
leaq 0x5d8(%rsp), %rbx
leal -0x100000(%r14), %eax
cmpl %r12d, %eax
jae 0x518f
cmpl %r14d, %ebp
movl %r14d, %esi
cmovbl %ebp, %esi
movl %eax, %eax
leaq (,%rax,4), %rdx
addq %r13, %rdx
shlq $0x20, %rsi
orq %rax, %rsi
addl $0x100000, %r14d        # imm = 0x100000
movq %rbx, %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x8b3e
jmp 0x50bf
movq 0x22ee7(%rip), %rbx     # 0x27ff0
leaq 0x190d1(%rip), %rsi     # 0x1e1e1
movl $0x1f, %edx
movq %rbx, %rdi
callq 0x32b0
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x3240
movsbl %al, %esi
movq 0x22eb5(%rip), %rdi     # 0x27ff0
callq 0x3040
movl $0x2, %ebx
movq %rax, %rdi
callq 0x3190
leaq 0x5d8(%rsp), %rdi
callq 0x7f6e
leaq 0xa8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x517b
movq 0xa8(%rsp), %rsi
incq %rsi
callq 0x3270
movl %ebx, %eax
addq $0xe08, %rsp            # imm = 0xE08
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %ebp, 0x90(%rsp)
callq 0x1c2cf
movsd %xmm0, 0x28(%rsp)
movq 0x22e28(%rip), %rdi     # 0x27fd0
leaq 0x19052(%rip), %rsi     # 0x1e201
movl $0x8, %edx
callq 0x32b0
movsd 0x28(%rsp), %xmm0
subsd 0x8(%rsp), %xmm0
movq 0x22e04(%rip), %rdi     # 0x27fd0
callq 0x33d0
movq %rax, %rbx
leaq 0x1902f(%rip), %rsi     # 0x1e20a
movl $0x8, %edx
movq %rax, %rdi
callq 0x32b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3240
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3190
leal 0x1(%r12), %edi
shlq $0x2, %rdi
callq 0x3030
movq %rax, %r15
movl $0x0, (%rax,%r12,4)
leaq 0x5d8(%rsp), %rdi
movl $0x10, %esi
callq 0xa39c
movq %rax, %r14
leaq 0x360(%rsp), %rdi
movq %rax, %rsi
callq 0x193ac
movq %r12, 0x8(%rsp)
testl %r12d, %r12d
je 0x5286
xorl %r12d, %r12d
leaq 0x360(%rsp), %rbx
movl (%r13,%r12,4), %esi
movq %rbx, %rdi
callq 0x19698
movl (%r13,%r12,4), %ecx
addl %ecx, %ecx
subl %ecx, %eax
movl %eax, (%r15,%r12,4)
incq %r12
cmpq %r12, 0x8(%rsp)
jne 0x5262
movq %r14, %rdi
callq 0x1939a
movl $0x48, %esi
movq %r14, %rdi
callq 0x3270
callq 0x1c2cf
movsd %xmm0, 0xc0(%rsp)
movq 0x22d20(%rip), %rdi     # 0x27fd0
leaq 0x18f5c(%rip), %rsi     # 0x1e213
movl $0x5, %edx
callq 0x32b0
movsd 0xc0(%rsp), %xmm0
subsd 0x28(%rsp), %xmm0
movq 0x22cf9(%rip), %rdi     # 0x27fd0
callq 0x33d0
movq %rax, %rbx
leaq 0x18f24(%rip), %rsi     # 0x1e20a
movl $0x8, %edx
movq %rax, %rdi
callq 0x32b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3240
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3190
movq 0x8(%rsp), %r12
testl %r12d, %r12d
je 0x537c
xorl %ebp, %ebp
movl $0x100000, %r14d        # imm = 0x100000
leaq 0x5d8(%rsp), %rbx
movl %ebp, %eax
leaq (,%rax,4), %rsi
addq %r13, %rsi
cmpl %r14d, %r12d
movl $0x100000, %edx         # imm = 0x100000
cmovbl %r12d, %edx
movq %rbx, %rdi
callq 0x9b48
addl $0x100000, %ebp         # imm = 0x100000
addl $0xfff00000, %r12d      # imm = 0xFFF00000
cmpl 0x8(%rsp), %ebp
jb 0x5334
xorl %eax, %eax
movq 0x8(%rsp), %r12
incl (%r13,%rax,4)
incq %rax
cmpq %rax, %r12
jne 0x536f
callq 0x1c2cf
movsd %xmm0, 0xb8(%rsp)
movq 0x22c3f(%rip), %rdi     # 0x27fd0
leaq 0x18e81(%rip), %rsi     # 0x1e219
movl $0xb, %edx
callq 0x32b0
movsd 0xb8(%rsp), %xmm0
subsd 0xc0(%rsp), %xmm0
movq 0x22c15(%rip), %rdi     # 0x27fd0
callq 0x33d0
movq %rax, %rbx
leaq 0x18e40(%rip), %rsi     # 0x1e20a
movl $0x8, %edx
movq %rax, %rdi
callq 0x32b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3240
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3190
xorpd %xmm0, %xmm0
leaq 0x40(%rsp), %rdi
movapd %xmm0, 0x40(%rdi)
movapd %xmm0, 0x30(%rdi)
movapd %xmm0, 0x20(%rdi)
movapd %xmm0, 0x10(%rdi)
movapd %xmm0, (%rdi)
xorl %esi, %esi
callq 0x65ce
movl $0x48, %edi
callq 0x3260
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x11168
leaq 0x160(%rsp), %rsi
movq %rbx, (%rsi)
leaq 0x40(%rsp), %rdi
callq 0x6744
movq %r13, 0x28(%rsp)
movq $0x0, 0x10(%rsp)
testl %r12d, %r12d
je 0x5625
movl $0x1, %r13d
xorl %r12d, %r12d
movl %r13d, %ebx
movl %r13d, %r13d
decl %ebx
movl %ebx, %ebp
movl (%r15,%r13,4), %r14d
movq 0x70(%rsp), %rax
movq 0x78(%rsp), %rdi
cmpq %rdi, %rax
je 0x54ae
movq -0x8(%rax), %rdi
movl (%rdi), %ecx
cmpl %ecx, %r14d
jae 0x558a
addq $-0x8, %rax
movl %ebx, 0x8(%rdi)
movq %rdi, 0x10(%rsp)
jmp 0x5515
movq 0x88(%rsp), %rax
movq -0x8(%rax), %rax
movq 0x1f8(%rax), %rax
movl (%rax), %ecx
cmpl %ecx, %r14d
jae 0x558a
movl %ebx, 0x8(%rax)
movq %rax, 0x10(%rsp)
movl $0x200, %esi            # imm = 0x200
callq 0x3270
movq 0x88(%rsp), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x88(%rsp)
movq -0x8(%rax), %rax
movq %rax, 0x78(%rsp)
leaq 0x200(%rax), %rcx
movq %rcx, 0x80(%rsp)
addq $0x1f8, %rax            # imm = 0x1F8
movq 0x10(%rsp), %rdi
movq %rax, 0x70(%rsp)
movq 0x4(%rdi), %rbp
movq %rbp, %rcx
shrq $0x20, %rcx
subl %ebp, %ecx
incl %ecx
cmpl 0x18(%rsp), %ecx
jbe 0x5534
movq %rdi, %r12
jmp 0x5548
callq 0x11260
movq 0x10(%rsp), %r12
movl 0x4(%r12), %ebp
movq 0x70(%rsp), %rax
movl (%r15,%r13,4), %ecx
cmpq 0x78(%rsp), %rax
je 0x5559
movq -0x8(%rax), %rdi
jmp 0x556c
movq 0x88(%rsp), %rax
movq -0x8(%rax), %rax
movq 0x1f8(%rax), %rdi
cmpl (%rdi), %ecx
ja 0x547e
movq %r12, %rsi
callq 0x11226
movq $0x0, 0x10(%rsp)
jmp 0x547e
cmpl %ecx, %r14d
jbe 0x5615
movl $0x48, %edi
callq 0x3260
movq %rax, %rbx
movl %ebp, %eax
movq %rax, %rdx
shlq $0x20, %rdx
orq %rax, %rdx
movq %rbx, %rdi
movl %r14d, %esi
callq 0x11168
movq %rbx, 0x160(%rsp)
movq 0x10(%rsp), %rsi
testq %rsi, %rsi
je 0x55da
movq %rbx, %rdi
callq 0x11226
movq $0x0, 0x10(%rsp)
movq 0x70(%rsp), %rax
movq 0x80(%rsp), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x5603
movq 0x160(%rsp), %rcx
movq %rcx, (%rax)
addq $0x8, 0x70(%rsp)
jmp 0x5615
leaq 0x40(%rsp), %rdi
leaq 0x160(%rsp), %rsi
callq 0x69a6
incl %r13d
cmpl 0x8(%rsp), %r13d
jbe 0x5474
jmp 0x5628
xorl %r12d, %r12d
movq %r12, %r14
movq 0x10(%r12), %r12
testq %r12, %r12
jne 0x5628
movl 0x90(%rsp), %eax
movl %eax, 0x8(%r14)
movq %r14, %rdi
callq 0x11942
movq 0x28(%rsp), %r13
movq %r15, %rdi
callq 0x32f0
xorl %eax, %eax
movl %eax, 0x3c(%rsp)
movl %eax, 0x38(%rsp)
movq %r14, %rdi
callq 0x11296
movq 0x8(%rsp), %r15
movq %r14, %rdi
callq 0x1143e
leaq 0x3c(%rsp), %rsi
leaq 0x38(%rsp), %rdx
movq %r14, %rdi
callq 0x11806
callq 0x1c2cf
movsd %xmm0, 0x18(%rsp)
movq 0x22938(%rip), %rdi     # 0x27fd0
leaq 0x18b86(%rip), %rsi     # 0x1e225
movl $0xd, %edx
callq 0x32b0
movsd 0x18(%rsp), %xmm0
subsd 0xb8(%rsp), %xmm0
movq 0x22911(%rip), %rdi     # 0x27fd0
callq 0x33d0
movq %rax, %rbx
leaq 0x18b3c(%rip), %rsi     # 0x1e20a
movl $0x8, %edx
movq %rax, %rdi
callq 0x32b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3240
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3190
movq 0x228c7(%rip), %rdi     # 0x27fd0
leaq 0x18b23(%rip), %rsi     # 0x1e233
movl $0x6, %edx
callq 0x32b0
movq 0x228af(%rip), %rdi     # 0x27fd0
movq %r15, %rsi
callq 0x3180
movq %rax, %rbx
leaq 0x18b07(%rip), %rsi     # 0x1e23a
movl $0xc, %edx
movq %rax, %rdi
callq 0x32b0
movq %rbx, %rdi
movq 0x30(%rsp), %rsi
callq 0x3180
movq %rax, %rbx
leaq 0x18af0(%rip), %rsi     # 0x1e247
movl $0xa, %edx
movq %rax, %rdi
callq 0x32b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3240
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3190
movq 0x2283e(%rip), %rdi     # 0x27fd0
leaq 0x18ab9(%rip), %rsi     # 0x1e252
movl $0x1a, %edx
callq 0x32b0
movl 0x3c(%rsp), %esi
movq 0x22822(%rip), %r15     # 0x27fd0
movq %r15, %rdi
callq 0x3180
movq %rax, %rbx
leaq 0x18aad(%rip), %rsi     # 0x1e26d
movl $0x6, %edx
movq %rax, %rdi
callq 0x32b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3240
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3190
movq (%r15), %rax
addq -0x18(%rax), %r15
movq %r15, %rdi
movl $0xa, %esi
callq 0x3240
movsbl %al, %esi
movq 0x227be(%rip), %rdi     # 0x27fd0
callq 0x3040
movq %rax, %rdi
callq 0x3190
movl 0x38(%rsp), %eax
movl %eax, 0x4(%rsp)
xorl %eax, %eax
movl %eax, 0x24(%rsp)
movl %eax, 0x20(%rsp)
leaq 0xd8(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x98(%rsp), %rsi
movq 0xa0(%rsp), %rdx
addq %rsi, %rdx
leaq 0xc8(%rsp), %rdi
callq 0x64a2
leaq 0x18a0f(%rip), %rsi     # 0x1e274
leaq 0xc8(%rsp), %rdi
callq 0x34a0
movq 0xc8(%rsp), %rsi
leaq 0x160(%rsp), %rdi
movl $0x4, %edx
callq 0x32a0
movq 0x160(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x180(%rsp,%rax)
je 0x5907
movq 0x22747(%rip), %rdi     # 0x27ff0
leaq 0x189cb(%rip), %rsi     # 0x1e27b
movl $0x1f, %edx
callq 0x32b0
movq 0xc8(%rsp), %rsi
movq 0xd0(%rsp), %rdx
movq 0x2271f(%rip), %rdi     # 0x27ff0
callq 0x32b0
movq %rax, %rbx
leaq 0x18fd8(%rip), %rsi     # 0x1e8b8
movl $0x1, %edx
movq %rax, %rdi
callq 0x32b0
movq %rbx, %rdi
callq 0x3110
movq %r13, %rdi
callq 0x32f0
movl $0x3, %ebx
jmp 0x5fae
leaq 0x1898d(%rip), %rdx     # 0x1e29b
leaq 0xf0(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0x63e9
movq 0xf0(%rsp), %rsi
leaq 0x3d8(%rsp), %rdi
movl $0x4, %edx
callq 0x32a0
movq 0x3d8(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x3f8(%rsp,%rax)
je 0x59c5
movq 0x22696(%rip), %rdi     # 0x27ff0
leaq 0x1891a(%rip), %rsi     # 0x1e27b
movl $0x1f, %edx
callq 0x32b0
movq 0xf0(%rsp), %rsi
movq 0xf8(%rsp), %rdx
movq 0x2266e(%rip), %rdi     # 0x27ff0
callq 0x32b0
movq %rax, %rbx
leaq 0x18f27(%rip), %rsi     # 0x1e8b8
movl $0x1, %edx
movq %rax, %rdi
callq 0x32b0
movq %rbx, %rdi
callq 0x3110
movq %r13, %rdi
callq 0x32f0
movl $0x3, %ebx
leaq 0x160(%rsp), %rdi
callq 0x3330
jmp 0x5f80
leaq 0x160(%rsp), %rdi
leaq 0x4(%rsp), %rsi
movl $0x4, %edx
callq 0x3300
leaq 0x160(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movl $0x4, %edx
callq 0x3300
callq 0x1c2cf
movsd %xmm0, 0x8(%rsp)
movq 0x50(%rsp), %rax
movq 0x70(%rsp), %rcx
cmpq %rax, %rcx
je 0x5a69
movq 0x78(%rsp), %rdi
cmpq %rdi, %rcx
je 0x5a1d
addq $-0x8, %rcx
jmp 0x5a5f
movl $0x200, %esi            # imm = 0x200
callq 0x3270
movq 0x50(%rsp), %rax
movq 0x88(%rsp), %rcx
leaq -0x8(%rcx), %rdx
movq %rdx, 0x88(%rsp)
movq -0x8(%rcx), %rdi
movq %rdi, 0x78(%rsp)
leaq 0x200(%rdi), %rcx
movq %rcx, 0x80(%rsp)
leaq 0x1f8(%rdi), %rcx
movq %rcx, 0x70(%rsp)
cmpq %rax, %rcx
jne 0x5a12
leaq 0x10(%rsp), %rbx
movq %r14, (%rbx)
leaq 0x40(%rsp), %r15
movq %r14, %rax
movq 0x70(%rsp), %rcx
movq 0x80(%rsp), %rdx
addq $-0x8, %rdx
cmpq %rdx, %rcx
je 0x5a9a
movq %rax, (%rcx)
addq $0x8, 0x70(%rsp)
jmp 0x5aa5
movq %r15, %rdi
movq %rbx, %rsi
callq 0x69a6
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
jne 0x5a79
movq $0x0, 0x18(%rsp)
leaq 0x110(%rsp), %r15
leaq 0x40(%rsp), %r13
movq 0x70(%rsp), %rax
movq 0x78(%rsp), %rdi
cmpq %rdi, %rax
je 0x5af0
movq -0x8(%rax), %rbp
cmpq %r14, %rbp
je 0x5d3a
addq $-0x8, %rax
jmp 0x5b48
movq 0x88(%rsp), %rax
movq -0x8(%rax), %rax
movq 0x1f8(%rax), %rbp
cmpq %r14, %rbp
je 0x5d3a
movl $0x200, %esi            # imm = 0x200
callq 0x3270
movq 0x88(%rsp), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x88(%rsp)
movq -0x8(%rax), %rax
movq %rax, 0x78(%rsp)
leaq 0x200(%rax), %rcx
movq %rcx, 0x80(%rsp)
addq $0x1f8, %rax            # imm = 0x1F8
movq %rax, 0x70(%rsp)
movq 0x20(%rbp), %rax
movq %rax, 0x110(%rsp)
testq %rax, %rax
je 0x5b98
movq 0x70(%rsp), %rcx
movq 0x80(%rsp), %rdx
addq $-0x8, %rdx
cmpq %rdx, %rcx
je 0x5b7f
movq %rax, (%rcx)
addq $0x8, 0x70(%rsp)
jmp 0x5b8a
movq %r13, %rdi
movq %r15, %rsi
callq 0x69a6
movq 0x110(%rsp), %rax
movq 0x18(%rax), %rax
jmp 0x5b51
cmpb $0x0, 0x38(%rbp)
je 0x5bb0
movl 0x4(%rsp), %eax
movl %eax, 0x34(%rbp)
incl %eax
movl %eax, 0x4(%rsp)
jmp 0x5ace
movq %rbp, %rdi
movq 0x28(%rsp), %rsi
callq 0x1183e
movq 0x40(%rbp), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x2, %rcx
cmpq 0x30(%rsp), %rcx
jb 0x5bdb
movq %rbp, %rdi
callq 0x11942
cmpq $0x0, 0x18(%rbp)
je 0x5c2a
cmpb $0x0, 0x38(%rbp)
jne 0x5c2a
movq 0x40(%rbp), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
movl 0x30(%rbp), %eax
sarq $0x2, %rcx
imulq 0xe8(%rsp), %rcx
cmpq %rax, %rcx
jb 0x5c2a
movq %rbp, %rdi
callq 0x1179a
movq %rbp, %rdi
callq 0x11186
movl $0x48, %esi
movq %rbp, %rdi
callq 0x3270
jmp 0x5ace
movq %rbp, %rdi
callq 0x1199e
cmpq $0x0, 0x18(%rbp)
je 0x5c46
movl 0x4(%rsp), %esi
leal 0x1(%rsi), %eax
movl %eax, 0x4(%rsp)
jmp 0x5c54
movq 0x18(%rsp), %rax
movl %eax, %esi
incl %eax
movq %rax, 0x18(%rsp)
movl %esi, 0x34(%rbp)
notl %esi
subl 0x30(%rsp), %esi
movl %esi, 0x110(%rsp)
cmpb $0x0, 0x38(%rbp)
jne 0x5ace
movq 0x40(%rbp), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
cmpq $0x4, %rcx
jne 0x5ccd
negl %esi
leaq 0x3d8(%rsp), %rdi
callq 0x3420
movq %rax, %rbx
movl $0x2, %edx
movq %rax, %rdi
leaq 0x18576(%rip), %rsi     # 0x1e216
callq 0x32b0
movq 0x40(%rbp), %rcx
movq (%rcx), %rax
cmpq %rax, 0x8(%rcx)
je 0x601f
movl (%rax), %esi
movq %rbx, %rdi
callq 0x3180
movq %rax, %rdi
callq 0x3110
jmp 0x5ace
movl $0x4, %edx
leaq 0x160(%rsp), %rdi
movq %r15, %rsi
callq 0x3300
movq 0x40(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rbx
cmpq 0x8(%rcx), %rax
je 0x5d26
movl (%rbx), %eax
movl %eax, 0x94(%rsp)
movl $0x4, %edx
leaq 0x160(%rsp), %rdi
leaq 0x94(%rsp), %rsi
callq 0x3300
addq $0x4, %rbx
movq 0x40(%rbp), %rax
cmpq 0x8(%rax), %rbx
jne 0x5cf2
movq (%rax), %rax
subq %rax, %rbx
incl 0x24(%rsp)
shrq $0x2, %rbx
addl %ebx, 0x20(%rsp)
jmp 0x5ace
movl 0x4(%rsp), %eax
movl %eax, 0x34(%r14)
incl %eax
movl %eax, 0x4(%rsp)
callq 0x1c2cf
movsd %xmm0, 0x30(%rsp)
movq 0x22276(%rip), %rdi     # 0x27fd0
leaq 0x18546(%rip), %rsi     # 0x1e2a7
movl $0x8, %edx
callq 0x32b0
movsd 0x30(%rsp), %xmm0
subsd 0x8(%rsp), %xmm0
movq 0x22252(%rip), %rdi     # 0x27fd0
callq 0x33d0
movq %rax, %rbx
leaq 0x1847d(%rip), %rsi     # 0x1e20a
movl $0x8, %edx
movq %rax, %rdi
callq 0x32b0
movq %rbx, %rdi
callq 0x3110
movq 0x22227(%rip), %rdi     # 0x27fd0
callq 0x3110
leaq 0x160(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3250
leaq 0x160(%rsp), %rdi
leaq 0x24(%rsp), %rsi
movl $0x4, %edx
callq 0x3300
leaq 0x160(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movl $0x4, %edx
callq 0x3300
movq 0x221dc(%rip), %rdi     # 0x27fd0
leaq 0x184b5(%rip), %rsi     # 0x1e2b0
movl $0xa, %edx
callq 0x32b0
movl 0x24(%rsp), %esi
movq 0x221c0(%rip), %rdi     # 0x27fd0
callq 0x3180
movq %rax, %rbx
leaq 0x1849c(%rip), %rsi     # 0x1e2bb
movl $0x8, %edx
movq %rax, %rdi
callq 0x32b0
movl 0x20(%rsp), %esi
movq %rbx, %rdi
callq 0x3180
movq %rax, %rbx
leaq 0x18482(%rip), %rsi     # 0x1e2c4
movl $0x6, %edx
movq %rax, %rdi
callq 0x32b0
movq %rbx, %rdi
callq 0x3110
movq 0x22172(%rip), %rdi     # 0x27fd0
callq 0x3110
leaq 0x160(%rsp), %rdi
callq 0x3330
leaq 0x3d8(%rsp), %rdi
callq 0x3330
movq 0x28(%rsp), %rdi
callq 0x32f0
leaq 0x110(%rsp), %rdi
leaq 0x5d8(%rsp), %rdx
movq %r14, %rsi
callq 0x11c6c
cmpb $0x1, 0x158(%rsp)
jne 0x5f5c
movq 0x2211c(%rip), %rdi     # 0x27fd0
leaq 0x18410(%rip), %rsi     # 0x1e2cb
movl $0xf, %edx
callq 0x32b0
movq 0x118(%rsp), %rax
movq 0x120(%rsp), %rcx
movl 0x4(%rcx), %esi
addl 0x4(%rax), %esi
movq 0x220ee(%rip), %rdi     # 0x27fd0
callq 0x3180
movq %rax, %rbx
leaq 0x183ca(%rip), %rsi     # 0x1e2bb
movl $0x8, %edx
movq %rax, %rdi
callq 0x32b0
movl 0x18(%rsp), %esi
movq %rbx, %rdi
callq 0x3180
movq %rax, %rbx
leaq 0x183c7(%rip), %rsi     # 0x1e2db
movl $0x7, %edx
movq %rax, %rdi
callq 0x32b0
movq %rbx, %rdi
callq 0x3110
movq 0x220a0(%rip), %rdi     # 0x27fd0
callq 0x3110
leaq 0x110(%rsp), %rdi
movl $0x1, %esi
callq 0x142a2
leaq 0x110(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0x140c4
movq %r14, %rdi
callq 0x11186
movl $0x48, %esi
movq %r14, %rdi
callq 0x3270
leaq 0x110(%rsp), %rdi
callq 0x1264e
xorl %ebx, %ebx
leaq 0x3d8(%rsp), %rdi
callq 0x3350
leaq 0x100(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5fae
movq 0x100(%rsp), %rsi
incq %rsi
callq 0x3270
movq 0x2200b(%rip), %rax     # 0x27fc0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x168(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x160(%rsp,%rcx)
callq 0x3210
leaq 0x258(%rsp), %rdi
callq 0x30d0
movq 0xc8(%rsp), %rdi
cmpq %r12, %rdi
je 0x6003
movq 0xd8(%rsp), %rsi
incq %rsi
callq 0x3270
leaq 0x40(%rsp), %rdi
callq 0x644a
leaq 0x360(%rsp), %rdi
callq 0x193b2
jmp 0x514d
leaq 0x18317(%rip), %rdi     # 0x1e33d
xorl %esi, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x3370
jmp 0x610f
jmp 0x610f
jmp 0x610f
jmp 0x610f
jmp 0x610f
movq %rax, %r14
jmp 0x611f
jmp 0x609e
movq %rax, %r14
leaq 0x110(%rsp), %rdi
callq 0x1264e
jmp 0x6112
jmp 0x610f
jmp 0x6070
movq %rax, %r14
jmp 0x614d
jmp 0x619b
jmp 0x619b
jmp 0x619b
jmp 0x60e4
jmp 0x619b
jmp 0x60f8
jmp 0x6107
jmp 0x6107
jmp 0x6107
jmp 0x6107
jmp 0x6107
jmp 0x610f
jmp 0x610f
movq %rax, %r14
jmp 0x6140
jmp 0x610f
jmp 0x619b
jmp 0x610f
jmp 0x60f8
jmp 0x60f8
jmp 0x6107
movq %rax, %r14
leaq 0x170(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x61c2
movq 0x170(%rsp), %rsi
jmp 0x618c
jmp 0x6196
jmp 0x6196
movq %rax, %r14
movl $0x48, %esi
movq %rbx, %rdi
jmp 0x6165
jmp 0x619b
jmp 0x60f8
movq %rax, %r14
jmp 0x61a8
jmp 0x619b
jmp 0x6107
movq %rax, %r14
jmp 0x61b5
movq %rax, %r14
leaq 0x3d8(%rsp), %rdi
callq 0x3350
leaq 0x100(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6140
movq 0x100(%rsp), %rsi
incq %rsi
callq 0x3270
leaq 0x160(%rsp), %rdi
callq 0x3350
movq 0xc8(%rsp), %rdi
cmpq %r12, %rdi
je 0x619e
movq 0xd8(%rsp), %rsi
incq %rsi
callq 0x3270
jmp 0x619e
jmp 0x6196
jmp 0x6196
movq %rax, %r14
leaq 0x5e8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x61c2
movq 0x5e8(%rsp), %rsi
incq %rsi
callq 0x3270
jmp 0x61c2
movq %rax, %r14
jmp 0x61c2
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x644a
leaq 0x360(%rsp), %rdi
callq 0x193b2
leaq 0x5d8(%rsp), %rdi
callq 0x7f6e
leaq 0xa8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x61e3
movq 0xa8(%rsp), %rsi
incq %rsi
callq 0x3270
movq %r14, %rdi
callq 0x3460