LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/cktan[P]tomlc99/toml.c
// Function: eat_token
static inline int eat_token(context_t *ctx, tokentype_t typ, int isdotspecial,
                            const char *fline) {
  if (ctx->tok.tok != typ)
    return e_internal(ctx, fline);

  if (next_token(ctx, isdotspecial))
    return -1;

  return 0;
}

// Assembly:
pushq %rax
cmpl %esi, 0x20(%rdi)
jne 0x34c8
movl %edx, %esi
callq 0x2b77
movl %eax, %ecx
xorl %eax, %eax
negl %ecx
sbbl %eax, %eax
jmp 0x34e6
movq 0x10(%rdi), %rax
movslq 0x18(%rdi), %rsi
leaq 0x2ed7(%rip), %rdx      # 0x63ae
movq %rax, %rdi
xorl %eax, %eax
callq 0x10f0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/cktan[P]tomlc99/toml.c
// Function: xfree_tab
static void xfree_tab(toml_table_t *p) {
  int i;

  if (!p)
    return;

  xfree(p->key);

  for (i = 0; i < p->nkval; i++)
    xfree_kval(p->kval[i]);
  xfree(p->kval);

  for (i = 0; i < p->narr; i++)
    xfree_arr(p->arr[i]);
  xfree(p->arr);

  for (i = 0; i < p->ntab; i++)
    xfree_tab(p->tab[i]);
  xfree(p->tab);

  xfree(p);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x37d5
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x370e
callq *0x5a12(%rip)           # 0x9120
cmpl $0x0, 0xc(%rbx)
jle 0x3756
xorl %r15d, %r15d
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %r14
testq %r14, %r14
je 0x374a
movq (%r14), %rdi
testq %rdi, %rdi
je 0x3732
callq *0x59ee(%rip)           # 0x9120
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x3741
callq *0x59df(%rip)           # 0x9120
movq %r14, %rdi
callq *0x59d6(%rip)           # 0x9120
incq %r15
movslq 0xc(%rbx), %rax
cmpq %rax, %r15
jl 0x3717
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x3765
callq *0x59bb(%rip)           # 0x9120
cmpl $0x0, 0x18(%rbx)
jle 0x3787
xorl %r14d, %r14d
movq 0x20(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x5975
incq %r14
movslq 0x18(%rbx), %rax
cmpq %rax, %r14
jl 0x376e
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x3796
callq *0x598a(%rip)           # 0x9120
cmpl $0x0, 0x28(%rbx)
jle 0x37b8
xorl %r14d, %r14d
movq 0x30(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x36ef
incq %r14
movslq 0x28(%rbx), %rax
cmpq %rax, %r14
jl 0x379f
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x37c7
callq *0x5959(%rip)           # 0x9120
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *0x594b(%rip)           # 0x9120
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/cktan[P]tomlc99/toml.c
// Function: toml_key_in
const char *toml_key_in(const toml_table_t *tab, int keyidx) {
  if (keyidx < tab->nkval)
    return tab->kval[keyidx]->key;

  keyidx -= tab->nkval;
  if (keyidx < tab->narr)
    return tab->arr[keyidx]->key;

  keyidx -= tab->narr;
  if (keyidx < tab->ntab)
    return tab->tab[keyidx]->key;

  return 0;
}

// Assembly:
movl $0x10, %eax
movl %esi, %edx
subl 0xc(%rdi), %edx
jl 0x3801
movl $0x20, %eax
movl %edx, %ecx
movl %edx, %esi
subl 0x18(%rdi), %ecx
jl 0x3801
movl $0x30, %eax
movl %ecx, %esi
cmpl 0x28(%rdi), %ecx
jge 0x3810
movq (%rdi,%rax), %rax
movslq %esi, %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/cktan[P]tomlc99/toml.c
// Function: toml_key_exists
int toml_key_exists(const toml_table_t *tab, const char *key) {
  int i;
  for (i = 0; i < tab->nkval; i++) {
    if (0 == strcmp(key, tab->kval[i]->key))
      return 1;
  }
  for (i = 0; i < tab->narr; i++) {
    if (0 == strcmp(key, tab->arr[i]->key))
      return 1;
  }
  for (i = 0; i < tab->ntab; i++) {
    if (0 == strcmp(key, tab->tab[i]->key))
      return 1;
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movslq 0xc(%rdi), %r15
testq %r15, %r15
jle 0x384d
movq 0x10(%r14), %r12
xorl %r13d, %r13d
movq (%r12,%r13,8), %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x1150
testl %eax, %eax
je 0x38a7
incq %r13
cmpq %r13, %r15
jne 0x3832
movslq 0x18(%r14), %r15
testq %r15, %r15
jle 0x3878
movq 0x20(%r14), %r12
xorl %r13d, %r13d
movq (%r12,%r13,8), %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x1150
testl %eax, %eax
je 0x38a7
incq %r13
cmpq %r13, %r15
jne 0x385d
movslq 0x28(%r14), %r15
testq %r15, %r15
jle 0x38a3
movq 0x30(%r14), %r14
xorl %r12d, %r12d
movq (%r14,%r12,8), %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x1150
testl %eax, %eax
je 0x38a7
incq %r12
cmpq %r12, %r15
jne 0x3888
xorl %eax, %eax
jmp 0x38ac
movl $0x1, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/cktan[P]tomlc99/toml.c
// Function: toml_raw_in
toml_raw_t toml_raw_in(const toml_table_t *tab, const char *key) {
  int i;
  for (i = 0; i < tab->nkval; i++) {
    if (0 == strcmp(key, tab->kval[i]->key))
      return tab->kval[i]->val;
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq 0xc(%rdi), %r15
testq %r15, %r15
jle 0x38f4
movq %rsi, %r14
movq 0x10(%rdi), %r12
xorl %ebx, %ebx
xorl %r13d, %r13d
movq (%r12,%r13,8), %rbp
movq (%rbp), %rsi
movq %r14, %rdi
callq 0x1150
testl %eax, %eax
je 0x38f8
incq %r13
cmpq %r13, %r15
jne 0x38d6
jmp 0x38fc
xorl %ebx, %ebx
jmp 0x38fc
movq 0x8(%rbp), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cktan[P]tomlc99/toml.c
// Function: toml_array_in
toml_array_t *toml_array_in(const toml_table_t *tab, const char *key) {
  int i;
  for (i = 0; i < tab->narr; i++) {
    if (0 == strcmp(key, tab->arr[i]->key))
      return tab->arr[i];
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movslq 0x18(%rdi), %r15
testq %r15, %r15
jle 0x3945
movq %rsi, %rbx
movq 0x20(%rdi), %r12
xorl %r13d, %r13d
movq (%r12,%r13,8), %r14
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x1150
testl %eax, %eax
je 0x3948
incq %r13
cmpq %r13, %r15
jne 0x392a
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/cktan[P]tomlc99/toml.c
// Function: toml_table_in
toml_table_t *toml_table_in(const toml_table_t *tab, const char *key) {
  int i;
  for (i = 0; i < tab->ntab; i++) {
    if (0 == strcmp(key, tab->tab[i]->key))
      return tab->tab[i];
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movslq 0x28(%rdi), %r15
testq %r15, %r15
jle 0x398c
movq %rsi, %rbx
movq 0x30(%rdi), %r12
xorl %r13d, %r13d
movq (%r12,%r13,8), %r14
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x1150
testl %eax, %eax
je 0x398f
incq %r13
cmpq %r13, %r15
jne 0x3971
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/cktan[P]tomlc99/toml.c
// Function: scan_date
static int scan_date(const char *p, int *YY, int *MM, int *DD) {
  int year, month, day;
  year = scan_digits(p, 4);
  month = (year >= 0 && p[4] == '-') ? scan_digits(p + 5, 2) : -1;
  day = (month >= 0 && p[7] == '-') ? scan_digits(p + 8, 2) : -1;
  if (YY)
    *YY = year;
  if (MM)
    *MM = month;
  if (DD)
    *DD = day;
  return (year >= 0 && month >= 0 && day >= 0) ? 0 : -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, (%rsp)
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movl $0x4, %esi
callq 0x5a02
movl %eax, %ebp
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
testl %eax, %eax
js 0x3cbe
cmpb $0x2d, 0x4(%rbx)
jne 0x3cbe
leaq 0x5(%rbx), %rdi
movl $0x2, %esi
callq 0x5a02
movl %eax, %r13d
testl %r13d, %r13d
js 0x3cdd
cmpb $0x2d, 0x7(%rbx)
jne 0x3cdd
addq $0x8, %rbx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a02
movl %eax, %r15d
testq %r12, %r12
je 0x3ce6
movl %ebp, (%r12)
testq %r14, %r14
movq (%rsp), %rax
je 0x3cf2
movl %r13d, (%r14)
testq %rax, %rax
je 0x3cfa
movl %r15d, (%rax)
sarl $0x1f, %r15d
orl %ebp, %r13d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovnsl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cktan[P]tomlc99/toml.c
// Function: scan_time
static int scan_time(const char *p, int *hh, int *mm, int *ss) {
  int hour, minute, second;
  hour = scan_digits(p, 2);
  minute = (hour >= 0 && p[2] == ':') ? scan_digits(p + 3, 2) : -1;
  second = (minute >= 0 && p[5] == ':') ? scan_digits(p + 6, 2) : -1;
  if (hh)
    *hh = hour;
  if (mm)
    *mm = minute;
  if (ss)
    *ss = second;
  return (hour >= 0 && minute >= 0 && second >= 0) ? 0 : -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, (%rsp)
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movl $0x2, %esi
callq 0x5a02
movl %eax, %ebp
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
testl %eax, %eax
js 0x3d64
cmpb $0x3a, 0x2(%rbx)
jne 0x3d64
leaq 0x3(%rbx), %rdi
movl $0x2, %esi
callq 0x5a02
movl %eax, %r13d
testl %r13d, %r13d
js 0x3d83
cmpb $0x3a, 0x5(%rbx)
jne 0x3d83
addq $0x6, %rbx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a02
movl %eax, %r15d
testq %r12, %r12
je 0x3d8c
movl %ebp, (%r12)
testq %r14, %r14
movq (%rsp), %rax
je 0x3d98
movl %r13d, (%r14)
testq %rax, %rax
je 0x3da0
movl %r15d, (%rax)
sarl $0x1f, %r15d
orl %ebp, %r13d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovnsl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cktan[P]tomlc99/toml.c
// Function: toml_rtob
int toml_rtob(toml_raw_t src, int *ret_) {
  if (!src)
    return -1;
  int dummy;
  int *ret = ret_ ? ret_ : &dummy;

  if (0 == strcmp(src, "true")) {
    *ret = 1;
    return 0;
  }
  if (0 == strcmp(src, "false")) {
    *ret = 0;
    return 0;
  }
  return -1;
}

// Assembly:
testq %rdi, %rdi
je 0x3e0a
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x228d(%rip), %rsi      # 0x6062
callq 0x1150
testl %eax, %eax
je 0x3e10
testq %rbx, %rbx
sete %bpl
leaq 0x227b(%rip), %rsi      # 0x6067
movq %r14, %rdi
callq 0x1150
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setne %dl
xorl %ecx, %ecx
orb %dl, %bpl
je 0x3e1a
movb %dl, %al
negl %eax
jmp 0x3e1e
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
movl $0x1, %ecx
testq %rbx, %rbx
je 0x3e1c
movl %ecx, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cktan[P]tomlc99/toml.c
// Function: toml_rtoi
int toml_rtoi(toml_raw_t src, int64_t *ret_) {
  if (!src)
    return -1;

  char buf[100];
  char *p = buf;
  char *q = p + sizeof(buf);
  const char *s = src;
  int base = 0;
  int64_t dummy;
  int64_t *ret = ret_ ? ret_ : &dummy;

  /* allow +/- */
  if (s[0] == '+' || s[0] == '-')
    *p++ = *s++;

  /* disallow +_100 */
  if (s[0] == '_')
    return -1;

  /* if 0* ... */
  if ('0' == s[0]) {
    switch (s[1]) {
    case 'x':
      base = 16;
      s += 2;
      break;
    case 'o':
      base = 8;
      s += 2;
      break;
    case 'b':
      base = 2;
      s += 2;
      break;
    case '\0':
      return *ret = 0, 0;
    default:
      /* ensure no other digits after it */
      if (s[1])
        return -1;
    }
  }

  /* just strip underscores and pass to strtoll */
  while (*s && p < q) {
    int ch = *s++;
    if (ch == '_') {
      // disallow '__'
      if (s[0] == '_')
        return -1;
      // numbers cannot end with '_'
      if (s[0] == '\0')
        return -1;
      continue; /* skip _ */
    }
    *p++ = ch;
  }

  // if not at end-of-string or we ran out of buffer ...
  if (*s || p == q)
    return -1;

  /* cap with NUL */
  *p = 0;

  /* Run strtoll on buf to get the integer */
  char *endp;
  errno = 0;
  *ret = strtoll(buf, &endp, base);
  return (errno || *endp) ? -1 : 0;
}

// Assembly:
testq %rdi, %rdi
je 0x3e56
pushq %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %rbx
movzbl (%rdi), %eax
cmpl $0x2d, %eax
je 0x3e43
cmpl $0x2b, %eax
jne 0x3e5c
leaq 0x11(%rsp), %rsi
leaq 0x1(%rdi), %rdx
movb %al, -0x1(%rsi)
movl $0x1, %ecx
jmp 0x3e66
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
xorl %ecx, %ecx
leaq 0x10(%rsp), %rsi
movq %rdi, %rdx
movzbl (%rdi,%rcx), %edi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x5f, %edi
je 0x3f86
xorl %ebp, %ebp
cmpl $0x30, %edi
jne 0x3ed9
movzbl 0x1(%rdx), %edi
cmpl $0x6e, %edi
jg 0x3ea0
testl %edi, %edi
je 0x3eb9
cmpl $0x62, %edi
jne 0x3f86
addq $0x2, %rdx
movl $0x2, %ebp
jmp 0x3ed9
cmpl $0x6f, %edi
je 0x3ed0
cmpl $0x78, %edi
jne 0x3f86
addq $0x2, %rdx
movl $0x10, %ebp
jmp 0x3ed9
xorl %eax, %eax
testq %rbx, %rbx
je 0x3f86
movq $0x0, (%rbx)
jmp 0x3f86
addq $0x2, %rdx
movl $0x8, %ebp
movb (%rdx), %dil
testb %dil, %dil
setne %r8b
je 0x3f41
incq %rdx
cmpb $0x5f, %dil
jne 0x3f06
movzbl (%rdx), %edi
movl $0x1, %esi
testl %edi, %edi
je 0x3f0e
cmpl $0x5f, %edi
je 0x3f0e
movl $0x3, %esi
jmp 0x3f0e
incq %rcx
movb %dil, (%rsi)
xorl %esi, %esi
cmpl $0x3, %esi
je 0x3f17
testl %esi, %esi
jne 0x3f86
leaq (%rsp,%rcx), %rsi
addq $0x10, %rsi
movb (%rdx), %dil
testb %dil, %dil
je 0x3f30
incq %rdx
cmpq $0x64, %rcx
jl 0x3ee8
testb %dil, %dil
setne %dl
cmpq $0x64, %rcx
sete %r8b
orb %dl, %r8b
testb %r8b, %r8b
jne 0x3f86
movb $0x0, (%rsi)
callq 0x1050
movq %rax, %r14
movl $0x0, (%rax)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl %ebp, %edx
callq 0x1160
testq %rbx, %rbx
je 0x3f70
movq %rax, (%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x0, (%r14)
jne 0x3f86
movq 0x8(%rsp), %rcx
xorl %eax, %eax
cmpb (%rcx), %al
sbbl %eax, %eax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cktan[P]tomlc99/toml.c
// Function: toml_string_at
toml_datum_t toml_string_at(const toml_array_t *arr, int idx) {
  toml_datum_t ret;
  memset(&ret, 0, sizeof(ret));
  ret.ok = (0 == toml_rtos(toml_raw_at(arr, idx), &ret.u.s));
  return ret;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
testl %esi, %esi
js 0x4796
cmpl %esi, 0x10(%rdi)
jle 0x4796
movq 0x18(%rdi), %rax
movl %esi, %ecx
shlq $0x5, %rcx
movq 0x8(%rax,%rcx), %rdi
jmp 0x4798
xorl %edi, %edi
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
callq 0x4133
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
movl %ecx, -0x8(%rbx)
movq (%rbx), %rdx
movl %ecx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/cktan[P]tomlc99/toml.c
// Function: toml_bool_at
toml_datum_t toml_bool_at(const toml_array_t *arr, int idx) {
  toml_datum_t ret;
  memset(&ret, 0, sizeof(ret));
  ret.ok = (0 == toml_rtob(toml_raw_at(arr, idx), &ret.u.b));
  return ret;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
testl %esi, %esi
js 0x47e0
cmpl %esi, 0x10(%rdi)
jle 0x47e0
movq 0x18(%rdi), %rax
movl %esi, %ecx
shlq $0x5, %rcx
movq 0x8(%rax,%rcx), %rdi
jmp 0x47e2
xorl %edi, %edi
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
callq 0x3dbf
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
movl %ecx, -0x8(%rbx)
movq (%rbx), %rdx
movl %ecx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/cktan[P]tomlc99/toml.c
// Function: toml_int_at
toml_datum_t toml_int_at(const toml_array_t *arr, int idx) {
  toml_datum_t ret;
  memset(&ret, 0, sizeof(ret));
  ret.ok = (0 == toml_rtoi(toml_raw_at(arr, idx), &ret.u.i));
  return ret;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
testl %esi, %esi
js 0x482a
cmpl %esi, 0x10(%rdi)
jle 0x482a
movq 0x18(%rdi), %rax
movl %esi, %ecx
shlq $0x5, %rcx
movq 0x8(%rax,%rcx), %rdi
jmp 0x482c
xorl %edi, %edi
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
callq 0x3e23
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
movl %ecx, -0x8(%rbx)
movq (%rbx), %rdx
movl %ecx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/cktan[P]tomlc99/toml.c
// Function: toml_double_at
toml_datum_t toml_double_at(const toml_array_t *arr, int idx) {
  toml_datum_t ret;
  memset(&ret, 0, sizeof(ret));
  ret.ok = (0 == toml_rtod(toml_raw_at(arr, idx), &ret.u.d));
  return ret;
}

// Assembly:
pushq %rbx
subq $0x80, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
testl %esi, %esi
js 0x4877
cmpl %esi, 0x10(%rdi)
jle 0x4877
movq 0x18(%rdi), %rax
movl %esi, %ecx
shlq $0x5, %rcx
movq 0x8(%rax,%rcx), %rdi
jmp 0x4879
xorl %edi, %edi
leaq 0x8(%rsp), %rbx
leaq 0x10(%rsp), %rdx
movq %rbx, %rsi
movl $0x64, %ecx
callq 0x3f92
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
movl %ecx, -0x8(%rbx)
movq (%rbx), %rdx
movl %ecx, %eax
addq $0x80, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/cktan[P]tomlc99/toml.c
// Function: toml_timestamp_at
toml_datum_t toml_timestamp_at(const toml_array_t *arr, int idx) {
  toml_timestamp_t ts;
  toml_datum_t ret;
  memset(&ret, 0, sizeof(ret));
  ret.ok = (0 == toml_rtots(toml_raw_at(arr, idx), &ts));
  if (ret.ok) {
    ret.ok = !!(ret.u.ts = MALLOC(sizeof(*ret.u.ts)));
    if (ret.ok) {
      *ret.u.ts = ts;
      if (ret.u.ts->year)
        ret.u.ts->year = &ret.u.ts->__buffer.year;
      if (ret.u.ts->month)
        ret.u.ts->month = &ret.u.ts->__buffer.month;
      if (ret.u.ts->day)
        ret.u.ts->day = &ret.u.ts->__buffer.day;
      if (ret.u.ts->hour)
        ret.u.ts->hour = &ret.u.ts->__buffer.hour;
      if (ret.u.ts->minute)
        ret.u.ts->minute = &ret.u.ts->__buffer.minute;
      if (ret.u.ts->second)
        ret.u.ts->second = &ret.u.ts->__buffer.second;
      if (ret.u.ts->millisec)
        ret.u.ts->millisec = &ret.u.ts->__buffer.millisec;
      if (ret.u.ts->z)
        ret.u.ts->z = ret.u.ts->__buffer.z;
    }
  }
  return ret;
}

// Assembly:
testl %esi, %esi
js 0x48c2
cmpl %esi, 0x10(%rdi)
jle 0x48c2
movq 0x18(%rdi), %rax
movl %esi, %ecx
shlq $0x5, %rcx
movq 0x8(%rax,%rcx), %rdi
jmp 0x48c4
xorl %edi, %edi
subq $0x68, %rsp
movq %rsp, %rsi
callq 0x3a2f
testl %eax, %eax
sete %al
je 0x48e1
xorl %edx, %edx
movzbl %al, %eax
addq $0x68, %rsp
retq
movl $0x68, %edi
callq *0x482c(%rip)           # 0x9118
movq %rax, %rdx
testq %rax, %rax
setne %al
je 0x48d7
movq %rsp, %rsi
movl $0xd, %ecx
movq %rdx, %rdi
rep  movsq (%rsi), %es:(%rdi)
cmpq $0x0, 0x28(%rdx)
je 0x4910
movq %rdx, 0x28(%rdx)
cmpq $0x0, 0x30(%rdx)
je 0x491f
leaq 0x4(%rdx), %rax
movq %rax, 0x30(%rdx)
cmpq $0x0, 0x38(%rdx)
je 0x492e
leaq 0x8(%rdx), %rax
movq %rax, 0x38(%rdx)
cmpq $0x0, 0x40(%rdx)
je 0x493d
leaq 0xc(%rdx), %rax
movq %rax, 0x40(%rdx)
cmpq $0x0, 0x48(%rdx)
je 0x494c
leaq 0x10(%rdx), %rax
movq %rax, 0x48(%rdx)
cmpq $0x0, 0x50(%rdx)
je 0x495b
leaq 0x14(%rdx), %rax
movq %rax, 0x50(%rdx)
cmpq $0x0, 0x58(%rdx)
je 0x496a
leaq 0x18(%rdx), %rax
movq %rax, 0x58(%rdx)
movb $0x1, %al
cmpq $0x0, 0x60(%rdx)
je 0x48d9
movq %rdx, %rcx
addq $0x1c, %rcx
movq %rcx, 0x60(%rdx)
jmp 0x48d9
// File: /workspace/github_c_makefile_star2_O1/cktan[P]tomlc99/toml.c
// Function: toml_string_in
toml_datum_t toml_string_in(const toml_table_t *arr, const char *key) {
  toml_datum_t ret;
  memset(&ret, 0, sizeof(ret));
  toml_raw_t raw = toml_raw_in(arr, key);
  if (raw) {
    ret.ok = (0 == toml_rtos(raw, &ret.u.s));
  }
  return ret;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
callq 0x38b6
testq %rax, %rax
je 0x49b7
leaq 0x8(%rsp), %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4133
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
movl %ecx, -0x8(%rbx)
movl (%rsp), %eax
movq 0x8(%rsp), %rdx
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/cktan[P]tomlc99/toml.c
// Function: toml_bool_in
toml_datum_t toml_bool_in(const toml_table_t *arr, const char *key) {
  toml_datum_t ret;
  memset(&ret, 0, sizeof(ret));
  ret.ok = (0 == toml_rtob(toml_raw_in(arr, key), &ret.u.b));
  return ret;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
xorps %xmm0, %xmm0
leaq 0x8(%rsp), %rbx
movaps %xmm0, -0x8(%rbx)
callq 0x38b6
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3dbf
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
movl %ecx, -0x8(%rbx)
movq (%rbx), %rdx
movl %ecx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/cktan[P]tomlc99/toml.c
// Function: toml_double_in
toml_datum_t toml_double_in(const toml_table_t *arr, const char *key) {
  toml_datum_t ret;
  memset(&ret, 0, sizeof(ret));
  ret.ok = (0 == toml_rtod(toml_raw_in(arr, key), &ret.u.d));
  return ret;
}

// Assembly:
pushq %rbx
subq $0x80, %rsp
xorps %xmm0, %xmm0
leaq 0x8(%rsp), %rbx
movaps %xmm0, -0x8(%rbx)
callq 0x38b6
leaq 0x10(%rsp), %rdx
movq %rax, %rdi
movq %rbx, %rsi
movl $0x64, %ecx
callq 0x3f92
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
movl %ecx, -0x8(%rbx)
movq (%rbx), %rdx
movl %ecx, %eax
addq $0x80, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/cktan[P]tomlc99/toml.c
// Function: toml_timestamp_in
toml_datum_t toml_timestamp_in(const toml_table_t *arr, const char *key) {
  toml_timestamp_t ts;
  toml_datum_t ret;
  memset(&ret, 0, sizeof(ret));
  ret.ok = (0 == toml_rtots(toml_raw_in(arr, key), &ts));
  if (ret.ok) {
    ret.ok = !!(ret.u.ts = MALLOC(sizeof(*ret.u.ts)));
    if (ret.ok) {
      *ret.u.ts = ts;
      if (ret.u.ts->year)
        ret.u.ts->year = &ret.u.ts->__buffer.year;
      if (ret.u.ts->month)
        ret.u.ts->month = &ret.u.ts->__buffer.month;
      if (ret.u.ts->day)
        ret.u.ts->day = &ret.u.ts->__buffer.day;
      if (ret.u.ts->hour)
        ret.u.ts->hour = &ret.u.ts->__buffer.hour;
      if (ret.u.ts->minute)
        ret.u.ts->minute = &ret.u.ts->__buffer.minute;
      if (ret.u.ts->second)
        ret.u.ts->second = &ret.u.ts->__buffer.second;
      if (ret.u.ts->millisec)
        ret.u.ts->millisec = &ret.u.ts->__buffer.millisec;
      if (ret.u.ts->z)
        ret.u.ts->z = ret.u.ts->__buffer.z;
    }
  }
  return ret;
}

// Assembly:
subq $0x68, %rsp
callq 0x38b6
movq %rsp, %rsi
movq %rax, %rdi
callq 0x3a2f
testl %eax, %eax
sete %al
je 0x4a9c
xorl %edx, %edx
movzbl %al, %eax
addq $0x68, %rsp
retq
movl $0x68, %edi
callq *0x4671(%rip)           # 0x9118
movq %rax, %rdx
testq %rax, %rax
setne %al
je 0x4a92
movq %rsp, %rsi
movl $0xd, %ecx
movq %rdx, %rdi
rep  movsq (%rsi), %es:(%rdi)
cmpq $0x0, 0x28(%rdx)
je 0x4acb
movq %rdx, 0x28(%rdx)
cmpq $0x0, 0x30(%rdx)
je 0x4ada
leaq 0x4(%rdx), %rax
movq %rax, 0x30(%rdx)
cmpq $0x0, 0x38(%rdx)
je 0x4ae9
leaq 0x8(%rdx), %rax
movq %rax, 0x38(%rdx)
cmpq $0x0, 0x40(%rdx)
je 0x4af8
leaq 0xc(%rdx), %rax
movq %rax, 0x40(%rdx)
cmpq $0x0, 0x48(%rdx)
je 0x4b07
leaq 0x10(%rdx), %rax
movq %rax, 0x48(%rdx)
cmpq $0x0, 0x50(%rdx)
je 0x4b16
leaq 0x14(%rdx), %rax
movq %rax, 0x50(%rdx)
cmpq $0x0, 0x58(%rdx)
je 0x4b25
leaq 0x18(%rdx), %rax
movq %rax, 0x58(%rdx)
movb $0x1, %al
cmpq $0x0, 0x60(%rdx)
je 0x4a94
movq %rdx, %rcx
addq $0x1c, %rcx
movq %rcx, 0x60(%rdx)
jmp 0x4a94
// File: /workspace/github_c_makefile_star2_O1/cktan[P]tomlc99/toml.c
// Function: create_keyval_in_table
static toml_keyval_t *create_keyval_in_table(context_t *ctx, toml_table_t *tab,
                                             token_t keytok) {
  /* first, normalize the key to be used for lookup.
   * remember to free it if we error out.
   */
  char *newkey = normalize_key(ctx, keytok);
  if (!newkey)
    return 0;

  /* if key exists: error out. */
  toml_keyval_t *dest = 0;
  if (key_kind(tab, newkey)) {
    xfree(newkey);
    e_keyexists(ctx, keytok.lineno);
    return 0;
  }

  /* make a new entry */
  int n = tab->nkval;
  toml_keyval_t **base;
  if (0 == (base = (toml_keyval_t **)expand_ptrarr((void **)tab->kval, n))) {
    xfree(newkey);
    e_outofmemory(ctx, FLINE);
    return 0;
  }
  tab->kval = base;

  if (0 == (base[n] = (toml_keyval_t *)CALLOC(1, sizeof(*base[n])))) {
    xfree(newkey);
    e_outofmemory(ctx, FLINE);
    return 0;
  }
  dest = tab->kval[tab->nkval++];

  /* save the key in the new value struct */
  dest->key = newkey;
  return dest;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x50(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x4b42
testq %rax, %rax
je 0x4f3c
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x56f6
testl %eax, %eax
je 0x4f43
leaq 0x50(%rsp), %r14
movq %r15, %rdi
callq *0x4205(%rip)           # 0x9120
movl 0x4(%r14), %ecx
movq 0x10(%rbx), %rdi
movslq 0x18(%rbx), %rsi
leaq 0x1383(%rip), %rdx      # 0x62b1
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x10f0
jmp 0x5017
xorl %ebx, %ebx
jmp 0x5017
movslq 0xc(%r14), %rbp
movq 0x10(%r14), %r13
leaq 0x8(,%rbp,8), %rdi
callq *0x41bf(%rip)           # 0x9118
testq %rax, %rax
je 0x4f8c
movq %rax, %r12
movq $0x0, (%rax,%rbp,8)
testq %r13, %r13
je 0x4f8f
leaq (,%rbp,8), %rdx
movq %r12, %rdi
movq %r13, %rsi
callq 0x1190
movq %r13, %rdi
callq *0x4196(%rip)           # 0x9120
jmp 0x4f8f
xorl %r12d, %r12d
testq %r12, %r12
je 0x4fca
movq %r12, 0x10(%r14)
movl $0x10, %edi
callq *0x4175(%rip)           # 0x9118
testq %rax, %rax
je 0x4feb
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rax, (%r12,%rbp,8)
movq 0x10(%r14), %rax
movslq 0xc(%r14), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0xc(%r14)
movq (%rax,%rcx,8), %rbx
movq %r15, (%rbx)
jmp 0x5017
movq %r15, %rdi
callq *0x414d(%rip)           # 0x9120
movq 0x10(%rbx), %rdi
movslq 0x18(%rbx), %rsi
leaq 0x11d8(%rip), %rdx      # 0x61ba
leaq 0x12dc(%rip), %rcx      # 0x62c5
jmp 0x500e
movq %rax, (%r12,%rbp,8)
movq %r15, %rdi
callq *0x4128(%rip)           # 0x9120
movq 0x10(%rbx), %rdi
movslq 0x18(%rbx), %rsi
leaq 0x11b3(%rip), %rdx      # 0x61ba
leaq 0x12c2(%rip), %rcx      # 0x62d0
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x10f0
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cktan[P]tomlc99/toml.c
// Function: create_keyarray_in_table
static toml_array_t *create_keyarray_in_table(context_t *ctx, toml_table_t *tab,
                                              token_t keytok, char kind) {
  /* first, normalize the key to be used for lookup.
   * remember to free it if we error out.
   */
  char *newkey = normalize_key(ctx, keytok);
  if (!newkey)
    return 0;

  /* if key exists: error out */
  if (key_kind(tab, newkey)) {
    xfree(newkey); /* don't need this anymore */
    e_keyexists(ctx, keytok.lineno);
    return 0;
  }

  /* make a new array entry */
  int n = tab->narr;
  toml_array_t **base;
  if (0 == (base = (toml_array_t **)expand_ptrarr((void **)tab->arr, n))) {
    xfree(newkey);
    e_outofmemory(ctx, FLINE);
    return 0;
  }
  tab->arr = base;

  if (0 == (base[n] = (toml_array_t *)CALLOC(1, sizeof(*base[n])))) {
    xfree(newkey);
    e_outofmemory(ctx, FLINE);
    return 0;
  }
  toml_array_t *dest = tab->arr[tab->narr++];

  /* save the key in the new array struct */
  dest->key = newkey;
  dest->kind = kind;
  return dest;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x60(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x4b42
testq %rax, %rax
je 0x50a4
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x56f6
testl %eax, %eax
je 0x50ab
leaq 0x60(%rsp), %r14
movq %r15, %rdi
callq *0x409d(%rip)           # 0x9120
movl 0x4(%r14), %ecx
movq 0x10(%rbx), %rdi
movslq 0x18(%rbx), %rsi
leaq 0x121b(%rip), %rdx      # 0x62b1
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x10f0
jmp 0x518f
xorl %ebx, %ebx
jmp 0x518f
movl %ebp, 0x24(%rsp)
movslq 0x18(%r14), %rbp
movq 0x20(%r14), %r13
leaq 0x8(,%rbp,8), %rdi
callq *0x4053(%rip)           # 0x9118
testq %rax, %rax
je 0x50f8
movq %rax, %r12
movq $0x0, (%rax,%rbp,8)
testq %r13, %r13
je 0x50fb
leaq (,%rbp,8), %rdx
movq %r12, %rdi
movq %r13, %rsi
callq 0x1190
movq %r13, %rdi
callq *0x402a(%rip)           # 0x9120
jmp 0x50fb
xorl %r12d, %r12d
testq %r12, %r12
je 0x5142
movq %r12, 0x20(%r14)
movl $0x20, %edi
callq *0x4009(%rip)           # 0x9118
testq %rax, %rax
je 0x5163
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movq %rax, (%r12,%rbp,8)
movq 0x20(%r14), %rax
movslq 0x18(%r14), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x18(%r14)
movq (%rax,%rcx,8), %rbx
movq %r15, (%rbx)
movzbl 0x24(%rsp), %eax
movl %eax, 0x8(%rbx)
jmp 0x518f
movq %r15, %rdi
callq *0x3fd5(%rip)           # 0x9120
movq 0x10(%rbx), %rdi
movslq 0x18(%rbx), %rsi
leaq 0x1060(%rip), %rdx      # 0x61ba
leaq 0x117a(%rip), %rcx      # 0x62db
jmp 0x5186
movq %rax, (%r12,%rbp,8)
movq %r15, %rdi
callq *0x3fb0(%rip)           # 0x9120
movq 0x10(%rbx), %rdi
movslq 0x18(%rbx), %rsi
leaq 0x103b(%rip), %rdx      # 0x61ba
leaq 0x1160(%rip), %rcx      # 0x62e6
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x10f0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cktan[P]tomlc99/toml.c
// Function: parse_inline_table
static int parse_inline_table(context_t *ctx, toml_table_t *tab) {
  if (eat_token(ctx, LBRACE, 1, FLINE))
    return -1;

  for (;;) {
    if (ctx->tok.tok == NEWLINE)
      return e_syntax(ctx, ctx->tok.lineno,
                      "newline not allowed in inline table");

    /* until } */
    if (ctx->tok.tok == RBRACE)
      break;

    if (ctx->tok.tok != STRING)
      return e_syntax(ctx, ctx->tok.lineno, "expect a string");

    if (parse_keyval(ctx, tab))
      return -1;

    if (ctx->tok.tok == NEWLINE)
      return e_syntax(ctx, ctx->tok.lineno,
                      "newline not allowed in inline table");

    /* on comma, continue to scan for next keyval */
    if (ctx->tok.tok == COMMA) {
      if (eat_token(ctx, COMMA, 1, FLINE))
        return -1;
      continue;
    }
    break;
  }

  if (eat_token(ctx, RBRACE, 1, FLINE))
    return -1;

  tab->readonly = 1;

  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
cmpl $0x4, 0x20(%rdi)
jne 0x563b
movq %rsi, %r15
movq %r14, %rdi
movl $0x1, %esi
callq 0x2b77
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0x565d
movl 0x20(%r14), %eax
cmpl $0x9, %eax
jne 0x5665
movq %r14, %rdi
movq %r15, %rsi
callq 0x319f
testl %eax, %eax
jne 0x565d
movl 0x20(%r14), %eax
cmpl $0x2, %eax
jne 0x568b
movq %r14, %rdi
movl $0x1, %esi
callq 0x2b77
jmp 0x5607
movq 0x10(%r14), %rdi
movslq 0x18(%r14), %rsi
leaq 0xd64(%rip), %rdx       # 0x63ae
leaq 0xd13(%rip), %rcx       # 0x6364
xorl %eax, %eax
callq 0x10f0
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
cmpl $0x5, %eax
je 0x56b3
cmpl $0x6, %eax
je 0x5690
movl 0x24(%r14), %ecx
movq 0x10(%r14), %rdi
movslq 0x18(%r14), %rsi
leaq 0xbe6(%rip), %rdx       # 0x6268
leaq 0xd0a(%rip), %r8        # 0x6393
jmp 0x56aa
cmpl $0x6, %eax
jne 0x56b3
movl 0x24(%r14), %ecx
movq 0x10(%r14), %rdi
movslq 0x18(%r14), %rsi
leaq 0xbc5(%rip), %rdx       # 0x6268
leaq 0xcc5(%rip), %r8        # 0x636f
xorl %eax, %eax
callq 0x10f0
jmp 0x565d
cmpl $0x5, 0x20(%r14)
jne 0x56d4
movq %r14, %rdi
movl $0x1, %esi
callq 0x2b77
testl %eax, %eax
jne 0x565d
movb $0x1, 0x9(%r15)
xorl %ebx, %ebx
jmp 0x565d
movq 0x10(%r14), %rdi
movslq 0x18(%r14), %rsi
leaq 0xccb(%rip), %rdx       # 0x63ae
leaq 0xcb9(%rip), %rcx       # 0x63a3
xorl %eax, %eax
callq 0x10f0
jmp 0x565d
// File: /workspace/github_c_makefile_star2_O1/cktan[P]tomlc99/toml.c
// Function: check_key
static int check_key(toml_table_t *tab, const char *key,
                     toml_keyval_t **ret_val, toml_array_t **ret_arr,
                     toml_table_t **ret_tab) {
  int i;
  void *dummy;

  if (!ret_tab)
    ret_tab = (toml_table_t **)&dummy;
  if (!ret_arr)
    ret_arr = (toml_array_t **)&dummy;
  if (!ret_val)
    ret_val = (toml_keyval_t **)&dummy;

  *ret_tab = 0;
  *ret_arr = 0;
  *ret_val = 0;

  for (i = 0; i < tab->nkval; i++) {
    if (0 == strcmp(key, tab->kval[i]->key)) {
      *ret_val = tab->kval[i];
      return 'v';
    }
  }
  for (i = 0; i < tab->narr; i++) {
    if (0 == strcmp(key, tab->arr[i]->key)) {
      *ret_arr = tab->arr[i];
      return 'a';
    }
  }
  for (i = 0; i < tab->ntab; i++) {
    if (0 == strcmp(key, tab->tab[i]->key)) {
      *ret_tab = tab->tab[i];
      return 't';
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %r12
testq %r8, %r8
je 0x5716
movq $0x0, (%r8)
testq %rcx, %rcx
je 0x5722
movq $0x0, (%rcx)
movq %rcx, 0x8(%rsp)
movq %r8, (%rsp)
testq %rdx, %rdx
je 0x5737
movq $0x0, (%rdx)
movq %rdx, 0x10(%rsp)
movslq 0xc(%r12), %rbp
testq %rbp, %rbp
jle 0x576a
movq 0x10(%r12), %rbx
xorl %r15d, %r15d
movq (%rbx,%r15,8), %r13
movq (%r13), %rsi
movq %r14, %rdi
callq 0x1150
testl %eax, %eax
je 0x57ca
incq %r15
cmpq %r15, %rbp
jne 0x574e
movslq 0x18(%r12), %r13
testq %r13, %r13
jle 0x5798
movq 0x20(%r12), %rbx
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rbp
movq (%rbp), %rsi
movq %r14, %rdi
callq 0x1150
testl %eax, %eax
je 0x57d6
incq %r15
cmpq %r15, %r13
jne 0x577c
movslq 0x28(%r12), %r15
testq %r15, %r15
jle 0x57c6
movq 0x30(%r12), %rbx
xorl %r12d, %r12d
movq (%rbx,%r12,8), %r13
movq (%r13), %rsi
movq %r14, %rdi
callq 0x1150
testl %eax, %eax
je 0x57ea
incq %r12
cmpq %r12, %r15
jne 0x57aa
xorl %eax, %eax
jmp 0x57fb
movl $0x76, %eax
movq 0x10(%rsp), %rcx
jmp 0x57f3
movl $0x61, %eax
movq 0x8(%rsp), %rcx
testq %rcx, %rcx
je 0x57fb
movq %rbp, (%rcx)
jmp 0x57fb
movl $0x74, %eax
movq (%rsp), %rcx
testq %rcx, %rcx
je 0x57fb
movq %r13, (%rcx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cktan[P]tomlc99/toml.c
// Function: create_table_in_array
static toml_table_t *create_table_in_array(context_t *ctx,
                                           toml_array_t *parent) {
  int n = parent->nitem;
  toml_arritem_t *base = expand_arritem(parent->item, n);
  if (!base) {
    e_outofmemory(ctx, FLINE);
    return 0;
  }
  toml_table_t *ret = (toml_table_t *)CALLOC(1, sizeof(toml_table_t));
  if (!ret) {
    e_outofmemory(ctx, FLINE);
    return 0;
  }
  base[n].tab = ret;
  parent->item = base;
  parent->nitem++;
  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0x10(%rsi), %ebp
movq 0x18(%rsi), %rdi
movl %ebp, %esi
callq 0x58b0
testq %rax, %rax
je 0x586d
movq %rax, %r12
movl $0x38, %edi
callq *0x38df(%rip)           # 0x9118
testq %rax, %rax
je 0x5885
movq %rax, %rbx
movslq %ebp, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movq $0x0, 0x30(%rbx)
shlq $0x5, %rax
movq %rbx, 0x18(%r12,%rax)
movq %r12, 0x18(%r14)
incl 0x10(%r14)
jmp 0x58a4
movq 0x10(%r15), %rdi
movslq 0x18(%r15), %rsi
leaq 0x93e(%rip), %rdx       # 0x61ba
leaq 0xacb(%rip), %rcx       # 0x634e
jmp 0x589b
movq 0x10(%r15), %rdi
movslq 0x18(%r15), %rsi
leaq 0x926(%rip), %rdx       # 0x61ba
leaq 0xabe(%rip), %rcx       # 0x6359
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x10f0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cktan[P]tomlc99/toml.c
// Function: expand_arritem
static toml_arritem_t *expand_arritem(toml_arritem_t *p, int n) {
  toml_arritem_t *pp = expand(p, n * sizeof(*p), (n + 1) * sizeof(*p));
  if (!pp)
    return 0;

  memset(&pp[n], 0, sizeof(pp[n]));
  return pp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %r15d
shll $0x5, %r15d
leal 0x20(%r15), %eax
movslq %eax, %rdi
callq *0x3848(%rip)           # 0x9118
testq %rax, %rax
je 0x58f6
movq %rax, %rbx
testq %r14, %r14
je 0x58f8
movslq %r15d, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1190
movq %r14, %rdi
callq *0x382c(%rip)           # 0x9120
jmp 0x58f8
xorl %ebx, %ebx
testq %rbx, %rbx
je 0x5912
movslq %ebp, %rax
shlq $0x5, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx,%rax)
movups %xmm0, (%rbx,%rax)
jmp 0x5914
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cktan[P]tomlc99/toml.c
// Function: STRDUP
static char *STRDUP(const char *s) {
  int len = strlen(s);
  char *p = MALLOC(len + 1);
  if (p) {
    memcpy(p, s, len);
    p[len] = 0;
  }
  return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x10c0
movq %rax, %r14
shlq $0x20, %r14
movabsq $0x100000000, %rdi      # imm = 0x100000000
addq %r14, %rdi
sarq $0x20, %rdi
callq *0x37cb(%rip)           # 0x9118
movq %rax, %r15
testq %rax, %rax
je 0x596c
sarq $0x20, %r14
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1190
movb $0x0, (%r15,%r14)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/cktan[P]tomlc99/toml.c
// Function: xfree_arr
static void xfree_arr(toml_array_t *p) {
  if (!p)
    return;

  xfree(p->key);
  const int n = p->nitem;
  for (int i = 0; i < n; i++) {
    toml_arritem_t *a = &p->item[i];
    if (a->val)
      xfree(a->val);
    else if (a->arr)
      xfree_arr(a->arr);
    else if (a->tab)
      xfree_tab(a->tab);
  }
  xfree(p->item);
  xfree(p);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x59fc
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x5990
callq *0x3790(%rip)           # 0x9120
movslq 0x10(%rbx), %r14
testq %r14, %r14
jle 0x59df
shlq $0x5, %r14
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
movq 0x8(%rax,%r15), %rdi
testq %rdi, %rdi
je 0x59b6
callq *0x376c(%rip)           # 0x9120
jmp 0x59d6
movq 0x10(%rax,%r15), %rdi
testq %rdi, %rdi
je 0x59c7
callq 0x5975
jmp 0x59d6
movq 0x18(%rax,%r15), %rdi
testq %rdi, %rdi
je 0x59d6
callq 0x36ef
addq $0x20, %r15
cmpq %r15, %r14
jne 0x59a0
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x59ee
callq *0x3732(%rip)           # 0x9120
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *0x3724(%rip)           # 0x9120
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/cktan[P]tomlc99/toml.c
// Function: scan_digits
static int scan_digits(const char *p, int n) {
  int ret = 0;
  for (; n > 0 && isdigit(*p); n--, p++) {
    ret = 10 * ret + (*p - '0');
  }
  return n ? -1 : ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %r14d
xorl %ebx, %ebx
testl %esi, %esi
jle 0x5a46
movq %rdi, %r15
callq 0x1200
movq (%rax), %rcx
xorl %eax, %eax
movsbq (%r15), %rdx
testb $0x8, 0x1(%rcx,%rdx,2)
je 0x5a48
leal (%rax,%rax,4), %eax
leal (%rdx,%rax,2), %eax
addl $-0x30, %eax
leal -0x1(%r14), %edx
incq %r15
cmpl $0x1, %r14d
movl %edx, %r14d
jg 0x5a1d
xorl %r14d, %r14d
jmp 0x5a48
xorl %eax, %eax
negl %r14d
sbbl %ebx, %ebx
orl %eax, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jwang11[P]intel_avx_perf/matrix_int8.c
// Function: init
void init(void) {
  srand(time(0));
  for (int i = 0; i < row; i++) {
    for (int j = 0; j < col; j++) {
      mat[i][j] = (int8_t)(rand() % 32);
    }   
  }
  for (int j = 0; j < col; j++) {
    mutiplier[j] = (int8_t)(rand() % 32);
  }

  for (int i = 0; i < 32; i++) {
       op4_int16[i] = 1;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x1070
movl %eax, %edi
callq 0x1060
leaq 0x2f18(%rip), %r14      # 0x40c0
xorl %r15d, %r15d
callq 0x1080
leal 0x1f(%rax), %ecx
testl %eax, %eax
cmovnsl %eax, %ecx
andl $0xe0, %ecx
subl %ecx, %eax
movb %al, (%r14,%r15)
incq %r15
cmpq $0x1000, %r15           # imm = 0x1000
jne 0x11ab
incq %rbx
addq $0x1000, %r14           # imm = 0x1000
cmpq $0x40, %rbx
jne 0x11a8
xorl %ebx, %ebx
leaq 0x42ed7(%rip), %r14     # 0x440c0
callq 0x1080
leal 0x1f(%rax), %ecx
testl %eax, %eax
cmovnsl %eax, %ecx
andl $0xe0, %ecx
subl %ecx, %eax
movb %al, (%rbx,%r14)
incq %rbx
cmpq $0x1000, %rbx           # imm = 0x1000
jne 0x11e9
vpbroadcastw 0xdec(%rip), %zmm0 # 0x2004
vmovdqa64 %zmm0, 0x43e9e(%rip) # 0x450c0
popq %rbx
popq %r14
popq %r15
vzeroupper
retq
// File: /workspace/github_c_makefile_star2_O1/jwang11[P]intel_avx_perf/matrix_int8.c
// Function: calc_non
void calc_non(void) {
  for(int j = 0; j < row; j++) {
    int sum = 0;
    int8_t *vec = mat[j];

    for(int i = 0; i < col; i += 4) {
      int16_t hw_0 = (int16_t)(vec[i] * mutiplier[i] + vec[i + 1] * mutiplier[i + 1]);
      int16_t hw_1 = (int16_t)(vec[i + 2] * mutiplier[i + 2] + vec[i + 3] * mutiplier[i + 3]);
      sum += (int)hw_0 + (int)hw_1;
    }
    result[j] = sum;
  }
}

// Assembly:
leaq 0x2e8e(%rip), %rax      # 0x40c0
xorl %ecx, %ecx
leaq 0x42e85(%rip), %rdx     # 0x440c0
leaq 0x43ebe(%rip), %rsi     # 0x45100
vpxor %xmm0, %xmm0, %xmm0
xorl %edi, %edi
vmovdqu64 (%rax,%rdi), %zmm1
vpmovdb %zmm1, %xmm2
vpsrld $0x8, %zmm1, %zmm3
vpmovdb %zmm3, %xmm3
vpsrld $0x10, %zmm1, %zmm4
vpmovdb %zmm4, %xmm4
vpsrld $0x18, %zmm1, %zmm1
vpmovdb %zmm1, %xmm1
vpmovsxbd %xmm2, %zmm2
vmovdqu64 (%rdi,%rdx), %zmm5
vpmovdb %zmm5, %xmm6
vpsrld $0x8, %zmm5, %zmm7
vpmovdb %zmm7, %xmm7
vpsrld $0x10, %zmm5, %zmm8
vpmovdb %zmm8, %xmm8
vpsrld $0x18, %zmm5, %zmm5
vpmovdb %zmm5, %xmm5
vpmovsxbd %xmm6, %zmm6
vpmulld %zmm2, %zmm6, %zmm2
vpmovsxbd %xmm3, %zmm3
vpmovsxbd %xmm7, %zmm6
vpmulld %zmm3, %zmm6, %zmm3
vpaddd %zmm2, %zmm3, %zmm2
vpmovsxbd %xmm4, %zmm3
vpmovsxbd %xmm8, %zmm4
vpmulld %zmm3, %zmm4, %zmm3
vpmovsxbd %xmm1, %zmm1
vpmovsxbd %xmm5, %zmm4
vpmulld %zmm1, %zmm4, %zmm1
vpaddd %zmm3, %zmm1, %zmm1
vpslld $0x10, %zmm2, %zmm2
vpsrad $0x10, %zmm2, %zmm2
vpaddd %zmm0, %zmm2, %zmm0
vpslld $0x10, %zmm1, %zmm1
vpsrad $0x10, %zmm1, %zmm1
vpaddd %zmm1, %zmm0, %zmm0
addq $0x40, %rdi
cmpq $0x1000, %rdi           # imm = 0x1000
jne 0x1248
vextracti64x4 $0x1, %zmm0, %ymm1
vpaddd %zmm1, %zmm0, %zmm0
vextracti128 $0x1, %ymm0, %xmm1
vpaddd %xmm1, %xmm0, %xmm0
vpshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
vpaddd %xmm1, %xmm0, %xmm0
vpshufd $0x55, %xmm0, %xmm1     # xmm1 = xmm0[1,1,1,1]
vpaddd %xmm1, %xmm0, %xmm0
vmovd %xmm0, (%rsi,%rcx,4)
incq %rcx
addq $0x1000, %rax           # imm = 0x1000
cmpq $0x40, %rcx
jne 0x1242
vzeroupper
retq
// File: /workspace/github_c_makefile_star2_O1/jwang11[P]intel_avx_perf/matrix_int8.c
// Function: calc_avx512
void calc_avx512(void) {
  #define VLEN (512/8/sizeof(int))
  const int col_aligned = col - col % VLEN;

  __m512i op0, op1;
  volatile __m512i tgt;

  __m512i v4_int16 = _mm512_load_si512(&op4_int16);

  for (int i = 0; i < row; i++) {
    int sum = 0;

    tgt = _mm512_setzero_si512();
    for (int j = 0; j < col_aligned; j += 64) {
      op0 = _mm512_load_si512(&mutiplier[j]);
      op1 = _mm512_load_si512(&mat[i][j]);
      __m512i vresult1 = _mm512_maddubs_epi16(op0, op1);
      __m512i vresult2 = _mm512_madd_epi16(vresult1, v4_int16);
      tgt = _mm512_add_epi32(vresult2, tgt);
    }

    int *presult = (int *)&tgt;
    for (int k = 0; k < VLEN; k++)
      sum += presult[k];

    for (int l = col_aligned; l < col; l++)
      sum += (int)(mat[i][l] * mutiplier[l]);

    result[i] = sum;
  }
  #undef VLEN
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
andq $-0x40, %rsp
subq $0x80, %rsp
leaq 0x2d28(%rip), %rax      # 0x40c0
vmovdqa64 0x43d1e(%rip), %zmm0 # 0x450c0
xorl %ecx, %ecx
vxorps %xmm1, %xmm1, %xmm1
leaq 0x42d11(%rip), %rdx     # 0x440c0
leaq 0x43d4a(%rip), %rsi     # 0x45100
vmovaps %zmm1, (%rsp)
xorl %edi, %edi
vmovdqa64 (%rdi,%rdx), %zmm2
vpmaddubsw (%rax,%rdi), %zmm2, %zmm2
vpmaddwd %zmm0, %zmm2, %zmm2
vpaddd (%rsp), %zmm2, %zmm2
vmovdqa64 %zmm2, (%rsp)
leaq 0x40(%rdi), %r8
cmpq $0xfc0, %rdi            # imm = 0xFC0
movq %r8, %rdi
jb 0x13bf
vmovdqa 0x20(%rsp), %ymm2
vpaddd (%rsp), %zmm2, %zmm2
vextracti128 $0x1, %ymm2, %xmm3
vpaddd %xmm3, %xmm2, %xmm2
vpshufd $0xee, %xmm2, %xmm3     # xmm3 = xmm2[2,3,2,3]
vpaddd %xmm3, %xmm2, %xmm2
vpshufd $0x55, %xmm2, %xmm3     # xmm3 = xmm2[1,1,1,1]
vpaddd %xmm3, %xmm2, %xmm2
vmovd %xmm2, (%rsi,%rcx,4)
incq %rcx
addq $0x1000, %rax           # imm = 0x1000
cmpq $0x40, %rcx
jne 0x13b6
movq %rbp, %rsp
popq %rbp
vzeroupper
retq
// File: /workspace/github_c_makefile_star2_O1/jwang11[P]intel_avx_perf/matrix_int8.c
// Function: calc_avx512_vnni
void calc_avx512_vnni(void) {
  #define VLEN (512/8/sizeof(int))
  const int col_aligned = col - col % VLEN;

  __m512i op0, op1;
  volatile __m512i tgt;

  for (int i = 0; i < row; i++) {
    int sum = 0;

    tgt = _mm512_setzero_si512();
    for (int j = 0; j < col_aligned; j += 64) {
      op0 = _mm512_load_si512(&mutiplier[j]);
      op1 = _mm512_load_si512(&mat[i][j]);
      tgt = _mm512_dpbusds_epi32(tgt, op0, op1);
    }
    int *presult = (int *)&tgt;
    for (int k = 0; k < VLEN; k++)
      sum += presult[k];

    for (int l = col_aligned; l < col; l++)
      sum += (int)(mat[i][l] * mutiplier[l]);

    result[i] = sum;
  }
  #undef VLEN
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
andq $-0x40, %rsp
subq $0x80, %rsp
leaq 0x2c74(%rip), %rax      # 0x40c0
xorl %ecx, %ecx
vxorps %xmm0, %xmm0, %xmm0
leaq 0x42c67(%rip), %rdx     # 0x440c0
leaq 0x43ca0(%rip), %rsi     # 0x45100
vmovaps %zmm0, (%rsp)
xorl %edi, %edi
vmovdqa64 (%rdi,%rdx), %zmm1
vmovdqa64 (%rsp), %zmm2
vpdpbusds (%rax,%rdi), %zmm1, %zmm2
vmovdqa64 %zmm2, (%rsp)
leaq 0x40(%rdi), %r8
cmpq $0xfc0, %rdi            # imm = 0xFC0
movq %r8, %rdi
jb 0x1469
vmovdqa 0x20(%rsp), %ymm1
vpaddd (%rsp), %zmm1, %zmm1
vextracti128 $0x1, %ymm1, %xmm2
vpaddd %xmm2, %xmm1, %xmm1
vpshufd $0xee, %xmm1, %xmm2     # xmm2 = xmm1[2,3,2,3]
vpaddd %xmm2, %xmm1, %xmm1
vpshufd $0x55, %xmm1, %xmm2     # xmm2 = xmm1[1,1,1,1]
vpaddd %xmm2, %xmm1, %xmm1
vmovd %xmm1, (%rsi,%rcx,4)
incq %rcx
addq $0x1000, %rax           # imm = 0x1000
cmpq $0x40, %rcx
jne 0x1460
movq %rbp, %rsp
popq %rbp
vzeroupper
retq
// File: /workspace/github_c_makefile_star2_O1/richarddurbin[P]hash10x/moshset.c
// Function: moshsetDepthPrune
void moshsetDepthPrune (Moshset *ms, int min, int max)
{
  U32 i ;
  U32 N = ms->max ; ms->max = 0 ;
  memset (ms->index, 0, ms->tableSize*sizeof(U32)) ;
  for (i = 1 ; i <= N ; ++i)	/* NB index runs from 1..max */
    if (ms->depth[i] >= min && (!max || ms->depth[i] < max))
      { moshsetIndexFind (ms, ms->value[i], TRUE) ;
	ms->info[ms->max] = ms->info[i] ;
	ms->depth[ms->max] = ms->depth[i] ;
      }
  fprintf (stderr, "  pruned Moshset from %d to %d with min %d <= depth < max %d\n",
	   N, ms->max, min, max) ;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r15
movl 0x40(%rdi), %ebp
andl $0x0, 0x40(%rdi)
movl %esi, %r14d
movq 0x10(%rdi), %rdx
movq 0x20(%rdi), %rdi
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x10d0
testl %ebp, %ebp
je 0x21dc
pushq $0x1
popq %r12
movl %r12d, %r13d
testl %ebx, %ebx
sete %al
movq 0x30(%r15), %rcx
movl %r13d, %r13d
movzwl (%rcx,%r13,2), %edx
cmpl %ebx, %edx
setl %cl
cmpl %r14d, %edx
jl 0x21d4
orb %cl, %al
je 0x21d4
movq 0x28(%r15), %rax
movq (%rax,%r13,8), %rsi
movq %r15, %rdi
movl %r12d, %edx
callq 0x3d7f
movq 0x38(%r15), %rax
movb (%rax,%r13), %cl
movl 0x40(%r15), %edx
movb %cl, (%rax,%rdx)
movq 0x30(%r15), %rax
movzwl (%rax,%r13,2), %ecx
movl 0x40(%r15), %edx
movw %cx, (%rax,%rdx,2)
incl %r13d
cmpl %ebp, %r13d
jbe 0x2182
movq 0x7e15(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
movl 0x40(%r15), %ecx
leaq 0x49e3(%rip), %rsi      # 0x6bd4
movl %ebp, %edx
movl %r14d, %r8d
movl %ebx, %r9d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1120
// File: /workspace/github_c_makefile_star2_O1/richarddurbin[P]hash10x/moshutils.c
// Function: depthHistogram
void depthHistogram (Moshset *ms, FILE *f)
{
  Array h = arrayCreate (256, U32) ;
  U32 i ;
  for (i = 1 ; i <= ms->max ; ++i)
    if (ms->depth[i] < arrayMax(h)) ++arr(h,ms->depth[i],U32) ; /* more efficient to check */
    else ++array(h,ms->depth[i],U32) ;
  for (i = 0 ; i < arrayMax(h) ; ++i)
    if (arr(h,i,U32)) fprintf (f, "DP\t%u\t%u\n", i, arr(h,i,U32)) ;
  arrayDestroy (h) ;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movl $0x100, %edi            # imm = 0x100
movl $0x4, %esi
callq 0x4f40
movq %rax, %r14
cmpl $0x0, 0x40(%r15)
je 0x2389
movl $0x1, %ebp
movq 0x30(%r15), %rax
movl %ebp, %ecx
movzwl (%rax,%rcx,2), %esi
cmpl %esi, 0x18(%r14)
jle 0x2377
movslq 0x14(%r14), %rcx
movl %esi, %eax
imulq %rcx, %rax
addq 0x8(%r14), %rax
jmp 0x237f
movq %r14, %rdi
callq 0x51fb
incl (%rax)
incl %ebp
cmpl 0x40(%r15), %ebp
jbe 0x2357
cmpl $0x0, 0x18(%r14)
je 0x23c2
leaq 0x3c6d(%rip), %r15      # 0x6004
xorl %ebp, %ebp
movq 0x8(%r14), %rax
movl 0x14(%r14), %ecx
imull %ebp, %ecx
movl (%rax,%rcx), %ecx
testl %ecx, %ecx
je 0x23ba
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x1120
incl %ebp
cmpl 0x18(%r14), %ebp
jb 0x2399
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5099