LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpcf_re_repeat
static mpc_val_t *mpcf_re_repeat(int n, mpc_val_t **xs) {
  int num;
  (void) n;
  if (xs[1] == NULL) { return xs[0]; }
  switch(((char*)xs[1])[0])
  {
    case '*': { free(xs[1]); return mpc_many(mpcf_strfold, xs[0]); }; break;
    case '+': { free(xs[1]); return mpc_many1(mpcf_strfold, xs[0]); }; break;
    case '?': { free(xs[1]); return mpc_maybe_lift(xs[0], mpcf_ctor_str); }; break;
    default:
      num = *(int*)xs[1];
      free(xs[1]);
  }

  return mpc_count(num, mpcf_strfold, xs[0], free);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x9bda
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x9cb3
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %eax
movl %eax, -0x20(%rbp)
subl $0x2a, %eax
je 0x9c03
jmp 0x9bef
movl -0x20(%rbp), %eax
subl $0x2b, %eax
je 0x9c2c
jmp 0x9bf9
movl -0x20(%rbp), %eax
subl $0x3f, %eax
je 0x9c52
jmp 0x9c78
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4850
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq 0xd3a2(%rip), %rdi      # 0x16fc0
callq 0x4280
movq %rax, -0x8(%rbp)
jmp 0x9cb3
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4850
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq 0xd379(%rip), %rdi      # 0x16fc0
callq 0x4250
movq %rax, -0x8(%rbp)
jmp 0x9cb3
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4850
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq 0xd30b(%rip), %rsi      # 0x16f78
callq 0x45b0
movq %rax, -0x8(%rbp)
jmp 0x9cb3
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4850
movl -0x1c(%rbp), %edi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
movq 0xd31d(%rip), %rsi      # 0x16fc0
movq 0xd276(%rip), %rcx      # 0x16f20
callq 0x4730
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpcf_strtriml
mpc_val_t *mpcf_strtriml(mpc_val_t *x) {
  char *s = x;
  while (isspace((unsigned char)*s)) {
    memmove(s, s+1, strlen(s));
  }
  return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x4820
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0xa443
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x41b0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq %rax, %rdx
callq 0x4660
jmp 0xa3f4
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpcf_strtrimr
mpc_val_t *mpcf_strtrimr(mpc_val_t *x) {
  char *s = x;
  size_t l = strlen(s);
  while (l > 0 && isspace((unsigned char)s[l-1])) {
    s[l-1] = '\0'; l--;
  }
  return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x41b0
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x19(%rbp)
jbe 0xa4aa
callq 0x4820
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rdx
subq $0x1, %rdx
movzbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xa4b3
jmp 0xa4d1
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xa471
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpcf_escape_new
static mpc_val_t *mpcf_escape_new(mpc_val_t *x, const char *input, const char **output) {

  int i;
  int found;
  char buff[2];
  char *s = x;
  char *y = calloc(1, 1);

  while (*s) {

    i = 0;
    found = 0;

    while (output[i]) {
      if (*s == input[i]) {
        y = realloc(y, strlen(y) + strlen(output[i]) + 1);
        strcat(y, output[i]);
        found = 1;
        break;
      }
      i++;
    }

    if (!found) {
      y = realloc(y, strlen(y) + 2);
      buff[0] = *s; buff[1] = '\0';
      strcat(y, buff);
    }

    s++;
  }


  return y;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x1, %esi
movq %rsi, %rdi
callq 0x4390
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpb $0x0, (%rax)
je 0xa682
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0xa62c
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
movq -0x10(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0xa61e
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x41b0
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x41b0
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdi
addq %rax, %rsi
addq $0x1, %rsi
callq 0x45e0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x4720
movl $0x1, -0x20(%rbp)
jmp 0xa62c
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xa598
cmpl $0x0, -0x20(%rbp)
jne 0xa671
movq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rdi
callq 0x41b0
movq -0x50(%rbp), %rdi
movq %rax, %rsi
addq $0x2, %rsi
callq 0x45e0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movb (%rax), %al
movb %al, -0x22(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x38(%rbp), %rdi
leaq -0x22(%rbp), %rsi
callq 0x4720
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xa57d
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpcf_unescape_new
static mpc_val_t *mpcf_unescape_new(mpc_val_t *x, const char *input, const char **output) {

  int i;
  int found = 0;
  char buff[2];
  char *s = x;
  char *y = calloc(1, 1);

  while (*s) {

    i = 0;
    found = 0;

    while (output[i]) {
      if ((*(s+0)) == output[i][0] &&
          (*(s+1)) == output[i][1]) {
        y = realloc(y, strlen(y) + 1 + 1);
        buff[0] = input[i]; buff[1] = '\0';
        strcat(y, buff);
        found = 1;
        s++;
        break;
      }
      i++;
    }

    if (!found) {
      y = realloc(y, strlen(y) + 1 + 1);
      buff[0] = *s; buff[1] = '\0';
      strcat(y, buff);
    }

    if (*s == '\0') { break; }
    else { s++; }
  }

  return y;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x1, %esi
movq %rsi, %rdi
callq 0x4390
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpb $0x0, (%rax)
je 0xa83b
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0xa7d3
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0xa7c5
movq -0x30(%rbp), %rax
movsbl 0x1(%rax), %eax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movsbl 0x1(%rcx), %ecx
cmpl %ecx, %eax
jne 0xa7c5
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x41b0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
addq $0x1, %rsi
addq $0x1, %rsi
callq 0x45e0
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x22(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x38(%rbp), %rdi
leaq -0x22(%rbp), %rsi
callq 0x4720
movl $0x1, -0x20(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xa7d3
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xa71f
cmpl $0x0, -0x20(%rbp)
jne 0xa81c
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rdi
callq 0x41b0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
addq $0x1, %rsi
addq $0x1, %rsi
callq 0x45e0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movb (%rax), %al
movb %al, -0x22(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x38(%rbp), %rdi
leaq -0x22(%rbp), %rsi
callq 0x4720
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xa82a
jmp 0xa83b
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xa704
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpcf_nth_free
static mpc_val_t *mpcf_nth_free(int n, mpc_val_t **xs, int x) {
  int i;
  for (i = 0; i < n; i++) {
    if (i != x) { free(xs[i]); }
  }
  return xs[x];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0xaa77
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0xaa6a
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x4850
jmp 0xaa6c
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xaa49
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpcf_all_free
mpc_val_t *mpcf_all_free(int n, mpc_val_t** xs) {
  int i;
  for (i = 0; i < n; i++) {
    free(xs[i]);
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0xaafa
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x4850
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xaad6
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_test_fail
int mpc_test_fail(mpc_parser_t *p, const char *s, const void *d,
  int(*tester)(const void*, const void*),
  mpc_dtor_t destructor,
  void(*printer)(const void*)) {
  mpc_result_t r;
  (void) printer;
  if (mpc_parse("<test>", s, p, &r)) {

    if (tester(r.output, d)) {
      destructor(r.output);
      return 0;
    } else {
      destructor(r.output);
      return 1;
    }

  } else {
    mpc_err_delete(r.error);
    return 1;
  }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0x759f(%rip), %rdi      # 0x1273e
leaq -0x40(%rbp), %rcx
callq 0x4830
cmpl $0x0, %eax
je 0xb1e6
movq -0x28(%rbp), %rax
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq *%rax
cmpl $0x0, %eax
je 0xb1d3
movq -0x30(%rbp), %rax
movq -0x40(%rbp), %rdi
callq *%rax
movl $0x0, -0x4(%rbp)
jmp 0xb1f6
movq -0x30(%rbp), %rax
movq -0x40(%rbp), %rdi
callq *%rax
movl $0x1, -0x4(%rbp)
jmp 0xb1f6
movq -0x40(%rbp), %rdi
callq 0x4550
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_test_pass
int mpc_test_pass(mpc_parser_t *p, const char *s, const void *d,
  int(*tester)(const void*, const void*),
  mpc_dtor_t destructor,
  void(*printer)(const void*)) {

  mpc_result_t r;
  if (mpc_parse("<test>", s, p, &r)) {

    if (tester(r.output, d)) {
      destructor(r.output);
      return 1;
    } else {
      printf("Got "); printer(r.output); printf("\n");
      printf("Expected "); printer(d); printf("\n");
      destructor(r.output);
      return 0;
    }

  } else {
    mpc_err_print(r.error);
    mpc_err_delete(r.error);
    return 0;

  }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0x750f(%rip), %rdi      # 0x1273e
leaq -0x40(%rbp), %rcx
callq 0x4830
cmpl $0x0, %eax
je 0xb2c6
movq -0x28(%rbp), %rax
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq *%rax
cmpl $0x0, %eax
je 0xb267
movq -0x30(%rbp), %rax
movq -0x40(%rbp), %rdi
callq *%rax
movl $0x1, -0x4(%rbp)
jmp 0xb2df
leaq 0x74d7(%rip), %rdi      # 0x12745
movb $0x0, %al
callq 0x4230
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rdi
callq *%rax
leaq 0x7720(%rip), %rdi      # 0x129a6
movb $0x0, %al
callq 0x4230
leaq 0x74b6(%rip), %rdi      # 0x1274a
movb $0x0, %al
callq 0x4230
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rdi
callq *%rax
leaq 0x76fa(%rip), %rdi      # 0x129a6
movb $0x0, %al
callq 0x4230
movq -0x30(%rbp), %rax
movq -0x40(%rbp), %rdi
callq *%rax
movl $0x0, -0x4(%rbp)
jmp 0xb2df
movq -0x40(%rbp), %rdi
callq 0x4460
movq -0x40(%rbp), %rdi
callq 0x4550
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_ast_delete
void mpc_ast_delete(mpc_ast_t *a) {

  int i;

  if (a == NULL) { return; }

  for (i = 0; i < a->children_num; i++) {
    mpc_ast_delete(a->children[i]);
  }

  free(a->children);
  free(a->tag);
  free(a->contents);
  free(a);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xb305
jmp 0xb367
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x30(%rcx), %eax
jge 0xb338
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x4880
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xb30c
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x4850
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x4850
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4850
movq -0x8(%rbp), %rdi
callq 0x4850
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_ast_new
mpc_ast_t *mpc_ast_new(const char *tag, const char *contents) {

  mpc_ast_t *a = malloc(sizeof(mpc_ast_t));

  a->tag = malloc(strlen(tag) + 1);
  strcpy(a->tag, tag);

  a->contents = malloc(strlen(contents) + 1);
  strcpy(a->contents, contents);

  a->state = mpc_state_new();

  a->children_num = 0;
  a->children = NULL;
  return a;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x40, %edi
callq 0x4570
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x41b0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x4570
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x40e0
movq -0x10(%rbp), %rdi
callq 0x41b0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x4570
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x40e0
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xb450
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_state_new
static mpc_state_t mpc_state_new(void) {
  mpc_state_t s;
  s.pos = 0;
  s.row = 0;
  s.col = 0;
  s.term = 0;
  return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movq $0x0, (%rdi)
movq $0x0, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movl $0x0, 0x18(%rdi)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_ast_build
mpc_ast_t *mpc_ast_build(int n, const char *tag, ...) {

  mpc_ast_t *a = mpc_ast_new(tag, "");

  int i;
  va_list va;
  va_start(va, tag);

  for (i = 0; i < n; i++) {
    mpc_ast_add_child(a, va_arg(va, mpc_ast_t*));
  }

  va_end(va);

  return a;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
testb %al, %al
je 0xb4bb
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x7424(%rip), %rsi      # 0x1290d
callq 0x47f0
movq %rax, -0x18(%rbp)
leaq -0x40(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0xb5b0
movq -0x18(%rbp), %rax
movq %rax, -0x108(%rbp)
leaq -0x40(%rbp), %rax
movq %rax, -0x100(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0xf4(%rbp)
cmpl $0x28, %eax
ja 0xb56f
movq -0x100(%rbp), %rcx
movl -0xf4(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x110(%rbp)
jmp 0xb58c
movq -0x100(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x110(%rbp)
movq -0x108(%rbp), %rdi
movq -0x110(%rbp), %rax
movq (%rax), %rsi
callq 0x4470
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xb51d
movq -0x18(%rbp), %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_ast_add_child
mpc_ast_t *mpc_ast_add_child(mpc_ast_t *r, mpc_ast_t *a) {
  r->children_num++;
  r->children = realloc(r->children, sizeof(mpc_ast_t*) * r->children_num);
  r->children[r->children_num-1] = a;
  return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x30(%rax)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x30(%rax), %rsi
shlq $0x3, %rsi
callq 0x45e0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x30(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_ast_add_root
mpc_ast_t *mpc_ast_add_root(mpc_ast_t *a) {

  mpc_ast_t *r;

  if (a == NULL) { return a; }
  if (a->children_num == 0) { return a; }
  if (a->children_num == 1) { return a; }

  r = mpc_ast_new(">", "");
  mpc_ast_add_child(r, a);
  return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xb64d
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb6a1
movq -0x10(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jne 0xb661
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb6a1
movq -0x10(%rbp), %rax
cmpl $0x1, 0x30(%rax)
jne 0xb675
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb6a1
leaq 0x72d4(%rip), %rdi      # 0x12950
leaq 0x728a(%rip), %rsi      # 0x1290d
callq 0x47f0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4470
movq -0x18(%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/orangeduck[P]mpc/mpc.c
// Function: mpc_ast_eq
int mpc_ast_eq(mpc_ast_t *a, mpc_ast_t *b) {

  int i;

  if (strcmp(a->tag, b->tag) != 0) { return 0; }
  if (strcmp(a->contents, b->contents) != 0) { return 0; }
  if (a->children_num != b->children_num) { return 0; }

  for (i = 0; i < a->children_num; i++) {
    if (!mpc_ast_eq(a->children[i], b->children[i])) { return 0; }
  }

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x43c0
cmpl $0x0, %eax
je 0xb6e4
movl $0x0, -0x4(%rbp)
jmp 0xb77a
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x43c0
cmpl $0x0, %eax
je 0xb707
movl $0x0, -0x4(%rbp)
jmp 0xb77a
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x30(%rcx), %eax
je 0xb720
movl $0x0, -0x4(%rbp)
jmp 0xb77a
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x30(%rcx), %eax
jge 0xb773
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x41d0
cmpl $0x0, %eax
jne 0xb766
movl $0x0, -0x4(%rbp)
jmp 0xb77a
jmp 0xb768
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xb727
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_ast_add_tag
mpc_ast_t *mpc_ast_add_tag(mpc_ast_t *a, const char *t) {
  if (a == NULL) { return a; }
  a->tag = realloc(a->tag, strlen(t) + 1 + strlen(a->tag) + 1);
  memmove(a->tag + strlen(t) + 1, a->tag, strlen(a->tag)+1);
  memmove(a->tag, t, strlen(t));
  memmove(a->tag + strlen(t), "|", 1);
  return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xb7b4
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb8a5
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0x41b0
addq $0x1, %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x41b0
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdi
addq %rax, %rsi
addq $0x1, %rsi
callq 0x45e0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x41b0
movq %rax, %rcx
movq -0x48(%rbp), %rax
addq %rcx, %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x41b0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
addq $0x1, %rdx
callq 0x4660
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x41b0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x4660
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x41b0
movq %rax, %rcx
movq -0x20(%rbp), %rax
addq %rcx, %rax
movb 0x6e7d(%rip), %cl       # 0x12718
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_ast_add_root_tag
mpc_ast_t *mpc_ast_add_root_tag(mpc_ast_t *a, const char *t) {
  if (a == NULL) { return a; }
  a->tag = realloc(a->tag, (strlen(t)-1) + strlen(a->tag) + 1);
  memmove(a->tag + (strlen(t)-1), a->tag, strlen(a->tag)+1);
  memmove(a->tag, t, (strlen(t)-1));
  return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xb8d4
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb9a3
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x41b0
subq $0x1, %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x41b0
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdi
addq %rax, %rsi
addq $0x1, %rsi
callq 0x45e0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x41b0
movq %rax, %rcx
movq -0x40(%rbp), %rax
subq $0x1, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x41b0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
addq $0x1, %rdx
callq 0x4660
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x41b0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq %rax, %rdx
subq $0x1, %rdx
callq 0x4660
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_ast_print_depth
static void mpc_ast_print_depth(mpc_ast_t *a, int d, FILE *fp) {

  int i;

  if (a == NULL) {
    fprintf(fp, "NULL\n");
    return;
  }

  for (i = 0; i < d; i++) { fprintf(fp, "  "); }

  if (strlen(a->contents)) {
    fprintf(fp, "%s:%lu:%lu '%s'\n", a->tag,
      (long unsigned int)(a->state.row+1),
      (long unsigned int)(a->state.col+1),
      a->contents);
  } else {
    fprintf(fp, "%s \n", a->tag);
  }

  for (i = 0; i < a->children_num; i++) {
    mpc_ast_print_depth(a->children[i], d+1, fp);
  }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xbad1
movq -0x18(%rbp), %rdi
leaq 0x6ec4(%rip), %rsi      # 0x12989
movb $0x0, %al
callq 0x4430
jmp 0xbba1
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xbafd
movq -0x18(%rbp), %rdi
leaq 0x6ea4(%rip), %rsi      # 0x1298f
movb $0x0, %al
callq 0x4430
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xbad8
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x41b0
cmpq $0x0, %rax
je 0xbb4b
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %r8
addq $0x1, %r8
movq -0x8(%rbp), %rax
movq 0x8(%rax), %r9
leaq 0x6e50(%rip), %rsi      # 0x12992
movb $0x0, %al
callq 0x4430
jmp 0xbb64
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
leaq 0x6e46(%rip), %rsi      # 0x129a3
movb $0x0, %al
callq 0x4430
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x30(%rcx), %eax
jge 0xbba1
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
movq -0x18(%rbp), %rdx
callq 0xbaa0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xbb6b
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_ast_get_index_lb
int mpc_ast_get_index_lb(mpc_ast_t *ast, const char *tag, int lb) {
  int i;

  for(i=lb; i<ast->children_num; i++) {
    if(strcmp(ast->children[i]->tag, tag) == 0) {
      return i;
    }
  }

  return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x30(%rcx), %eax
jge 0xbc6b
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x43c0
cmpl $0x0, %eax
jne 0xbc5e
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xbc72
jmp 0xbc60
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xbc29
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_ast_get_child_lb
mpc_ast_t *mpc_ast_get_child_lb(mpc_ast_t *ast, const char *tag, int lb) {
  int i;

  for(i=lb; i<ast->children_num; i++) {
    if(strcmp(ast->children[i]->tag, tag) == 0) {
      return ast->children[i];
    }
  }

  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x30(%rcx), %eax
jge 0xbd19
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x43c0
cmpl $0x0, %eax
jne 0xbd0c
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0xbd21
jmp 0xbd0e
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xbcc9
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_ast_traverse_start
mpc_ast_trav_t *mpc_ast_traverse_start(mpc_ast_t *ast,
                                       mpc_ast_trav_order_t order)
{
  mpc_ast_trav_t *trav, *n_trav;
  mpc_ast_t *cnode = ast;

  /* Create the traversal structure */
  trav = malloc(sizeof(mpc_ast_trav_t));
  trav->curr_node = cnode;
  trav->parent = NULL;
  trav->curr_child = 0;
  trav->order = order;

  /* Get start node */
  switch(order) {
    case mpc_ast_trav_order_pre:
      /* Nothing else is needed for pre order start */
      break;

    case mpc_ast_trav_order_post:
      while(cnode->children_num > 0) {
        cnode = cnode->children[0];

        n_trav = malloc(sizeof(mpc_ast_trav_t));
        n_trav->curr_node = cnode;
        n_trav->parent = trav;
        n_trav->curr_child = 0;
        n_trav->order = order;

        trav = n_trav;
      }

      break;

    default:
      /* Unreachable, but compiler complaints */
      break;
  }

  return trav;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x18, %edi
callq 0x4570
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x10(%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x14(%rax)
movl -0xc(%rbp), %eax
movl %eax, -0x2c(%rbp)
testl %eax, %eax
je 0xbd97
jmp 0xbd8d
movl -0x2c(%rbp), %eax
subl $0x1, %eax
je 0xbd99
jmp 0xbdfa
jmp 0xbdfc
jmp 0xbd9b
movq -0x28(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jle 0xbdf8
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x18, %edi
callq 0x4570
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x10(%rax)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xbd9b
jmp 0xbdfc
jmp 0xbdfc
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_ast_traverse_free
void mpc_ast_traverse_free(mpc_ast_trav_t **trav) {
  mpc_ast_trav_t *n_trav;

  /* Go through parents until all are free */
  while(*trav != NULL) {
      n_trav = (*trav)->parent;
      free(*trav);
      *trav = n_trav;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0xc0ae
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x4850
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0xc07c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_ast_delete_no_children
static void mpc_ast_delete_no_children(mpc_ast_t *a) {
  free(a->children);
  free(a->tag);
  free(a->contents);
  free(a);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x4850
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x4850
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4850
movq -0x8(%rbp), %rdi
callq 0x4850
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpcf_state_ast
mpc_val_t *mpcf_state_ast(int n, mpc_val_t **xs) {
  mpc_state_t *s = ((mpc_state_t**)xs)[0];
  mpc_ast_t *a = ((mpc_ast_t**)xs)[1];
  (void)n;
  a = mpc_ast_state(a, *s);
  free(s);
  return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x4090
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4850
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpca_and
mpc_parser_t *mpca_and(int n, ...) {

  int i;
  va_list va;

  mpc_parser_t *p = mpc_undefined();

  p->type = MPC_TYPE_AND;
  p->data.and.n = n;
  p->data.and.f = mpcf_fold_ast;
  p->data.and.xs = malloc(sizeof(mpc_parser_t*) * n);
  p->data.and.dxs = malloc(sizeof(mpc_dtor_t) * (n-1));

  va_start(va, n);
  for (i = 0; i < n; i++) {
    p->data.and.xs[i] = va_arg(va, mpc_parser_t*);
  }
  for (i = 0; i < (n-1); i++) {
    p->data.and.dxs[i] = (mpc_dtor_t)mpc_ast_delete;
  }
  va_end(va);

  return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0xc758
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rsi, -0xd8(%rbp)
movl %edi, -0x4(%rbp)
callq 0x6e40
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movb $0x18, 0x30(%rax)
movl -0x4(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq 0xa804(%rip), %rcx      # 0x16fa8
movq %rcx, 0x10(%rax)
movslq -0x4(%rbp), %rdi
shlq $0x3, %rdi
callq 0x4570
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movl -0x4(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x4570
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
leaq -0x20(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0xc894
leaq -0x20(%rbp), %rax
movq %rax, -0xf0(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0xe4(%rbp)
cmpl $0x28, %eax
ja 0xc84f
movq -0xf0(%rbp), %rcx
movl -0xe4(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0xf8(%rbp)
jmp 0xc86c
movq -0xf0(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0xf8(%rbp)
movq -0xf8(%rbp), %rax
movq (%rax), %rdx
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x8(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xc808
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl -0x4(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0xc8ca
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x8(%rbp), %rcx
movq 0xa715(%rip), %rdx      # 0x16fd0
movq %rdx, (%rax,%rcx,8)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xc89b
movq -0x28(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpcaf_grammar_and
static mpc_val_t *mpcaf_grammar_and(int n, mpc_val_t **xs) {
  int i;
  mpc_parser_t *p = mpc_pass();
  for (i = 0; i < n; i++) {
    if (xs[i] != NULL) { p = mpca_and(2, p, xs[i]); }
  }
  return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x4530
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0xce43
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0xce36
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movl $0x2, %edi
movb $0x0, %al
callq 0x4560
movq %rax, -0x20(%rbp)
jmp 0xce38
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xcdff
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpcaf_grammar_repeat
static mpc_val_t *mpcaf_grammar_repeat(int n, mpc_val_t **xs) {
  int num;
  (void) n;
  if (xs[1] == NULL) { return xs[0]; }
  switch(((char*)xs[1])[0])
  {
    case '*': { free(xs[1]); return mpca_many(xs[0]); }; break;
    case '+': { free(xs[1]); return mpca_many1(xs[0]); }; break;
    case '?': { free(xs[1]); return mpca_maybe(xs[0]); }; break;
    case '!': { free(xs[1]); return mpca_not(xs[0]); }; break;
    default:
      num = *((int*)xs[1]);
      free(xs[1]);
  }
  return mpca_count(num, xs[0]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xce7a
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xcf57
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %eax
addl $-0x21, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x1e, %eax
ja 0xcf2a
movq -0x28(%rbp), %rax
leaq 0x533a(%rip), %rcx      # 0x121dc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4850
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x42d0
movq %rax, -0x8(%rbp)
jmp 0xcf57
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4850
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x4360
movq %rax, -0x8(%rbp)
jmp 0xcf57
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4850
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x45f0
movq %rax, -0x8(%rbp)
jmp 0xcf57
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4850
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x4690
movq %rax, -0x8(%rbp)
jmp 0xcf57
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4850
movl -0x1c(%rbp), %edi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x4800
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpcaf_grammar_string
static mpc_val_t *mpcaf_grammar_string(mpc_val_t *x, void *s) {
  mpca_grammar_st_t *st = s;
  char *y = mpcf_unescape(x);
  mpc_parser_t *p = (st->flags & MPCA_LANG_WHITESPACE_SENSITIVE) ? mpc_string(y) : mpc_tok(mpc_string(y));
  free(y);
  return mpca_state(mpca_tag(mpc_apply(p, mpcf_str_ast), "string"));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x43d0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0xcfb3
movq -0x20(%rbp), %rdi
callq 0x43b0
movq %rax, -0x30(%rbp)
jmp 0xcfc8
movq -0x20(%rbp), %rdi
callq 0x43b0
movq %rax, %rdi
callq 0x4780
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4850
movq -0x28(%rbp), %rdi
movq 0x9fa4(%rip), %rsi      # 0x16f88
callq 0x4240
movq %rax, %rdi
leaq 0x56f8(%rip), %rsi      # 0x126eb
callq 0x4180
movq %rax, %rdi
callq 0x41e0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpcaf_grammar_char
static mpc_val_t *mpcaf_grammar_char(mpc_val_t *x, void *s) {
  mpca_grammar_st_t *st = s;
  char *y = mpcf_unescape(x);
  mpc_parser_t *p = (st->flags & MPCA_LANG_WHITESPACE_SENSITIVE) ? mpc_char(y[0]) : mpc_tok(mpc_char(y[0]));
  free(y);
  return mpca_state(mpca_tag(mpc_apply(p, mpcf_str_ast), "char"));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x43d0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0xd056
movq -0x20(%rbp), %rax
movsbl (%rax), %edi
callq 0x4580
movq %rax, -0x30(%rbp)
jmp 0xd06e
movq -0x20(%rbp), %rax
movsbl (%rax), %edi
callq 0x4580
movq %rax, %rdi
callq 0x4780
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4850
movq -0x28(%rbp), %rdi
movq 0x9efe(%rip), %rsi      # 0x16f88
callq 0x4240
movq %rax, %rdi
leaq 0x564d(%rip), %rsi      # 0x126e6
callq 0x4180
movq %rax, %rdi
callq 0x41e0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpcaf_fold_regex
static mpc_val_t *mpcaf_fold_regex(int n, mpc_val_t **xs) {
  char *y = xs[0];
  char *m = xs[1];
  mpca_grammar_st_t *st = xs[2];
  mpc_parser_t *p;
  int mode = MPC_RE_DEFAULT;

  (void)n;
  if (strchr(m, 'm')) { mode |= MPC_RE_MULTILINE; }
  if (strchr(m, 's')) { mode |= MPC_RE_DOTALL; }
  y = mpcf_unescape_regex(y);
  p = (st->flags & MPCA_LANG_WHITESPACE_SENSITIVE) ? mpc_re_mode(y, mode) : mpc_tok(mpc_re_mode(y, mode));
  free(y);
  free(m);

  return mpca_state(mpca_tag(mpc_apply(p, mpcf_str_ast), "regex"));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x20(%rbp), %rdi
movl $0x6d, %esi
callq 0x4210
cmpq $0x0, %rax
je 0xd106
movl -0x34(%rbp), %eax
orl $0x1, %eax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rdi
movl $0x73, %esi
callq 0x4210
cmpq $0x0, %rax
je 0xd123
movl -0x34(%rbp), %eax
orl $0x2, %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rdi
callq 0x43f0
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movl 0x18(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0xd151
movq -0x18(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x4610
movq %rax, -0x40(%rbp)
jmp 0xd169
movq -0x18(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x4610
movq %rax, %rdi
callq 0x4780
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4850
movq -0x20(%rbp), %rdi
callq 0x4850
movq -0x30(%rbp), %rdi
movq 0x9dfa(%rip), %rsi      # 0x16f88
callq 0x4240
movq %rax, %rdi
leaq 0x5555(%rip), %rsi      # 0x126f2
callq 0x4180
movq %rax, %rdi
callq 0x41e0
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpcaf_grammar_id
static mpc_val_t *mpcaf_grammar_id(mpc_val_t *x, void *s) {

  mpca_grammar_st_t *st = s;
  mpc_parser_t *p = mpca_grammar_find_parser(x, st);
  free(x);

  if (p->name) {
    return mpca_state(mpca_root(mpca_add_tag(p, p->name)));
  } else {
    return mpca_state(mpca_root(p));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x110a0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4850
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
je 0xd212
movq -0x28(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
callq 0x4630
movq %rax, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x41e0
movq %rax, -0x8(%rbp)
jmp 0xd227
movq -0x28(%rbp), %rdi
callq 0x4040
movq %rax, %rdi
callq 0x41e0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpca_grammar
mpc_parser_t *mpca_grammar(int flags, const char *grammar, ...) {
  mpca_grammar_st_t st;
  mpc_parser_t *res;
  va_list va;
  va_start(va, grammar);

  st.va = &va;
  st.parsers_num = 0;
  st.parsers = NULL;
  st.flags = flags;

  res = mpca_grammar_st(grammar, &st);
  free(st.parsers);
  va_end(va);
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0xd27e
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
movq %r9, -0xd8(%rbp)
movq %r8, -0xe0(%rbp)
movq %rcx, -0xe8(%rbp)
movq %rdx, -0xf0(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x100(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x30, -0x4c(%rbp)
movl $0x10, -0x50(%rbp)
leaq -0x50(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x47d0
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4850
movq -0x38(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpca_lang_file
mpc_err_t *mpca_lang_file(int flags, FILE *f, ...) {
  mpca_grammar_st_t st;
  mpc_input_t *i;
  mpc_err_t *err;

  va_list va;
  va_start(va, f);

  st.va = &va;
  st.parsers_num = 0;
  st.parsers = NULL;
  st.flags = flags;

  i = mpc_input_new_file("<mpca_lang_file>", f);
  err = mpca_lang_st(i, &st);
  mpc_input_delete(i);

  free(st.parsers);
  va_end(va);
  return err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
testb %al, %al
je 0xd351
movaps %xmm0, -0xe0(%rbp)
movaps %xmm1, -0xd0(%rbp)
movaps %xmm2, -0xc0(%rbp)
movaps %xmm3, -0xb0(%rbp)
movaps %xmm4, -0xa0(%rbp)
movaps %xmm5, -0x90(%rbp)
movaps %xmm6, -0x80(%rbp)
movaps %xmm7, -0x70(%rbp)
movq %r9, -0xe8(%rbp)
movq %r8, -0xf0(%rbp)
movq %rcx, -0xf8(%rbp)
movq %rdx, -0x100(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x110(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0x30, -0x5c(%rbp)
movl $0x10, -0x60(%rbp)
leaq -0x60(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x53df(%rip), %rdi      # 0x1279c
callq 0x6780
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xd400
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x64e0
movq -0x20(%rbp), %rdi
callq 0x4850
movq -0x40(%rbp), %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopw %cs:(%rax,%rax)