// File: /workspace/github_c_makefile_star2_O2/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, %r13
movq %rdi, %r14
cmpl $0x0, (%rdx)
jne 0x3283
movq %r14, %rdi
movq %r13, %rdx
callq 0x31b8
movq 0x18(%r14), %rbx
leaq 0x271f(%rip), %rdi      # 0x59ad
callq 0x1060
movl (%r13), %esi
leaq 0x1aac(%rip), %rdi      # 0x4d4a
xorl %eax, %eax
callq 0x1090
movl 0x4(%r13), %esi
leaq 0x1aba(%rip), %rdi      # 0x4d6a
xorl %eax, %eax
callq 0x1090
movl 0x8(%r13), %esi
leaq 0x1ac8(%rip), %rdi      # 0x4d8a
xorl %eax, %eax
callq 0x1090
movswl 0xc(%r13), %esi
leaq 0x1ad5(%rip), %rdi      # 0x4daa
xorl %eax, %eax
callq 0x1090
movzwl 0xe(%r13), %esi
leaq 0x1ae2(%rip), %rdi      # 0x4dca
xorl %eax, %eax
callq 0x1090
movswl 0x10(%r13), %esi
leaq 0x1aef(%rip), %rdi      # 0x4dea
xorl %eax, %eax
callq 0x1090
movzwl 0x12(%r13), %esi
leaq 0x1afc(%rip), %rdi      # 0x4e0a
xorl %eax, %eax
callq 0x1090
movzwl 0x14(%r13), %esi
leaq 0x1b09(%rip), %rdi      # 0x4e2a
xorl %eax, %eax
callq 0x1090
movzwl 0x16(%r13), %esi
leaq 0x1b16(%rip), %rdi      # 0x4e4a
xorl %eax, %eax
callq 0x1090
movl 0x18(%r13), %esi
leaq 0x1b24(%rip), %rdi      # 0x4e6a
xorl %eax, %eax
callq 0x1090
movl 0x1c(%r13), %esi
leaq 0x1b32(%rip), %rdi      # 0x4e8a
xorl %eax, %eax
callq 0x1090
movl 0x20(%r13), %esi
leaq 0x1b40(%rip), %rdi      # 0x4eaa
xorl %eax, %eax
callq 0x1090
movl 0x24(%r13), %esi
leaq 0x1b4e(%rip), %rdi      # 0x4eca
xorl %eax, %eax
callq 0x1090
movl 0x28(%r13), %esi
leaq 0x1b5c(%rip), %rdi      # 0x4eea
xorl %eax, %eax
callq 0x1090
movl 0x2c(%r13), %esi
leaq 0x1b6a(%rip), %rdi      # 0x4f0a
xorl %eax, %eax
callq 0x1090
movl 0x30(%r13), %esi
leaq 0x1b78(%rip), %rdi      # 0x4f2a
xorl %eax, %eax
callq 0x1090
movl 0x34(%r13), %esi
leaq 0x1b86(%rip), %rdi      # 0x4f4a
xorl %eax, %eax
callq 0x1090
movzwl 0x38(%r13), %esi
leaq 0x1b93(%rip), %rdi      # 0x4f6a
xorl %eax, %eax
callq 0x1090
movzwl 0x3a(%r13), %esi
leaq 0x1ba0(%rip), %rdi      # 0x4f8a
xorl %eax, %eax
callq 0x1090
movl 0x3c(%r13), %esi
leaq 0x1bb2(%rip), %rdi      # 0x4fae
xorl %eax, %eax
callq 0x1090
addq $0x40, %rbx
pushq $0xa
popq %r12
xorl %r14d, %r14d
xorl %ebp, %ebp
movq %r13, (%rsp)
cmpl 0x18(%r13), %r14d
jae 0x3602
leaq 0x1ba9(%rip), %rdi      # 0x4fce
movl %ebp, %esi
xorl %eax, %eax
callq 0x1090
movl (%rbx), %esi
leaq 0x1bb1(%rip), %rdi      # 0x4fe8
xorl %eax, %eax
callq 0x1090
movswl 0x4(%rbx), %esi
leaq 0x1bbb(%rip), %rdi      # 0x5004
xorl %eax, %eax
callq 0x1090
movzwl 0x6(%rbx), %esi
leaq 0x1bc5(%rip), %rdi      # 0x5020
xorl %eax, %eax
callq 0x1090
movl 0x8(%rbx), %esi
leaq 0x1bd0(%rip), %rdi      # 0x503c
xorl %eax, %eax
callq 0x1090
movl 0xc(%rbx), %esi
leaq 0xe9a(%rip), %rdi       # 0x4317
xorl %eax, %eax
callq 0x1090
movl 0x10(%rbx), %esi
leaq 0x2244(%rip), %rdi      # 0x56d2
xorl %eax, %eax
callq 0x1090
movswl 0x14(%rbx), %esi
leaq 0x1bb8(%rip), %rdi      # 0x5058
xorl %eax, %eax
callq 0x1090
movzwl 0x16(%rbx), %esi
leaq 0x1bc2(%rip), %rdi      # 0x5074
xorl %eax, %eax
callq 0x1090
movl 0x18(%rbx), %esi
leaq 0x1bcd(%rip), %rdi      # 0x5090
xorl %eax, %eax
callq 0x1090
movl 0x1c(%rbx), %esi
leaq 0x1bda(%rip), %rdi      # 0x50ae
xorl %eax, %eax
callq 0x1090
movzwl 0x20(%rbx), %esi
leaq 0x1a88(%rip), %rdi      # 0x4f6e
xorl %eax, %eax
callq 0x1090
movzwl 0x22(%rbx), %esi
leaq 0x1bd4(%rip), %rdi      # 0x50cc
xorl %eax, %eax
callq 0x1090
movl 0x24(%rbx), %esi
leaq 0x1bdf(%rip), %rdi      # 0x50e8
xorl %eax, %eax
callq 0x1090
movl 0x28(%rbx), %esi
leaq 0x1bea(%rip), %rdi      # 0x5104
xorl %eax, %eax
callq 0x1090
movl 0x2c(%rbx), %esi
leaq 0x1bf5(%rip), %rdi      # 0x5120
xorl %eax, %eax
callq 0x1090
movzwl 0x30(%rbx), %esi
leaq 0x1bff(%rip), %rdi      # 0x513c
xorl %eax, %eax
callq 0x1090
movzwl 0x32(%rbx), %esi
leaq 0x1a63(%rip), %rdi      # 0x4fb2
xorl %eax, %eax
callq 0x1090
movl 0x34(%rbx), %esi
leaq 0x1bf8(%rip), %rdi      # 0x5158
xorl %eax, %eax
callq 0x1090
movl 0x38(%rbx), %esi
leaq 0x1c03(%rip), %rdi      # 0x5174
xorl %eax, %eax
callq 0x1090
movl 0x3c(%rbx), %esi
leaq 0x1c0e(%rip), %rdi      # 0x5190
xorl %eax, %eax
callq 0x1090
leaq 0x1c1c(%rip), %rdi      # 0x51ac
xorl %eax, %eax
callq 0x1090
pushq $0x41
popq %r15
pushq $0x40
popq %r13
movzbl (%rbx,%r13), %edi
testl %edi, %edi
je 0x35b5
callq 0x1040
incq %r13
incq %r15
jmp 0x359f
movl %r12d, %edi
callq 0x1040
leaq 0x1c01(%rip), %rdi      # 0x51c5
xorl %eax, %eax
callq 0x1090
movq (%rsp), %r13
movzbl (%rbx,%r15), %edi
testl %edi, %edi
je 0x35e2
callq 0x1040
incq %r15
jmp 0x35cf
movl %r12d, %edi
callq 0x1040
addl $0x4, %r15d
andl $0x7ffffffc, %r15d      # imm = 0x7FFFFFFC
addl %r15d, %r14d
addq %r15, %rbx
incl %ebp
jmp 0x3414
movl (%rbx), %ebp
leaq 0x1bd3(%rip), %rdi      # 0x51de
movl %ebp, %esi
xorl %eax, %eax
callq 0x1090
xorl %eax, %eax
cmpl $0xf13151e4, %ebp       # imm = 0xF13151E4
sete %al
leal 0x1c(,%rax,4), %r13d
addq $0x20, %rbx
pushq $0x4
popq %r14
leaq 0x1c1b(%rip), %r15      # 0x5251
xorl %r12d, %r12d
movq (%rsp), %rax
cmpl 0x1c(%rax), %r14d
jae 0x3717
leaq 0x1bbb(%rip), %rdi      # 0x5209
movl %r12d, %esi
xorl %eax, %eax
callq 0x1090
movswl -0x1c(%rbx), %esi
leaq 0x19a1(%rip), %rdi      # 0x5004
xorl %eax, %eax
callq 0x1090
movzwl -0x1a(%rbx), %esi
leaq 0x19ab(%rip), %rdi      # 0x5020
xorl %eax, %eax
callq 0x1090
movl -0x18(%rbx), %esi
leaq 0x19b6(%rip), %rdi      # 0x503c
xorl %eax, %eax
callq 0x1090
movl -0x14(%rbx), %esi
leaq 0xc80(%rip), %rdi       # 0x4317
xorl %eax, %eax
callq 0x1090
movl -0x10(%rbx), %esi
leaq 0x202a(%rip), %rdi      # 0x56d2
xorl %eax, %eax
callq 0x1090
movzwl -0xc(%rbx), %esi
leaq 0x199e(%rip), %rdi      # 0x5058
xorl %eax, %eax
callq 0x1090
movzwl -0xa(%rbx), %esi
leaq 0x19a8(%rip), %rdi      # 0x5074
xorl %eax, %eax
callq 0x1090
movl -0x8(%rbx), %esi
leaq 0x1b54(%rip), %rdi      # 0x5231
xorl %eax, %eax
callq 0x1090
movl -0x4(%rbx), %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x1090
cmpl $0xf13151e4, %ebp       # imm = 0xF13151E4
jne 0x3709
movl (%rbx), %esi
leaq 0x1b6f(%rip), %rdi      # 0x5271
xorl %eax, %eax
callq 0x1090
addl %r13d, %r14d
incl %r12d
addq %r13, %rbx
jmp 0x3639
movzwl -0x1c(%rbx), %esi
movzwl -0x1a(%rbx), %edx
leaq 0x1b67(%rip), %rdi      # 0x528d
xorl %eax, %eax
callq 0x1090
leaq -0x14(%rbx), %r14
addq $-0x18, %rbx
pushq $0x4
popq %rcx
xorl %r13d, %r13d
movzwl (%rbx), %ebp
movq (%rsp), %rax
cmpl 0x20(%rax), %ecx
jae 0x388d
testb $0x1, %bpl
pushq $0x72
popq %rdx
pushq $0x2d
popq %rax
cmovel %eax, %edx
testb $0x2, %bpl
movl %ecx, 0x8(%rsp)
pushq $0x77
popq %rcx
cmovel %eax, %ecx
testb $0x4, %bpl
pushq $0x65
popq %r8
cmovel %eax, %r8d
testb $0x8, %bpl
leaq 0xff0(%rip), %r9        # 0x476d
leaq 0x2179(%rip), %rsi      # 0x58fd
cmoveq %rsi, %r9
btl $0x8, %ebp
pushq $0x53
popq %rsi
movl %esi, %r10d
cmovael %eax, %r10d
btl $0x9, %ebp
pushq $0x41
popq %rsi
movl %esi, %r11d
cmovael %eax, %r11d
btl $0xa, %ebp
pushq $0x47
popq %rsi
movl %esi, %r15d
cmovael %eax, %r15d
subq $0x8, %rsp
leaq 0x18(%rsp), %r12
movq %r12, %rdi
leaq 0x1af2(%rip), %rsi      # 0x52b7
xorl %eax, %eax
pushq %r15
pushq %r11
pushq %r10
callq 0x1120
addq $0x20, %rsp
leaq 0x1aeb(%rip), %rdi      # 0x52c8
movl %r13d, %esi
xorl %eax, %eax
callq 0x1090
leaq 0x1aff(%rip), %rdi      # 0x52ed
movl %ebp, %esi
movq %r12, %rdx
xorl %eax, %eax
callq 0x1090
movzwl 0x2(%rbx), %esi
leaq 0x1b0b(%rip), %rdi      # 0x5310
xorl %eax, %eax
callq 0x1090
movzwl 0x4(%rbx), %esi
leaq 0x1b15(%rip), %rdi      # 0x532c
xorl %eax, %eax
callq 0x1090
movzwl 0x6(%rbx), %esi
leaq 0x1b1f(%rip), %rdi      # 0x5348
xorl %eax, %eax
callq 0x1090
movswl 0x8(%rbx), %esi
leaq 0x1b29(%rip), %rdi      # 0x5364
xorl %eax, %eax
callq 0x1090
movswl 0xa(%rbx), %esi
leaq 0x1b33(%rip), %rdi      # 0x5380
xorl %eax, %eax
callq 0x1090
movl 0xc(%rbx), %esi
leaq 0x17de(%rip), %rdi      # 0x503c
xorl %eax, %eax
callq 0x1090
movl 0x10(%rbx), %esi
leaq 0x1b2d(%rip), %rdi      # 0x539c
xorl %eax, %eax
callq 0x1090
movl 0x8(%rsp), %ecx
addl $0x14, %ecx
addq $0x14, %rbx
incl %r13d
addq $0x14, %r14
jmp 0x373b
movzwl 0x2(%rbx), %edx
leaq 0x1b20(%rip), %rdi      # 0x53b8
movl %ebp, %esi
movq %rdx, 0x8(%rsp)
xorl %eax, %eax
callq 0x1090
leal (,%rbp,2), %r13d
leaq 0x1b30(%rip), %r15      # 0x53e5
xorl %r12d, %r12d
cmpl %r12d, %r13d
je 0x38da
movzwl (%r14), %esi
movzwl (%r14,%r13), %edx
movq %r15, %rdi
xorl %eax, %eax
callq 0x1090
addq $0x2, %r14
addq $0x2, %r12
jmp 0x38b8
movl %ebp, %eax
leaq (%rbx,%rax,4), %r15
movq 0x8(%rsp), %rax
leaq (%r15,%rax,4), %r13
addq $0x4, %r13
movl %eax, %r12d
leaq 0x1b14(%rip), %r14      # 0x540b
xorl %ebp, %ebp
cmpl %ebp, %r12d
je 0x3917
movslq (%r15,%rbp,4), %rsi
movq %rsi, %rdx
addq %r13, %rdx
movq %r14, %rdi
xorl %eax, %eax
callq 0x1090
incq %rbp
jmp 0x38f9
movq (%rsp), %r13
movslq 0x24(%r13), %r12
movslq 0x28(%r13), %r15
movslq 0x34(%r13), %r14
leaq 0x2091(%rip), %rdi      # 0x59bf
callq 0x1060
movl 0x30(%r13), %esi
cmpl $0x16, %esi
jl 0x3a2b
addq %r12, %rbx
addq %r15, %rbx
movswl (%r14,%rbx), %esi
leaq 0x1ac7(%rip), %rdi      # 0x5419
xorl %eax, %eax
callq 0x1090
movswl 0x2(%r14,%rbx), %esi
leaq 0x1ad6(%rip), %rdi      # 0x543c
xorl %eax, %eax
callq 0x1090
movswl 0x4(%r14,%rbx), %esi
leaq 0x1ae5(%rip), %rdi      # 0x545f
xorl %eax, %eax
callq 0x1090
movswl 0x6(%r14,%rbx), %esi
leaq 0x1af4(%rip), %rdi      # 0x5482
xorl %eax, %eax
callq 0x1090
movswl 0x8(%r14,%rbx), %esi
leaq 0x1b03(%rip), %rdi      # 0x54a5
xorl %eax, %eax
callq 0x1090
movswl 0xa(%r14,%rbx), %esi
leaq 0x1b12(%rip), %rdi      # 0x54c8
xorl %eax, %eax
callq 0x1090
movswl 0xc(%r14,%rbx), %esi
leaq 0x1b21(%rip), %rdi      # 0x54eb
xorl %eax, %eax
callq 0x1090
movswl 0xe(%r14,%rbx), %esi
leaq 0x1b30(%rip), %rdi      # 0x550e
xorl %eax, %eax
callq 0x1090
movswl 0x10(%r14,%rbx), %esi
leaq 0x1b3f(%rip), %rdi      # 0x5531
xorl %eax, %eax
callq 0x1090
movswl 0x12(%r14,%rbx), %esi
leaq 0x1b4e(%rip), %rdi      # 0x5554
xorl %eax, %eax
callq 0x1090
movswl 0x14(%r14,%rbx), %esi
leaq 0x1b5d(%rip), %rdi      # 0x5577
xorl %eax, %eax
callq 0x1090
pushq $0xa
popq %rdi
callq 0x1040
jmp 0x3a39
leaq 0x1b68(%rip), %rdi      # 0x559a
xorl %eax, %eax
callq 0x1090
leaq 0x1ddc(%rip), %rdi      # 0x581c
callq 0x1060
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq