// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/src/DagGenerator.cpp
// Function: t2::CompileDag(t2::JsonObjectValue const*, t2::BinaryWriter*, t2::MemAllocHeap*, t2::MemAllocLinear*)
static bool CompileDag(const JsonObjectValue* root, BinaryWriter* writer, MemAllocHeap* heap, MemAllocLinear* scratch)
{
  printf("compiling mmapable DAG data..\n");

  HashTable<CommonStringRecord, kFlagCaseSensitive> shared_strings;
  HashTableInit(&shared_strings, heap);

  BinarySegment         *main_seg      = BinaryWriterAddSegment(writer);
  BinarySegment         *node_guid_seg = BinaryWriterAddSegment(writer);
  BinarySegment         *node_data_seg = BinaryWriterAddSegment(writer);
  BinarySegment         *aux_seg       = BinaryWriterAddSegment(writer);
  BinarySegment         *aux2_seg      = BinaryWriterAddSegment(writer);
  BinarySegment         *str_seg       = BinaryWriterAddSegment(writer);

  const JsonArrayValue  *nodes         = FindArrayValue(root, "Nodes");
  const JsonArrayValue  *passes        = FindArrayValue(root, "Passes");
  const JsonArrayValue  *scanners      = FindArrayValue(root, "Scanners");

  if (EmptyArray(nodes))
  {
    fprintf(stderr, "invalid Nodes data\n");
    return false;
  }

  if (EmptyArray(passes))
  {
    fprintf(stderr, "invalid Passes data\n");
    return false;
  }

  // Write scanners, store pointers
  BinaryLocator* scanner_ptrs = nullptr;

  if (!EmptyArray(scanners))
  {
    scanner_ptrs = (BinaryLocator*) alloca(sizeof(BinaryLocator) * scanners->m_Count);
    for (size_t i = 0, count = scanners->m_Count; i < count; ++i)
    {
      if (!WriteScanner(&scanner_ptrs[i], aux_seg, aux2_seg, str_seg, scanners->m_Values[i]->AsObject(), &shared_strings, scratch))
      {
        fprintf(stderr, "invalid scanner data\n");
        return false;
      }
    }
  }

  // Write magic number
  BinarySegmentWriteUint32(main_seg, DagData::MagicNumber);

  // Compute node guids and index remapping table.
  int32_t      *remap_table = HeapAllocateArray<int32_t>(heap, nodes->m_Count);
  TempNodeGuid *guid_table  = HeapAllocateArray<TempNodeGuid>(heap, nodes->m_Count);

  if (!ComputeNodeGuids(nodes, remap_table, guid_table))
    return false;

  // m_NodeCount
  size_t node_count = nodes->m_Count;
  BinarySegmentWriteInt32(main_seg, int(node_count));

  // Write node guids
  BinarySegmentWritePointer(main_seg, BinarySegmentPosition(node_guid_seg));  // m_NodeGuids
  for (size_t i = 0; i < node_count; ++i)
  {
    BinarySegmentWrite(node_guid_seg, (char*) &guid_table[i].m_Digest, sizeof guid_table[i].m_Digest);
  }

  // Write nodes.
  if (!WriteNodes(nodes, main_seg, node_data_seg, aux_seg, str_seg, scanner_ptrs, heap, &shared_strings, scratch, guid_table, remap_table))
    return false;

  // Write passes
  BinarySegmentWriteInt32(main_seg, (int) passes->m_Count);
  BinarySegmentWritePointer(main_seg, BinarySegmentPosition(aux_seg));
  for (size_t i = 0, count = passes->m_Count; i < count; ++i)
  {
    const char* pass_name = passes->m_Values[i]->GetString();
    if (!pass_name)
      return false;
    WriteStringPtr(aux_seg, str_seg, pass_name);
  }

  // Write configs
  const JsonObjectValue *setup       = FindObjectValue(root, "Setup");
  const JsonArrayValue  *configs     = FindArrayValue(setup, "Configs");
  const JsonArrayValue  *variants    = FindArrayValue(setup, "Variants");
  const JsonArrayValue  *subvariants = FindArrayValue(setup, "SubVariants");
  const JsonArrayValue  *tuples      = FindArrayValue(setup, "BuildTuples");

  if (nullptr == setup || EmptyArray(configs) || EmptyArray(variants) || EmptyArray(subvariants) || EmptyArray(tuples))
  {
    fprintf(stderr, "invalid Setup data\n");
    return false;
  }

  if (!WriteStrHashArray(main_seg, aux_seg, str_seg, configs))
  {
    fprintf(stderr, "invalid Setup.Configs data\n");
    return false;
  }

  if (!WriteStrHashArray(main_seg, aux_seg, str_seg, variants))
  {
    fprintf(stderr, "invalid Setup.Variants data\n");
    return false;
  }

  if (!WriteStrHashArray(main_seg, aux_seg, str_seg, subvariants))
  {
    fprintf(stderr, "invalid Setup.SubVariants data\n");
    return false;
  }

  BinarySegmentWriteInt32(main_seg, (int) tuples->m_Count);
  BinarySegmentWritePointer(main_seg, BinarySegmentPosition(aux_seg));

  for (size_t i = 0, count = tuples->m_Count; i < count; ++i)
  {
    const JsonObjectValue* obj = tuples->m_Values[i]->AsObject();
    if (!obj)
    {
      fprintf(stderr, "invalid Setup.BuildTuples[%d] data\n", (int) i);
      return false;
    }

    int                    config_index     = (int) FindIntValue(obj, "ConfigIndex", -1);
    int                    variant_index    = (int) FindIntValue(obj, "VariantIndex", -1);
    int                    subvariant_index = (int) FindIntValue(obj, "SubVariantIndex", -1);
    const JsonArrayValue  *default_nodes    = FindArrayValue(obj, "DefaultNodes");
    const JsonArrayValue  *always_nodes     = FindArrayValue(obj, "AlwaysNodes");
    const JsonObjectValue *named_nodes      = FindObjectValue(obj, "NamedNodes");

    if (config_index == -1 || variant_index == -1 || subvariant_index == -1 ||
        !default_nodes || !always_nodes)
    {
      fprintf(stderr, "invalid Setup.BuildTuples[%d] data\n", (int) i);
      return false;
    }

    BinarySegmentWriteInt32(aux_seg, config_index);
    BinarySegmentWriteInt32(aux_seg, variant_index);
    BinarySegmentWriteInt32(aux_seg, subvariant_index);

    if (!WriteNodeArray(aux_seg, aux2_seg, default_nodes, remap_table))
    {
      fprintf(stderr, "bad DefaultNodes data\n");
      return false;
    }

    if (!WriteNodeArray(aux_seg, aux2_seg, always_nodes, remap_table))
    {
      fprintf(stderr, "bad AlwaysNodes data\n");
      return false;
    }

    if (named_nodes)
    {
      size_t ncount = named_nodes->m_Count;
      BinarySegmentWriteInt32(aux_seg, (int) ncount);
      BinarySegmentWritePointer(aux_seg, BinarySegmentPosition(aux2_seg));
      for (size_t i = 0; i < ncount; ++i)
      {
        WriteStringPtr(aux2_seg, str_seg, named_nodes->m_Names[i]);
        const JsonNumberValue* node_index = named_nodes->m_Values[i]->AsNumber();
        if (!node_index)
        {
          fprintf(stderr, "named node index must be number\n");
          return false;
        }
        int remapped_index = remap_table[(int) node_index->m_Number];
        BinarySegmentWriteInt32(aux2_seg, remapped_index);
      }
    }
    else
    {
      BinarySegmentWriteInt32(aux_seg, 0);
      BinarySegmentWriteNullPointer(aux_seg);
    }
  }

  const JsonObjectValue* default_tuple = FindObjectValue(setup, "DefaultBuildTuple");
  if (!default_tuple)
  {
    fprintf(stderr, "missing Setup.DefaultBuildTuple\n");
    return false;
  }

  int def_config_index = (int) FindIntValue(default_tuple, "ConfigIndex", -2);
  int def_variant_index = (int) FindIntValue(default_tuple, "VariantIndex", -2);
  int def_subvariant_index = (int) FindIntValue(default_tuple, "SubVariantIndex", -2);

  if (-2 == def_config_index || -2 == def_variant_index || -2 == def_subvariant_index)
  {
    fprintf(stderr, "bad Setup.DefaultBuildTuple data\n");
    return false;
  }

  BinarySegmentWriteInt32(main_seg, def_config_index);
  BinarySegmentWriteInt32(main_seg, def_variant_index);
  BinarySegmentWriteInt32(main_seg, def_subvariant_index);

  if (const JsonArrayValue* file_sigs = FindArrayValue(root, "FileSignatures"))
  {
    size_t count = file_sigs->m_Count;
    BinarySegmentWriteInt32(main_seg, (int) count);
    BinarySegmentWritePointer(main_seg, BinarySegmentPosition(aux_seg));
    for (size_t i = 0; i < count; ++i)
    {
      if (const JsonObjectValue* sig = file_sigs->m_Values[i]->AsObject())
      {
        const char* path = FindStringValue(sig, "File");

        if (!path)
        {
          fprintf(stderr, "bad FileSignatures data (null path in File node)\n");
          return false;
        }

        int64_t timestamp = GetFileInfo(path).m_Timestamp;
        WriteStringPtr(aux_seg, str_seg, path);
        char padding[4] = { 0, 0, 0, 0 };
        BinarySegmentWrite(aux_seg, padding, 4);
        BinarySegmentWriteUint64(aux_seg, uint64_t(timestamp));
      }
      else
      {
        fprintf(stderr, "bad FileSignatures data (FileSignatures must contain objects)\n");
        return false;
      }
    }
  }
  else
  {
    BinarySegmentWriteInt32(main_seg, 0);
    BinarySegmentWriteNullPointer(main_seg);
  }

  if (const JsonArrayValue* glob_sigs = FindArrayValue(root, "GlobSignatures"))
  {
    size_t count = glob_sigs->m_Count;
    BinarySegmentWriteInt32(main_seg, (int) count);
    BinarySegmentWritePointer(main_seg, BinarySegmentPosition(aux_seg));
    for (size_t i = 0; i < count; ++i)
    {
      if (const JsonObjectValue* sig = glob_sigs->m_Values[i]->AsObject())
      {
        const char* path = FindStringValue(sig, "Path");
        if (!path)
        {
          fprintf(stderr, "bad GlobSignatures data\n");
          return false;
        }

        HashDigest digest = CalculateGlobSignatureFor(path, heap, scratch);

        WriteStringPtr(aux_seg, str_seg, path);
        BinarySegmentWrite(aux_seg, (char*) &digest, sizeof digest);
      }
    }
  }
  else
  {
    BinarySegmentWriteInt32(main_seg, 0);
    BinarySegmentWriteNullPointer(main_seg);
  }

  // Emit hashes of file extensions to sign using SHA-1 content digest instead of the normal timestamp signing.
  if (const JsonArrayValue* sha_exts = FindArrayValue(root, "ContentDigestExtensions"))
  {
    BinarySegmentWriteInt32(main_seg, (int) sha_exts->m_Count);
    BinarySegmentWritePointer(main_seg, BinarySegmentPosition(aux_seg));

    for (size_t i = 0, count = sha_exts->m_Count; i < count; ++i)
    {
      const JsonValue* v = sha_exts->m_Values[i];
      if (const JsonStringValue* sv = v->AsString())
      {
        const char* str = sv->m_String;
        if (str[0] != '.')
        {
          fprintf(stderr, "ContentDigestExtensions: Expected extension to start with dot: %s\b", str);
          return false;
        }

        BinarySegmentWriteUint32(aux_seg, Djb2Hash(str));
      }
      else
        return false;
    }
  }
  else
  {
    BinarySegmentWriteInt32(main_seg, 0);
    BinarySegmentWriteNullPointer(main_seg);
  }

  BinarySegmentWriteInt32(main_seg, (int) FindIntValue(root, "MaxExpensiveCount", -1));

  WriteStringPtr(main_seg, str_seg, FindStringValue(root, "StateFileName", ".tundra2.state"));
  WriteStringPtr(main_seg, str_seg, FindStringValue(root, "StateFileNameTmp", ".tundra2.state.tmp"));

  WriteStringPtr(main_seg, str_seg, FindStringValue(root, "ScanCacheFileName", ".tundra2.scancache"));
  WriteStringPtr(main_seg, str_seg, FindStringValue(root, "ScanCacheFileNameTmp", ".tundra2.scancache.tmp"));

  WriteStringPtr(main_seg, str_seg, FindStringValue(root, "DigestCacheFileName", ".tundra2.digestcache"));
  WriteStringPtr(main_seg, str_seg, FindStringValue(root, "DigestCacheFileNameTmp", ".tundra2.digestcache.tmp"));

  HashTableDestroy(&shared_strings);

  HeapFree(heap, guid_table);
  HeapFree(heap, remap_table);

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rcx, -0xa0(%rbp)
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq 0xdf4f(%rip), %rdi      # 0x14560
callq 0x3540
xorps %xmm0, %xmm0
movups %xmm0, -0x124(%rbp)
movaps %xmm0, -0x130(%rbp)
movq %r14, -0x88(%rbp)
movq %r14, -0x110(%rbp)
andq $0x0, -0x108(%rbp)
movq %rbx, %rdi
callq 0x11d4e
movq %rax, %r12
movq %rbx, %rdi
callq 0x11d4e
movq %rax, -0x98(%rbp)
movq %rbx, %rdi
callq 0x11d4e
movq %rax, -0x38(%rbp)
movq %rbx, %rdi
callq 0x11d4e
movq %rax, %r14
movq %rbx, %rdi
callq 0x11d4e
movq %rax, -0x80(%rbp)
movq %rbx, %rdi
callq 0x11d4e
movq %rax, %rbx
leaq 0xdb53(%rip), %rsi      # 0x141df
movq %r15, %rdi
callq 0x5f55
movq %rax, %r13
leaq 0xda01(%rip), %rsi      # 0x1409f
movq %r15, %rdi
callq 0x5f55
movq %rax, -0xb0(%rbp)
leaq 0xd9f2(%rip), %rsi      # 0x140a6
movq %r15, -0x90(%rbp)
movq %r15, %rdi
callq 0x5f55
testq %r13, %r13
je 0x6b92
cmpq $0x0, 0x8(%r13)
je 0x6b92
movq %rax, %rdx
movq %r13, -0x78(%rbp)
movq -0xb0(%rbp), %rax
testq %rax, %rax
je 0x6bb0
cmpq $0x0, 0x8(%rax)
je 0x6bb0
testq %rdx, %rdx
movq %rbx, -0x40(%rbp)
movq %r14, -0x30(%rbp)
je 0x69e4
movq 0x8(%rdx), %rsi
testq %rsi, %rsi
je 0x69e4
movq %r12, -0x68(%rbp)
movq %rsi, %rax
shlq $0x4, %rax
movq %rsp, %rcx
subq %rax, %rcx
movq %rcx, -0x50(%rbp)
movq %rcx, %rsp
xorl %ebx, %ebx
leaq -0x1d0(%rbp), %r13
movq %rdx, -0x70(%rbp)
movq %rsi, -0xa8(%rbp)
cmpq %rsi, %rbx
je 0x6ba7
movq 0x10(%rdx), %rax
movq (%rax,%rbx,8), %rax
movq %rax, -0x48(%rbp)
cmpl $0x2, (%rax)
jne 0x6b7d
movq -0x48(%rbp), %r14
movq %r14, %rdi
leaq 0xdd23(%rip), %rsi      # 0x14492
xorl %edx, %edx
callq 0x5f34
movq %rax, %r15
movq %r14, %rdi
leaq 0xdd14(%rip), %rsi      # 0x14497
callq 0x5f55
testq %r15, %r15
je 0x6b7d
movq %rax, %r12
testq %rax, %rax
je 0x6b7d
movq %rbx, -0x58(%rbp)
shlq $0x4, %rbx
addq -0x50(%rbp), %rbx
movq -0x30(%rbp), %r14
movq %r14, %rdi
pushq $0x4
popq %rsi
callq 0x11ae1
movq %r14, %rdi
callq 0x11b99
movl %eax, (%rbx)
movq %rdx, 0x8(%rbx)
movq %r15, %rdi
leaq 0xebee(%rip), %rsi      # 0x153be
callq 0x3470
movl %eax, %ebx
testl %eax, %eax
je 0x67f6
movq %r15, %rdi
leaq 0xdcbf(%rip), %rsi      # 0x144a4
callq 0x3470
pushq $0x1
popq %rsi
testl %eax, %eax
je 0x67f8
jmp 0x6b7d
xorl %esi, %esi
movl %ebx, -0x60(%rbp)
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x7e14
movl 0x8(%r12), %esi
movq %rbx, %rdi
callq 0x7e14
movq -0x80(%rbp), %rdi
callq 0x11b99
movq %rbx, %rdi
movl %eax, %esi
callq 0x11b5e
movq %r13, %rdi
callq 0xcd00
movq %r13, %rdi
movq %r15, %rsi
callq 0x557d
movq 0x8(%r12), %rbx
xorl %r14d, %r14d
cmpq %r14, %rbx
je 0x688b
movq 0x10(%r12), %rax
movq (%rax,%r14,8), %rax
cmpl $0x4, (%rax)
je 0x6857
xorl %eax, %eax
movq 0x8(%rax), %r15
testq %r15, %r15
je 0x6b7d
movq %r13, %rdi
movq %r15, %rsi
callq 0x557d
movq -0x80(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %r15, %rdx
leaq -0x130(%rbp), %rcx
callq 0x5c6c
incq %r14
jmp 0x6842
movq -0x30(%rbp), %rdi
pushq $0x10
popq %rsi
callq 0x11b22
cmpl $0x0, -0x60(%rbp)
je 0x69c2
movq %rax, -0x60(%rbp)
movq -0x48(%rbp), %r12
movq %r12, %rdi
leaq 0xdbf9(%rip), %rsi      # 0x144ac
callq 0x7b4d
movzbl %al, %ebx
movq %r12, %rdi
leaq 0xdbf9(%rip), %rsi      # 0x144be
callq 0x7b4d
leal 0x2(%rbx), %r14d
testb %al, %al
cmovel %ebx, %r14d
movq %r12, %rdi
leaq 0xdbee(%rip), %rsi      # 0x144cc
callq 0x7b4d
leal 0x4(%r14), %esi
testb %al, %al
cmovel %r14d, %esi
movq -0x30(%rbp), %rdi
callq 0x7df6
movq %r12, %rdi
leaq 0xdbdc(%rip), %rsi      # 0x144dc
callq 0x5f55
movq %rax, %r15
movq %r12, %rdi
leaq 0xdbd3(%rip), %rsi      # 0x144e5
callq 0x5f55
movq %rax, %rbx
testq %r15, %r15
je 0x6925
movq 0x8(%r15), %rax
jmp 0x6927
xorl %eax, %eax
testq %rbx, %rbx
je 0x6932
movq 0x8(%rbx), %r12
jmp 0x6935
xorl %r12d, %r12d
addq %rax, %r12
movq -0x30(%rbp), %r14
movq %r14, %rdi
movl %r12d, %esi
callq 0x7e14
testq %r12, %r12
je 0x69b6
movq -0x80(%rbp), %r12
movq %r12, %rdi
pushq $0x4
popq %rsi
callq 0x11ae1
movq %r12, %rdi
callq 0x11b99
movq %r14, %rdi
movl %eax, %esi
callq 0x11b5e
movq %r12, -0x100(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0xf8(%rbp)
leaq -0x100(%rbp), %r14
movq %r14, %rdi
movq %r15, %rsi
pushq $0x1
popq %rdx
callq 0x7b66
testb %al, %al
je 0x6b7d
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x7b66
testb %al, %al
movq -0x60(%rbp), %rax
jne 0x69c2
jmp 0x6b7d
movq %r14, %rdi
callq 0x7e29
movq -0x60(%rbp), %rax
movq %r13, %rdi
movq %rax, %rsi
callq 0xcd14
movq -0x58(%rbp), %rbx
incq %rbx
movq -0x70(%rbp), %rdx
movq -0xa8(%rbp), %rsi
jmp 0x6743
movq $0x0, -0x50(%rbp)
movq %r12, %rdi
movl $0x6d992313, %esi       # imm = 0x6D992313
callq 0x7df6
movq -0x78(%rbp), %r13
movq 0x8(%r13), %rsi
movq -0x88(%rbp), %rbx
movq %rbx, %rdi
callq 0x543c
movq %rax, %r14
movq 0x8(%r13), %rsi
movq %rbx, %rdi
callq 0x7e0b
movq %rax, %r15
movq %r13, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x5d0d
testb %al, %al
je 0x7029
movq %r14, -0x60(%rbp)
movq 0x8(%r13), %rbx
movq %r12, %rdi
movl %ebx, %esi
callq 0x7e14
movq -0x98(%rbp), %r13
movq %r13, %rdi
callq 0x11b99
movq %r12, %rdi
movl %eax, %esi
callq 0x11b5e
pushq $0x10
popq %r14
movq %r15, -0xa8(%rbp)
subq $0x1, %rbx
jb 0x6a88
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x11b32
addq $0x14, %r15
jmp 0x6a6e
movq -0x38(%rbp), %rdi
callq 0x11b99
movq %r12, -0x68(%rbp)
movq %r12, %rdi
movl %eax, %esi
callq 0x11b5e
movq -0xa0(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x78(%rbp), %rax
movq 0x8(%rax), %rbx
imulq $0x240, %rbx, %rsi      # imm = 0x240
movq -0x88(%rbp), %rdi
callq 0xd79a
imulq $0x18, %rbx, %rdx
xorl %r14d, %r14d
movq %rax, -0x48(%rbp)
movq %rax, %rdi
xorl %esi, %esi
callq 0x31b0
movq -0x78(%rbp), %rax
cmpq %rbx, %r14
je 0x6bd1
movq 0x10(%rax), %rax
movq (%rax,%r14,8), %rdi
cmpl $0x2, (%rdi)
jne 0x701a
movq %rbx, %r13
leaq 0xd9f0(%rip), %rsi      # 0x144f6
callq 0x5f55
movq %rax, %r12
testq %rax, %rax
movq -0x78(%rbp), %rax
je 0x6b72
movq 0x8(%r12), %r15
testq %r15, %r15
je 0x6b72
xorl %ebx, %ebx
cmpq %rbx, %r15
je 0x6b72
movq 0x10(%r12), %rax
movq (%rax,%rbx,8), %rax
cmpl $0x5, (%rax)
jne 0x701a
cvttsd2si 0x8(%rax), %eax
testl %eax, %eax
js 0x701a
cmpl %r13d, %eax
jge 0x701a
movl %eax, %eax
imulq $0x18, %rax, %rdi
addq -0x48(%rbp), %rdi
movq -0x88(%rbp), %rsi
movl %r14d, %edx
callq 0x7e97
incq %rbx
movq -0x78(%rbp), %rax
jmp 0x6b23
incq %r14
movq %r13, %rbx
jmp 0x6ae2
movq 0x16454(%rip), %rax     # 0x1cfd8
movq (%rax), %rcx
leaq 0xd54a(%rip), %rdi      # 0x140d8
pushq $0x15
jmp 0x6bc3
movq 0x1643f(%rip), %rax     # 0x1cfd8
movq (%rax), %rcx
leaq 0xd50c(%rip), %rdi      # 0x140af
pushq $0x13
jmp 0x6bc3
movq -0x68(%rbp), %r12
jmp 0x69ec
movq 0x16421(%rip), %rax     # 0x1cfd8
movq (%rax), %rcx
leaq 0xd502(%rip), %rdi      # 0x140c3
pushq $0x14
popq %rsi
pushq $0x1
popq %rdx
callq 0x3650
jmp 0x7029
xorl %esi, %esi
movq -0xa8(%rbp), %rcx
movq %rbx, -0xb8(%rbp)
cmpq %rbx, %rsi
je 0x703c
movq %rax, %rdx
movq %rsi, -0xc0(%rbp)
imulq $0x14, %rsi, %rax
movslq 0x10(%rcx,%rax), %rcx
movq 0x10(%rdx), %rax
movq %rcx, %r13
movq (%rax,%rcx,8), %rbx
cmpl $0x2, (%rbx)
movl $0x0, %eax
cmovneq %rax, %rbx
movq %rbx, %rdi
leaq 0xd8e0(%rip), %rsi      # 0x144fe
xorl %edx, %edx
callq 0x5f34
movq %rax, -0x98(%rbp)
movq %rbx, %rdi
leaq 0xd26f(%rip), %rsi      # 0x13ea5
xorl %edx, %edx
callq 0x5f34
movq %rax, -0xf0(%rbp)
movq %rbx, %rdi
leaq 0xd8ad(%rip), %rsi      # 0x144fb
xorl %edx, %edx
callq 0x5f34
movq %rax, %r14
movq %rbx, %rdi
leaq 0xd8a3(%rip), %rsi      # 0x14505
xorl %edx, %edx
callq 0x7ac0
movq %rax, %r12
movq %rbx, %rdi
leaq 0xd880(%rip), %rsi      # 0x144f6
callq 0x5f55
movq %rax, %r15
movq %rbx, %rdi
leaq 0xd216(%rip), %rsi      # 0x13e9e
callq 0x5f55
movq %rax, -0xe8(%rbp)
movq %rbx, %rdi
leaq 0xda3e(%rip), %rsi      # 0x146dc
callq 0x5f55
movq %rax, -0xe0(%rbp)
movq %rbx, %rdi
leaq 0xd85b(%rip), %rsi      # 0x1450f
callq 0x5f55
movq %rax, -0xd8(%rbp)
movq %rbx, %rdi
leaq 0xd850(%rip), %rsi      # 0x1451a
callq 0x5f55
movq %rax, -0x70(%rbp)
movq %rbx, -0xc8(%rbp)
movq %rbx, %rdi
leaq 0xd83a(%rip), %rsi      # 0x1451e
pushq $-0x1
popq %rdx
callq 0x7ac0
movq %rax, -0xd0(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x98(%rbp), %rdx
callq 0x79a3
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %r14, %rdx
callq 0x79a3
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0xf0(%rbp), %rdx
leaq -0x130(%rbp), %rcx
callq 0x5c6c
movq -0x38(%rbp), %rdi
movl %r12d, %esi
callq 0x7e14
testq %r15, %r15
je 0x6da9
movq -0x30(%rbp), %rdi
pushq $0x4
popq %rsi
callq 0x11ae1
movl 0x8(%r15), %esi
movq -0x38(%rbp), %rdi
callq 0x7e14
movq -0x30(%rbp), %rdi
callq 0x11b99
movq -0x38(%rbp), %rdi
movl %eax, %esi
callq 0x11b5e
movq 0x8(%r15), %rbx
xorl %r14d, %r14d
cmpq %r14, %rbx
je 0x6dbd
movq 0x10(%r15), %rax
movq (%rax,%r14,8), %rax
cmpl $0x5, (%rax)
jne 0x701a
cvttsd2si 0x8(%rax), %eax
cltq
movq -0x60(%rbp), %rcx
movl (%rcx,%rax,4), %esi
movq -0x30(%rbp), %rdi
callq 0x7e14
incq %r14
jmp 0x6d77
movq -0x38(%rbp), %rdi
xorl %esi, %esi
callq 0x7e14
movq -0x38(%rbp), %rdi
callq 0x7e29
imulq $0x18, %r13, %r14
movq -0x48(%rbp), %rax
movq 0x8(%rax,%r14), %rsi
testq %rsi, %rsi
je 0x6e1d
movq -0x38(%rbp), %rdi
callq 0x7e14
movq -0x30(%rbp), %rdi
callq 0x11b99
movq -0x38(%rbp), %rdi
movl %eax, %esi
callq 0x11b5e
addq -0x48(%rbp), %r14
movq (%r14), %rbx
movq 0x8(%r14), %r14
shlq $0x2, %r14
xorl %r15d, %r15d
cmpq %r15, %r14
je 0x6e31
movslq (%rbx,%r15), %rax
movq -0x60(%rbp), %rcx
movl (%rcx,%rax,4), %esi
movq -0x30(%rbp), %rdi
callq 0x7e14
addq $0x4, %r15
jmp 0x6dfe
movq -0x38(%rbp), %rdi
xorl %esi, %esi
callq 0x7e14
movq -0x38(%rbp), %rdi
callq 0x7e29
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0xe8(%rbp), %rcx
callq 0x7bf8
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0xe0(%rbp), %rcx
callq 0x7bf8
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0xd8(%rbp), %rcx
callq 0x7bf8
movq -0x70(%rbp), %rax
testq %rax, %rax
je 0x6f61
cmpq $0x0, 0x8(%rax)
je 0x6f61
movq -0x30(%rbp), %rdi
pushq $0x4
popq %rsi
callq 0x11ae1
movq -0x70(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x38(%rbp), %rdi
callq 0x7e14
movq -0x30(%rbp), %rdi
callq 0x11b99
movq -0x38(%rbp), %rdi
movl %eax, %esi
callq 0x11b5e
movq -0x70(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x98(%rbp)
xorl %r12d, %r12d
cmpq %r12, -0x98(%rbp)
je 0x6f75
movq -0x70(%rbp), %rbx
movq 0x10(%rbx), %rax
movq (%rax,%r12,8), %rdi
leaq 0xd638(%rip), %rsi      # 0x1452b
xorl %edx, %edx
callq 0x5f34
movq %rax, %r15
movq 0x10(%rbx), %rax
movq (%rax,%r12,8), %rdi
leaq 0xd623(%rip), %rsi      # 0x1452f
xorl %edx, %edx
callq 0x5f34
testq %r15, %r15
je 0x701a
movq %rax, %r14
testq %rax, %rax
je 0x701a
movq -0x30(%rbp), %r13
movq %r13, %rdi
movq -0x40(%rbp), %rbx
movq %rbx, %rsi
movq %r15, %rdx
leaq -0x130(%rbp), %r15
movq %r15, %rcx
callq 0x5c6c
movq %r13, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0x5c6c
incq %r12
jmp 0x6ed3
movq -0x38(%rbp), %rdi
xorl %esi, %esi
callq 0x7e14
movq -0x38(%rbp), %rdi
callq 0x7e29
movq -0xd0(%rbp), %rax
cmpl $-0x1, %eax
jne 0x6f8c
movq -0x38(%rbp), %rdi
callq 0x7e29
jmp 0x6fa7
cltq
shlq $0x4, %rax
movq -0x50(%rbp), %rcx
movl (%rcx,%rax), %esi
movq 0x8(%rcx,%rax), %rdx
movq -0x38(%rbp), %rdi
callq 0x11b5e
movq -0xc8(%rbp), %rbx
movq %rbx, %rdi
leaq 0xd57d(%rip), %rsi      # 0x14535
pushq $0x1
popq %rdx
callq 0x7ce2
movl %eax, %r14d
movq %rbx, %rdi
leaq 0xd579(%rip), %rsi      # 0x14546
pushq $0x2
popq %rdx
callq 0x7ce2
orl %eax, %r14d
movq %rbx, %rdi
leaq 0xd574(%rip), %rsi      # 0x14556
pushq $0x4
popq %rdx
callq 0x7ce2
orl %eax, %r14d
movq -0x38(%rbp), %rdi
movl %r14d, %esi
callq 0x7df6
movq -0xc0(%rbp), %rsi
incq %rsi
movq -0xa8(%rbp), %rcx
movq -0x78(%rbp), %rax
movq -0xb8(%rbp), %rbx
jmp 0x6be1
movq -0xa0(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, 0x18(%rax)
xorl %ebx, %ebx
movl %ebx, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq -0x48(%rbp), %r14
subq $0x1, %rbx
jb 0x705b
movq %r14, %rdi
movq -0x88(%rbp), %rsi
callq 0x7ea6
addq $0x18, %r14
jmp 0x7040
movq -0x88(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0xd7a2
movq -0xa0(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0xb0(%rbp), %rbx
movl 0x8(%rbx), %esi
movq -0x68(%rbp), %r14
movq %r14, %rdi
callq 0x7e14
movq -0x30(%rbp), %rdi
callq 0x11b99
movq %r14, %rdi
movl %eax, %esi
callq 0x11b5e
movq %rbx, %rax
movq 0x8(%rbx), %r14
xorl %r15d, %r15d
cmpq %r15, %r14
je 0x70e9
movq 0x10(%rax), %rax
movq (%rax,%r15,8), %rax
xorl %ebx, %ebx
cmpl $0x4, (%rax)
je 0x70c3
xorl %eax, %eax
movq 0x8(%rax), %rdx
testq %rdx, %rdx
je 0x702b
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x79a3
incq %r15
movq -0xb0(%rbp), %rax
jmp 0x70ad
leaq 0xcffe(%rip), %rsi      # 0x140ee
movq -0x90(%rbp), %rdi
callq 0x79e5
movq %rax, %rbx
leaq 0xcfee(%rip), %rsi      # 0x140f4
movq %rax, %rdi
callq 0x5f55
movq %rax, %r12
leaq 0xcfe7(%rip), %rsi      # 0x140ff
movq %rbx, %rdi
callq 0x5f55
movq %rax, %r15
leaq 0xcfd2(%rip), %rsi      # 0x140fc
movq %rbx, %rdi
callq 0x5f55
movq %rax, %r14
leaq 0xcfcc(%rip), %rsi      # 0x14108
movq %rbx, %rdi
callq 0x5f55
movq %rax, -0x50(%rbp)
movq %rbx, -0x38(%rbp)
testq %rbx, %rbx
je 0x7412
testq %r12, %r12
je 0x7412
testq %r15, %r15
je 0x7412
cmpq $0x0, 0x8(%r12)
je 0x7412
testq %r14, %r14
je 0x7412
cmpq $0x0, 0x8(%r15)
je 0x7412
cmpq $0x0, -0x50(%rbp)
je 0x7412
cmpq $0x0, 0x8(%r14)
je 0x7412
movq -0x50(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x7412
movq %r14, -0x48(%rbp)
movq -0x68(%rbp), %r13
movq %r13, %rdi
movq -0x30(%rbp), %rbx
movq %rbx, %rsi
movq -0x40(%rbp), %r14
movq %r14, %rdx
movq %r12, %rcx
callq 0x7a02
testb %al, %al
je 0x784e
movq %r13, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0x7a02
testb %al, %al
je 0x7866
movq %r13, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq -0x48(%rbp), %rcx
callq 0x7a02
testb %al, %al
je 0x787e
movq -0x50(%rbp), %r14
movl 0x8(%r14), %esi
movq %r13, %rdi
callq 0x7e14
movq %rbx, %rdi
callq 0x11b99
movq %r13, %rdi
movl %eax, %esi
callq 0x11b5e
movq 0x8(%r14), %rax
movq %rax, -0x70(%rbp)
xorl %ecx, %ecx
cmpq -0x70(%rbp), %rcx
je 0x7428
movq -0x50(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, -0x58(%rbp)
movq (%rax,%rcx,8), %r12
cmpl $0x2, (%r12)
jne 0x7896
movq %r12, %rdi
leaq 0xcf42(%rip), %rsi      # 0x141a5
pushq $-0x1
popq %rbx
movq %rbx, %rdx
callq 0x7ac0
movq %rax, -0x48(%rbp)
movq %r12, %rdi
leaq 0xcf38(%rip), %rsi      # 0x141b4
movq %rbx, %rdx
callq 0x7ac0
movq %rax, %r14
movq %r12, %rdi
leaq 0xcf20(%rip), %rsi      # 0x141b1
movq %rbx, %rdx
callq 0x7ac0
movq %rax, %r13
movq %r12, %rdi
leaq 0xcf1b(%rip), %rsi      # 0x141c1
callq 0x5f55
movq %rax, %r15
movq %r12, %rdi
leaq 0xcf16(%rip), %rsi      # 0x141ce
callq 0x5f55
movq %rax, %rbx
movq %r12, %rdi
leaq 0xcf10(%rip), %rsi      # 0x141da
callq 0x79e5
movq -0x48(%rbp), %rsi
movq %rbx, -0x78(%rbp)
testq %rbx, %rbx
je 0x7896
testq %r15, %r15
je 0x7896
cmpl $-0x1, %esi
je 0x7896
cmpl $-0x1, %r14d
je 0x7896
cmpl $-0x1, %r13d
je 0x7896
movq %rax, %r12
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x7e14
movq %rbx, %rdi
movl %r14d, %esi
callq 0x7e14
movq %rbx, %rdi
movl %r13d, %esi
callq 0x7e14
movq %rbx, %rdi
movq -0x80(%rbp), %r14
movq %r14, %rsi
movq %r15, %rdx
movq -0x60(%rbp), %r15
movq %r15, %rcx
callq 0x7ade
testb %al, %al
je 0x78b9
movq %rbx, %rdi
movq %r14, %rsi
movq -0x78(%rbp), %rdx
movq %r15, %rcx
callq 0x7ade
testb %al, %al
je 0x78d1
testq %r12, %r12
je 0x73d8
movq 0x8(%r12), %rbx
movq -0x30(%rbp), %r14
movq %r14, %rdi
movl %ebx, %esi
callq 0x7e14
movq -0x80(%rbp), %rdi
callq 0x11b99
movq %r14, %rdi
movl %eax, %esi
callq 0x11b5e
xorl %r14d, %r14d
cmpq %r14, %rbx
je 0x73ee
movq 0x10(%r12), %rax
movq (%rax,%r14,8), %rdx
movq -0x80(%rbp), %r13
movq %r13, %rdi
movq -0x40(%rbp), %rsi
callq 0x79a3
movq 0x18(%r12), %rax
movq (%rax,%r14,8), %rax
cmpl $0x5, (%rax)
jne 0x73fa
cvttsd2si 0x8(%rax), %eax
cltq
movl (%r15,%rax,4), %esi
movq %r13, %rdi
callq 0x7e14
incq %r14
jmp 0x7394
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x7e14
movq %rbx, %rdi
callq 0x7e29
movq -0x58(%rbp), %rcx
incq %rcx
jmp 0x7234
movq 0x15bd7(%rip), %rax     # 0x1cfd8
movq (%rax), %rcx
leaq 0xce07(%rip), %rdi      # 0x14212
pushq $0x20
jmp 0x6bc3
movq 0x15bbf(%rip), %rax     # 0x1cfd8
movq (%rax), %rcx
leaq 0xccf1(%rip), %rdi      # 0x14114
jmp 0x6ba3
leaq 0xce04(%rip), %rsi      # 0x14233
movq -0x38(%rbp), %rdi
callq 0x79e5
testq %rax, %rax
je 0x78e7
movq %rax, %r15
leaq 0xcd5a(%rip), %rsi      # 0x141a5
pushq $-0x2
popq %r12
movq %rax, %rdi
movq %r12, %rdx
callq 0x7ac0
movq %rax, %rbx
leaq 0xcd50(%rip), %rsi      # 0x141b4
movq %r15, %rdi
movq %r12, %rdx
callq 0x7ac0
movq %rax, %r14
leaq 0xcd38(%rip), %rsi      # 0x141b1
movq %r15, %rdi
movq %r12, %rdx
callq 0x7ac0
cmpl $-0x2, %ebx
je 0x78fd
cmpl $-0x2, %r14d
je 0x78fd
movq %rax, %r15
cmpl $-0x2, %r15d
je 0x78fd
movq -0x68(%rbp), %r13
movq %r13, %rdi
movl %ebx, %esi
callq 0x7e14
movq %r13, %rdi
movl %r14d, %esi
callq 0x7e14
movq %r13, %rdi
movl %r15d, %esi
callq 0x7e14
leaq 0xcdb9(%rip), %rsi      # 0x14288
movq -0x90(%rbp), %rdi
callq 0x5f55
testq %rax, %rax
je 0x759b
movq %rax, %r12
movq 0x8(%rax), %rsi
movq %r13, %rdi
movq %rsi, -0x80(%rbp)
callq 0x7e14
movq -0x30(%rbp), %rdi
callq 0x11b99
movq %r13, %rdi
movl %eax, %esi
callq 0x11b5e
xorl %ebx, %ebx
movq -0x30(%rbp), %r14
cmpq %rbx, -0x80(%rbp)
je 0x75ad
movq 0x10(%r12), %rax
movq (%rax,%rbx,8), %rdi
cmpl $0x2, (%rdi)
jne 0x7915
leaq 0xcd64(%rip), %rsi      # 0x14297
xorl %edx, %edx
callq 0x5f34
testq %rax, %rax
je 0x792d
movq %rax, %r15
leaq -0x1d0(%rbp), %rdi
movq %rax, %rsi
callq 0xc948
movq -0x1c0(%rbp), %r13
movq %r14, %rdi
movq -0x40(%rbp), %rsi
movq %r15, %rdx
callq 0x79a3
andl $0x0, -0x1d0(%rbp)
movq %r14, %rdi
leaq -0x1d0(%rbp), %rsi
pushq $0x4
popq %rdx
callq 0x11b32
movq %r14, %rdi
movq %r13, %rsi
callq 0x7e30
incq %rbx
movq -0x68(%rbp), %r13
jmp 0x7510
movq %r13, %rdi
xorl %esi, %esi
callq 0x7e14
movq %r13, %rdi
callq 0x7e29
leaq 0xcd59(%rip), %rsi      # 0x1430d
movq -0x90(%rbp), %rdi
callq 0x5f55
testq %rax, %rax
je 0x766f
movq %rax, %rbx
movq 0x8(%rax), %r14
movq %r13, %rdi
movl %r14d, %esi
callq 0x7e14
movq -0x30(%rbp), %rdi
callq 0x11b99
movq %r13, %rdi
movl %eax, %esi
callq 0x11b5e
xorl %r12d, %r12d
movq -0x30(%rbp), %r13
cmpq %r12, %r14
je 0x7681
movq 0x10(%rbx), %rax
movq (%rax,%r12,8), %rdi
cmpl $0x2, (%rdi)
jne 0x766a
leaq 0xcd0a(%rip), %rsi      # 0x1431c
xorl %edx, %edx
callq 0x5f34
testq %rax, %rax
je 0x7945
movq %rax, %r15
movq %rax, %rdi
movq -0x88(%rbp), %rsi
movq -0xa0(%rbp), %rdx
callq 0x116ee
movq %rax, -0x1d0(%rbp)
movq %rdx, -0x1c8(%rbp)
movq %r13, %rdi
movq -0x40(%rbp), %rsi
movq %r15, %rdx
callq 0x79a3
movq %r13, %rdi
leaq -0x1d0(%rbp), %rsi
pushq $0x10
popq %rdx
callq 0x11b32
incq %r12
jmp 0x75f5
movq %r13, %rdi
xorl %esi, %esi
callq 0x7e14
movq %r13, %rdi
callq 0x7e29
leaq 0xccb2(%rip), %rsi      # 0x1433a
movq -0x90(%rbp), %rdi
callq 0x5f55
testq %rax, %rax
je 0x7704
movq %rax, %rbx
movl 0x8(%rax), %esi
movq -0x68(%rbp), %r12
movq %r12, %rdi
callq 0x7e14
movq -0x30(%rbp), %rdi
callq 0x11b99
movq %r12, %rdi
movl %eax, %esi
callq 0x11b5e
movq 0x8(%rbx), %r14
xorl %r15d, %r15d
movq -0x40(%rbp), %r13
cmpq %r15, %r14
je 0x771e
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rax
cmpl $0x4, (%rax)
jne 0x7029
movq 0x8(%rax), %rdx
cmpb $0x2e, (%rdx)
jne 0x795d
movq %rdx, %rdi
callq 0x58de
movq -0x30(%rbp), %rdi
movl %eax, %esi
callq 0x7df6
incq %r15
jmp 0x76c9
movq -0x68(%rbp), %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0x7e14
movq %r12, %rdi
callq 0x7e29
movq -0x40(%rbp), %r13
leaq 0xcc70(%rip), %rsi      # 0x14395
pushq $-0x1
popq %rdx
movq -0x90(%rbp), %rbx
movq %rbx, %rdi
callq 0x7ac0
movq %r12, %rdi
movl %eax, %esi
callq 0x7e14
leaq 0xcc5f(%rip), %rsi      # 0x143a7
leaq 0xcc66(%rip), %rdx      # 0x143b5
movq %rbx, %rdi
callq 0x5f34
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x79a3
leaq 0xcc58(%rip), %rsi      # 0x143c4
leaq 0xcc62(%rip), %rdx      # 0x143d5
movq %rbx, %rdi
callq 0x5f34
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x79a3
leaq 0xcc58(%rip), %rsi      # 0x143e8
leaq 0xcc63(%rip), %rdx      # 0x143fa
movq %rbx, %rdi
callq 0x5f34
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x79a3
leaq 0xcc59(%rip), %rsi      # 0x1440d
leaq 0xcc67(%rip), %rdx      # 0x14422
movq %rbx, %rdi
callq 0x5f34
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x79a3
leaq 0xcc61(%rip), %rsi      # 0x14439
leaq 0xcc6e(%rip), %rdx      # 0x1444d
movq %rbx, %rdi
callq 0x5f34
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x79a3
leaq 0xcc66(%rip), %rsi      # 0x14462
leaq 0xcc76(%rip), %rdx      # 0x14479
movq %rbx, %rdi
callq 0x5f34
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x79a3
leaq -0x130(%rbp), %rdi
callq 0x7e44
movq -0x88(%rbp), %rbx
movq %rbx, %rdi
movq -0xa8(%rbp), %rsi
callq 0xd7a2
movq %rbx, %rdi
movq -0x60(%rbp), %rsi
callq 0xd7a2
movb $0x1, %bl
jmp 0x702b
movq 0x15783(%rip), %rax     # 0x1cfd8
movq (%rax), %rcx
leaq 0xc8c9(%rip), %rdi      # 0x14128
pushq $0x1b
jmp 0x6bc3
movq 0x1576b(%rip), %rax     # 0x1cfd8
movq (%rax), %rcx
leaq 0xc8cd(%rip), %rdi      # 0x14144
pushq $0x1c
jmp 0x6bc3
movq 0x15753(%rip), %rax     # 0x1cfd8
movq (%rax), %rcx
leaq 0xc8d2(%rip), %rdi      # 0x14161
pushq $0x1f
jmp 0x6bc3
movq 0x1573b(%rip), %rax     # 0x1cfd8
movq (%rax), %rdi
leaq 0xc8da(%rip), %rsi      # 0x14181
xorl %ebx, %ebx
movq -0x58(%rbp), %rdx
xorl %eax, %eax
callq 0x3480
jmp 0x702b
movq 0x15718(%rip), %rax     # 0x1cfd8
movq (%rax), %rcx
leaq 0xc91b(%rip), %rdi      # 0x141e5
pushq $0x16
jmp 0x6bc3
movq 0x15700(%rip), %rax     # 0x1cfd8
movq (%rax), %rcx
leaq 0xc91a(%rip), %rdi      # 0x141fc
jmp 0x6b8e
movq 0x156ea(%rip), %rax     # 0x1cfd8
movq (%rax), %rcx
leaq 0xc94d(%rip), %rdi      # 0x14245
jmp 0x740b
movq 0x156d4(%rip), %rax     # 0x1cfd8
movq (%rax), %rcx
leaq 0xc958(%rip), %rdi      # 0x14266
pushq $0x21
jmp 0x6bc3
movq 0x156bc(%rip), %rax     # 0x1cfd8
movq (%rax), %rcx
leaq 0xc9a8(%rip), %rdi      # 0x142ce
pushq $0x3e
jmp 0x6bc3
movq 0x156a4(%rip), %rax     # 0x1cfd8
movq (%rax), %rcx
leaq 0xc95e(%rip), %rdi      # 0x1429c
pushq $0x31
jmp 0x6bc3
movq 0x1568c(%rip), %rax     # 0x1cfd8
movq (%rax), %rcx
leaq 0xc9cb(%rip), %rdi      # 0x14321
pushq $0x18
jmp 0x6bc3
movq 0x15674(%rip), %rax     # 0x1cfd8
movq (%rax), %rdi
leaq 0xc9e4(%rip), %rsi      # 0x14352
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x3480
jmp 0x702b
jmp 0x798c
jmp 0x798c
jmp 0x798c
jmp 0x798c
jmp 0x798c
jmp 0x798c
jmp 0x798c
jmp 0x798c
movq %rax, %rdi
movq -0xa0(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, 0x18(%rax)
callq 0x35e0