LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/cktan[P]tomlc99/toml_cat.c
// Function: main
int main(int argc, const char *argv[]) {
  int i;
  if (argc == 1) {
    cat(stdin);
  } else {
    for (i = 1; i < argc; i++) {

      FILE *fp = fopen(argv[i], "r");
      if (!fp) {
        fprintf(stderr, "ERROR: cannot open %s: %s\n", argv[i],
                strerror(errno));
        exit(1);
      }
      cat(fp);
      fclose(fp);
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jne 0x1310
movq 0x9cd5(%rip), %rax      # 0xafd8
movq (%rax), %rdi
callq 0x13c0
jmp 0x13b5
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x13b3
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x6da4(%rip), %rsi      # 0x80da
callq 0x1190
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1393
movq 0x9cab(%rip), %rax      # 0xaff8
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
callq 0x1050
movl (%rax), %edi
callq 0x11b0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq %rax, %rcx
leaq 0x6c82(%rip), %rsi      # 0x8004
movb $0x0, %al
callq 0x1150
movl $0x1, %edi
callq 0x11a0
movq -0x20(%rbp), %rdi
callq 0x13c0
movq -0x20(%rbp), %rdi
callq 0x10a0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1317
jmp 0x13b5
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cktan[P]tomlc99/toml_cat.c
// Function: cat
static void cat(FILE *fp) {
  char errbuf[200];

  toml_table_t *tab = toml_parse_file(fp, errbuf, sizeof(errbuf));
  if (!tab) {
    fprintf(stderr, "ERROR: %s\n", errbuf);
    return;
  }

  stack[stacktop].tab = tab;
  stack[stacktop].key = "";
  stacktop++;
  printf("{\n");
  indent++;
  print_table(tab);
  indent--;
  printf("}\n");
  stacktop--;

  toml_free(tab);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
movl $0xc8, %edx
callq 0x3550
movq %rax, -0xd8(%rbp)
cmpq $0x0, -0xd8(%rbp)
jne 0x1419
movq 0x9bfc(%rip), %rax      # 0xaff8
movq (%rax), %rdi
leaq -0xd0(%rbp), %rdx
leaq 0x6c12(%rip), %rsi      # 0x801f
movb $0x0, %al
callq 0x1150
jmp 0x14c8
movq -0xd8(%rbp), %rcx
movslq 0x9cf9(%rip), %rdx      # 0xb120
leaq 0x9d02(%rip), %rax      # 0xb130
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movslq 0x9ce0(%rip), %rcx      # 0xb120
leaq 0x9ce9(%rip), %rax      # 0xb130
shlq $0x4, %rcx
addq %rcx, %rax
leaq 0x732d(%rip), %rcx      # 0x8782
movq %rcx, (%rax)
movl 0x9cc2(%rip), %eax      # 0xb120
addl $0x1, %eax
movl %eax, 0x9cb9(%rip)      # 0xb120
leaq 0x6bd0(%rip), %rdi      # 0x803e
movb $0x0, %al
callq 0x10d0
movl 0x9ca9(%rip), %eax      # 0xb124
addl $0x1, %eax
movl %eax, 0x9ca0(%rip)      # 0xb124
movq -0xd8(%rbp), %rdi
callq 0x14e0
movl 0x9c8e(%rip), %eax      # 0xb124
addl $-0x1, %eax
movl %eax, 0x9c85(%rip)      # 0xb124
leaq 0x6b84(%rip), %rdi      # 0x802a
movb $0x0, %al
callq 0x10d0
movl 0x9c6d(%rip), %eax      # 0xb120
addl $-0x1, %eax
movl %eax, 0x9c64(%rip)      # 0xb120
movq -0xd8(%rbp), %rdi
callq 0x3530
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x1dc4
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl (%rax), %esi
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movl (%rax), %edx
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movl (%rax), %ecx
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
leaq 0x69db(%rip), %r8       # 0x8782
leaq 0x674a(%rip), %rax      # 0x84f8
cmpq $0x0, %rdi
cmovneq %rax, %r8
leaq 0x632d(%rip), %rdi      # 0x80ea
movb $0x0, %al
callq 0x10d0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x1e41
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movl (%rax), %esi
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movl (%rax), %edx
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movl (%rax), %ecx
leaq 0x6307(%rip), %rdi      # 0x80fb
movb $0x0, %al
callq 0x10d0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x1e1e
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl (%rax), %esi
leaq 0x62f3(%rip), %rdi      # 0x810a
movb $0x0, %al
callq 0x10d0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0x1e3f
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rsi
leaq 0x6541(%rip), %rdi      # 0x8379
movb $0x0, %al
callq 0x10d0
jmp 0x1e41
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1eae
movq -0x8(%rbp), %rax
movq %rax, 0x9252(%rip)      # 0xb100
cmpq $0x0, -0x10(%rbp)
je 0x1ec0
movq -0x10(%rbp), %rax
movq %rax, 0x9248(%rip)      # 0xb108
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cktan[P]tomlc99/toml.c
// Function: CALLOC
static void *CALLOC(size_t nmemb, size_t sz) {
  int nb = ALIGN8(sz) * nmemb;
  void *p = MALLOC(nb);
  if (p) {
    memset(p, 0, nb);
  }
  return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x7, %rax
andq $-0x8, %rax
imulq -0x8(%rbp), %rax
movl %eax, -0x14(%rbp)
movq 0x8825(%rip), %rax      # 0xb100
movslq -0x14(%rbp), %rdi
callq *%rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x28fb
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rdx
xorl %esi, %esi
callq 0x1100
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
cmpl -0x14(%rbp), %eax
je 0x3094
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6cd0
movl %eax, -0x4(%rbp)
jmp 0x30b5
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x2950
cmpl $0x0, %eax
je 0x30ae
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x30b5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cktan[P]tomlc99/toml.c
// Function: expand
static void *expand(void *p, int sz, int newsz) {
  void *s = MALLOC(newsz);
  if (!s)
    return 0;

  if (p) {
    memcpy(s, p, sz);
    FREE(p);
  }
  return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq 0x7997(%rip), %rax      # 0xb100
movslq -0x18(%rbp), %rdi
callq *%rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3784
movq $0x0, -0x8(%rbp)
jmp 0x37b1
cmpq $0x0, -0x10(%rbp)
je 0x37a9
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x1170
movq 0x7965(%rip), %rax      # 0xb108
movq -0x10(%rbp), %rdi
callq *%rax
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x37d8
jmp 0x38ad
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3500
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x3817
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x71c0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x37eb
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3500
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x3857
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x7200
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x382b
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x3500
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x3897
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x37c0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x386b
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x3500
movq -0x8(%rbp), %rdi
callq 0x3500
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x38f0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x3960
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
movl -0x14(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x3924
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x3960
movq -0x10(%rbp), %rax
movl 0x18(%rax), %ecx
movl -0x14(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x3958
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x3960
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x39d0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rsi
callq 0x1130
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x39c3
movl $0x1, -0x4(%rbp)
jmp 0x3a71
jmp 0x39c5
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3987
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x3a1d
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rsi
callq 0x1130
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x3a10
movl $0x1, -0x4(%rbp)
jmp 0x3a71
jmp 0x3a12
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x39d7
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x3a6a
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rsi
callq 0x1130
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x3a5d
movl $0x1, -0x4(%rbp)
jmp 0x3a71
jmp 0x3a5f
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3a24
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x3aee
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rsi
callq 0x1130
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x3ae1
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x3af6
jmp 0x3ae3
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3a97
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x3b6a
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rsi
callq 0x1130
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x3b5d
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x3b72
jmp 0x3b5f
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3b17
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x3bea
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rsi
callq 0x1130
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x3bdd
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x3bf2
jmp 0x3bdf
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3b97
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cktan[P]tomlc99/toml.c
// Function: toml_array_type
char toml_array_type(const toml_array_t *arr) {
  if (arr->kind != 'v')
    return 0;

  if (arr->nitem == 0)
    return 0;

  return arr->type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x76, 0x8(%rax)
je 0x3c88
movb $0x0, -0x1(%rbp)
jmp 0x3ca2
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x3c98
movb $0x0, -0x1(%rbp)
jmp 0x3ca2
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0x4, %esi
callq 0x7a90
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0x4293
movq -0x8(%rbp), %rax
movsbl 0x4(%rax), %eax
cmpl $0x2d, %eax
jne 0x4293
movq -0x8(%rbp), %rdi
addq $0x5, %rdi
movl $0x2, %esi
callq 0x7a90
movl %eax, -0x30(%rbp)
jmp 0x429d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x30(%rbp)
jmp 0x429d
movl -0x30(%rbp), %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jl 0x42cd
movq -0x8(%rbp), %rax
movsbl 0x7(%rax), %eax
cmpl $0x2d, %eax
jne 0x42cd
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movl $0x2, %esi
callq 0x7a90
movl %eax, -0x34(%rbp)
jmp 0x42d7
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x34(%rbp)
jmp 0x42d7
movl -0x34(%rbp), %eax
movl %eax, -0x2c(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x42ed
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x18(%rbp)
je 0x42fd
movl -0x28(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0x430d
movl -0x2c(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
xorl %eax, %eax
cmpl $0x0, -0x24(%rbp)
movb %al, -0x35(%rbp)
jl 0x432d
xorl %eax, %eax
cmpl $0x0, -0x28(%rbp)
movb %al, -0x35(%rbp)
jl 0x432d
cmpl $0x0, -0x2c(%rbp)
setge %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %dl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x7a90
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0x43a3
movq -0x8(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x3a, %eax
jne 0x43a3
movq -0x8(%rbp), %rdi
addq $0x3, %rdi
movl $0x2, %esi
callq 0x7a90
movl %eax, -0x30(%rbp)
jmp 0x43ad
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x30(%rbp)
jmp 0x43ad
movl -0x30(%rbp), %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jl 0x43dd
movq -0x8(%rbp), %rax
movsbl 0x5(%rax), %eax
cmpl $0x3a, %eax
jne 0x43dd
movq -0x8(%rbp), %rdi
addq $0x6, %rdi
movl $0x2, %esi
callq 0x7a90
movl %eax, -0x34(%rbp)
jmp 0x43e7
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x34(%rbp)
jmp 0x43e7
movl -0x34(%rbp), %eax
movl %eax, -0x2c(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x43fd
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x18(%rbp)
je 0x440d
movl -0x28(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0x441d
movl -0x2c(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
xorl %eax, %eax
cmpl $0x0, -0x24(%rbp)
movb %al, -0x35(%rbp)
jl 0x443d
xorl %eax, %eax
cmpl $0x0, -0x28(%rbp)
movb %al, -0x35(%rbp)
jl 0x443d
cmpl $0x0, -0x2c(%rbp)
setge %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %dl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cktan[P]tomlc99/toml.c
// Function: parse_millisec
static int parse_millisec(const char *p, const char **endp) {
  int ret = 0;
  int unit = 100; /* unit in millisec */
  for (; '0' <= *p && *p <= '9'; p++, unit /= 10) {
    ret += (*p - '0') * unit;
  }
  *endp = p;
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x64, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %edx
xorl %eax, %eax
movl $0x30, %ecx
cmpl %edx, %ecx
movb %al, -0x19(%rbp)
jg 0x449f
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
setle %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x44a8
jmp 0x44d8
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
subl $0x30, %eax
imull -0x18(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movl -0x18(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0x18(%rbp)
jmp 0x447a
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x14(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4513
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4593
cmpq $0x0, -0x18(%rbp)
je 0x4524
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x452e
leaq -0x1c(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x452e
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x3b14(%rip), %rsi      # 0x8055
callq 0x1130
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x4561
movq -0x28(%rbp), %rax
movl $0x1, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x4593
movq -0x10(%rbp), %rdi
leaq 0x3aee(%rip), %rsi      # 0x805a
callq 0x1130
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x458c
movq -0x28(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x4593
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x3c00
movq %rax, %rdi
leaq -0x8(%rbp), %rsi
callq 0x4bc0
testl %eax, %eax
sete %al
movzbl %al, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1100
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x3c00
movq %rax, %rdi
leaq -0x88(%rbp), %rsi
callq 0x3e30
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x5661
movl $0x68, %edi
callq *0x5bad(%rip)           # 0xb100
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x565f
movq -0x8(%rbp), %rdi
leaq -0x88(%rbp), %rsi
movl $0x68, %edx
callq 0x1170
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x55a0
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x55bb
movq -0x8(%rbp), %rcx
addq $0x4, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x55d6
movq -0x8(%rbp), %rcx
addq $0x8, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x55f1
movq -0x8(%rbp), %rcx
addq $0xc, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x560c
movq -0x8(%rbp), %rcx
addq $0x10, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x5627
movq -0x8(%rbp), %rcx
addq $0x14, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x5642
movq -0x8(%rbp), %rcx
addq $0x18, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0x565d
movq -0x8(%rbp), %rcx
addq $0x1c, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x60(%rax)
jmp 0x565f
jmp 0x5661
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1100
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3a80
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x56da
movq -0x28(%rbp), %rdi
leaq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x4bc0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3a80
movq %rax, %rdi
leaq -0x8(%rbp), %rsi
callq 0x44f0
testl %eax, %eax
sete %al
movzbl %al, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1100
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3a80
movq %rax, %rdi
leaq -0x88(%rbp), %rsi
callq 0x3e30
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x5953
movl $0x68, %edi
callq *0x58bb(%rip)           # 0xb100
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x5951
movq -0x8(%rbp), %rdi
leaq -0x88(%rbp), %rsi
movl $0x68, %edx
callq 0x1170
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x5892
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x58ad
movq -0x8(%rbp), %rcx
addq $0x4, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x58c8
movq -0x8(%rbp), %rcx
addq $0x8, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x58e3
movq -0x8(%rbp), %rcx
addq $0xc, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x58fe
movq -0x8(%rbp), %rcx
addq $0x10, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x5919
movq -0x8(%rbp), %rcx
addq $0x14, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x5934
movq -0x8(%rbp), %rcx
addq $0x18, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0x594f
movq -0x8(%rbp), %rcx
addq $0x1c, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x60(%rax)
jmp 0x5951
jmp 0x5953
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x59c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x5e22
movq $0x0, -0x8(%rbp)
jmp 0x5f39
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x68a0
cmpl $0x0, %eax
je 0x5e62
movq -0x20(%rbp), %rdi
callq 0x3500
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0x4(%rax), %esi
callq 0x67d0
movq $0x0, -0x8(%rbp)
jmp 0x5f39
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0x2c(%rbp), %esi
callq 0x6810
movq %rax, %rcx
movq %rcx, -0x38(%rbp)
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x5eb0
movq -0x20(%rbp), %rdi
callq 0x3500
movq -0x10(%rbp), %rdi
leaq 0x252f(%rip), %rsi      # 0x83cd
callq 0x2910
movq $0x0, -0x8(%rbp)
jmp 0x5f39
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x1, %edi
movl $0x10, %esi
callq 0x28b0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movslq -0x2c(%rbp), %rdx
movq %rcx, (%rax,%rdx,8)
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x5f04
movq -0x20(%rbp), %rdi
callq 0x3500
movq -0x10(%rbp), %rdi
leaq 0x24e3(%rip), %rsi      # 0x83d8
callq 0x2910
movq $0x0, -0x8(%rbp)
jmp 0x5f39
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rdx
movl 0xc(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0xc(%rdx)
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cktan[P]tomlc99/toml.c
// Function: STRNDUP
static char *STRNDUP(const char *s, size_t n) {
  size_t len = strnlen(s, n);
  char *p = MALLOC(len + 1);
  if (p) {
    memcpy(p, s, len);
    p[len] = 0;
  }
  return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1110
movq %rax, -0x18(%rbp)
movq 0x5188(%rip), %rax      # 0xb100
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
callq *%rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5faa
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1170
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movb %dl, %cl
leaq 0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %cl, -0x19(%rbp)
movq -0x10(%rbp), %rdi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x59c0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x6017
movq $0x0, -0x8(%rbp)
jmp 0x6131
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x68a0
cmpl $0x0, %eax
je 0x604f
movq -0x28(%rbp), %rdi
callq 0x3500
movq -0x48(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0x4(%rax), %esi
callq 0x67d0
movq $0x0, -0x8(%rbp)
jmp 0x6131
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
movl -0x2c(%rbp), %esi
callq 0x6810
movq %rax, %rcx
movq %rcx, -0x38(%rbp)
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x609d
movq -0x28(%rbp), %rdi
callq 0x3500
movq -0x10(%rbp), %rdi
leaq 0x2358(%rip), %rsi      # 0x83e3
callq 0x2910
movq $0x0, -0x8(%rbp)
jmp 0x6131
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movl $0x1, %edi
movl $0x20, %esi
callq 0x28b0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movslq -0x2c(%rbp), %rdx
movq %rcx, (%rax,%rdx,8)
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x60f1
movq -0x28(%rbp), %rdi
callq 0x3500
movq -0x10(%rbp), %rdi
leaq 0x230c(%rip), %rsi      # 0x83ee
callq 0x2910
movq $0x0, -0x8(%rbp)
jmp 0x6131
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rdx
movl 0x18(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x18(%rdx)
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movsbl -0x19(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
leaq 0x1fd3(%rip), %rcx      # 0x8478
callq 0x3060
cmpl $0x0, %eax
je 0x64bb
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x65d2
jmp 0x64bd
movq -0x10(%rbp), %rax
cmpl $0x6, 0x20(%rax)
jne 0x64e6
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x24(%rax), %esi
leaq 0x1faa(%rip), %rdx      # 0x8483
callq 0x3010
movl %eax, -0x4(%rbp)
jmp 0x65d2
movq -0x10(%rbp), %rax
cmpl $0x5, 0x20(%rax)
jne 0x64f5
jmp 0x659b
movq -0x10(%rbp), %rax
cmpl $0x9, 0x20(%rax)
je 0x651e
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x24(%rax), %esi
leaq 0x1f96(%rip), %rdx      # 0x84a7
callq 0x3010
movl %eax, -0x4(%rbp)
jmp 0x65d2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2c30
cmpl $0x0, %eax
je 0x653c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x65d2
movq -0x10(%rbp), %rax
cmpl $0x6, 0x20(%rax)
jne 0x6562
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x24(%rax), %esi
leaq 0x1f2b(%rip), %rdx      # 0x8483
callq 0x3010
movl %eax, -0x4(%rbp)
jmp 0x65d2
movq -0x10(%rbp), %rax
cmpl $0x2, 0x20(%rax)
jne 0x6599
movq -0x10(%rbp), %rdi
movl $0x2, %esi
movl $0x1, %edx
leaq 0x1f36(%rip), %rcx      # 0x84b7
callq 0x3060
cmpl $0x0, %eax
je 0x6594
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x65d2
jmp 0x64bd
jmp 0x659b
movq -0x10(%rbp), %rdi
movl $0x5, %esi
movl $0x1, %edx
leaq 0x1f12(%rip), %rcx      # 0x84c2
callq 0x3060
cmpl $0x0, %eax
je 0x65c3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x65d2
movq -0x18(%rbp), %rax
movb $0x1, 0x9(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cktan[P]tomlc99/toml.c
// Function: expand_ptrarr
static void **expand_ptrarr(void **p, int n) {
  void **s = MALLOC((n + 1) * sizeof(void *));
  if (!s)
    return 0;

  s[n] = 0;
  if (p) {
    memcpy(s, p, n * sizeof(void *));
    FREE(p);
  }
  return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq 0x48da(%rip), %rax      # 0xb100
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rdi
shlq $0x3, %rdi
callq *%rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x684a
movq $0x0, -0x8(%rbp)
jmp 0x688b
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
cmpq $0x0, -0x10(%rbp)
je 0x6883
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
shlq $0x3, %rdx
callq 0x1170
movq 0x488b(%rip), %rax      # 0xb108
movq -0x10(%rbp), %rdi
callq *%rax
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cktan[P]tomlc99/toml.c
// Function: skip_newlines
static int skip_newlines(context_t *ctx, int isdotspecial) {
  while (ctx->tok.tok == NEWLINE) {
    if (next_token(ctx, isdotspecial))
      return -1;
    if (ctx->tok.eof)
      break;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x6, 0x20(%rax)
jne 0x6911
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x2950
cmpl $0x0, %eax
je 0x6903
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6918
movq -0x10(%rbp), %rax
cmpl $0x0, 0x34(%rax)
je 0x690f
jmp 0x6911
jmp 0x68df
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cktan[P]tomlc99/toml.c
// Function: create_value_in_array
static toml_arritem_t *create_value_in_array(context_t *ctx,
                                             toml_array_t *parent) {
  const int n = parent->nitem;
  toml_arritem_t *base = expand_arritem(parent->item, n);
  if (!base) {
    e_outofmemory(ctx, FLINE);
    return 0;
  }
  parent->item = base;
  parent->nitem++;
  return &parent->item[n];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0x1c(%rbp), %esi
callq 0x6c50
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x697f
movq -0x10(%rbp), %rdi
leaq 0x1ad1(%rip), %rsi      # 0x8441
callq 0x2910
movq $0x0, -0x8(%rbp)
jmp 0x69af
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cktan[P]tomlc99/toml.c
// Function: valtype
static int valtype(const char *val) {
  toml_timestamp_t ts;
  if (*val == '\'' || *val == '"')
    return 's';
  if (0 == toml_rtob(val, 0))
    return 'b';
  if (0 == toml_rtoi(val, 0))
    return 'i';
  if (0 == toml_rtod(val, 0))
    return 'd';
  if (0 == toml_rtots(val, &ts)) {
    if (ts.year && ts.hour)
      return 'T'; /* timestamp */
    if (ts.year)
      return 'D'; /* date */
    return 't';   /* time */
  }
  return 'u'; /* unknown */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x27, %eax
je 0x69e7
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0x69f3
movl $0x73, -0x4(%rbp)
jmp 0x6a9c
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x44f0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x6a14
movl $0x62, -0x4(%rbp)
jmp 0x6a9c
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x45a0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x6a32
movl $0x69, -0x4(%rbp)
jmp 0x6a9c
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4b80
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x6a50
movl $0x64, -0x4(%rbp)
jmp 0x6a9c
movq -0x10(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x3e30
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x6a95
cmpq $0x0, -0x50(%rbp)
je 0x6a7c
cmpq $0x0, -0x38(%rbp)
je 0x6a7c
movl $0x54, -0x4(%rbp)
jmp 0x6a9c
cmpq $0x0, -0x50(%rbp)
je 0x6a8c
movl $0x44, -0x4(%rbp)
jmp 0x6a9c
movl $0x74, -0x4(%rbp)
jmp 0x6a9c
movl $0x75, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cktan[P]tomlc99/toml.c
// Function: create_array_in_array
static toml_array_t *create_array_in_array(context_t *ctx,
                                           toml_array_t *parent) {
  const int n = parent->nitem;
  toml_arritem_t *base = expand_arritem(parent->item, n);
  if (!base) {
    e_outofmemory(ctx, FLINE);
    return 0;
  }
  toml_array_t *ret = (toml_array_t *)CALLOC(1, sizeof(toml_array_t));
  if (!ret) {
    e_outofmemory(ctx, FLINE);
    return 0;
  }
  base[n].arr = ret;
  parent->item = base;
  parent->nitem++;
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0x1c(%rbp), %esi
callq 0x6c50
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x6aff
movq -0x10(%rbp), %rdi
leaq 0x195c(%rip), %rsi      # 0x844c
callq 0x2910
movq $0x0, -0x8(%rbp)
jmp 0x6b6b
movl $0x1, %edi
movl $0x20, %esi
callq 0x28b0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x6b33
movq -0x10(%rbp), %rdi
leaq 0x1933(%rip), %rsi      # 0x8457
callq 0x2910
movq $0x0, -0x8(%rbp)
jmp 0x6b6b
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)