// File: /workspace/github_c_makefile_star2_O1/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, -0xb8(%rbp)
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r12
leaq 0xf87d(%rip), %rdi      # 0x16572
callq 0x3540
xorps %xmm0, %xmm0
movups %xmm0, -0x1c4(%rbp)
movaps %xmm0, -0x1d0(%rbp)
movq %r14, -0xa8(%rbp)
movq %r14, -0x1b0(%rbp)
movq $0x0, -0x1a8(%rbp)
movq %rbx, %rdi
callq 0x13e05
movq %rax, %r14
movq %rbx, %rdi
callq 0x13e05
movq %rax, -0x90(%rbp)
movq %rbx, %rdi
callq 0x13e05
movq %rax, -0x50(%rbp)
movq %rbx, %rdi
callq 0x13e05
movq %rax, -0x38(%rbp)
movq %rbx, %rdi
callq 0x13e05
movq %rax, %r15
movq %rbx, %rdi
callq 0x13e05
movq %rax, -0x60(%rbp)
leaq 0xf47d(%rip), %rsi      # 0x161f1
movq %r12, %rdi
callq 0x65a4
movq %rax, %r13
leaq 0xf32b(%rip), %rsi      # 0x160b1
movq %r12, %rdi
callq 0x65a4
movq %rax, %rbx
leaq 0xf320(%rip), %rsi      # 0x160b8
movq %r12, %rdi
callq 0x65a4
testq %r13, %r13
je 0x7f5e
cmpq $0x0, 0x8(%r13)
je 0x7f5e
movq %r13, -0x70(%rbp)
testq %rbx, %rbx
je 0x7f6c
cmpq $0x0, 0x8(%rbx)
je 0x7f6c
movq %rax, %rdx
testq %rax, %rax
movq %r14, -0x68(%rbp)
movq %r15, -0x48(%rbp)
movq %rbx, -0x1a0(%rbp)
je 0x727f
cmpq $0x0, 0x8(%rdx)
movq -0x90(%rbp), %r13
je 0x7293
movq 0x8(%rdx), %rsi
movq %rsi, %rax
shlq $0x4, %rax
movq %rsp, %rcx
subq %rax, %rcx
movq %rcx, -0xb0(%rbp)
movq %rcx, %rsp
movq %rsi, -0x80(%rbp)
testq %rsi, %rsi
je 0x729e
movq %r12, -0x78(%rbp)
xorl %ebx, %ebx
movq %rdx, -0x98(%rbp)
movq 0x10(%rdx), %rax
movq (%rax,%rbx,8), %r12
cmpl $0x2, (%r12)
jne 0x7f65
movq %r12, %rdi
leaq 0xf659(%rip), %rsi      # 0x164a4
xorl %edx, %edx
callq 0x6529
movq %rax, %r13
movq %r12, %rdi
leaq 0xf64a(%rip), %rsi      # 0x164a9
callq 0x65a4
testq %r13, %r13
je 0x7f65
movq %rax, %r15
testq %rax, %rax
je 0x7f65
movq %rbx, -0xa0(%rbp)
shlq $0x4, %rbx
addq -0xb0(%rbp), %rbx
movl $0x4, %esi
movq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x13b21
movq %r14, %rdi
callq 0x13bed
movl %eax, (%rbx)
movq %rdx, 0x8(%rbx)
movq %r13, %rdi
leaq 0x104e5(%rip), %rsi     # 0x17399
callq 0x3470
movl %eax, %ebx
testl %eax, %eax
je 0x6edc
movq %r13, %rdi
leaq 0xf5ed(%rip), %rsi      # 0x164b6
callq 0x3470
movl $0x1, %ecx
testl %eax, %eax
je 0x6ede
jmp 0x7f65
xorl %ecx, %ecx
movl %ebx, -0x40(%rbp)
movl %ecx, -0x160(%rbp)
movl $0x4, %edx
movq -0x38(%rbp), %rbx
movq %rbx, %rdi
leaq -0x160(%rbp), %r14
movq %r14, %rsi
callq 0x13b75
movl 0x8(%r15), %eax
movl %eax, -0x160(%rbp)
movl $0x4, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13b75
movq -0x48(%rbp), %rdi
callq 0x13bed
movq %rbx, %rdi
movl %eax, %esi
callq 0x13ba1
movq %r14, %rdi
callq 0xe17e
movq %r13, %rdi
callq 0x3150
movq %r14, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0xe068
movq 0x8(%r15), %r14
testq %r14, %r14
je 0x6fad
xorl %ebx, %ebx
movq 0x10(%r15), %rax
movq (%rax,%rbx,8), %rax
cmpl $0x4, (%rax)
je 0x6f67
xorl %eax, %eax
movq 0x8(%rax), %r13
testq %r13, %r13
je 0x7f65
movq %r13, %rdi
callq 0x3150
leaq -0x160(%rbp), %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0xe068
movq -0x48(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq %r13, %rdx
leaq -0x1d0(%rbp), %rcx
callq 0x61e0
incq %rbx
cmpq %rbx, %r14
jne 0x6f58
movl $0x10, %esi
movq -0x38(%rbp), %rdi
callq 0x13b65
movq %rax, -0x58(%rbp)
cmpl $0x0, -0x40(%rbp)
je 0x724a
movq %r12, %rdi
leaq 0xf4eb(%rip), %rsi      # 0x164be
callq 0x8964
movzbl %al, %ebx
movq %r12, %rdi
leaq 0xf4eb(%rip), %rsi      # 0x164d0
callq 0x8964
leal 0x2(%rbx), %r14d
testb %al, %al
cmovel %ebx, %r14d
movq %r12, %rdi
leaq 0xf4e0(%rip), %rsi      # 0x164de
callq 0x8964
leal 0x4(%r14), %ecx
testb %al, %al
cmovel %r14d, %ecx
movl %ecx, -0x2c(%rbp)
movl $0x4, %edx
movq -0x38(%rbp), %rdi
leaq -0x2c(%rbp), %r13
movq %r13, %rsi
callq 0x13b75
movq %r12, %rdi
leaq 0xf4bf(%rip), %rsi      # 0x164ee
callq 0x65a4
movq %rax, %r15
movq %r12, %rdi
leaq 0xf4b6(%rip), %rsi      # 0x164f7
callq 0x65a4
movq %rax, %r12
testq %r15, %r15
je 0x7054
movq 0x8(%r15), %rax
jmp 0x7056
xorl %eax, %eax
testq %r12, %r12
movq -0x38(%rbp), %r14
je 0x7066
movq 0x8(%r12), %rbx
jmp 0x7068
xorl %ebx, %ebx
addq %rax, %rbx
movl %ebx, -0x2c(%rbp)
movl $0x4, %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x13b75
testq %rbx, %rbx
je 0x7233
movq %r12, -0x40(%rbp)
movl $0x4, %esi
movq -0x48(%rbp), %rbx
movq %rbx, %rdi
callq 0x13b21
movq %rbx, %rdi
callq 0x13bed
movq %r14, %rdi
movl %eax, %esi
callq 0x13ba1
testq %r15, %r15
je 0x7169
movq 0x8(%r15), %rax
movq %rax, -0x88(%rbp)
testq %rax, %rax
je 0x7169
movq 0x10(%r15), %rax
movq (%rax), %rbx
cmpl $0x4, (%rbx)
jne 0x7f65
movq -0x88(%rbp), %rax
leaq -0x1(%rax), %r13
xorl %r12d, %r12d
movq 0x8(%rbx), %rdx
movq -0x48(%rbp), %r14
movq %r14, %rdi
movq -0x60(%rbp), %rsi
callq 0x8645
movq 0x8(%rbx), %rdi
callq 0x3150
movw %ax, -0x2c(%rbp)
movl $0x2, %edx
movq %r14, %rdi
leaq -0x2c(%rbp), %rbx
movq %rbx, %rsi
callq 0x13b75
movb $0x1, -0x2c(%rbp)
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x13b75
movb $0x0, -0x2c(%rbp)
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x13b75
cmpq %r12, %r13
je 0x7169
movq 0x10(%r15), %rax
movq 0x8(%rax,%r12,8), %rbx
incq %r12
cmpl $0x4, (%rbx)
je 0x70e9
cmpq -0x88(%rbp), %r12
jb 0x7f65
cmpq $0x0, -0x40(%rbp)
je 0x724a
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x88(%rbp)
testq %rax, %rax
je 0x724a
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rbx
cmpl $0x4, (%rbx)
jne 0x7f65
movq -0x88(%rbp), %rax
leaq -0x1(%rax), %r13
xorl %r15d, %r15d
movq 0x8(%rbx), %rdx
movq -0x48(%rbp), %r14
movq %r14, %rdi
movq -0x60(%rbp), %rsi
callq 0x8645
movq 0x8(%rbx), %rdi
callq 0x3150
movw %ax, -0x2c(%rbp)
movl $0x2, %edx
movq %r14, %rdi
leaq -0x2c(%rbp), %r12
movq %r12, %rsi
callq 0x13b75
xorl %ebx, %ebx
movb %bl, -0x2c(%rbp)
movl $0x1, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x13b75
movb %bl, -0x2c(%rbp)
movl $0x1, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x13b75
cmpq %r15, %r13
je 0x724a
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax,%r15,8), %rbx
incq %r15
cmpl $0x4, (%rbx)
je 0x71ae
cmpq -0x88(%rbp), %r15
jae 0x724a
jmp 0x7f65
movl $0x0, -0x2c(%rbp)
movl $0x4, %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x13b75
leaq -0x160(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0xe195
movq -0xa0(%rbp), %rbx
incq %rbx
cmpq -0x80(%rbp), %rbx
movq -0x98(%rbp), %rdx
jne 0x6e2e
movq -0x78(%rbp), %r12
movq -0x68(%rbp), %r14
jmp 0x728a
movq $0x0, -0xb0(%rbp)
movq -0x90(%rbp), %r13
jmp 0x729e
movq $0x0, -0xb0(%rbp)
leaq -0x160(%rbp), %rsi
movl $0x6d992313, (%rsi)     # imm = 0x6D992313
movl $0x4, %edx
movq %r14, %rdi
callq 0x13b75
movq -0x70(%rbp), %r15
movq 0x8(%r15), %rsi
shlq $0x2, %rsi
movq -0xa8(%rbp), %rbx
movq %rbx, %rdi
callq 0xef62
movq 0x8(%r15), %rcx
shlq $0x2, %rcx
leaq (%rcx,%rcx,4), %rsi
movq %rbx, %rdi
movq %rax, %rbx
callq 0xef62
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, -0x90(%rbp)
movq %rax, %rdx
callq 0x6299
testb %al, %al
je 0x7f71
movq %rbx, -0xa0(%rbp)
movq 0x8(%r15), %r15
leaq -0x160(%rbp), %rsi
movl %r15d, (%rsi)
movl $0x4, %edx
movq %r14, %rdi
callq 0x13b75
movq %r13, %rdi
callq 0x13bed
movq %r14, %rdi
movl %eax, %esi
callq 0x13ba1
testq %r15, %r15
je 0x7360
movq -0x90(%rbp), %rbx
movl $0x10, %edx
movq %r13, %rdi
movq %rbx, %rsi
callq 0x13b75
addq $0x14, %rbx
decq %r15
jne 0x7347
movq -0x50(%rbp), %rdi
callq 0x13bed
movq %r14, %rdi
movl %eax, %esi
callq 0x13ba1
movq -0xb8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0xc0(%rbp)
movq -0x70(%rbp), %rax
movq 0x8(%rax), %rbx
movq %rbx, %rax
shlq $0x6, %rax
leaq (%rax,%rax,8), %rsi
movq -0xa8(%rbp), %rdi
callq 0xef62
movq %rax, %rdi
leaq (,%rbx,8), %rax
leaq (%rax,%rax,2), %rdx
movq %rdi, -0x58(%rbp)
xorl %esi, %esi
callq 0x31b0
movq %rbx, -0x40(%rbp)
testq %rbx, %rbx
movq %r12, -0x78(%rbp)
je 0x7a37
xorl %r12d, %r12d
leaq 0xf12f(%rip), %r13      # 0x16508
movq -0x70(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax,%r12,8), %rdi
cmpl $0x2, (%rdi)
jne 0x7453
movq %r13, %rsi
callq 0x65a4
movq %rax, %r15
movl $0x4, %eax
testq %r15, %r15
je 0x7458
movq 0x8(%r15), %r14
testq %r14, %r14
je 0x7458
xorl %ebx, %ebx
movq 0x10(%r15), %rax
movq (%rax,%rbx,8), %rax
cmpl $0x5, (%rax)
jne 0x7453
cvttsd2si 0x8(%rax), %eax
testl %eax, %eax
js 0x7453
cmpl -0x40(%rbp), %eax
jge 0x7453
movl %eax, %eax
leaq (%rax,%rax,2), %rax
movq -0x58(%rbp), %rcx
leaq (%rcx,%rax,8), %rdi
movl $0x1, %edx
movq -0xa8(%rbp), %rsi
callq 0x8bc1
movl %r12d, (%rax)
incq %rbx
cmpq %rbx, %r14
jne 0x740a
xorl %eax, %eax
jmp 0x7458
movl $0x1, %eax
testb $0x3, %al
jne 0x7f4a
incq %r12
cmpq -0x40(%rbp), %r12
jne 0x73d9
xorl %eax, %eax
movq -0x60(%rbp), %r14
movq -0x70(%rbp), %rdx
movq %rax, -0x168(%rbp)
leaq (%rax,%rax,4), %rax
movq -0x90(%rbp), %rcx
movslq 0x10(%rcx,%rax,4), %rcx
movq 0x10(%rdx), %rax
movq %rcx, -0x198(%rbp)
movq (%rax,%rcx,8), %r13
cmpl $0x2, (%r13)
movl $0x0, %eax
cmovneq %rax, %r13
movq %r13, %rdi
leaq 0xf05b(%rip), %rsi      # 0x16510
xorl %edx, %edx
callq 0x6529
movq %rax, -0x98(%rbp)
movq %r13, %rdi
leaq 0xe9ea(%rip), %rsi      # 0x15eb7
xorl %edx, %edx
callq 0x6529
movq %rax, -0x88(%rbp)
movq %r13, %rdi
leaq 0xf028(%rip), %rsi      # 0x1650d
xorl %edx, %edx
callq 0x6529
movq %rax, %rbx
movq %r13, %rdi
leaq 0xf01e(%rip), %rsi      # 0x16517
xorl %edx, %edx
callq 0x883e
movq %rax, %r15
movq %r13, %rdi
leaq 0xeffb(%rip), %rsi      # 0x16508
callq 0x65a4
movq %rax, %r12
movq %r13, %rdi
leaq 0xe991(%rip), %rsi      # 0x15eb0
callq 0x65a4
movq %rax, -0x190(%rbp)
movq %r13, %rdi
leaq 0xf1b9(%rip), %rsi      # 0x166ee
callq 0x65a4
movq %rax, -0x188(%rbp)
movq %r13, %rdi
leaq 0xefd6(%rip), %rsi      # 0x16521
callq 0x65a4
movq %rax, -0x180(%rbp)
movq %r13, %rdi
leaq 0xefcb(%rip), %rsi      # 0x1652c
callq 0x65a4
movq %rax, -0x80(%rbp)
movq %r13, -0x170(%rbp)
movq %r13, %rdi
leaq 0xefb5(%rip), %rsi      # 0x16530
movq $-0x1, %rdx
callq 0x883e
movq %rax, -0x178(%rbp)
movq -0x50(%rbp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq -0x98(%rbp), %rdx
callq 0x8645
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x8645
movq %r13, %rdi
movq %r14, %rsi
movq -0x88(%rbp), %rdx
leaq -0x1d0(%rbp), %rcx
callq 0x61e0
movl %r15d, -0x160(%rbp)
movl $0x4, %edx
movq %r13, %rdi
leaq -0x160(%rbp), %rsi
callq 0x13b75
testq %r12, %r12
je 0x768c
movl $0x4, %esi
movq -0x38(%rbp), %rdi
callq 0x13b21
movq -0x50(%rbp), %rbx
movl 0x8(%r12), %eax
movl %eax, -0x160(%rbp)
movl $0x4, %edx
movq %rbx, %rdi
leaq -0x160(%rbp), %rsi
callq 0x13b75
movq -0x38(%rbp), %rdi
callq 0x13bed
movq %rbx, %rdi
movl %eax, %esi
callq 0x13ba1
movq 0x8(%r12), %rbx
testq %rbx, %rbx
je 0x76cc
xorl %r14d, %r14d
movq 0x10(%r12), %rax
movq (%rax,%r14,8), %rax
cmpl $0x5, (%rax)
jne 0x7f4a
cvttsd2si 0x8(%rax), %eax
cltq
movq -0xa0(%rbp), %rcx
movl (%rcx,%rax,4), %eax
movl %eax, -0x160(%rbp)
movl $0x4, %edx
movq -0x38(%rbp), %rdi
leaq -0x160(%rbp), %rsi
callq 0x13b75
incq %r14
cmpq %r14, %rbx
jne 0x7644
jmp 0x76cc
movl $0x0, -0x160(%rbp)
movl $0x4, %edx
movq -0x50(%rbp), %rbx
movq %rbx, %rdi
leaq -0x160(%rbp), %rsi
callq 0x13b75
movl $0x0, -0x160(%rbp)
movl $0x4, %edx
movq %rbx, %rdi
leaq -0x160(%rbp), %rsi
callq 0x13b75
movq -0x198(%rbp), %rax
leaq (%rax,%rax,2), %rbx
movq -0x58(%rbp), %rax
movq 0x8(%rax,%rbx,8), %rax
testq %rax, %rax
je 0x776f
movl %eax, -0x160(%rbp)
movl $0x4, %edx
movq -0x50(%rbp), %r14
movq %r14, %rdi
leaq -0x160(%rbp), %rsi
callq 0x13b75
movq -0x38(%rbp), %r12
movq %r12, %rdi
callq 0x13bed
movq %r14, %rdi
movl %eax, %esi
callq 0x13ba1
movq -0x58(%rbp), %rax
leaq (%rax,%rbx,8), %rax
movq 0x8(%rax), %rbx
testq %rbx, %rbx
je 0x77b3
movq (%rax), %r14
shlq $0x2, %rbx
xorl %r15d, %r15d
movslq (%r14,%r15), %rax
movq -0xa0(%rbp), %rcx
movl (%rcx,%rax,4), %eax
movl %eax, -0x160(%rbp)
movl $0x4, %edx
movq %r12, %rdi
leaq -0x160(%rbp), %rsi
callq 0x13b75
addq $0x4, %r15
cmpq %r15, %rbx
jne 0x773c
jmp 0x77b3
movl $0x0, -0x160(%rbp)
movl $0x4, %edx
movq -0x50(%rbp), %rbx
movq %rbx, %rdi
leaq -0x160(%rbp), %rsi
callq 0x13b75
movq -0x38(%rbp), %r12
movl $0x0, -0x160(%rbp)
movl $0x4, %edx
movq %rbx, %rdi
leaq -0x160(%rbp), %rsi
callq 0x13b75
movq -0x50(%rbp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
movq -0x60(%rbp), %r14
movq %r14, %rdx
movq -0x190(%rbp), %rcx
callq 0x89d6
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq -0x188(%rbp), %rcx
callq 0x89d6
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq -0x180(%rbp), %rcx
callq 0x89d6
movq -0x80(%rbp), %rax
testq %rax, %rax
je 0x78f6
cmpq $0x0, 0x8(%rax)
je 0x78f6
movl $0x4, %esi
movq %r12, %rdi
callq 0x13b21
movq -0x80(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x160(%rbp)
movl $0x4, %edx
movq %rbx, %rdi
leaq -0x160(%rbp), %rsi
callq 0x13b75
movq %r12, %rdi
callq 0x13bed
movq %rbx, %rdi
movl %eax, %esi
callq 0x13ba1
movq -0x80(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x98(%rbp)
testq %rax, %rax
je 0x7932
xorl %r12d, %r12d
movq -0x80(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax,%r12,8), %rbx
movq %rbx, %rdi
leaq 0xecba(%rip), %rsi      # 0x1653d
xorl %edx, %edx
callq 0x6529
movq %rax, %r15
movq %rbx, %rdi
leaq 0xecaa(%rip), %rsi      # 0x16541
xorl %edx, %edx
callq 0x6529
testq %r15, %r15
je 0x7f4a
movq %rax, %rbx
testq %rax, %rax
je 0x7f4a
movq -0x38(%rbp), %r13
movq %r13, %rdi
movq -0x60(%rbp), %r14
movq %r14, %rsi
movq %r15, %rdx
leaq -0x1d0(%rbp), %r15
movq %r15, %rcx
callq 0x61e0
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x61e0
incq %r12
cmpq %r12, -0x98(%rbp)
jne 0x786d
jmp 0x7932
movl $0x0, -0x160(%rbp)
movl $0x4, %edx
movq %rbx, %rdi
leaq -0x160(%rbp), %rsi
callq 0x13b75
movl $0x0, -0x160(%rbp)
movl $0x4, %edx
movq %rbx, %rdi
leaq -0x160(%rbp), %rsi
callq 0x13b75
movq -0x178(%rbp), %rax
cmpl $-0x1, %eax
jne 0x7962
movl $0x0, -0x160(%rbp)
movl $0x4, %edx
movq -0x50(%rbp), %r12
movq %r12, %rdi
leaq -0x160(%rbp), %rsi
callq 0x13b75
jmp 0x7983
cltq
shlq $0x4, %rax
movq -0xb0(%rbp), %rcx
movl (%rcx,%rax), %esi
movq 0x8(%rcx,%rax), %rdx
movq -0x50(%rbp), %r12
movq %r12, %rdi
callq 0x13ba1
movq -0x170(%rbp), %r13
movq %r13, %rdi
leaq 0xebb3(%rip), %rsi      # 0x16547
movl $0x1, %edx
callq 0x8afe
movl %eax, %ebx
movq %r13, %rdi
leaq 0xebae(%rip), %rsi      # 0x16558
movl $0x2, %edx
callq 0x8afe
movl %eax, %r15d
orl %ebx, %r15d
movq %r13, %rdi
leaq 0xeba4(%rip), %rsi      # 0x16568
movl $0x4, %edx
callq 0x8afe
orl %r15d, %eax
movl %eax, -0x160(%rbp)
movl $0x4, %edx
movq %r12, %rdi
leaq -0x160(%rbp), %rsi
callq 0x13b75
movq -0x168(%rbp), %rax
incq %rax
cmpq -0x40(%rbp), %rax
movq -0x70(%rbp), %rdx
jne 0x7477
movq -0x58(%rbp), %rbx
movq -0x78(%rbp), %r12
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x7a2d
movq -0xa8(%rbp), %rdi
callq 0xef6a
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
addq $0x18, %rbx
decq -0x40(%rbp)
jne 0x7a0b
movq -0xa8(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0xef6a
movq -0xb8(%rbp), %rax
movq -0xc0(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x1a0(%rbp), %rbx
movl 0x8(%rbx), %eax
leaq -0x160(%rbp), %rsi
movl %eax, (%rsi)
movl $0x4, %edx
movq -0x68(%rbp), %r14
movq %r14, %rdi
callq 0x13b75
movq -0x38(%rbp), %rdi
callq 0x13bed
movq %r14, %rdi
movl %eax, %esi
callq 0x13ba1
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x7ad5
xorl %r15d, %r15d
movq %rbx, %r13
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rax
xorl %ebx, %ebx
cmpl $0x4, (%rax)
je 0x7ab0
xorl %eax, %eax
movq 0x8(%rax), %rdx
testq %rdx, %rdx
je 0x7f73
movq -0x38(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x8645
incq %r15
cmpq %r15, %r14
movq %r13, %rbx
jne 0x7a9c
leaq 0xe624(%rip), %rsi      # 0x16100
movq %r12, %rdi
callq 0x86b0
movq %rax, %r14
leaq 0xe618(%rip), %rsi      # 0x16106
movq %rax, %rdi
callq 0x65a4
movq %rax, %r12
leaq 0xe611(%rip), %rsi      # 0x16111
movq %r14, %rdi
callq 0x65a4
movq %rax, %rbx
leaq 0xe5fc(%rip), %rsi      # 0x1610e
movq %r14, %rdi
callq 0x65a4
movq %rax, %r15
leaq 0xe5f6(%rip), %rsi      # 0x1611a
movq %r14, %rdi
callq 0x65a4
movq %rax, -0x50(%rbp)
testq %r14, %r14
je 0x818a
testq %r12, %r12
je 0x818a
testq %rbx, %rbx
je 0x818a
cmpq $0x0, 0x8(%r12)
je 0x818a
testq %r15, %r15
je 0x818a
cmpq $0x0, 0x8(%rbx)
je 0x818a
cmpq $0x0, -0x50(%rbp)
je 0x818a
cmpq $0x0, 0x8(%r15)
je 0x818a
movq -0x50(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x818a
movq %r15, -0x40(%rbp)
movq %r14, -0x98(%rbp)
movq -0x68(%rbp), %r13
movq %r13, %rdi
movq -0x38(%rbp), %r15
movq %r15, %rsi
movq -0x60(%rbp), %r14
movq %r14, %rdx
movq %r12, %rcx
callq 0x871e
testb %al, %al
je 0x8352
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x871e
testb %al, %al
je 0x835c
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq -0x40(%rbp), %rcx
callq 0x871e
testb %al, %al
je 0x8366
movq -0x50(%rbp), %rbx
movl 0x8(%rbx), %eax
leaq -0x160(%rbp), %rsi
movl %eax, (%rsi)
movl $0x4, %edx
movq %r13, %rdi
callq 0x13b75
movq %r15, %rdi
callq 0x13bed
movq %r13, %rdi
movl %eax, %esi
callq 0x13ba1
movq 0x8(%rbx), %rax
movq %rax, -0x80(%rbp)
testq %rax, %rax
je 0x7f84
xorl %r15d, %r15d
movq -0x50(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax,%r15,8), %r12
cmpl $0x2, (%r12)
jne 0x85ea
movq %r15, -0x70(%rbp)
movq %r12, %rdi
leaq 0xe55c(%rip), %rsi      # 0x161b7
movq $-0x1, %rdx
callq 0x883e
movq %rax, -0x58(%rbp)
movq %r12, %rdi
leaq 0xe551(%rip), %rsi      # 0x161c6
movq $-0x1, %rdx
callq 0x883e
movq %rax, %rbx
movq %r12, %rdi
leaq 0xe535(%rip), %rsi      # 0x161c3
movq $-0x1, %rdx
callq 0x883e
movq %rax, %r15
movq %r12, %rdi
leaq 0xe52c(%rip), %rsi      # 0x161d3
callq 0x65a4
movq %rax, %r13
movq %r12, %rdi
leaq 0xe527(%rip), %rsi      # 0x161e0
callq 0x65a4
movq %rax, %r14
movq %r12, %rdi
leaq 0xe521(%rip), %rsi      # 0x161ec
callq 0x86b0
movq %rax, -0x40(%rbp)
movq -0x58(%rbp), %rax
movq %r14, -0xb0(%rbp)
testq %r14, %r14
je 0x7f00
movq %r13, %r14
testq %r13, %r13
je 0x7f00
cmpl $-0x1, %eax
je 0x7f00
movq %rbx, %r13
cmpl $-0x1, %r13d
je 0x7f00
cmpl $-0x1, %r15d
je 0x7f00
movl %eax, -0x160(%rbp)
movl $0x4, %edx
movq -0x38(%rbp), %rbx
movq %rbx, %rdi
leaq -0x160(%rbp), %r12
movq %r12, %rsi
callq 0x13b75
movl %r13d, -0x160(%rbp)
movl $0x4, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x13b75
movl %r15d, -0x160(%rbp)
movl $0x4, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x13b75
movq %rbx, %rdi
movq -0x48(%rbp), %r12
movq %r12, %rsi
movq %r14, %rdx
movq -0xa0(%rbp), %r15
movq %r15, %rcx
callq 0x88bb
testb %al, %al
je 0x7f2a
movq %rbx, %rdi
movq %r12, %rsi
movq -0xb0(%rbp), %rdx
movq %r15, %rcx
callq 0x88bb
testb %al, %al
movq -0x68(%rbp), %r13
je 0x7f3a
movq -0x40(%rbp), %rax
testq %rax, %rax
je 0x7e8b
movq 0x8(%rax), %r15
movl %r15d, -0x160(%rbp)
movl $0x4, %edx
movq -0x38(%rbp), %rbx
movq %rbx, %rdi
leaq -0x160(%rbp), %rsi
callq 0x13b75
movq -0x48(%rbp), %rdi
callq 0x13bed
movq %rbx, %rdi
movl %eax, %esi
callq 0x13ba1
xorl %eax, %eax
testq %r15, %r15
setne %r13b
je 0x7ed6
movq %r15, -0x58(%rbp)
negq %r15
movl $0x1, %ebx
movq -0x60(%rbp), %rsi
movq -0x40(%rbp), %r14
movq 0x10(%r14), %rax
movq -0x8(%rax,%rbx,8), %rdx
movq -0x48(%rbp), %r12
movq %r12, %rdi
callq 0x8645
movq 0x18(%r14), %rax
movq -0x8(%rax,%rbx,8), %rax
movl (%rax), %r14d
cmpl $0x5, %r14d
jne 0x7e84
cvttsd2si 0x8(%rax), %eax
cltq
movq -0xa0(%rbp), %rcx
movl (%rcx,%rax,4), %eax
movl %eax, -0x160(%rbp)
movl $0x4, %edx
movq %r12, %rdi
leaq -0x160(%rbp), %rsi
callq 0x13b75
cmpl $0x5, %r14d
jne 0x7ecd
cmpq -0x58(%rbp), %rbx
setb %r13b
leaq (%r15,%rbx), %rax
incq %rax
incq %rbx
cmpq $0x1, %rax
movq -0x60(%rbp), %rsi
jne 0x7e0a
jmp 0x7ed4
callq 0x374c
jmp 0x7e60
xorl %r15d, %r15d
movl %r15d, -0x160(%rbp)
movl $0x4, %edx
movq -0x38(%rbp), %rbx
movq %rbx, %rdi
leaq -0x160(%rbp), %r12
movq %r12, %rsi
callq 0x13b75
movl %r15d, -0x160(%rbp)
movl $0x4, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x13b75
movq -0x70(%rbp), %r15
jmp 0x7ee4
movl $0x1, %eax
jmp 0x7ed6
xorl %eax, %eax
testb $0x1, %r13b
movq -0x68(%rbp), %r13
movq -0x70(%rbp), %r15
jne 0x7ee6
xorl %eax, %eax
testl %eax, %eax
jne 0x7f71
incq %r15
cmpq -0x80(%rbp), %r15
jne 0x7c36
jmp 0x7f84
movq 0x150d1(%rip), %rax     # 0x1cfd8
movq (%rax), %rdi
leaq 0xe282(%rip), %rsi      # 0x16193
movq -0x70(%rbp), %r15
movl %r15d, %edx
xorl %eax, %eax
callq 0x3480
movl $0x1, %eax
movq -0x68(%rbp), %r13
jmp 0x7ee6
callq 0x3708
movl $0x1, %eax
movq -0x68(%rbp), %r13
jmp 0x7f44
callq 0x372a
movl $0x1, %eax
movq -0x70(%rbp), %r15
jmp 0x7ee6
movq -0xb8(%rbp), %rax
movq -0xc0(%rbp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x7f71
callq 0x3856
jmp 0x7f71
callq 0x3680
jmp 0x7f71
callq 0x383a
xorl %ebx, %ebx
movl %ebx, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe2ba(%rip), %rsi      # 0x16245
movq -0x98(%rbp), %rdi
callq 0x86b0
testq %rax, %rax
je 0x8378
movq %rax, %rbx
leaq 0xe20d(%rip), %rsi      # 0x161b7
movq %rax, %rdi
movq $-0x2, %rdx
callq 0x883e
movq %rax, %r15
leaq 0xe203(%rip), %rsi      # 0x161c6
movq %rbx, %rdi
movq $-0x2, %rdx
callq 0x883e
movq %rax, %r14
leaq 0xe1e7(%rip), %rsi      # 0x161c3
movq %rbx, %rdi
movq $-0x2, %rdx
callq 0x883e
cmpl $-0x2, %r15d
je 0x8382
cmpl $-0x2, %r14d
je 0x8382
movq %rax, %rbx
cmpl $-0x2, %ebx
je 0x8382
leaq -0x160(%rbp), %r12
movl %r15d, (%r12)
movl $0x4, %edx
movq %r13, %rdi
movq %r12, %rsi
callq 0x13b75
movl %r14d, (%r12)
leaq -0x160(%rbp), %r14
movl $0x4, %edx
movq %r13, %rdi
movq %r14, %rsi
callq 0x13b75
movl %ebx, (%r14)
leaq -0x160(%rbp), %rsi
movl $0x4, %edx
movq %r13, %rdi
callq 0x13b75
leaq 0xe23b(%rip), %rsi      # 0x1629a
movq -0x78(%rbp), %r12
movq %r12, %rdi
callq 0x65a4
testq %rax, %rax
je 0x8194
movq %rax, %rbx
movq 0x8(%rax), %r14
leaq -0x160(%rbp), %rsi
movl %r14d, (%rsi)
movl $0x4, %edx
movq %r13, %rdi
callq 0x13b75
movq -0x38(%rbp), %rdi
callq 0x13bed
movq %r13, %rdi
movl %eax, %esi
callq 0x13ba1
testq %r14, %r14
setne %cl
je 0x81ca
movb %cl, -0x48(%rbp)
movq %r14, %rax
negq %rax
movq %rax, -0x40(%rbp)
movl $0x1, %r15d
movq %r14, -0x58(%rbp)
movq -0x38(%rbp), %r12
movq 0x10(%rbx), %rax
movq -0x8(%rax,%r15,8), %rdi
cmpl $0x2, (%rdi)
jne 0x860c
leaq 0xe1c4(%rip), %rsi      # 0x162a9
xorl %edx, %edx
callq 0x6529
movq %rax, %r13
testq %rax, %rax
je 0x8183
leaq -0x160(%rbp), %rdi
movq %r13, %rsi
callq 0xdd8c
movq %rbx, %r14
movq -0x150(%rbp), %rbx
movq %r12, %rdi
movq -0x60(%rbp), %rsi
movq %r13, %rdx
callq 0x8645
movl $0x0, -0x2c(%rbp)
movl $0x4, %edx
movq %r12, %rdi
leaq -0x2c(%rbp), %rsi
callq 0x13b75
movq %rbx, -0x160(%rbp)
movq %r14, %rbx
movq -0x58(%rbp), %r14
movl $0x8, %edx
movq %r12, %rdi
leaq -0x160(%rbp), %rsi
callq 0x13b75
testq %r13, %r13
je 0x81ce
cmpq %r14, %r15
setb -0x48(%rbp)
movq -0x40(%rbp), %rax
addq %r15, %rax
incq %rax
incq %r15
cmpq $0x1, %rax
movq -0x68(%rbp), %r13
jne 0x80cc
jmp 0x81dd
callq 0x3790
jmp 0x815a
callq 0x3818
jmp 0x7f71
xorl %r14d, %r14d
leaq -0x160(%rbp), %rbx
movl %r14d, (%rbx)
movl $0x4, %edx
movq %r13, %rdi
movq %rbx, %rsi
callq 0x13b75
movl %r14d, (%rbx)
leaq -0x160(%rbp), %rsi
movl $0x4, %edx
movq %r13, %rdi
callq 0x13b75
jmp 0x81eb
xorl %eax, %eax
jmp 0x81e6
movl $0x1, %eax
movq -0x78(%rbp), %r12
movq -0x68(%rbp), %r13
jmp 0x81e3
xorl %eax, %eax
movq -0x78(%rbp), %r12
movb -0x48(%rbp), %cl
testb $0x1, %cl
jne 0x81ed
xorl %eax, %eax
testl %eax, %eax
jne 0x7f71
leaq 0xe123(%rip), %rsi      # 0x1631f
movq %r12, %rdi
callq 0x65a4
testq %rax, %rax
je 0x831c
movq %rax, %r14
movq 0x8(%rax), %rbx
leaq -0x160(%rbp), %rsi
movl %ebx, (%rsi)
movl $0x4, %edx
movq %r13, %rdi
callq 0x13b75
movq -0x38(%rbp), %rdi
callq 0x13bed
movq %r13, %rdi
movl %eax, %esi
callq 0x13ba1
testq %rbx, %rbx
setne %r15b
je 0x8374
movq %rbx, %rcx
negq %rcx
movq %rbx, %r13
movl $0x1, %ebx
movq %rcx, -0x40(%rbp)
movq 0x10(%r14), %rax
movq -0x8(%rax,%rbx,8), %rdi
cmpl $0x2, (%rdi)
jne 0x82f8
leaq 0xe0b9(%rip), %rsi      # 0x1632e
xorl %edx, %edx
callq 0x6529
movq %rax, %r12
testq %rax, %rax
je 0x8315
movq %r12, %rdi
movq -0xa8(%rbp), %rsi
movq -0xb8(%rbp), %rdx
callq 0x136ed
movq %rax, -0x160(%rbp)
movq %rdx, -0x158(%rbp)
movb %r15b, -0x48(%rbp)
movq %r13, %r15
movq %r14, %r13
movq -0x38(%rbp), %r14
movq %r14, %rdi
movq -0x60(%rbp), %rsi
movq %r12, %rdx
callq 0x8645
movl $0x10, %edx
movq %r14, %rdi
movq %r13, %r14
movq %r15, %r13
movb -0x48(%rbp), %r15b
leaq -0x160(%rbp), %rsi
callq 0x13b75
testq %r12, %r12
movq -0x78(%rbp), %r12
movq -0x40(%rbp), %rcx
je 0x838c
cmpq %r13, %rbx
setb %r15b
leaq (%rcx,%rbx), %rax
incq %rax
incq %rbx
cmpq $0x1, %rax
jne 0x825c
jmp 0x8370
callq 0x37b2
jmp 0x82e7
xorl %r14d, %r14d
leaq -0x160(%rbp), %rbx
movl %r14d, (%rbx)
movl $0x4, %edx
movq %r13, %rdi
movq %rbx, %rsi
callq 0x13b75
movl %r14d, (%rbx)
leaq -0x160(%rbp), %rsi
movl $0x4, %edx
movq %r13, %rdi
callq 0x13b75
jmp 0x839b
callq 0x36a2
jmp 0x7f71
callq 0x36c4
jmp 0x7f71
callq 0x36e6
jmp 0x7f71
xorl %eax, %eax
jmp 0x8391
xorl %eax, %eax
jmp 0x8395
callq 0x37f6
jmp 0x7f71
callq 0x37d4
jmp 0x7f71
movl $0x1, %eax
movq -0x68(%rbp), %r13
testb $0x1, %r15b
jne 0x839d
xorl %eax, %eax
testl %eax, %eax
jne 0x7f71
leaq 0xdfa0(%rip), %rsi      # 0x1634c
movq %r12, %rdi
callq 0x65a4
testq %rax, %rax
je 0x846e
movq %rax, %rbx
movl 0x8(%rax), %eax
leaq -0x160(%rbp), %rsi
movl %eax, (%rsi)
movl $0x4, %edx
movq %r13, %rdi
callq 0x13b75
movq -0x38(%rbp), %rdi
callq 0x13bed
movq %r13, %rdi
movl %eax, %esi
callq 0x13ba1
movq 0x8(%rbx), %r12
testq %r12, %r12
je 0x84a2
leaq -0x160(%rbp), %r14
xorl %r13d, %r13d
movq 0x10(%rbx), %rax
movq (%rax,%r13,8), %rax
cmpl $0x4, (%rax)
jne 0x7f71
movq 0x8(%rax), %rdx
movb (%rdx), %r15b
cmpb $0x2e, %r15b
jne 0x8454
movq %rdx, %rdi
callq 0x5df8
movl %eax, -0x160(%rbp)
movl $0x4, %edx
movq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x13b75
cmpb $0x2e, %r15b
jne 0x7f71
incq %r13
cmpq %r13, %r12
jne 0x8403
jmp 0x84a2
movq 0x14b7d(%rip), %rax     # 0x1cfd8
movq (%rax), %rdi
leaq 0xdeff(%rip), %rsi      # 0x16364
xorl %eax, %eax
callq 0x3480
jmp 0x8440
xorl %r14d, %r14d
leaq -0x160(%rbp), %rbx
movl %r14d, (%rbx)
movl $0x4, %edx
movq %r13, %rdi
movq %rbx, %rsi
callq 0x13b75
movl %r14d, (%rbx)
leaq -0x160(%rbp), %rsi
movl $0x4, %edx
movq %r13, %rdi
callq 0x13b75
leaq 0xdefe(%rip), %rsi      # 0x163a7
movq -0x78(%rbp), %rbx
movq %rbx, %rdi
movq $-0x1, %rdx
callq 0x883e
leaq -0x160(%rbp), %rsi
movl %eax, (%rsi)
movl $0x4, %edx
movq -0x68(%rbp), %r14
movq %r14, %rdi
callq 0x13b75
leaq 0xdedc(%rip), %rsi      # 0x163b9
leaq 0xdee3(%rip), %rdx      # 0x163c7
movq %rbx, %rdi
callq 0x6529
movq %r14, %rdi
movq -0x60(%rbp), %r15
movq %r15, %rsi
movq %rax, %rdx
callq 0x8645
leaq 0xded1(%rip), %rsi      # 0x163d6
leaq 0xdedb(%rip), %rdx      # 0x163e7
movq %rbx, %rdi
callq 0x6529
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x8645
leaq 0xded1(%rip), %rsi      # 0x163fa
leaq 0xdedc(%rip), %rdx      # 0x1640c
movq %rbx, %rdi
callq 0x6529
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x8645
leaq 0xded2(%rip), %rsi      # 0x1641f
leaq 0xdee0(%rip), %rdx      # 0x16434
movq %rbx, %rdi
callq 0x6529
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x8645
leaq 0xdeda(%rip), %rsi      # 0x1644b
leaq 0xdee7(%rip), %rdx      # 0x1645f
movq %rbx, %rdi
callq 0x6529
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x8645
leaq 0xdedf(%rip), %rsi      # 0x16474
leaq 0xdeef(%rip), %rdx      # 0x1648b
movq %rbx, %rdi
callq 0x6529
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x8645
leaq -0x1d0(%rbp), %rdi
callq 0x8b83
movq -0xa8(%rbp), %rbx
movq %rbx, %rdi
movq -0x90(%rbp), %rsi
callq 0xef6a
movq %rbx, %rdi
movq -0xa0(%rbp), %rsi
callq 0xef6a
movb $0x1, %bl
jmp 0x7f73
movq 0x149e7(%rip), %rax     # 0x1cfd8
movq (%rax), %rdi
leaq 0xdb98(%rip), %rsi      # 0x16193
xorl %ebx, %ebx
movl %r15d, %edx
xorl %eax, %eax
callq 0x3480
jmp 0x7f73
callq 0x376e
movl $0x1, %eax
jmp 0x81df
jmp 0x862b
jmp 0x862b
jmp 0x862b
jmp 0x862b
jmp 0x862b
jmp 0x862b
jmp 0x862b
jmp 0x862b
movq -0xb8(%rbp), %rcx
movq -0xc0(%rbp), %rdx
movq %rdx, 0x18(%rcx)
movq %rax, %rdi
callq 0x35e0