// File: /workspace/github_c_makefile_star2_O3/mikeakohn[P]print_pe/build/../src/pdb.c
// Function: print_pdb_dbi_stream
void print_pdb_dbi_stream(
  struct pdb_dir_t *pdb_dir,
  struct pdb_header_t *pdb_header,
  struct pdb_dbi_t *pdb_dbi,
  FILE *in)
{
  if (pdb_dbi->version_signature == 0)
  {
    read_pdb_dbi_stream(pdb_dir, pdb_header, pdb_dbi, in);
  }

  uint8_t *data = pdb_dir->heap;

#if 0
  read_data(pdb_dir, 3, pdb_header->block_size, in);

  uint8_t *data = pdb_dir->heap;

  pdb_dbi->version_signature = get_int32(data + 0);
  pdb_dbi->version_header = get_uint32(data + 4);
  pdb_dbi->age = get_uint32(data + 8);
  pdb_dbi->global_stream_index = get_int16(data + 12);
  pdb_dbi->build_number = get_int16(data + 14);
  pdb_dbi->public_stream_index = get_int16(data + 16);
  pdb_dbi->pdb_dll_version = get_int16(data + 18);
  pdb_dbi->symbol_record_stream = get_int16(data + 20);
  pdb_dbi->pdb_dll_rbld = get_int16(data + 22);
  pdb_dbi->mod_info_size = get_int32(data + 24);
  pdb_dbi->section_contribution_size = get_int32(data + 28);
  pdb_dbi->section_map_size = get_int32(data + 32);
  pdb_dbi->source_info_size = get_int32(data + 36);
  pdb_dbi->type_server_size = get_int32(data + 40);
  pdb_dbi->mfc_type_server_index = get_uint32(data + 44);
  pdb_dbi->optional_debug_header_size = get_int32(data + 48);
  pdb_dbi->ec_substream_size = get_int32(data + 52);
  pdb_dbi->flags = get_int16(data + 56);
  pdb_dbi->machine = get_uint16(data + 58);
  pdb_dbi->padding = get_uint32(data + 60);
#endif

  printf(" -- DBI Stream --\n");
  printf("         version_signature: %d\n", pdb_dbi->version_signature);
  printf("            version_header: %d\n", pdb_dbi->version_header);
  printf("                       age: %d\n", pdb_dbi->age);
  printf("       global_stream_index: %d\n", pdb_dbi->global_stream_index);
  printf("              build_number: %d\n", pdb_dbi->build_number);
  printf("       public_stream_index: %d\n", pdb_dbi->public_stream_index);
  printf("           pdb_dll_version: %d\n", pdb_dbi->pdb_dll_version);
  printf("      symbol_record_stream: %d\n", pdb_dbi->symbol_record_stream);
  printf("              pdb_dll_rbld: %d\n", pdb_dbi->pdb_dll_rbld);
  printf("             mod_info_size: %d\n", pdb_dbi->mod_info_size);
  printf(" section_contribution_size: %d\n", pdb_dbi->section_contribution_size);
  printf("          section_map_size: %d\n", pdb_dbi->section_map_size);
  printf("          source_info_size: %d\n", pdb_dbi->source_info_size);
  printf("          type_server_size: %d\n", pdb_dbi->type_server_size);
  printf("     mfc_type_server_index: %d\n", pdb_dbi->mfc_type_server_index);
  printf("optional_debug_header_size: %d\n", pdb_dbi->optional_debug_header_size);
  printf("         ec_substream_size: %d\n", pdb_dbi->ec_substream_size);
  printf("                     flags: %d\n", pdb_dbi->flags);
  printf("                   machine: 0x%04x\n", pdb_dbi->machine);
  printf("                   padding: %d\n", pdb_dbi->padding);

  uint8_t *next = data + 64;
  int count = 0;
  uint32_t bytes = 0;
  int i;

  while (bytes < pdb_dbi->mod_info_size)
  {
    printf("       --- module %d ---\n", count);
    printf("            reserved_1: %d\n", get_uint32(next + 0));
    printf("               section: %d\n", get_int16(next + 4));
    printf("             padding_1: %d\n", get_uint16(next + 6));
    printf("                offset: %d\n", get_int32(next + 8));
    printf("                  size: %d\n", get_int32(next + 12));
    printf("       characteristics: 0x%08x\n", get_uint32(next + 16));
    printf("          module_index: %d\n", get_int16(next + 20));
    printf("             padding_2: %d\n", get_uint16(next + 22));
    printf("              data_crc: %08x\n", get_uint32(next + 24));
    printf("             reloc_crc: %08x\n", get_uint32(next + 28));
    printf("                 flags: %d\n", get_uint16(next + 32));
    printf("  module_symbol_stream: %d\n", get_uint16(next + 34));
    printf("      symbol_byte_size: %d\n", get_uint32(next + 36));
    printf("         c11_byte_size: %d\n", get_uint32(next + 40));
    printf("         c13_byte_size: %d\n", get_uint32(next + 44));
    printf("     source_file_count: %d\n", get_uint16(next + 48));
    printf("               padding: %d\n", get_uint16(next + 50));
    printf("            reserved_2: %d\n", get_uint32(next + 52));
    printf("source_file_name_index: %d\n", get_uint32(next + 56));
    printf("   pdb_file_path_index: %d\n", get_uint32(next + 60));
    printf("           module_name: ");

    for (i = 64; next[i] != 0; i++)
    {
      printf("%c", next[i]);
    }
    printf("\n");

    printf("      object_file_name: ");
    i++;
    for (;next[i] != 0; i++)
    {
      printf("%c", next[i]);
    }
    printf("\n");
    i++;

    i = (i + 3) & ~3;

    bytes += i;
    next += i;
    count++;
  }

  uint32_t version = get_uint32(next + 0);

  printf("    -- section contriubtion version: %08x\n", version);

  int length = 28;
  count = 0;
  bytes = 4;
  next += 4;

  if (version == 0xeffe0000 + 20140516) { length += 4; }

  while (bytes < pdb_dbi->section_contribution_size)
  {
    printf("       --- section contribution %d ---\n", count);
    printf("               section: %d\n", get_int16(next + 0));
    printf("             padding_1: %d\n", get_uint16(next + 2));
    printf("                offset: %d\n", get_int32(next + 4));
    printf("                  size: %d\n", get_int32(next + 8));
    printf("       characteristics: 0x%08x\n", get_uint32(next + 12));
    printf("          module_index: %d\n", get_uint16(next + 16));
    printf("             padding_2: %d\n", get_uint16(next + 18));
    printf("              data_crc: 0x%08x\n", get_uint32(next + 20));
    printf("             reloc_crc: 0x%08x\n", get_uint32(next + 24));

    if (version == 0xeffe0000 + 20140516)
    {
      printf("            isect_coff: %d\n", get_uint32(next + 28));
    }

    bytes += length;
    next += length;
    count++;
  }

  printf("    -- section map count=%d log_count=%d\n",
    get_uint16(next + 0),
    get_uint16(next + 2));

  count = 0;
  bytes = 4;
  next += 4;

  while (bytes < pdb_dbi->section_map_size)
  {
    uint16_t flags = get_uint16(next + 0);
    char temp[80];

    sprintf(temp, "%c%c%c %s %c%c%c",
      (flags & 1) != 0 ? 'r' : '-',
      (flags & 2) != 0 ? 'w' : '-',
      (flags & 4) != 0 ? 'e' : '-',
      (flags & 8) != 0 ? "32" : "-",
      (flags & 256) != 0 ? 'S' : '-',
      (flags & 512) != 0 ? 'A' : '-',
      (flags & 1024) != 0 ? 'G' : '-');

    printf("       --- section map entry %d ---\n", count);
    printf("                 flags: 0x%04x %s\n", flags, temp);
    printf("                   ovl: %d\n", get_uint16(next + 2));
    printf("                 group: %d\n", get_uint16(next + 4));
    printf("                 frame: %d\n", get_uint16(next + 6));
    printf("          section_name: %d\n", get_int16(next + 8));
    printf("            class_name: %d\n", get_int16(next + 10));
    printf("                offset: %d\n", get_uint32(next + 12));
    printf("        section_length: %d\n", get_uint32(next + 16));

    bytes += 20;
    next += 20;
    count++;
  }

  uint8_t *save = next;
  int module_count = get_uint16(next + 0);
  int source_file_count = get_uint16(next + 2);

  printf("    -- file_info modules=%d source_files=%d\n",
    module_count, source_file_count);

  bytes = 4;
  int offset = bytes + (module_count * 2);

  for (i = 0; i < module_count; i++)
  {
    printf("   module: indices=%d file_counts=%d\n",
      get_uint16(next + bytes), get_uint16(next + offset));
    bytes += 2;
    offset += 2;
  }

  next += module_count * 4;
  uint8_t *names_buffer = save + (module_count * 4) + (source_file_count * 4) + 4;

  for (i = 0; i < source_file_count; i++)
  {
    offset = get_uint32(next);
    printf("    %04x: %s\n", offset, names_buffer + offset);
    next += 4;
  }

  next = save + pdb_dbi->source_info_size;

  // FIXME: Skiping Type Server Substream.
  next += pdb_dbi->type_server_size;

  // FIXME: Skiping EC Substream.
  next += pdb_dbi->ec_substream_size;

  printf("       --- optional_debug ---\n");

  if (pdb_dbi->optional_debug_header_size >= 22)
  {
    printf("                     fpo_data: %d\n", get_int16(next + 0));
    printf("               exception data: %d\n", get_int16(next + 2));
    printf("                   fixup_data: %d\n", get_int16(next + 4));
    printf("             omap_to_src_data: %d\n", get_int16(next + 6));
    printf("           omap_from_src_data: %d\n", get_int16(next + 8));
    printf("          section_header_data: %d\n", get_int16(next + 10));
    printf("                token_rid_map: %d\n", get_int16(next + 12));
    printf("                        xdata: %d\n", get_int16(next + 14));
    printf("                        pdata: %d\n", get_int16(next + 16));
    printf("                 new_fpo_data: %d\n", get_int16(next + 18));
    printf(" original_section_header_data: %d\n", get_int16(next + 20));
    printf("\n");
  }
    else
  {
    printf("section size is only %d?\n", pdb_dbi->optional_debug_header_size);
  }

  printf("\n\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r15
movq %rdi, %r14
cmpl $0x0, (%rdx)
jne 0x33d7
movq %r14, %rdi
movq %r15, %rdx
callq 0x330a
movq 0x18(%r14), %rbx
leaq 0x35cb(%rip), %rdi      # 0x69ad
callq 0x1060
movl (%r15), %esi
leaq 0x2959(%rip), %rdi      # 0x5d4a
xorl %eax, %eax
callq 0x1090
movl 0x4(%r15), %esi
leaq 0x2967(%rip), %rdi      # 0x5d6a
xorl %eax, %eax
callq 0x1090
movl 0x8(%r15), %esi
leaq 0x2975(%rip), %rdi      # 0x5d8a
xorl %eax, %eax
callq 0x1090
movswl 0xc(%r15), %esi
leaq 0x2982(%rip), %rdi      # 0x5daa
xorl %eax, %eax
callq 0x1090
movzwl 0xe(%r15), %esi
leaq 0x298f(%rip), %rdi      # 0x5dca
xorl %eax, %eax
callq 0x1090
movswl 0x10(%r15), %esi
leaq 0x299c(%rip), %rdi      # 0x5dea
xorl %eax, %eax
callq 0x1090
movzwl 0x12(%r15), %esi
leaq 0x29a9(%rip), %rdi      # 0x5e0a
xorl %eax, %eax
callq 0x1090
movzwl 0x14(%r15), %esi
leaq 0x29b6(%rip), %rdi      # 0x5e2a
xorl %eax, %eax
callq 0x1090
movzwl 0x16(%r15), %esi
leaq 0x29c3(%rip), %rdi      # 0x5e4a
xorl %eax, %eax
callq 0x1090
movl 0x18(%r15), %esi
leaq 0x29d1(%rip), %rdi      # 0x5e6a
xorl %eax, %eax
callq 0x1090
movl 0x1c(%r15), %esi
leaq 0x29df(%rip), %rdi      # 0x5e8a
xorl %eax, %eax
callq 0x1090
movl 0x20(%r15), %esi
leaq 0x29ed(%rip), %rdi      # 0x5eaa
xorl %eax, %eax
callq 0x1090
movl 0x24(%r15), %esi
leaq 0x29fb(%rip), %rdi      # 0x5eca
xorl %eax, %eax
callq 0x1090
movl 0x28(%r15), %esi
leaq 0x2a09(%rip), %rdi      # 0x5eea
xorl %eax, %eax
callq 0x1090
movl 0x2c(%r15), %esi
leaq 0x2a17(%rip), %rdi      # 0x5f0a
xorl %eax, %eax
callq 0x1090
movl 0x30(%r15), %esi
leaq 0x2a25(%rip), %rdi      # 0x5f2a
xorl %eax, %eax
callq 0x1090
movl 0x34(%r15), %esi
leaq 0x2a33(%rip), %rdi      # 0x5f4a
xorl %eax, %eax
callq 0x1090
movzwl 0x38(%r15), %esi
leaq 0x2a40(%rip), %rdi      # 0x5f6a
xorl %eax, %eax
callq 0x1090
movzwl 0x3a(%r15), %esi
leaq 0x2a4d(%rip), %rdi      # 0x5f8a
xorl %eax, %eax
callq 0x1090
movl 0x3c(%r15), %esi
leaq 0x2a5f(%rip), %rdi      # 0x5fae
xorl %eax, %eax
callq 0x1090
addq $0x40, %rbx
cmpl $0x0, 0x18(%r15)
movq %r15, 0x8(%rsp)
je 0x3786
leaq 0x2c54(%rip), %r12      # 0x61c5
xorl %r13d, %r13d
xorl %ebp, %ebp
leaq 0x2a51(%rip), %rdi      # 0x5fce
movl %r13d, %esi
xorl %eax, %eax
callq 0x1090
movl (%rbx), %esi
leaq 0x2a58(%rip), %rdi      # 0x5fe8
xorl %eax, %eax
callq 0x1090
movswl 0x4(%rbx), %esi
leaq 0x2a62(%rip), %rdi      # 0x6004
xorl %eax, %eax
callq 0x1090
movzwl 0x6(%rbx), %esi
leaq 0x2a6c(%rip), %rdi      # 0x6020
xorl %eax, %eax
callq 0x1090
movl 0x8(%rbx), %esi
leaq 0x2a77(%rip), %rdi      # 0x603c
xorl %eax, %eax
callq 0x1090
movl 0xc(%rbx), %esi
leaq 0x1d41(%rip), %rdi      # 0x5317
xorl %eax, %eax
callq 0x1090
movl 0x10(%rbx), %esi
leaq 0x30eb(%rip), %rdi      # 0x66d2
xorl %eax, %eax
callq 0x1090
movswl 0x14(%rbx), %esi
leaq 0x2a5f(%rip), %rdi      # 0x6058
xorl %eax, %eax
callq 0x1090
movzwl 0x16(%rbx), %esi
leaq 0x2a69(%rip), %rdi      # 0x6074
xorl %eax, %eax
callq 0x1090
movl 0x18(%rbx), %esi
leaq 0x2a74(%rip), %rdi      # 0x6090
xorl %eax, %eax
callq 0x1090
movl 0x1c(%rbx), %esi
leaq 0x2a81(%rip), %rdi      # 0x60ae
xorl %eax, %eax
callq 0x1090
movzwl 0x20(%rbx), %esi
leaq 0x292f(%rip), %rdi      # 0x5f6e
xorl %eax, %eax
callq 0x1090
movzwl 0x22(%rbx), %esi
leaq 0x2a7b(%rip), %rdi      # 0x60cc
xorl %eax, %eax
callq 0x1090
movl 0x24(%rbx), %esi
leaq 0x2a86(%rip), %rdi      # 0x60e8
xorl %eax, %eax
callq 0x1090
movl 0x28(%rbx), %esi
leaq 0x2a91(%rip), %rdi      # 0x6104
xorl %eax, %eax
callq 0x1090
movl 0x2c(%rbx), %esi
leaq 0x2a9c(%rip), %rdi      # 0x6120
xorl %eax, %eax
callq 0x1090
movzwl 0x30(%rbx), %esi
leaq 0x2aa6(%rip), %rdi      # 0x613c
xorl %eax, %eax
callq 0x1090
movzwl 0x32(%rbx), %esi
leaq 0x290a(%rip), %rdi      # 0x5fb2
xorl %eax, %eax
callq 0x1090
movl 0x34(%rbx), %esi
leaq 0x2a9f(%rip), %rdi      # 0x6158
xorl %eax, %eax
callq 0x1090
movl 0x38(%rbx), %esi
leaq 0x2aaa(%rip), %rdi      # 0x6174
xorl %eax, %eax
callq 0x1090
movl 0x3c(%rbx), %esi
leaq 0x2ab5(%rip), %rdi      # 0x6190
xorl %eax, %eax
callq 0x1090
leaq 0x2ac3(%rip), %rdi      # 0x61ac
xorl %eax, %eax
callq 0x1090
movb 0x40(%rbx), %al
testb %al, %al
je 0x3715
movl $0x41, %r14d
movzbl %al, %edi
callq 0x1040
movb (%rbx,%r14), %al
incq %r14
testb %al, %al
jne 0x36fd
decl %r14d
jmp 0x371b
movl $0x40, %r14d
movl $0xa, %edi
callq 0x1040
movq %r12, %rdi
xorl %eax, %eax
callq 0x1090
movl %r14d, %ecx
movb 0x1(%rbx,%rcx), %al
testb %al, %al
je 0x3759
incq %rcx
leaq (%rbx,%rcx), %r15
incq %r15
movzbl %al, %edi
callq 0x1040
movb (%r15), %al
incl %r14d
incq %r15
testb %al, %al
jne 0x3744
movl $0xa, %edi
callq 0x1040
addl $0x5, %r14d
andl $0x7ffffffc, %r14d      # imm = 0x7FFFFFFC
addl %r14d, %ebp
addq %r14, %rbx
incl %r13d
movq 0x8(%rsp), %r15
cmpl 0x18(%r15), %ebp
jb 0x3576
movl (%rbx), %ebp
leaq 0x2a4f(%rip), %rdi      # 0x61de
movl %ebp, %esi
xorl %eax, %eax
callq 0x1090
xorl %eax, %eax
cmpl $0xf13151e4, %ebp       # imm = 0xF13151E4
sete %cl
cmpl $0x5, 0x1c(%r15)
jb 0x38bf
movb %cl, %al
leal 0x1c(,%rax,4), %eax
movl %eax, %r14d
movl $0x4, %r13d
leaq 0x2a8a(%rip), %r15      # 0x6251
xorl %r12d, %r12d
leaq 0x2a38(%rip), %rdi      # 0x6209
movl %r12d, %esi
xorl %eax, %eax
callq 0x1090
movswl (%rbx,%r13), %esi
leaq 0x281d(%rip), %rdi      # 0x6004
xorl %eax, %eax
callq 0x1090
movzwl 0x2(%rbx,%r13), %esi
leaq 0x2825(%rip), %rdi      # 0x6020
xorl %eax, %eax
callq 0x1090
movl 0x4(%rbx,%r13), %esi
leaq 0x282e(%rip), %rdi      # 0x603c
xorl %eax, %eax
callq 0x1090
movl 0x8(%rbx,%r13), %esi
leaq 0x1af6(%rip), %rdi      # 0x5317
xorl %eax, %eax
callq 0x1090
movl 0xc(%rbx,%r13), %esi
leaq 0x2e9e(%rip), %rdi      # 0x66d2
xorl %eax, %eax
callq 0x1090
movzwl 0x10(%rbx,%r13), %esi
leaq 0x2810(%rip), %rdi      # 0x6058
xorl %eax, %eax
callq 0x1090
movzwl 0x12(%rbx,%r13), %esi
leaq 0x2818(%rip), %rdi      # 0x6074
xorl %eax, %eax
callq 0x1090
movl 0x14(%rbx,%r13), %esi
leaq 0x29c2(%rip), %rdi      # 0x6231
xorl %eax, %eax
callq 0x1090
movl 0x18(%rbx,%r13), %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x1090
cmpl $0xf13151e4, %ebp       # imm = 0xF13151E4
jne 0x38a0
movl 0x1c(%rbx,%r13), %esi
leaq 0x29d8(%rip), %rdi      # 0x6271
xorl %eax, %eax
callq 0x1090
incl %r12d
addq %r14, %r13
movq 0x8(%rsp), %rax
cmpl 0x1c(%rax), %r13d
jb 0x37ca
addq %r13, %rbx
movq 0x8(%rsp), %r15
jmp 0x38c3
addq $0x4, %rbx
movzwl (%rbx), %esi
movzwl 0x2(%rbx), %edx
leaq 0x29bc(%rip), %rdi      # 0x628d
xorl %eax, %eax
callq 0x1090
cmpl $0x5, 0x20(%r15)
jb 0x3a4e
movl $0x4, %r14d
xorl %r13d, %r13d
movzbl (%rbx,%r14), %eax
movzbl 0x1(%rbx,%r14), %esi
movl %esi, %ebp
shll $0x8, %ebp
orl %eax, %ebp
testb $0x1, %al
movl $0x72, %edx
movl $0x2d, %edi
cmovel %edi, %edx
testb $0x2, %al
movl $0x77, %ecx
cmovel %edi, %ecx
testb $0x4, %al
movl $0x65, %r8d
cmovel %edi, %r8d
testb $0x8, %al
leaq 0x1e41(%rip), %r9       # 0x576d
leaq 0x2fca(%rip), %rax      # 0x68fd
cmoveq %rax, %r9
testb $0x1, %sil
movl $0x53, %r10d
cmovel %edi, %r10d
testb $0x2, %sil
movl $0x41, %r11d
cmovel %edi, %r11d
testb $0x4, %sil
movl $0x47, %r15d
cmovel %edi, %r15d
subq $0x8, %rsp
leaq 0x18(%rsp), %r12
movq %r12, %rdi
leaq 0x2943(%rip), %rsi      # 0x62b7
xorl %eax, %eax
pushq %r15
pushq %r11
pushq %r10
callq 0x1120
addq $0x20, %rsp
leaq 0x293c(%rip), %rdi      # 0x62c8
movl %r13d, %esi
xorl %eax, %eax
callq 0x1090
leaq 0x2950(%rip), %rdi      # 0x62ed
movl %ebp, %esi
movq %r12, %rdx
xorl %eax, %eax
callq 0x1090
movzwl 0x2(%rbx,%r14), %esi
leaq 0x295a(%rip), %rdi      # 0x6310
xorl %eax, %eax
callq 0x1090
movzwl 0x4(%rbx,%r14), %esi
leaq 0x2962(%rip), %rdi      # 0x632c
xorl %eax, %eax
callq 0x1090
movzwl 0x6(%rbx,%r14), %esi
leaq 0x296a(%rip), %rdi      # 0x6348
xorl %eax, %eax
callq 0x1090
movswl 0x8(%rbx,%r14), %esi
leaq 0x2972(%rip), %rdi      # 0x6364
xorl %eax, %eax
callq 0x1090
movswl 0xa(%rbx,%r14), %esi
leaq 0x297a(%rip), %rdi      # 0x6380
xorl %eax, %eax
callq 0x1090
movl 0xc(%rbx,%r14), %esi
leaq 0x2623(%rip), %rdi      # 0x603c
xorl %eax, %eax
callq 0x1090
movl 0x10(%rbx,%r14), %esi
leaq 0x2970(%rip), %rdi      # 0x639c
xorl %eax, %eax
callq 0x1090
incl %r13d
addq $0x14, %r14
movq 0x8(%rsp), %rax
cmpl 0x20(%rax), %r14d
jb 0x38ec
addq %r14, %rbx
jmp 0x3a52
addq $0x4, %rbx
movzwl (%rbx), %r14d
movzwl 0x2(%rbx), %ebp
leaq 0x2957(%rip), %rdi      # 0x63b8
movl %r14d, %esi
movl %ebp, %edx
xorl %eax, %eax
callq 0x1090
movl %r14d, %r15d
testl %r14d, %r14d
je 0x3aa4
leaq (%rbx,%r15,2), %r12
addq $0x4, %r12
leaq 0x2961(%rip), %r14      # 0x63e5
xorl %r13d, %r13d
movzwl 0x4(%rbx,%r13,2), %esi
movzwl (%r12,%r13,2), %edx
movq %r14, %rdi
xorl %eax, %eax
callq 0x1090
incq %r13
cmpl %r13d, %r15d
jne 0x3a87
testl %ebp, %ebp
je 0x3adc
leaq (%rbx,%r15,4), %r15
movl %ebp, %r12d
leaq (%r15,%r12,4), %r13
addq $0x4, %r13
leaq 0x294d(%rip), %r14      # 0x640b
xorl %ebp, %ebp
movslq (%r15,%rbp,4), %rsi
movq %rsi, %rdx
addq %r13, %rdx
movq %r14, %rdi
xorl %eax, %eax
callq 0x1090
incq %rbp
cmpl %ebp, %r12d
jne 0x3ac0
movq 0x8(%rsp), %r13
movslq 0x24(%r13), %r12
movslq 0x28(%r13), %r15
movslq 0x34(%r13), %r14
leaq 0x2ecb(%rip), %rdi      # 0x69bf
callq 0x1060
movl 0x30(%r13), %esi
cmpl $0x16, %esi
jl 0x3bf3
addq %r12, %rbx
addq %r15, %rbx
movswl (%r14,%rbx), %esi
leaq 0x2901(%rip), %rdi      # 0x6419
xorl %eax, %eax
callq 0x1090
movswl 0x2(%r14,%rbx), %esi
leaq 0x2910(%rip), %rdi      # 0x643c
xorl %eax, %eax
callq 0x1090
movswl 0x4(%r14,%rbx), %esi
leaq 0x291f(%rip), %rdi      # 0x645f
xorl %eax, %eax
callq 0x1090
movswl 0x6(%r14,%rbx), %esi
leaq 0x292e(%rip), %rdi      # 0x6482
xorl %eax, %eax
callq 0x1090
movswl 0x8(%r14,%rbx), %esi
leaq 0x293d(%rip), %rdi      # 0x64a5
xorl %eax, %eax
callq 0x1090
movswl 0xa(%r14,%rbx), %esi
leaq 0x294c(%rip), %rdi      # 0x64c8
xorl %eax, %eax
callq 0x1090
movswl 0xc(%r14,%rbx), %esi
leaq 0x295b(%rip), %rdi      # 0x64eb
xorl %eax, %eax
callq 0x1090
movswl 0xe(%r14,%rbx), %esi
leaq 0x296a(%rip), %rdi      # 0x650e
xorl %eax, %eax
callq 0x1090
movswl 0x10(%r14,%rbx), %esi
leaq 0x2979(%rip), %rdi      # 0x6531
xorl %eax, %eax
callq 0x1090
movswl 0x12(%r14,%rbx), %esi
leaq 0x2988(%rip), %rdi      # 0x6554
xorl %eax, %eax
callq 0x1090
movswl 0x14(%r14,%rbx), %esi
leaq 0x2997(%rip), %rdi      # 0x6577
xorl %eax, %eax
callq 0x1090
movl $0xa, %edi
callq 0x1040
jmp 0x3c01
leaq 0x29a0(%rip), %rdi      # 0x659a
xorl %eax, %eax
callq 0x1090
leaq 0x2c14(%rip), %rdi      # 0x681c
callq 0x1060
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq