// File: /workspace/github_cpp_makefile_star2_O1/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 0x517e
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 0xc0(%rsp), %rdi
leaq 0x5d8(%rsp), %rdx
callq 0x646a
leaq 0x19453(%rip), %rsi     # 0x1e1ae
movl $0xb, %edx
movq %r14, %rdi
callq 0x32b0
movq 0xc0(%rsp), %rsi
movq 0xc8(%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 0xc0(%rsp), %rdi
callq 0x62c4
movl %eax, %ebx
jmp 0x515d
movq 0x10(%rbx), %rsi
leaq 0x5d8(%rsp), %rdi
leaq 0x160(%rsp), %rdx
callq 0x646a
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 0xc0(%rsp), %rdi
leaq 0x5d8(%rsp), %rsi
callq 0x637c
movl %eax, %ebx
leaq 0x5e8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x515d
movq 0x5e8(%rsp), %rsi
incq %rsi
callq 0x3270
jmp 0x515d
movq 0x10(%rbx), %rdi
callq 0x33a0
movl %eax, 0x10(%rsp)
movq 0x230d8(%rip), %rdi     # 0x27fd0
leaq 0x192c4(%rip), %rsi     # 0x1e1c3
movl $0xc, %edx
callq 0x32b0
movl 0x10(%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 0x646a
leaq 0x5d8(%rsp), %rdi
leaq 0x160(%rsp), %rsi
xorl %edx, %edx
callq 0x6b30
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 0x5105
cmpb $0x0, 0xdf0(%rsp)
je 0x5105
leaq 0x5d8(%rsp), %rdi
callq 0xa0a8
leaq 0x5d8(%rsp), %rdi
movl $0x1, %esi
callq 0x9e00
cmpl $0x0, 0x10(%rsp)
sete %al
testl %r14d, %r14d
sete %cl
xorl %ebx, %ebx
orb %al, %cl
jne 0x5150
movq %r13, 0xe8(%rsp)
callq 0x1bdcb
movsd %xmm0, 0x8(%rsp)
movl 0x5dc(%rsp), %r12d
movl 0xdf8(%rsp), %eax
movq %rax, 0x90(%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 0x5192
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 0x8a9c
jmp 0x50c2
movq 0x22ee4(%rip), %rbx     # 0x27ff0
leaq 0x190ce(%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 0x22eb2(%rip), %rdi     # 0x27ff0
callq 0x3040
movl $0x2, %ebx
movq %rax, %rdi
callq 0x3190
leaq 0x5d8(%rsp), %rdi
callq 0x8018
leaq 0xd0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x517e
movq 0xd0(%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, 0x98(%rsp)
callq 0x1bdcb
movsd %xmm0, 0x28(%rsp)
movq 0x22e25(%rip), %rdi     # 0x27fd0
leaq 0x1904f(%rip), %rsi     # 0x1e201
movl $0x8, %edx
callq 0x32b0
movsd 0x28(%rsp), %xmm0
subsd 0x8(%rsp), %xmm0
movq 0x22e01(%rip), %rdi     # 0x27fd0
callq 0x33d0
movq %rax, %rbx
leaq 0x1902c(%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 0xa2aa
movq %rax, %r14
leaq 0x360(%rsp), %rdi
movq %rax, %rsi
callq 0x19094
movq %r12, 0x8(%rsp)
testl %r12d, %r12d
je 0x5289
xorl %r12d, %r12d
leaq 0x360(%rsp), %rbx
movl (%r13,%r12,4), %esi
movq %rbx, %rdi
callq 0x1938a
movl (%r13,%r12,4), %ecx
addl %ecx, %ecx
subl %ecx, %eax
movl %eax, (%r15,%r12,4)
incq %r12
cmpq %r12, 0x8(%rsp)
jne 0x5265
movq %r14, %rdi
callq 0x19082
movl $0x48, %esi
movq %r14, %rdi
callq 0x3270
callq 0x1bdcb
movsd %xmm0, 0x38(%rsp)
movq 0x22d20(%rip), %rdi     # 0x27fd0
leaq 0x18f5c(%rip), %rsi     # 0x1e213
movl $0x5, %edx
callq 0x32b0
movsd 0x38(%rsp), %xmm0
subsd 0x28(%rsp), %xmm0
movq 0x22cfc(%rip), %rdi     # 0x27fd0
callq 0x33d0
movq %rax, %rbx
leaq 0x18f27(%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 0x5379
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 0x9a5c
addl $0x100000, %ebp         # imm = 0x100000
addl $0xfff00000, %r12d      # imm = 0xFFF00000
cmpl 0x8(%rsp), %ebp
jb 0x5331
xorl %eax, %eax
movq 0x8(%rsp), %r12
incl (%r13,%rax,4)
incq %rax
cmpq %rax, %r12
jne 0x536c
callq 0x1bdcb
movsd %xmm0, 0xe0(%rsp)
movq 0x22c42(%rip), %rdi     # 0x27fd0
leaq 0x18e84(%rip), %rsi     # 0x1e219
movl $0xb, %edx
callq 0x32b0
movsd 0xe0(%rsp), %xmm0
subsd 0x38(%rsp), %xmm0
movq 0x22c1b(%rip), %rdi     # 0x27fd0
callq 0x33d0
movq %rax, %rbx
leaq 0x18e46(%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 0x6694
movl $0x48, %edi
callq 0x3260
movq %rax, %r14
movb $0x1, %bl
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x10ebc
leaq 0x160(%rsp), %rsi
movq %r14, (%rsi)
xorl %ebx, %ebx
leaq 0x40(%rsp), %rdi
callq 0x680a
movq %r13, 0x28(%rsp)
movq $0x0, 0x18(%rsp)
testl %r12d, %r12d
je 0x568d
movl $0x1, %r13d
xorl %r12d, %r12d
movl %r13d, %ebp
movl %r13d, %r13d
decl %ebp
movl %ebp, %ebx
movq 0x70(%rsp), %rax
movq 0x78(%rsp), %rdi
movq %rax, %rcx
cmpq %rdi, %rax
jne 0x54a2
movq 0x88(%rsp), %rcx
movq -0x8(%rcx), %rcx
movl $0x200, %edx            # imm = 0x200
addq %rdx, %rcx
movl (%r15,%r13,4), %r14d
movq -0x8(%rcx), %rcx
cmpl (%rcx), %r14d
jae 0x55d5
cmpq %rdi, %rax
je 0x54c4
movq -0x8(%rax), %rcx
movl %ebp, 0x8(%rcx)
movq %rax, %rcx
jmp 0x54ee
movq 0x88(%rsp), %rcx
movq -0x8(%rcx), %rcx
movq 0x1f8(%rcx), %rcx
movl %ebp, 0x8(%rcx)
movq 0x88(%rsp), %rcx
movq -0x8(%rcx), %rcx
movl $0x200, %edx            # imm = 0x200
addq %rdx, %rcx
movq -0x8(%rcx), %rcx
movq %rcx, 0x18(%rsp)
cmpq %rdi, %rax
je 0x5502
addq $-0x8, %rax
jmp 0x553e
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 0x18(%rsp), %rdi
movq 0x4(%rdi), %rax
movq %rax, %rcx
shrq $0x20, %rcx
subl %eax, %ecx
incl %ecx
cmpl 0x10(%rsp), %ecx
ja 0x5562
callq 0x10fa6
movq 0x70(%rsp), %rax
movq 0x78(%rsp), %rcx
movq %rax, %rdx
cmpq %rcx, %rax
jne 0x5588
movq 0x88(%rsp), %rdx
movq -0x8(%rdx), %rdx
movl $0x200, %esi            # imm = 0x200
addq %rsi, %rdx
movq 0x18(%rsp), %r12
movl 0x4(%r12), %ebx
movl (%r15,%r13,4), %esi
movq -0x8(%rdx), %rdx
cmpl (%rdx), %esi
ja 0x547c
cmpq %rcx, %rax
jne 0x55bb
movq 0x88(%rsp), %rax
movq -0x8(%rax), %rax
movl $0x200, %ecx            # imm = 0x200
addq %rcx, %rax
movq -0x8(%rax), %rdi
movq %r12, %rsi
callq 0x10f7a
movq $0x0, 0x18(%rsp)
jmp 0x547c
cmpq %rdi, %rax
jne 0x55ee
movq 0x88(%rsp), %rax
movq -0x8(%rax), %rax
movl $0x200, %ecx            # imm = 0x200
addq %rcx, %rax
movq -0x8(%rax), %rax
cmpl (%rax), %r14d
jbe 0x567d
movl $0x48, %edi
callq 0x3260
movq %rax, %rbp
movl %ebx, %eax
movq %rax, %rdx
shlq $0x20, %rdx
orq %rax, %rdx
movq %rbp, %rdi
movl %r14d, %esi
callq 0x10ebc
movq %rbp, 0x160(%rsp)
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x5642
movq %rbp, %rdi
callq 0x10f7a
movq $0x0, 0x18(%rsp)
movq 0x70(%rsp), %rax
movq 0x80(%rsp), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x566b
movq 0x160(%rsp), %rcx
movq %rcx, (%rax)
addq $0x8, 0x70(%rsp)
jmp 0x567d
leaq 0x40(%rsp), %rdi
leaq 0x160(%rsp), %rsi
callq 0x6a66
incl %r13d
cmpl 0x8(%rsp), %r13d
jbe 0x5472
jmp 0x5690
xorl %r12d, %r12d
movq %r12, %r14
movq 0x10(%r12), %r12
testq %r12, %r12
jne 0x5690
movl 0x98(%rsp), %eax
movl %eax, 0x8(%r14)
movq %r14, %rdi
callq 0x1168e
movq 0x28(%rsp), %r12
movq %r15, %rdi
callq 0x32f0
xorl %eax, %eax
movl %eax, 0x34(%rsp)
movl %eax, 0x30(%rsp)
movq %r14, %rdi
callq 0x10fdc
movq %r14, %rdi
callq 0x11184
leaq 0x34(%rsp), %rsi
leaq 0x30(%rsp), %rdx
movq %r14, %rdi
callq 0x11554
callq 0x1bdcb
movsd %xmm0, 0x10(%rsp)
movq 0x228d5(%rip), %rdi     # 0x27fd0
leaq 0x18b23(%rip), %rsi     # 0x1e225
movl $0xd, %edx
callq 0x32b0
movsd 0x10(%rsp), %xmm0
subsd 0xe0(%rsp), %xmm0
movq 0x228ae(%rip), %rdi     # 0x27fd0
callq 0x33d0
movq %rax, %rbx
leaq 0x18ad9(%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 0x22864(%rip), %rdi     # 0x27fd0
leaq 0x18ac0(%rip), %rsi     # 0x1e233
movl $0x6, %edx
callq 0x32b0
movq 0x2284c(%rip), %rdi     # 0x27fd0
movq 0x8(%rsp), %rsi
callq 0x3180
movq %rax, %rbx
leaq 0x18aa2(%rip), %rsi     # 0x1e23a
movl $0xc, %edx
movq %rax, %rdi
callq 0x32b0
movq %rbx, %rdi
movq 0x90(%rsp), %rsi
callq 0x3180
movq %rax, %rbx
leaq 0x18a88(%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 0x227d6(%rip), %rdi     # 0x27fd0
leaq 0x18a51(%rip), %rsi     # 0x1e252
movl $0x1a, %edx
callq 0x32b0
movl 0x34(%rsp), %esi
movq 0x227ba(%rip), %r15     # 0x27fd0
movq %r15, %rdi
callq 0x3180
movq %rax, %rbx
leaq 0x18a45(%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 0x22756(%rip), %rdi     # 0x27fd0
callq 0x3040
movq %rax, %rdi
callq 0x3190
movl 0x30(%rsp), %eax
movl %eax, 0x4(%rsp)
xorl %eax, %eax
movl %eax, 0x24(%rsp)
movl %eax, 0x20(%rsp)
leaq 0xb0(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0xc0(%rsp), %rsi
movq 0xc8(%rsp), %rdx
addq %rsi, %rdx
leaq 0xa0(%rsp), %rdi
callq 0x6574
leaq 0x189a8(%rip), %rsi     # 0x1e274
leaq 0xa0(%rsp), %rdi
callq 0x34a0
movq 0xa0(%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 0x596e
movq 0x226e0(%rip), %rdi     # 0x27ff0
leaq 0x18964(%rip), %rsi     # 0x1e27b
movl $0x1f, %edx
callq 0x32b0
movq 0xa0(%rsp), %rsi
movq 0xa8(%rsp), %rdx
movq 0x226b8(%rip), %rdi     # 0x27ff0
callq 0x32b0
movq %rax, %rbx
leaq 0x18f29(%rip), %rsi     # 0x1e870
movl $0x1, %edx
movq %rax, %rdi
callq 0x32b0
movq %rbx, %rdi
callq 0x3110
movq %r12, %rdi
callq 0x32f0
movl $0x3, %ebx
jmp 0x603c
leaq 0x18926(%rip), %rdx     # 0x1e29b
leaq 0xf0(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
callq 0x64c3
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 0x5a2c
movq 0x2262f(%rip), %rdi     # 0x27ff0
leaq 0x188b3(%rip), %rsi     # 0x1e27b
movl $0x1f, %edx
callq 0x32b0
movq 0xf0(%rsp), %rsi
movq 0xf8(%rsp), %rdx
movq 0x22607(%rip), %rdi     # 0x27ff0
callq 0x32b0
movq %rax, %rbx
leaq 0x18e78(%rip), %rsi     # 0x1e870
movl $0x1, %edx
movq %rax, %rdi
callq 0x32b0
movq %rbx, %rdi
callq 0x3110
movq %r12, %rdi
callq 0x32f0
movl $0x3, %ebx
leaq 0x160(%rsp), %rdi
callq 0x3330
jmp 0x600e
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 0x1bdcb
movsd %xmm0, 0x38(%rsp)
movq 0x70(%rsp), %rax
cmpq 0x50(%rsp), %rax
je 0x5ac4
movq 0x78(%rsp), %rdi
cmpq %rdi, %rax
je 0x5a81
addq $-0x8, %rax
jmp 0x5abd
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)
jmp 0x5a6a
leaq 0x18(%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 0x5af5
movq %rax, (%rcx)
addq $0x8, 0x70(%rsp)
jmp 0x5b00
movq %r15, %rdi
movq %rbx, %rsi
callq 0x6a66
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
testq %rax, %rax
jne 0x5ad4
movq 0x90(%rsp), %rax
negl %eax
movl %eax, 0x10(%rsp)
movl $0x0, 0x8(%rsp)
movl $0x200, %r12d           # imm = 0x200
leaq 0x110(%rsp), %r15
leaq 0x40(%rsp), %r13
movq 0x70(%rsp), %rax
movq 0x78(%rsp), %rdi
movq %rax, %rcx
cmpq %rdi, %rax
jne 0x5b5d
movq 0x88(%rsp), %rcx
movq -0x8(%rcx), %rcx
addq %r12, %rcx
cmpq %r14, -0x8(%rcx)
je 0x5dc0
movq %rax, %rcx
cmpq %rdi, %rax
jne 0x5b7e
movq 0x88(%rsp), %rcx
movq -0x8(%rcx), %rcx
addq %r12, %rcx
movq -0x8(%rcx), %rbp
cmpq %rdi, %rax
je 0x5b8d
addq $-0x8, %rax
jmp 0x5bc9
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 0x5c19
movq 0x70(%rsp), %rcx
movq 0x80(%rsp), %rdx
addq $-0x8, %rdx
cmpq %rdx, %rcx
je 0x5c00
movq %rax, (%rcx)
addq $0x8, 0x70(%rsp)
jmp 0x5c0b
movq %r13, %rdi
movq %r15, %rsi
callq 0x6a66
movq 0x110(%rsp), %rax
movq 0x18(%rax), %rax
jmp 0x5bd2
cmpb $0x0, 0x38(%rbp)
je 0x5c31
movl 0x4(%rsp), %eax
movl %eax, 0x34(%rbp)
incl %eax
movl %eax, 0x4(%rsp)
jmp 0x5b3c
movq %rbp, %rdi
movq 0x28(%rsp), %rsi
callq 0x1158c
movq 0x40(%rbp), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x2, %rcx
cmpq 0x90(%rsp), %rcx
jb 0x5c5f
movq %rbp, %rdi
callq 0x1168e
cmpq $0x0, 0x18(%rbp)
je 0x5cae
cmpb $0x0, 0x38(%rbp)
jne 0x5cae
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 0x5cae
movq %rbp, %rdi
callq 0x114e0
movq %rbp, %rdi
callq 0x10eda
movl $0x48, %esi
movq %rbp, %rdi
callq 0x3270
jmp 0x5b3c
movq %rbp, %rdi
callq 0x116ea
movl 0x10(%rsp), %eax
movl %eax, 0x110(%rsp)
cmpq $0x0, 0x18(%rbp)
je 0x5cd7
movl 0x4(%rsp), %eax
movl %eax, 0x34(%rbp)
incl %eax
movl %eax, 0x4(%rsp)
jmp 0x5ce4
movl 0x8(%rsp), %eax
movl %eax, 0x34(%rbp)
incl %eax
movl %eax, 0x8(%rsp)
movl 0x10(%rsp), %esi
subl %eax, %esi
movl %esi, 0x110(%rsp)
cmpb $0x0, 0x38(%rbp)
jne 0x5b3c
movq 0x40(%rbp), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
cmpq $0x4, %rcx
jne 0x5d5a
negl %esi
leaq 0x3d8(%rsp), %rdi
callq 0x3420
movq %rax, %rbx
movl $0x2, %edx
movq %rax, %rdi
leaq 0x184e9(%rip), %rsi     # 0x1e216
callq 0x32b0
movq 0x40(%rbp), %rcx
movq (%rcx), %rax
cmpq %rax, 0x8(%rcx)
je 0x60ad
movl (%rax), %esi
movq %rbx, %rdi
callq 0x3180
movq %rax, %rdi
callq 0x3110
jmp 0x5b3c
movl $0x4, %edx
leaq 0x160(%rsp), %rdi
movq %r15, %rsi
callq 0x3300
movq 0x40(%rbp), %rcx
movq (%rcx), %rbx
movq 0x8(%rcx), %rax
cmpq %rax, %rbx
je 0x5dac
movl (%rbx), %eax
movl %eax, 0x9c(%rsp)
movl $0x4, %edx
leaq 0x160(%rsp), %rdi
leaq 0x9c(%rsp), %rsi
callq 0x3300
addq $0x4, %rbx
movq 0x40(%rbp), %rcx
jmp 0x5d76
incl 0x24(%rsp)
subq (%rcx), %rax
shrq $0x2, %rax
addl %eax, 0x20(%rsp)
jmp 0x5b3c
movl 0x4(%rsp), %eax
movl %eax, 0x34(%r14)
incl %eax
movl %eax, 0x4(%rsp)
callq 0x1bdcb
movsd %xmm0, 0x10(%rsp)
movq 0x221f0(%rip), %rdi     # 0x27fd0
leaq 0x184c0(%rip), %rsi     # 0x1e2a7
movl $0x8, %edx
callq 0x32b0
movsd 0x10(%rsp), %xmm0
subsd 0x38(%rsp), %xmm0
movq 0x221cc(%rip), %rdi     # 0x27fd0
callq 0x33d0
movq %rax, %rbx
leaq 0x183f7(%rip), %rsi     # 0x1e20a
movl $0x8, %edx
movq %rax, %rdi
callq 0x32b0
movq %rbx, %rdi
callq 0x3110
movq 0x221a1(%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 0x22156(%rip), %rdi     # 0x27fd0
leaq 0x1842f(%rip), %rsi     # 0x1e2b0
movl $0xa, %edx
callq 0x32b0
movl 0x24(%rsp), %esi
movq 0x2213a(%rip), %rdi     # 0x27fd0
callq 0x3180
movq %rax, %rbx
leaq 0x18416(%rip), %rsi     # 0x1e2bb
movl $0x8, %edx
movq %rax, %rdi
callq 0x32b0
movl 0x20(%rsp), %esi
movq %rbx, %rdi
callq 0x3180
movq %rax, %rbx
leaq 0x183fc(%rip), %rsi     # 0x1e2c4
movl $0x6, %edx
movq %rax, %rdi
callq 0x32b0
movq %rbx, %rdi
callq 0x3110
movq 0x220ec(%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
leaq 0xb0(%rsp), %r13
callq 0x119c4
cmpb $0x1, 0x158(%rsp)
jne 0x5fea
movq 0x2208e(%rip), %rdi     # 0x27fd0
leaq 0x18382(%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 0x22060(%rip), %rdi     # 0x27fd0
callq 0x3180
movq %rax, %rbx
leaq 0x1833c(%rip), %rsi     # 0x1e2bb
movl $0x8, %edx
movq %rax, %rdi
callq 0x32b0
movl 0x8(%rsp), %esi
movq %rbx, %rdi
callq 0x3180
movq %rax, %rbx
leaq 0x18339(%rip), %rsi     # 0x1e2db
movl $0x7, %edx
movq %rax, %rdi
callq 0x32b0
movq %rbx, %rdi
callq 0x3110
movq 0x22012(%rip), %rdi     # 0x27fd0
callq 0x3110
leaq 0x110(%rsp), %rdi
movl $0x1, %esi
callq 0x13fce
leaq 0x110(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
callq 0x13dea
movq %r14, %rdi
callq 0x10eda
movl $0x48, %esi
movq %r14, %rdi
callq 0x3270
leaq 0x110(%rsp), %rdi
callq 0x123b8
xorl %ebx, %ebx
leaq 0x3d8(%rsp), %rdi
callq 0x3350
leaq 0x100(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x603c
movq 0x100(%rsp), %rsi
incq %rsi
callq 0x3270
movq 0x21f7d(%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 0xa0(%rsp), %rdi
cmpq %r13, %rdi
je 0x6091
movq 0xb0(%rsp), %rsi
incq %rsi
callq 0x3270
leaq 0x40(%rsp), %rdi
callq 0x6524
leaq 0x360(%rsp), %rdi
callq 0x1909a
jmp 0x5150
leaq 0x18289(%rip), %rdi     # 0x1e33d
xorl %esi, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x3370
jmp 0x61e0
jmp 0x61e0
jmp 0x61e0
jmp 0x61e0
jmp 0x61e0
movq %rax, %r15
jmp 0x61f0
jmp 0x616f
movq %rax, %r15
leaq 0x110(%rsp), %rdi
callq 0x123b8
jmp 0x61e3
jmp 0x61e0
movq %rax, %r15
jmp 0x621e
movq %rax, %r15
movq 0xa0(%rsp), %rdi
cmpq %r13, %rdi
jne 0x6233
jmp 0x6277
jmp 0x6274
jmp 0x6274
jmp 0x6274
jmp 0x61c9
jmp 0x61d8
jmp 0x61d8
jmp 0x61d8
jmp 0x61d8
jmp 0x61d8
jmp 0x61e0
jmp 0x61e0
movq %rax, %r15
testb %bl, %bl
je 0x6277
movl $0x48, %esi
movq %r14, %rdi
jmp 0x623e
movq %rax, %r15
jmp 0x6211
jmp 0x61e0
jmp 0x6274
jmp 0x61e0
jmp 0x61c9
jmp 0x61c9
jmp 0x61d8
movq %rax, %r15
leaq 0x170(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x629b
movq 0x170(%rsp), %rsi
jmp 0x6265
jmp 0x626f
jmp 0x626f
movq %rax, %r15
movl $0x48, %esi
movq %rbp, %rdi
jmp 0x623e
jmp 0x6274
jmp 0x61c9
movq %rax, %r15
jmp 0x6281
jmp 0x6274
jmp 0x61d8
movq %rax, %r15
jmp 0x628e
movq %rax, %r15
leaq 0x3d8(%rsp), %rdi
callq 0x3350
leaq 0x100(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6211
movq 0x100(%rsp), %rsi
incq %rsi
callq 0x3270
leaq 0x160(%rsp), %rdi
callq 0x3350
movq 0xa0(%rsp), %rdi
leaq 0xb0(%rsp), %rax
cmpq %rax, %rdi
je 0x6277
movq 0xb0(%rsp), %rsi
incq %rsi
callq 0x3270
jmp 0x6277
jmp 0x626f
jmp 0x626f
movq %rax, %r15
leaq 0x5e8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x629b
movq 0x5e8(%rsp), %rsi
incq %rsi
callq 0x3270
jmp 0x629b
movq %rax, %r15
jmp 0x629b
movq %rax, %r15
leaq 0x40(%rsp), %rdi
callq 0x6524
leaq 0x360(%rsp), %rdi
callq 0x1909a
leaq 0x5d8(%rsp), %rdi
callq 0x8018
leaq 0xd0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x62bc
movq 0xd0(%rsp), %rsi
incq %rsi
callq 0x3270
movq %r15, %rdi
callq 0x3460