LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/cktan[P]tomlc99/toml_cat.c
// Function: print_string
static void print_string(const char *s) {
  int ok = 1;
  for (const char *p = s; *p && ok; p++) {
    int ch = *p;
    ok = isprint(ch) && ch != '"' && ch != '\\';
  }

  if (ok) {
    printf("\"%s\"", s);
    return;
  }

  int len = strlen(s);

  printf("\"");
  for (; len; len--, s++) {
    int ch = *s;
    if (isprint(ch) && ch != '"' && ch != '\\') {
      putchar(ch);
      continue;
    }

    switch (ch) {
    case 0x8:
      printf("\\b");
      continue;
    case 0x9:
      printf("\\t");
      continue;
    case 0xa:
      printf("\\n");
      continue;
    case 0xc:
      printf("\\f");
      continue;
    case 0xd:
      printf("\\r");
      continue;
    case '"':
      printf("\\\"");
      continue;
    case '\\':
      printf("\\\\");
      continue;
    default:
      printf("\\0x%02x", ch & 0xff);
      continue;
    }
  }
  printf("\"");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb (%rdi), %bpl
testb %bpl, %bpl
je 0x1c50
callq 0x11f0
movq %rax, %r14
movq (%rax), %rcx
leaq 0x1(%rbx), %rdx
movl %ebp, %eax
movsbq %bpl, %rdi
movzwl (%rcx,%rdi,2), %esi
cmpb $0x22, %dil
je 0x1b4d
cmpb $0x5c, %al
je 0x1b4d
movb (%rdx), %bpl
testb %bpl, %bpl
je 0x1b4d
movl %esi, %edi
andl $0x4000, %edi           # imm = 0x4000
incq %rdx
testw %di, %di
jne 0x1b21
btl $0xe, %esi
jae 0x1b63
cmpb $0x22, %al
je 0x1b63
movzbl %al, %eax
cmpl $0x5c, %eax
jne 0x1c50
movq %rbx, %rdi
callq 0x10b0
movq %rax, %r15
movl $0x22, %edi
callq 0x1040
testl %r15d, %r15d
je 0x1c38
leaq 0x447c(%rip), %r12      # 0x6004
leaq 0x455d(%rip), %r13      # 0x60ec
xorl %ebp, %ebp
movsbq (%rbx,%rbp), %rdi
movq (%r14), %rax
movzwl (%rax,%rdi,2), %eax
btl $0xe, %eax
jb 0x1bc1
movzbl %dil, %eax
leal -0x8(%rax), %ecx
cmpl $0x5, %ecx
ja 0x1bd7
movslq (%r12,%rcx,4), %rax
addq %r12, %rax
jmpq *%rax
leaq 0x451b(%rip), %rdi      # 0x60da
jmp 0x1c25
cmpb $0x22, %dil
je 0x1be6
movzbl %dil, %eax
cmpl $0x5c, %eax
je 0x1be1
callq 0x1040
jmp 0x1c2c
cmpl $0x22, %eax
je 0x1be6
cmpl $0x5c, %eax
jne 0x1bef
movq %r13, %rdi
jmp 0x1c25
leaq 0x44fc(%rip), %rdi      # 0x60e9
jmp 0x1c25
movzbl %dil, %esi
leaq 0x44f5(%rip), %rdi      # 0x60ef
xorl %eax, %eax
callq 0x10d0
jmp 0x1c2c
leaq 0x44d3(%rip), %rdi      # 0x60dd
jmp 0x1c25
leaq 0x44cd(%rip), %rdi      # 0x60e0
jmp 0x1c25
leaq 0x44c7(%rip), %rdi      # 0x60e3
jmp 0x1c25
leaq 0x44c1(%rip), %rdi      # 0x60e6
xorl %eax, %eax
callq 0x10d0
incq %rbp
cmpl %ebp, %r15d
jne 0x1b91
movl $0x22, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1040
leaq 0x447e(%rip), %rdi      # 0x60d5
movq %rbx, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10d0
// File: /workspace/github_c_makefile_star2_O3/cktan[P]tomlc99/toml_cat.c
// Function: print_timestamp
static void print_timestamp(toml_datum_t d) {
  if (d.u.ts->year) {
    printf("%04d-%02d-%02d%s", *d.u.ts->year, *d.u.ts->month, *d.u.ts->day,
           d.u.ts->hour ? "T" : "");
  }
  if (d.u.ts->hour) {
    printf("%02d:%02d:%02d", *d.u.ts->hour, *d.u.ts->minute, *d.u.ts->second);
    if (d.u.ts->millisec) {
      printf(".%03d", *d.u.ts->millisec);
    }
    if (d.u.ts->z) {
      printf("%s", d.u.ts->z);
    }
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x1caf
movl (%rax), %esi
movq 0x30(%rbx), %rax
movq 0x38(%rbx), %rcx
movl (%rax), %edx
movl (%rcx), %ecx
cmpq $0x0, 0x40(%rbx)
leaq 0x49d9(%rip), %rax      # 0x666f
leaq 0x4760(%rip), %r8       # 0x63fd
cmoveq %rax, %r8
leaq 0x444f(%rip), %rdi      # 0x60f7
xorl %eax, %eax
callq 0x10d0
movq 0x40(%rbx), %rax
testq %rax, %rax
je 0x1d05
movl (%rax), %esi
movq 0x48(%rbx), %rax
movq 0x50(%rbx), %rcx
movl (%rax), %edx
movl (%rcx), %ecx
leaq 0x443b(%rip), %rdi      # 0x6108
xorl %eax, %eax
callq 0x10d0
movq 0x58(%rbx), %rax
testq %rax, %rax
je 0x1ced
movl (%rax), %esi
leaq 0x4431(%rip), %rdi      # 0x6117
xorl %eax, %eax
callq 0x10d0
movq 0x60(%rbx), %rsi
testq %rsi, %rsi
je 0x1d05
leaq 0x4598(%rip), %rdi      # 0x6295
xorl %eax, %eax
popq %rbx
jmp 0x10d0
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/cktan[P]tomlc99/toml.c
// Function: toml_set_memutil
void toml_set_memutil(void *(*xxmalloc)(size_t), void (*xxfree)(void *)) {
  if (xxmalloc)
    ppmalloc = xxmalloc;
  if (xxfree)
    ppfree = xxfree;
}

// Assembly:
testq %rdi, %rdi
je 0x1d14
movq %rdi, 0x73fc(%rip)      # 0x9110
testq %rsi, %rsi
je 0x1d20
movq %rsi, 0x73f8(%rip)      # 0x9118
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3303
movl %edx, %esi
callq 0x2988
movl %eax, %ecx
xorl %eax, %eax
negl %ecx
sbbl %eax, %eax
jmp 0x3321
movq 0x10(%rdi), %rax
movslq 0x18(%rdi), %rsi
leaq 0x30c0(%rip), %rdx      # 0x63d2
movq %rax, %rdi
xorl %eax, %eax
callq 0x10e0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x35ef
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x3525
callq *0x5bf3(%rip)           # 0x9118
movl 0xc(%rbx), %eax
testl %eax, %eax
jle 0x3570
xorl %r15d, %r15d
movq 0x10(%rbx), %rcx
movq (%rcx,%r15,8), %r14
testq %r14, %r14
je 0x3565
movq (%r14), %rdi
testq %rdi, %rdi
je 0x354a
callq *0x5bce(%rip)           # 0x9118
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x3559
callq *0x5bbf(%rip)           # 0x9118
movq %r14, %rdi
callq *0x5bb6(%rip)           # 0x9118
movl 0xc(%rbx), %eax
incq %r15
movslq %eax, %rcx
cmpq %rcx, %r15
jl 0x352f
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x357f
callq *0x5b99(%rip)           # 0x9118
cmpl $0x0, 0x18(%rbx)
jle 0x35a1
xorl %r14d, %r14d
movq 0x20(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x5681
incq %r14
movslq 0x18(%rbx), %rax
cmpq %rax, %r14
jl 0x3588
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x35b0
callq *0x5b68(%rip)           # 0x9118
cmpl $0x0, 0x28(%rbx)
jle 0x35d2
xorl %r14d, %r14d
movq 0x30(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x3506
incq %r14
movslq 0x28(%rbx), %rax
cmpq %rax, %r14
jl 0x35b9
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x35e1
callq *0x5b37(%rip)           # 0x9118
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *0x5b29(%rip)           # 0x9118
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x361b
movl $0x20, %eax
movl %edx, %ecx
movl %edx, %esi
subl 0x18(%rdi), %ecx
jl 0x361b
movl $0x30, %eax
movl %ecx, %esi
cmpl 0x28(%rdi), %ecx
jge 0x362a
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_O3/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 0x3667
movq 0x10(%r14), %r12
xorl %r13d, %r13d
movq (%r12,%r13,8), %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x1140
testl %eax, %eax
je 0x36c1
incq %r13
cmpq %r13, %r15
jne 0x364c
movslq 0x18(%r14), %r15
testq %r15, %r15
jle 0x3692
movq 0x20(%r14), %r12
xorl %r13d, %r13d
movq (%r12,%r13,8), %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x1140
testl %eax, %eax
je 0x36c1
incq %r13
cmpq %r13, %r15
jne 0x3677
movslq 0x28(%r14), %r15
testq %r15, %r15
jle 0x36bd
movq 0x30(%r14), %r14
xorl %r12d, %r12d
movq (%r14,%r12,8), %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x1140
testl %eax, %eax
je 0x36c1
incq %r12
cmpq %r12, %r15
jne 0x36a2
xorl %eax, %eax
jmp 0x36c6
movl $0x1, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x370e
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 0x1140
testl %eax, %eax
je 0x3712
incq %r13
cmpq %r13, %r15
jne 0x36f0
jmp 0x3716
xorl %ebx, %ebx
jmp 0x3716
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_O3/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 0x375f
movq %rsi, %rbx
movq 0x20(%rdi), %r12
xorl %r13d, %r13d
movq (%r12,%r13,8), %r14
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x1140
testl %eax, %eax
je 0x3762
incq %r13
cmpq %r13, %r15
jne 0x3744
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x37a6
movq %rsi, %rbx
movq 0x30(%rdi), %r12
xorl %r13d, %r13d
movq (%r12,%r13,8), %r14
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x1140
testl %eax, %eax
je 0x37a9
incq %r13
cmpq %r13, %r15
jne 0x378b
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x570e
movl %eax, %ebp
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
testl %eax, %eax
js 0x3ae6
cmpb $0x2d, 0x4(%rbx)
jne 0x3ae6
leaq 0x5(%rbx), %rdi
movl $0x2, %esi
callq 0x570e
movl %eax, %r13d
testl %eax, %eax
js 0x3aec
cmpb $0x2d, 0x7(%rbx)
jne 0x3aec
addq $0x8, %rbx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x570e
movl %eax, %r15d
jmp 0x3aec
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movq (%rsp), %rax
testq %r12, %r12
je 0x3af9
movl %ebp, (%r12)
testq %r14, %r14
je 0x3b01
movl %r13d, (%r14)
testq %rax, %rax
je 0x3b09
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_O3/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 0x570e
movl %eax, %ebp
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
testl %eax, %eax
js 0x3b8d
cmpb $0x3a, 0x2(%rbx)
jne 0x3b8d
leaq 0x3(%rbx), %rdi
movl $0x2, %esi
callq 0x570e
movl %eax, %r13d
testl %eax, %eax
js 0x3b93
cmpb $0x3a, 0x5(%rbx)
jne 0x3b93
addq $0x6, %rbx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x570e
movl %eax, %r15d
jmp 0x3b93
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movq (%rsp), %rax
testq %r12, %r12
je 0x3ba0
movl %ebp, (%r12)
testq %r14, %r14
je 0x3ba8
movl %r13d, (%r14)
testq %rax, %rax
je 0x3bb0
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_O3/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 0x3c1a
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x247d(%rip), %rsi      # 0x6062
callq 0x1140
testl %eax, %eax
je 0x3c20
testq %rbx, %rbx
sete %bpl
leaq 0x246b(%rip), %rsi      # 0x6067
movq %r14, %rdi
callq 0x1140
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setne %dl
xorl %ecx, %ecx
orb %dl, %bpl
je 0x3c2a
movb %dl, %al
negl %eax
jmp 0x3c2e
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
movl $0x1, %ecx
testq %rbx, %rbx
je 0x3c2c
movl %ecx, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3c6a
pushq %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %rbx
movzbl (%rdi), %esi
cmpl $0x2d, %esi
je 0x3c53
cmpl $0x2b, %esi
jne 0x3c70
leaq 0x11(%rsp), %rdx
movb %sil, -0x1(%rdx)
movb 0x1(%rdi), %sil
incq %rdi
movl $0x1, %ecx
jmp 0x3c77
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
xorl %ecx, %ecx
leaq 0x10(%rsp), %rdx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpb $0x5f, %sil
je 0x3d7c
movzbl %sil, %esi
xorl %ebp, %ebp
cmpl $0x30, %esi
jne 0x3ceb
movzbl 0x1(%rdi), %esi
cmpl $0x6e, %esi
jg 0x3cb2
testl %esi, %esi
je 0x3ccb
cmpl $0x62, %esi
jne 0x3d7c
addq $0x2, %rdi
movl $0x2, %ebp
jmp 0x3ceb
cmpl $0x6f, %esi
je 0x3ce2
cmpl $0x78, %esi
jne 0x3d7c
addq $0x2, %rdi
movl $0x10, %ebp
jmp 0x3ceb
xorl %eax, %eax
testq %rbx, %rbx
je 0x3d7c
movq $0x0, (%rbx)
jmp 0x3d7c
addq $0x2, %rdi
movl $0x8, %ebp
movb (%rdi), %sil
testb %sil, %sil
je 0x3d3c
incq %rdi
cmpb $0x5f, %sil
jne 0x3d0a
movzbl (%rdi), %esi
testl %esi, %esi
je 0x3d7c
cmpl $0x5f, %esi
jne 0x3d13
jmp 0x3d7c
incq %rcx
movb %sil, (%rdx)
movb (%rdi), %sil
leaq (%rsp,%rcx), %rdx
addq $0x10, %rdx
testb %sil, %sil
je 0x3d29
incq %rdi
cmpq $0x64, %rcx
jl 0x3cf6
testb %sil, %sil
setne %sil
cmpq $0x64, %rcx
sete %cl
orb %sil, %cl
jne 0x3d7c
movb $0x0, (%rdx)
callq 0x1050
movq %rax, %r14
movl $0x0, (%rax)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl %ebp, %edx
callq 0x1150
testq %rbx, %rbx
je 0x3d66
movq %rax, (%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x0, (%r14)
jne 0x3d7c
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_O3/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 0x44d8
cmpl %esi, 0x10(%rdi)
jle 0x44d8
movq 0x18(%rdi), %rax
movl %esi, %ecx
shlq $0x5, %rcx
movq 0x8(%rax,%rcx), %rdi
jmp 0x44da
xorl %edi, %edi
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
callq 0x3f11
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
movq (%rbx), %rdx
movl %ecx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x451f
cmpl %esi, 0x10(%rdi)
jle 0x451f
movq 0x18(%rdi), %rax
movl %esi, %ecx
shlq $0x5, %rcx
movq 0x8(%rax,%rcx), %rdi
jmp 0x4521
xorl %edi, %edi
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
callq 0x3bcf
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
movq (%rbx), %rdx
movl %ecx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4566
cmpl %esi, 0x10(%rdi)
jle 0x4566
movq 0x18(%rdi), %rax
movl %esi, %ecx
shlq $0x5, %rcx
movq 0x8(%rax,%rcx), %rdi
jmp 0x4568
xorl %edi, %edi
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
callq 0x3c33
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
movq (%rbx), %rdx
movl %ecx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x45b0
cmpl %esi, 0x10(%rdi)
jle 0x45b0
movq 0x18(%rdi), %rax
movl %esi, %ecx
shlq $0x5, %rcx
movq 0x8(%rax,%rcx), %rdi
jmp 0x45b2
xorl %edi, %edi
leaq 0x8(%rsp), %rbx
leaq 0x10(%rsp), %rdx
movq %rbx, %rsi
movl $0x64, %ecx
callq 0x3d88
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
movq (%rbx), %rdx
movl %ecx, %eax
addq $0x80, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbx
subq $0x70, %rsp
xorl %ebx, %ebx
testl %esi, %esi
js 0x45ff
cmpl %esi, 0x10(%rdi)
jle 0x45ff
movq 0x18(%rdi), %rax
movl %esi, %ecx
shlq $0x5, %rcx
movq 0x8(%rax,%rcx), %rdi
jmp 0x4601
xorl %edi, %edi
leaq 0x8(%rsp), %rsi
callq 0x3849
testl %eax, %eax
je 0x4619
xorl %edx, %edx
movl %ebx, %eax
addq $0x70, %rsp
popq %rbx
retq
movl $0x68, %edi
callq *0x4aec(%rip)           # 0x9110
testq %rax, %rax
je 0x46c5
movq %rax, %rdx
leaq 0x8(%rsp), %rsi
movl $0xd, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
cmpq $0x0, 0x28(%rax)
je 0x464b
movq %rdx, 0x28(%rdx)
cmpq $0x0, 0x30(%rdx)
je 0x465a
leaq 0x4(%rdx), %rax
movq %rax, 0x30(%rdx)
cmpq $0x0, 0x38(%rdx)
je 0x4669
leaq 0x8(%rdx), %rax
movq %rax, 0x38(%rdx)
cmpq $0x0, 0x40(%rdx)
je 0x4678
leaq 0xc(%rdx), %rax
movq %rax, 0x40(%rdx)
cmpq $0x0, 0x48(%rdx)
je 0x4687
leaq 0x10(%rdx), %rax
movq %rax, 0x48(%rdx)
cmpq $0x0, 0x50(%rdx)
je 0x4696
leaq 0x14(%rdx), %rax
movq %rax, 0x50(%rdx)
cmpq $0x0, 0x58(%rdx)
je 0x46a5
leaq 0x18(%rdx), %rax
movq %rax, 0x58(%rdx)
movl $0x1, %ebx
cmpq $0x0, 0x60(%rdx)
je 0x4611
movq %rdx, %rax
addq $0x1c, %rax
movq %rax, 0x60(%rdx)
jmp 0x4611
xorl %edx, %edx
xorl %ebx, %ebx
jmp 0x4611
// File: /workspace/github_c_makefile_star2_O3/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 0x36d0
testq %rax, %rax
je 0x4702
leaq 0x8(%rsp), %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3f11
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
sete %al
movq (%rbx), %rdx
jmp 0x4706
xorl %edx, %edx
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x36d0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3bcf
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
movq (%rbx), %rdx
movl %ecx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/cktan[P]tomlc99/toml.c
// Function: toml_int_in
toml_datum_t toml_int_in(const toml_table_t *arr, const char *key) {
  toml_datum_t ret;
  memset(&ret, 0, sizeof(ret));
  ret.ok = (0 == toml_rtoi(toml_raw_in(arr, key), &ret.u.i));
  return ret;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
xorps %xmm0, %xmm0
leaq 0x8(%rsp), %rbx
movaps %xmm0, -0x8(%rbx)
callq 0x36d0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3c33
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
movq (%rbx), %rdx
movl %ecx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x36d0
leaq 0x10(%rsp), %rdx
movq %rax, %rdi
movq %rbx, %rsi
movl $0x64, %ecx
callq 0x3d88
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
movq (%rbx), %rdx
movl %ecx, %eax
addq $0x80, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x36d0
movq %rsp, %rsi
movq %rax, %rdi
callq 0x3849
testl %eax, %eax
je 0x47d6
xorl %edx, %edx
xorl %eax, %eax
addq $0x68, %rsp
retq
movl $0x68, %edi
callq *0x492f(%rip)           # 0x9110
testq %rax, %rax
je 0x47cd
movq %rax, %rdx
movq %rsp, %rsi
movl $0xd, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
cmpq $0x0, 0x28(%rax)
je 0x4802
movq %rdx, 0x28(%rdx)
cmpq $0x0, 0x30(%rdx)
je 0x4811
leaq 0x4(%rdx), %rax
movq %rax, 0x30(%rdx)
cmpq $0x0, 0x38(%rdx)
je 0x4820
leaq 0x8(%rdx), %rax
movq %rax, 0x38(%rdx)
cmpq $0x0, 0x40(%rdx)
je 0x482f
leaq 0xc(%rdx), %rax
movq %rax, 0x40(%rdx)
cmpq $0x0, 0x48(%rdx)
je 0x483e
leaq 0x10(%rdx), %rax
movq %rax, 0x48(%rdx)
cmpq $0x0, 0x50(%rdx)
je 0x484d
leaq 0x14(%rdx), %rax
movq %rax, 0x50(%rdx)
cmpq $0x0, 0x58(%rdx)
je 0x485c
leaq 0x18(%rdx), %rax
movq %rax, 0x58(%rdx)
movl $0x1, %eax
cmpq $0x0, 0x60(%rdx)
je 0x47d1
movq %rdx, %rcx
addq $0x1c, %rcx
movq %rcx, 0x60(%rdx)
jmp 0x47d1
// File: /workspace/github_c_makefile_star2_O3/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 0x487c
testq %rax, %rax
je 0x4c70
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x53fd
testl %eax, %eax
je 0x4c77
leaq 0x50(%rsp), %r14
movq %r15, %rdi
callq *0x44c9(%rip)           # 0x9118
movl 0x4(%r14), %ecx
movq 0x10(%rbx), %rdi
movslq 0x18(%rbx), %rsi
leaq 0x1673(%rip), %rdx      # 0x62d5
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x10e0
jmp 0x4d45
xorl %ebx, %ebx
jmp 0x4d45
movslq 0xc(%r14), %rbp
movq 0x10(%r14), %r13
leaq 0x8(,%rbp,8), %rdi
callq *0x4483(%rip)           # 0x9110
testq %rax, %rax
je 0x4cf4
movq %rax, %r12
movq $0x0, (%rax,%rbp,8)
testq %r13, %r13
je 0x4cbe
leaq (,%rbp,8), %rdx
movq %r12, %rdi
movq %r13, %rsi
callq 0x1180
movq %r13, %rdi
callq *0x445a(%rip)           # 0x9118
movq %r12, 0x10(%r14)
movl $0x10, %edi
callq *0x4443(%rip)           # 0x9110
testq %rax, %rax
je 0x4d15
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 0x4d45
movq %r15, %rdi
callq *0x441b(%rip)           # 0x9118
movq 0x10(%rbx), %rdi
movslq 0x18(%rbx), %rsi
leaq 0x14d2(%rip), %rdx      # 0x61de
leaq 0x15d6(%rip), %rcx      # 0x62e9
jmp 0x4d3c
movq $0x0, (%r12,%rbp,8)
movq %r15, %rdi
callq *0x43f2(%rip)           # 0x9118
movq 0x10(%rbx), %rdi
movslq 0x18(%rbx), %rsi
leaq 0x14a9(%rip), %rdx      # 0x61de
leaq 0x15b8(%rip), %rcx      # 0x62f4
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x10e0
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_O3/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 0x487c
testq %rax, %rax
je 0x4dd2
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x53fd
testl %eax, %eax
je 0x4dd9
leaq 0x60(%rsp), %r14
movq %r15, %rdi
callq *0x4367(%rip)           # 0x9118
movl 0x4(%r14), %ecx
movq 0x10(%rbx), %rdi
movslq 0x18(%rbx), %rsi
leaq 0x1511(%rip), %rdx      # 0x62d5
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x10e0
jmp 0x4eb7
xorl %ebx, %ebx
jmp 0x4eb7
movl %ebp, 0x24(%rsp)
movslq 0x18(%r14), %rbp
movq 0x20(%r14), %r13
leaq 0x8(,%rbp,8), %rdi
callq *0x431d(%rip)           # 0x9110
testq %rax, %rax
je 0x4e66
movq %rax, %r12
movq $0x0, (%rax,%rbp,8)
testq %r13, %r13
je 0x4e24
leaq (,%rbp,8), %rdx
movq %r12, %rdi
movq %r13, %rsi
callq 0x1180
movq %r13, %rdi
callq *0x42f4(%rip)           # 0x9118
movq %r12, 0x20(%r14)
movl $0x20, %edi
callq *0x42dd(%rip)           # 0x9110
testq %rax, %rax
je 0x4e87
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 0x4eb7
movq %r15, %rdi
callq *0x42a9(%rip)           # 0x9118
movq 0x10(%rbx), %rdi
movslq 0x18(%rbx), %rsi
leaq 0x1360(%rip), %rdx      # 0x61de
leaq 0x147a(%rip), %rcx      # 0x62ff
jmp 0x4eae
movq $0x0, (%r12,%rbp,8)
movq %r15, %rdi
callq *0x4280(%rip)           # 0x9118
movq 0x10(%rbx), %rdi
movslq 0x18(%rbx), %rsi
leaq 0x1337(%rip), %rdx      # 0x61de
leaq 0x145c(%rip), %rcx      # 0x630a
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x10e0
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_O3/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 0x5344
movq %rsi, %r15
movq %r14, %rdi
movl $0x1, %esi
callq 0x2988
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0x5366
movl 0x20(%r14), %eax
cmpl $0x9, %eax
jne 0x536e
movq %r14, %rdi
movq %r15, %rsi
callq 0x2fe0
testl %eax, %eax
jne 0x5366
movl 0x20(%r14), %eax
cmpl $0x2, %eax
jne 0x5394
movq %r14, %rdi
movl $0x1, %esi
callq 0x2988
jmp 0x5310
movq 0x10(%r14), %rdi
movslq 0x18(%r14), %rsi
leaq 0x107f(%rip), %rdx      # 0x63d2
leaq 0x102e(%rip), %rcx      # 0x6388
xorl %eax, %eax
callq 0x10e0
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
cmpl $0x5, %eax
je 0x53c1
cmpl $0x6, %eax
je 0x539e
movl 0x24(%r14), %ecx
movq 0x10(%r14), %rdi
movslq 0x18(%r14), %rsi
leaq 0xf01(%rip), %rdx       # 0x628c
leaq 0x1025(%rip), %r8       # 0x63b7
jmp 0x53b8
cmpl $0x5, %eax
je 0x53c1
cmpl $0x6, %eax
jne 0x53db
movl 0x24(%r14), %ecx
movq 0x10(%r14), %rdi
movslq 0x18(%r14), %rsi
leaq 0xedb(%rip), %rdx       # 0x628c
leaq 0xfdb(%rip), %r8        # 0x6393
xorl %eax, %eax
callq 0x10e0
jmp 0x5366
movq %r14, %rdi
movl $0x1, %esi
callq 0x2988
testl %eax, %eax
jne 0x5366
movb $0x1, 0x9(%r15)
xorl %ebx, %ebx
jmp 0x5366
movq 0x10(%r14), %rdi
movslq 0x18(%r14), %rsi
leaq 0xfe8(%rip), %rdx       # 0x63d2
leaq 0xfd6(%rip), %rcx       # 0x63c7
xorl %eax, %eax
callq 0x10e0
jmp 0x5366
// File: /workspace/github_c_makefile_star2_O3/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 0x541d
movq $0x0, (%r8)
testq %rcx, %rcx
je 0x5429
movq $0x0, (%rcx)
movq %rcx, 0x8(%rsp)
movq %r8, (%rsp)
testq %rdx, %rdx
je 0x543e
movq $0x0, (%rdx)
movq %rdx, 0x10(%rsp)
movslq 0xc(%r12), %rbp
testq %rbp, %rbp
jle 0x5471
movq 0x10(%r12), %rbx
xorl %r15d, %r15d
movq (%rbx,%r15,8), %r13
movq (%r13), %rsi
movq %r14, %rdi
callq 0x1140
testl %eax, %eax
je 0x54d1
incq %r15
cmpq %r15, %rbp
jne 0x5455
movslq 0x18(%r12), %r13
testq %r13, %r13
jle 0x549f
movq 0x20(%r12), %rbx
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rbp
movq (%rbp), %rsi
movq %r14, %rdi
callq 0x1140
testl %eax, %eax
je 0x54dd
incq %r15
cmpq %r15, %r13
jne 0x5483
movslq 0x28(%r12), %r15
testq %r15, %r15
jle 0x54cd
movq 0x30(%r12), %rbx
xorl %r12d, %r12d
movq (%rbx,%r12,8), %r13
movq (%r13), %rsi
movq %r14, %rdi
callq 0x1140
testl %eax, %eax
je 0x54f1
incq %r12
cmpq %r12, %r15
jne 0x54b1
xorl %eax, %eax
jmp 0x5502
movl $0x76, %eax
movq 0x10(%rsp), %rcx
jmp 0x54fa
movl $0x61, %eax
movq 0x8(%rsp), %rcx
testq %rcx, %rcx
je 0x5502
movq %rbp, (%rcx)
jmp 0x5502
movl $0x74, %eax
movq (%rsp), %rcx
testq %rcx, %rcx
je 0x5502
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_O3/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 0x55b7
testq %rax, %rax
je 0x5574
movq %rax, %r12
movl $0x38, %edi
callq *0x3bd0(%rip)           # 0x9110
testq %rax, %rax
je 0x558c
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 0x55ab
movq 0x10(%r15), %rdi
movslq 0x18(%r15), %rsi
leaq 0xc5b(%rip), %rdx       # 0x61de
leaq 0xde8(%rip), %rcx       # 0x6372
jmp 0x55a2
movq 0x10(%r15), %rdi
movslq 0x18(%r15), %rsi
leaq 0xc43(%rip), %rdx       # 0x61de
leaq 0xddb(%rip), %rcx       # 0x637d
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x10e0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r15
movl %esi, %r12d
shll $0x5, %r12d
leal 0x20(%r12), %eax
movslq %eax, %rdi
callq *0x3b37(%rip)           # 0x9110
movq %rax, %r14
testq %rax, %rax
sete %al
testq %r15, %r15
sete %cl
orb %al, %cl
je 0x55f3
testq %r14, %r14
jne 0x560a
jmp 0x561f
movslq %r12d, %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x1180
movq %r15, %rdi
callq *0x3b0e(%rip)           # 0x9118
movslq %ebx, %rax
shlq $0x5, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14,%rax)
movups %xmm0, (%r14,%rax)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x10b0
movq %rax, %r14
shlq $0x20, %r14
movabsq $0x100000000, %rdi      # imm = 0x100000000
addq %r14, %rdi
sarq $0x20, %rdi
callq *0x3ab7(%rip)           # 0x9110
movq %rax, %r15
testq %rax, %rax
je 0x5678
sarq $0x20, %r14
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1180
movb $0x0, (%r15,%r14)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5708
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x569c
callq *0x3a7c(%rip)           # 0x9118
movslq 0x10(%rbx), %r14
testq %r14, %r14
jle 0x56eb
shlq $0x5, %r14
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
movq 0x8(%rax,%r15), %rdi
testq %rdi, %rdi
je 0x56c2
callq *0x3a58(%rip)           # 0x9118
jmp 0x56e2
movq 0x10(%rax,%r15), %rdi
testq %rdi, %rdi
je 0x56d3
callq 0x5681
jmp 0x56e2
movq 0x18(%rax,%r15), %rdi
testq %rdi, %rdi
je 0x56e2
callq 0x3506
addq $0x20, %r15
cmpq %r15, %r14
jne 0x56ac
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x56fa
callq *0x3a1e(%rip)           # 0x9118
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *0x3a10(%rip)           # 0x9118
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
testl %esi, %esi
jle 0x5747
movq %rdi, %r14
callq 0x11f0
movq (%rax), %rcx
incl %ebx
xorl %eax, %eax
movsbq (%r14), %rdx
testb $0x8, 0x1(%rcx,%rdx,2)
je 0x574f
leal (%rax,%rax,4), %eax
leal (%rdx,%rax,2), %eax
addl $-0x30, %eax
incq %r14
decl %ebx
cmpl $0x1, %ebx
jg 0x5727
jmp 0x5754
xorl %eax, %eax
negl %ebx
sbbl %eax, %eax
jmp 0x5754
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2371
movq 0x30(%r15), %rax
pushq $0x1
popq %r12
movl %r12d, %r13d
testl %ebx, %ebx
sete %cl
movl %r13d, %r13d
movzwl (%rax,%r13,2), %esi
cmpl %ebx, %esi
setl %dl
cmpl %r14d, %esi
jl 0x2369
orb %dl, %cl
je 0x2369
movq 0x28(%r15), %rax
movq (%rax,%r13,8), %rsi
movq %r15, %rdi
movl %r12d, %edx
callq 0x4053
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 0x231b
movq 0x7c80(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
movl 0x40(%r15), %ecx
leaq 0x486e(%rip), %rsi      # 0x6bf4
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_O3/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 0x5204
movq %rax, %r14
cmpl $0x0, 0x40(%r15)
je 0x2529
movl $0x1, %ebp
movq 0x30(%r15), %rax
movl %ebp, %ecx
movzwl (%rax,%rcx,2), %esi
cmpl %esi, 0x18(%r14)
jle 0x2517
movslq 0x14(%r14), %rcx
movl %esi, %eax
imulq %rcx, %rax
addq 0x8(%r14), %rax
jmp 0x251f
movq %r14, %rdi
callq 0x54ad
incl (%rax)
incl %ebp
cmpl 0x40(%r15), %ebp
jbe 0x24f7
movl 0x18(%r14), %eax
testl %eax, %eax
je 0x2565
leaq 0x3acc(%rip), %r15      # 0x6004
xorl %ebp, %ebp
movq 0x8(%r14), %rcx
movl 0x14(%r14), %edx
imull %ebp, %edx
movl (%rcx,%rdx), %ecx
testl %ecx, %ecx
je 0x255f
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x1120
movl 0x18(%r14), %eax
incl %ebp
cmpl %eax, %ebp
jb 0x253a
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5352
// File: /workspace/github_c_makefile_star2_O3/richarddurbin[P]hash10x/moshutils.c
// Function: reportDepths
void reportDepths (Moshset *ms, Array ma, FILE *f)
{
  U32 i, j, index ;
  for (i = 1 ; i <= ms->max ; ++i)
    { fprintf (f, "MH\t%llx\t%d\t%u", ms->value[i], msCopy(ms,i), ms->depth[i]) ;
      for (j = 0 ; j < arrayMax(ma) ; ++j)
	if ((index = moshsetIndexFind (arr(ma,j,Moshset*), ms->value[i], FALSE)))
	  fprintf (f, "\t%u", arr(ma,j,Moshset*)->depth[index]) ;
	else
	  fprintf (f, "\t0") ;
      fputc ('\n', f) ;
    }
}

// Assembly:
cmpl $0x0, 0x40(%rdi)
je 0x2673
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %r12d
leaq 0x3a76(%rip), %rbp      # 0x6018
movl %r12d, %r12d
movq 0x28(%r15), %rax
movq 0x30(%r15), %rsi
movq (%rax,%r12,8), %rdx
movq 0x38(%r15), %rax
movzbl (%rax,%r12), %ecx
andl $0x3, %ecx
movzwl (%rsi,%r12,2), %r8d
movq %rbx, %rdi
leaq 0x3a42(%rip), %rsi      # 0x600e
xorl %eax, %eax
callq 0x1120
cmpl $0x0, 0x18(%r14)
je 0x264b
xorl %r13d, %r13d
movq 0x8(%r14), %rax
movl 0x14(%r14), %ecx
imull %r13d, %ecx
movq (%rax,%rcx), %rdi
movq 0x28(%r15), %rax
movq (%rax,%r12,8), %rsi
xorl %edx, %edx
callq 0x4053
testl %eax, %eax
je 0x2629
movq 0x8(%r14), %rcx
movl 0x14(%r14), %edx
imull %r13d, %edx
movq (%rcx,%rdx), %rcx
movq 0x30(%rcx), %rcx
movl %eax, %eax
movzwl (%rcx,%rax,2), %edx
movq %rbx, %rdi
movq %rbp, %rsi
xorl %eax, %eax
callq 0x1120
jmp 0x2642
movl $0x2, %esi
movl $0x1, %edx
leaq 0x39e2(%rip), %rdi      # 0x601c
movq %rbx, %rcx
callq 0x1220
incl %r13d
cmpl 0x18(%r14), %r13d
jb 0x25dd
movl $0xa, %edi
movq %rbx, %rsi
callq 0x10e0
incl %r12d
cmpl 0x40(%r15), %r12d
jbe 0x25a2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq