LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq (%rsi), %r14
movq 0x8(%rsi), %rbx
movq 0x10(%rsi), %r12
movq %rbx, %rdi
movl $0x6d, %esi
callq 0x4180
xorl %r15d, %r15d
testq %rax, %rax
setne %r15b
movq %rbx, %rdi
movl $0x73, %esi
callq 0x4180
leal 0x2(%r15), %ebp
testq %rax, %rax
cmovel %r15d, %ebp
leaq 0x2f9c(%rip), %rsi      # 0xe28f
leaq 0x8036(%rip), %rdx      # 0x13330
movq %r14, %rdi
callq 0x9246
movq %rax, %r15
movq %r14, %rdi
callq 0x4580
movb 0x18(%r12), %r12b
movq %r15, %rdi
movl %ebp, %esi
callq 0x4420
movq %rax, %r14
testb $0x2, %r12b
jne 0xb34d
callq 0x4340
movq 0x7c27(%rip), %rsi      # 0x12f58
movq 0x7cc0(%rip), %r8       # 0x12ff8
movl $0x2, %edi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x4130
movq %rax, %r14
movq %r15, %rdi
callq 0x4580
movq %rbx, %rdi
callq 0x4580
movl $0x1, %edi
movl $0x38, %esi
callq 0x4280
movq %rax, %rbx
xorl %r15d, %r15d
movq %r15, (%rax)
movw $0xf, 0x30(%rax)
movq %r14, 0x8(%rax)
movq 0x7c02(%rip), %rax      # 0x12f88
movq %rax, 0x10(%rbx)
movl $0x1, %edi
movl $0x38, %esi
callq 0x4280
movq %r15, (%rax)
movw $0x10, 0x30(%rax)
movq %rbx, 0x8(%rax)
movq 0x7bbb(%rip), %rcx      # 0x12f68
movq %rcx, 0x10(%rax)
leaq 0x318c(%rip), %rcx      # 0xe544
movq %rcx, 0x18(%rax)
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4150
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0xd7c5
movq %rax, %r14
movq %rbx, %rdi
callq 0x4580
movq (%r14), %r15
movl $0x1, %edi
movl $0x38, %esi
callq 0x4280
movq %rax, %rbx
movw $0x0, 0x30(%rax)
movq $0x0, (%rax)
testq %r15, %r15
je 0xb447
movb $0x10, 0x30(%rbx)
movq %r14, 0x8(%rbx)
movq 0x7b9e(%rip), %rax      # 0x12fb8
movq %rax, 0x10(%rbx)
movq %r15, 0x18(%rbx)
movl $0x1, %edi
movl $0x38, %esi
callq 0x4280
movq $0x0, (%rax)
movw $0xf, 0x30(%rax)
movq %rbx, 0x8(%rax)
movq %rax, %rbx
jmp 0xb44f
movb $0xf, 0x30(%rbx)
movq %r14, 0x8(%rbx)
movq 0x7b5a(%rip), %rax      # 0x12fb0
movq %rax, 0x10(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x4150
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
subq $0xf8, %rsp
leaq 0x40(%rsp), %r10
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0xb4c7
movaps %xmm0, 0x70(%rsp)
movaps %xmm1, 0x80(%rsp)
movaps %xmm2, 0x90(%rsp)
movaps %xmm3, 0xa0(%rsp)
movaps %xmm4, 0xb0(%rsp)
movaps %xmm5, 0xc0(%rsp)
movaps %xmm6, 0xd0(%rsp)
movaps %xmm7, 0xe0(%rsp)
movq %rsp, %rax
movq %r10, 0x10(%rax)
leaq 0x110(%rsp), %rcx
movq %rcx, 0x8(%rax)
movabsq $0x3000000010, %rcx     # imm = 0x3000000010
movq %rcx, (%rax)
leaq 0x20(%rsp), %rbx
movq %rax, (%rbx)
movl $0x0, 0x8(%rbx)
movq $0x0, 0x10(%rbx)
movl %edi, 0x18(%rbx)
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x4530
movq %rax, %r14
movq 0x10(%rbx), %rdi
callq 0x4580
movq %r14, %rax
addq $0xf8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0xf0, %rsp
leaq 0x40(%rsp), %r10
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0xb588
movaps %xmm0, 0x70(%rsp)
movaps %xmm1, 0x80(%rsp)
movaps %xmm2, 0x90(%rsp)
movaps %xmm3, 0xa0(%rsp)
movaps %xmm4, 0xb0(%rsp)
movaps %xmm5, 0xc0(%rsp)
movaps %xmm6, 0xd0(%rsp)
movaps %xmm7, 0xe0(%rsp)
movq %rsp, %rax
movq %r10, 0x10(%rax)
leaq 0x110(%rsp), %rcx
movq %rcx, 0x8(%rax)
movabsq $0x3000000010, %rcx     # imm = 0x3000000010
movq %rcx, (%rax)
leaq 0x20(%rsp), %rbx
movq %rax, (%rbx)
movl $0x0, 0x8(%rbx)
movq $0x0, 0x10(%rbx)
movl %edi, 0x18(%rbx)
leaq 0x3025(%rip), %rdi      # 0xe5ee
callq 0x5dec
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0xb600
movq %rax, %r15
movq %r14, %rdi
callq 0x5c86
movq 0x10(%rbx), %rdi
callq 0x4580
movq %r15, %rax
addq $0xf0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/mpc.c
// Function: mpca_lang_pipe
mpc_err_t *mpca_lang_pipe(int flags, FILE *p, ...) {
  mpca_grammar_st_t st;
  mpc_input_t *i;
  mpc_err_t *err;

  va_list va;
  va_start(va, p);

  st.va = &va;
  st.parsers_num = 0;
  st.parsers = NULL;
  st.flags = flags;

  i = mpc_input_new_pipe("<mpca_lang_pipe>", p);
  err = mpca_lang_st(i, &st);
  mpc_input_delete(i);

  free(st.parsers);
  va_end(va);
  return err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xf0, %rsp
leaq 0x40(%rsp), %r10
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0xbd10
movaps %xmm0, 0x70(%rsp)
movaps %xmm1, 0x80(%rsp)
movaps %xmm2, 0x90(%rsp)
movaps %xmm3, 0xa0(%rsp)
movaps %xmm4, 0xb0(%rsp)
movaps %xmm5, 0xc0(%rsp)
movaps %xmm6, 0xd0(%rsp)
movaps %xmm7, 0xe0(%rsp)
movq %rsp, %rax
movq %r10, 0x10(%rax)
leaq 0x110(%rsp), %rcx
movq %rcx, 0x8(%rax)
movabsq $0x3000000010, %rcx     # imm = 0x3000000010
movq %rcx, (%rax)
leaq 0x20(%rsp), %rbx
movq %rax, (%rbx)
movl $0x0, 0x8(%rbx)
movq $0x0, 0x10(%rbx)
movl %edi, 0x18(%rbx)
leaq 0x28ae(%rip), %rdi      # 0xe5ff
callq 0x5eb4
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0xb600
movq %rax, %r15
movq %r14, %rdi
callq 0x5c86
movq 0x10(%rbx), %rdi
callq 0x4580
movq %r15, %rax
addq $0xf0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/mpc.c
// Function: mpca_lang
mpc_err_t *mpca_lang(int flags, const char *language, ...) {

  mpca_grammar_st_t st;
  mpc_input_t *i;
  mpc_err_t *err;

  va_list va;
  va_start(va, language);

  st.va = &va;
  st.parsers_num = 0;
  st.parsers = NULL;
  st.flags = flags;

  i = mpc_input_new_string("<mpca_lang>", language);
  err = mpca_lang_st(i, &st);
  mpc_input_delete(i);

  free(st.parsers);
  va_end(va);
  return err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xf0, %rsp
leaq 0x40(%rsp), %r10
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0xbdea
movaps %xmm0, 0x70(%rsp)
movaps %xmm1, 0x80(%rsp)
movaps %xmm2, 0x90(%rsp)
movaps %xmm3, 0xa0(%rsp)
movaps %xmm4, 0xb0(%rsp)
movaps %xmm5, 0xc0(%rsp)
movaps %xmm6, 0xd0(%rsp)
movaps %xmm7, 0xe0(%rsp)
movq %rsp, %rax
movq %r10, 0x10(%rax)
leaq 0x110(%rsp), %rcx
movq %rcx, 0x8(%rax)
movabsq $0x3000000010, %rcx     # imm = 0x3000000010
movq %rcx, (%rax)
leaq 0x20(%rsp), %rbx
movq %rax, (%rbx)
movl $0x0, 0x8(%rbx)
movq $0x0, 0x10(%rbx)
movl %edi, 0x18(%rbx)
leaq 0x27e5(%rip), %rdi      # 0xe610
callq 0x5bc4
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0xb600
movq %rax, %r15
movq %r14, %rdi
callq 0x5c86
movq 0x10(%rbx), %rdi
callq 0x4580
movq %r15, %rax
addq $0xf0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/mpc.c
// Function: mpca_lang_contents
mpc_err_t *mpca_lang_contents(int flags, const char *filename, ...) {

  mpca_grammar_st_t st;
  mpc_input_t *i;
  mpc_err_t *err;

  va_list va;

  FILE *f = fopen(filename, "rb");

  if (f == NULL) {
    err = mpc_err_file(filename, "Unable to open file!");
    return err;
  }

  va_start(va, filename);

  st.va = &va;
  st.parsers_num = 0;
  st.parsers = NULL;
  st.flags = flags;

  i = mpc_input_new_file(filename, f);
  err = mpca_lang_st(i, &st);
  mpc_input_delete(i);

  free(st.parsers);
  va_end(va);

  fclose(f);

  return err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xf0, %rsp
movq %rsi, %r14
movl %edi, %ebp
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0xbec5
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
leaq 0x2459(%rip), %rsi      # 0xe325
movq %r14, %rdi
callq 0x4480
testq %rax, %rax
je 0xbf6c
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
leaq 0x120(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rcx)
leaq 0xd0(%rsp), %r15
movq %rcx, (%r15)
movl $0x0, 0x8(%r15)
movq $0x0, 0x10(%r15)
movl %ebp, 0x18(%r15)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5dec
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0xb600
movq %rax, %r12
movq %r14, %rdi
callq 0x5c86
movq 0x10(%r15), %rdi
callq 0x4580
movq %rbx, %rdi
callq 0x4110
movq %r12, %rax
addq $0xf0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
addq $0xf0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5fc0
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/mpc.c
// Function: mpc_malloc
static void *mpc_malloc(mpc_input_t *i, size_t n) {
  size_t j;
  char *p;

  if (n > sizeof(mpc_mem_t)) { return malloc(n); }

  j = i->mem_index;
  do {
    if (!i->mem_full[i->mem_index]) {
      p = (void*)(i->mem + i->mem_index);
      i->mem_full[i->mem_index] = 1;
      i->mem_index = (i->mem_index+1) % MPC_INPUT_MEM_NUM;
      return p;
    }
    i->mem_index = (i->mem_index+1) % MPC_INPUT_MEM_NUM;
  } while (j != i->mem_index);

  return malloc(n);
}

// Assembly:
cmpq $0x41, %rsi
jae 0xc721
movq 0x70(%rdi), %rax
movq %rax, %rcx
cmpb $0x0, 0x78(%rdi,%rcx)
je 0xc729
incl %ecx
andl $0x1ff, %ecx            # imm = 0x1FF
movq %rcx, 0x70(%rdi)
cmpq %rcx, %rax
jne 0xc709
movq %rsi, %rdi
jmp 0x43a0
movq %rcx, %rax
shlq $0x6, %rax
addq %rdi, %rax
addq $0x278, %rax            # imm = 0x278
movb $0x1, 0x78(%rdi,%rcx)
movl 0x70(%rdi), %ecx
incl %ecx
andl $0x1ff, %ecx            # imm = 0x1FF
movq %rcx, 0x70(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/mpc.c
// Function: mpc_input_any
static int mpc_input_any(mpc_input_t *i, char **o) {
  char x;
  if (mpc_input_terminated(i)) { return 0; }
  x = mpc_input_getc(i);
  return mpc_input_success(i, x, o);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xd1c0
testb %al, %al
je 0xc77e
movq %r14, %rdi
callq 0xd0a1
movsbl %al, %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0xd111
movl $0x1, %eax
jmp 0xc780
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/mpc.c
// Function: mpc_input_char
static int mpc_input_char(mpc_input_t *i, char c, char **o) {
  char x;
  if (mpc_input_terminated(i)) { return 0; }
  x = mpc_input_getc(i);
  return x == c ? mpc_input_success(i, x, o) : mpc_input_failure(i, x);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
callq 0xd1c0
xorl %ebx, %ebx
testb %al, %al
je 0xc7c9
movq %r15, %rdi
callq 0xd0a1
movsbl %al, %esi
movq %r15, %rdi
cmpb %bpl, %al
jne 0xc7c4
movq %r14, %rdx
callq 0xd111
movl $0x1, %ebx
jmp 0xc7c9
callq 0xd27e
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/mpc.c
// Function: mpc_input_range
static int mpc_input_range(mpc_input_t *i, char c, char d, char **o) {
  char x;
  if (mpc_input_terminated(i)) { return 0; }
  x = mpc_input_getc(i);
  return x >= c && x <= d ? mpc_input_success(i, x, o) : mpc_input_failure(i, x);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movl %edx, %ebp
movl %esi, %r12d
movq %rdi, %r15
callq 0xd1c0
xorl %ebx, %ebx
testb %al, %al
je 0xc826
movq %r15, %rdi
callq 0xd0a1
cmpb %r12b, %al
setl %cl
cmpb %bpl, %al
setg %dl
movsbl %al, %esi
movq %r15, %rdi
orb %cl, %dl
je 0xc819
callq 0xd27e
jmp 0xc826
movq %r14, %rdx
callq 0xd111
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/mpc.c
// Function: mpc_input_oneof
static int mpc_input_oneof(mpc_input_t *i, const char *c, char **o) {
  char x;
  if (mpc_input_terminated(i)) { return 0; }
  x = mpc_input_getc(i);
  return strchr(c, x) != 0 ? mpc_input_success(i, x, o) : mpc_input_failure(i, x);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
callq 0xd1c0
xorl %ebx, %ebx
testb %al, %al
je 0xc880
movq %r15, %rdi
callq 0xd0a1
movsbl %al, %ebp
movq %r12, %rdi
movl %ebp, %esi
callq 0x4180
movq %r15, %rdi
movl %ebp, %esi
testq %rax, %rax
je 0xc87b
movq %r14, %rdx
callq 0xd111
movl $0x1, %ebx
jmp 0xc880
callq 0xd27e
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/mpc.c
// Function: mpc_input_satisfy
static int mpc_input_satisfy(mpc_input_t *i, int(*cond)(char), char **o) {
  char x;
  if (mpc_input_terminated(i)) { return 0; }
  x = mpc_input_getc(i);
  return cond(x) ? mpc_input_success(i, x, o) : mpc_input_failure(i, x);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
callq 0xd1c0
xorl %ebx, %ebx
testb %al, %al
je 0xc92e
movq %r15, %rdi
callq 0xd0a1
movsbl %al, %ebp
movl %ebp, %edi
callq *%r12
movq %r15, %rdi
movl %ebp, %esi
testl %eax, %eax
je 0xc929
movq %r14, %rdx
callq 0xd111
movl $0x1, %ebx
jmp 0xc92e
callq 0xd27e
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/mpc.c
// Function: mpc_input_string
static int mpc_input_string(mpc_input_t *i, const char *c, char **o) {

  const char *x = c;

  mpc_input_mark(i);
  while (*x) {
    if (!mpc_input_char(i, *x, NULL)) {
      mpc_input_rewind(i);
      return 0;
    }
    x++;
  }
  mpc_input_unmark(i);

  *o = mpc_malloc(i, strlen(c) + 1);
  strcpy(*o, c);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
callq 0xcc55
movb (%rbx), %al
testb %al, %al
je 0xc975
leaq 0x1(%rbx), %r12
movsbl %al, %esi
movq %r15, %rdi
xorl %edx, %edx
callq 0xc788
testl %eax, %eax
je 0xc9a6
movb (%r12), %al
incq %r12
testb %al, %al
jne 0xc959
movq %r15, %rdi
callq 0xcd42
movq %rbx, %rdi
callq 0x4120
leaq 0x1(%rax), %rsi
movq %r15, %rdi
callq 0xc6fc
movq %rax, (%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x40b0
movl $0x1, %eax
jmp 0xc9b0
movq %r15, %rdi
callq 0xccf1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/mpc.c
// Function: mpc_err_new
static mpc_err_t *mpc_err_new(mpc_input_t *i, const char *expected) {
  mpc_err_t *x;
  if (i->suppress) { return NULL; }
  x = mpc_malloc(i, sizeof(mpc_err_t));
  x->filename = mpc_malloc(i, strlen(i->filename) + 1);
  strcpy(x->filename, i->filename);
  x->state = i->state;
  x->expected_num = 1;
  x->expected = mpc_malloc(i, sizeof(char*));
  x->expected[0] = mpc_malloc(i, strlen(expected) + 1);
  strcpy(x->expected[0], expected);
  x->failure = NULL;
  x->received = mpc_input_peekc(i);
  return x;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x0, 0x48(%rdi)
je 0xcbac
xorl %ebx, %ebx
jmp 0xcc46
movq %rsi, %r15
movq %rdi, %r14
movl $0x48, %edi
callq 0x43a0
movq %rax, %rbx
movq 0x8(%r14), %rdi
callq 0x4120
leaq 0x1(%rax), %rsi
movq %r14, %rdi
callq 0xc6fc
movq %rax, 0x28(%rbx)
movq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x40b0
movups 0x10(%r14), %xmm0
movups 0x20(%r14), %xmm1
movups %xmm0, (%rbx)
movups %xmm1, 0x10(%rbx)
movl $0x1, 0x20(%rbx)
movl $0x8, %esi
movq %r14, %rdi
callq 0xc6fc
movq %rax, %r12
movq %rax, 0x38(%rbx)
movq %r15, %rdi
callq 0x4120
leaq 0x1(%rax), %rsi
movq %r14, %rdi
callq 0xc6fc
movq %rax, (%r12)
movq %rax, %rdi
movq %r15, %rsi
callq 0x40b0
movq $0x0, 0x30(%rbx)
movq %r14, %rdi
callq 0xd1c0
movb %al, 0x40(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/mpc.c
// Function: mpc_input_mark
static void mpc_input_mark(mpc_input_t *i) {

  if (i->backtrack < 1) { return; }

  i->marks_num++;

  if (i->marks_num > i->marks_slots) {
    i->marks_slots = i->marks_num + i->marks_num / 2;
    i->marks = realloc(i->marks, sizeof(mpc_state_t) * i->marks_slots);
    i->lasts = realloc(i->lasts, sizeof(char) * i->marks_slots);
  }

  i->marks[i->marks_num-1] = i->state;
  i->lasts[i->marks_num-1] = i->last;

  if (i->type == MPC_INPUT_PIPE && i->marks_num == 1) {
    i->buffer = calloc(1, 1);
  }

}

// Assembly:
cmpl $0x0, 0x4c(%rdi)
jle 0xccf0
pushq %rbx
movq %rdi, %rbx
movl 0x54(%rdi), %ecx
leal 0x1(%rcx), %eax
movl %eax, 0x54(%rdi)
cmpl 0x50(%rdi), %ecx
jl 0xcca4
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
movl %ecx, 0x50(%rbx)
movq 0x58(%rbx), %rdi
movslq %ecx, %rsi
shlq $0x5, %rsi
callq 0x4400
movq %rax, 0x58(%rbx)
movq 0x60(%rbx), %rdi
movslq 0x50(%rbx), %rsi
callq 0x4400
movq %rax, 0x60(%rbx)
movq 0x58(%rbx), %rax
movslq 0x54(%rbx), %rcx
shlq $0x5, %rcx
movups 0x10(%rbx), %xmm0
movups 0x20(%rbx), %xmm1
movups %xmm1, -0x10(%rax,%rcx)
movups %xmm0, -0x20(%rax,%rcx)
movb 0x68(%rbx), %al
movq 0x60(%rbx), %rcx
movslq 0x54(%rbx), %rdx
movb %al, -0x1(%rcx,%rdx)
cmpl $0x2, (%rbx)
jne 0xccef
cmpl $0x1, 0x54(%rbx)
jne 0xccef
movl $0x1, %edi
movl $0x1, %esi
callq 0x4280
movq %rax, 0x38(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/mpc.c
// Function: mpc_input_rewind
static void mpc_input_rewind(mpc_input_t *i) {

  if (i->backtrack < 1) { return; }

  i->state = i->marks[i->marks_num-1];
  i->last  = i->lasts[i->marks_num-1];

  if (i->type == MPC_INPUT_FILE) {
    fseek(i->file, i->state.pos, SEEK_SET);
  }

  mpc_input_unmark(i);
}

// Assembly:
cmpl $0x0, 0x4c(%rdi)
jle 0xcd41
pushq %rbx
movq %rdi, %rbx
movq 0x58(%rdi), %rax
movslq 0x54(%rdi), %rcx
movq %rcx, %rdx
shlq $0x5, %rdx
movups -0x20(%rax,%rdx), %xmm0
movups -0x10(%rax,%rdx), %xmm1
movups %xmm0, 0x10(%rdi)
movups %xmm1, 0x20(%rdi)
movq 0x60(%rdi), %rax
movb -0x1(%rax,%rcx), %al
movb %al, 0x68(%rdi)
cmpl $0x1, (%rdi)
jne 0xcd3b
movq 0x10(%rbx), %rsi
movq 0x40(%rbx), %rdi
xorl %edx, %edx
callq 0x43f0
movq %rbx, %rdi
popq %rbx
jmp 0xcd42
retq
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/mpc.c
// Function: mpc_input_unmark
static void mpc_input_unmark(mpc_input_t *i) {
  int j;

  if (i->backtrack < 1) { return; }

  i->marks_num--;

  if (i->marks_slots > i->marks_num + i->marks_num / 2
  &&  i->marks_slots > MPC_INPUT_MARKS_MIN) {
    i->marks_slots =
      i->marks_num > MPC_INPUT_MARKS_MIN ?
      i->marks_num : MPC_INPUT_MARKS_MIN;
    i->marks = realloc(i->marks, sizeof(mpc_state_t) * i->marks_slots);
    i->lasts = realloc(i->lasts, sizeof(char) * i->marks_slots);
  }

  if (i->type == MPC_INPUT_PIPE && i->marks_num == 0) {
    for (j = strlen(i->buffer) - 1; j >= 0; j--)
      ungetc(i->buffer[j], i->file);

    free(i->buffer);
    i->buffer = NULL;
  }

}

// Assembly:
cmpl $0x0, 0x4c(%rdi)
jle 0xcdf5
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x50(%rdi), %edx
movl 0x54(%rdi), %ecx
leal -0x1(%rcx), %eax
movl %eax, 0x54(%rdi)
cmpl $0x21, %edx
jl 0xcda7
movl %eax, %esi
shrl $0x1f, %esi
addl %ecx, %esi
decl %esi
sarl %esi
addl %ecx, %esi
decl %esi
cmpl %esi, %edx
jle 0xcda7
cmpl $0x22, %ecx
movl $0x20, %esi
cmovgel %eax, %esi
movl %esi, 0x50(%rbx)
movq 0x58(%rbx), %rdi
shlq $0x5, %rsi
callq 0x4400
movq %rax, 0x58(%rbx)
movq 0x60(%rbx), %rdi
movslq 0x50(%rbx), %rsi
callq 0x4400
movq %rax, 0x60(%rbx)
cmpl $0x2, (%rbx)
jne 0xcdee
cmpl $0x0, 0x54(%rbx)
jne 0xcdee
movq 0x38(%rbx), %rdi
callq 0x4120
decl %eax
js 0xcddd
movl %eax, %r14d
incq %r14
movq 0x38(%rbx), %rax
movq 0x40(%rbx), %rsi
movsbl -0x1(%rax,%r14), %edi
callq 0x43d0
decq %r14
jg 0xcdc5
movq 0x38(%rbx), %rdi
callq 0x4580
movq $0x0, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/mpc.c
// Function: mpc_grow_results
static mpc_result_t *mpc_grow_results(mpc_input_t *i, int j, mpc_result_t *results_stk, mpc_result_t *results){
  mpc_result_t *tmp_results = results;

  if (j == MPC_PARSE_STACK_MIN) {
    int results_slots = j + j / 2;
    tmp_results = mpc_malloc(i, sizeof(mpc_result_t) * results_slots);
    memcpy(tmp_results, results_stk, sizeof(mpc_result_t) * MPC_PARSE_STACK_MIN);
  } else if (j >= MPC_PARSE_STACK_MIN) {
    int results_slots = j + j / 2;
    tmp_results = mpc_realloc(i, tmp_results, sizeof(mpc_result_t) * results_slots);
  }

  return tmp_results;
}

// Assembly:
cmpl $0x4, %esi
jne 0xce19
pushq %rbx
movq %rdx, %rbx
movl $0x30, %esi
callq 0xc6fc
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups %xmm0, (%rax)
movups %xmm1, 0x10(%rax)
popq %rbx
retq
jl 0xce2d
movl %esi, %edx
shrl %edx
addl %esi, %edx
shlq $0x3, %rdx
movq %rcx, %rsi
jmp 0xd2e0
movq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/mpc.c
// Function: mpc_parse_fold
static mpc_val_t *mpc_parse_fold(mpc_input_t *i, mpc_fold_t f, int n, mpc_val_t **xs) {
  int j;
  if (f == mpcf_null)      { return mpcf_null(n, xs); }
  if (f == mpcf_fst)       { return mpcf_fst(n, xs); }
  if (f == mpcf_snd)       { return mpcf_snd(n, xs); }
  if (f == mpcf_trd)       { return mpcf_trd(n, xs); }
  if (f == mpcf_fst_free)  { return mpcf_input_fst_free(i, n, xs); }
  if (f == mpcf_snd_free)  { return mpcf_input_snd_free(i, n, xs); }
  if (f == mpcf_trd_free)  { return mpcf_input_trd_free(i, n, xs); }
  if (f == mpcf_strfold)   { return mpcf_input_strfold(i, n, xs); }
  if (f == mpcf_state_ast) { return mpcf_input_state_ast(i, n, xs); }
  for (j = 0; j < n; j++) { xs[j] = mpc_export(i, xs[j]); }
  return f(j, xs);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpq 0x60fa(%rip), %rsi      # 0x12f40
je 0xcf4f
movq %rcx, %rbx
movq %rsi, %rax
cmpq 0x60ff(%rip), %rsi      # 0x12f58
je 0xcf53
cmpq 0x6162(%rip), %rax      # 0x12fc8
je 0xcf58
cmpq 0x611d(%rip), %rax      # 0x12f90
je 0xcf5e
movq %rdi, %r14
cmpq 0x60a5(%rip), %rax      # 0x12f28
je 0xcf71
cmpq 0x6080(%rip), %rax      # 0x12f10
je 0xcf7d
cmpq 0x607b(%rip), %rax      # 0x12f18
je 0xcf8c
cmpq 0x6116(%rip), %rax      # 0x12fc0
je 0xcfac
cmpq 0x60a9(%rip), %rax      # 0x12f60
je 0xcfc7
testl %edx, %edx
jle 0xcfe0
movq %rax, 0x8(%rsp)
leaq 0x278(%r14), %rdi
leaq 0x8278(%r14), %rbp
movl %edx, %r12d
xorl %r15d, %r15d
movq %rdi, 0x10(%rsp)
movq (%rbx,%r15,8), %r13
cmpq %r13, %rdi
seta %al
cmpq %r13, %rbp
setbe %cl
orb %al, %cl
jne 0xcf39
movl $0x40, %edi
callq 0x43a0
movq 0x10(%rsp), %rdi
movups (%r13), %xmm0
movups 0x10(%r13), %xmm1
movups 0x20(%r13), %xmm2
movups 0x30(%r13), %xmm3
movups %xmm0, (%rax)
movups %xmm1, 0x10(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm3, 0x30(%rax)
subq %rdi, %r13
shrq $0x6, %r13
movb $0x0, 0x78(%r14,%r13)
movq %rax, %r13
movq %r13, (%rbx,%r15,8)
incq %r15
cmpq %r15, %r12
jne 0xcee3
movq 0x8(%rsp), %rax
jmp 0xcfe3
xorl %eax, %eax
jmp 0xcf62
movq (%rbx), %rax
jmp 0xcf62
movq 0x8(%rbx), %rax
jmp 0xcf62
movq 0x10(%rbx), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movl %edx, %esi
movq %rbx, %rdx
xorl %ecx, %ecx
jmp 0xcf99
movq %r14, %rdi
movl %edx, %esi
movq %rbx, %rdx
movl $0x1, %ecx
jmp 0xcf99
movq %r14, %rdi
movl %edx, %esi
movq %rbx, %rdx
movl $0x2, %ecx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd4b6
movq %r14, %rdi
movl %edx, %esi
movq %rbx, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd38f
movq %r14, %rdi
movq %rbx, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd45b
xorl %r15d, %r15d
movl %r15d, %edi
movq %rbx, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/mpc.c
// Function: mpc_err_count
static mpc_err_t *mpc_err_count(mpc_input_t *i, mpc_err_t *x, int n) {
  mpc_err_t *y;
  int digits = n/10 + 1;
  char *prefix;
  prefix = mpc_malloc(i, digits + strlen(" of ") + 1);
  if (!prefix) {
    return NULL;
  }
  sprintf(prefix, "%i of ", n);
  y = mpc_err_repeat(i, x, prefix);
  mpc_free(i, prefix);
  return y;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movslq %edx, %rax
imulq $0x66666667, %rax, %rax # imm = 0x66666667
movq %rax, %rcx
sarq $0x22, %rcx
shrq $0x3f, %rax
addl %ecx, %eax
addl $0x6, %eax
movslq %eax, %rsi
callq 0xc6fc
testq %rax, %rax
je 0xd081
movq %rax, %r14
leaq 0x1692(%rip), %rsi      # 0xe6cb
movq %rax, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x44d0
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xd534
movq %rax, %r15
leaq 0x278(%rbx), %rax
cmpq %r14, %rax
seta %cl
leaq 0x8278(%rbx), %rdx
cmpq %r14, %rdx
setbe %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0xd086
movq %r14, %rdi
callq 0x4580
jmp 0xd093
xorl %r15d, %r15d
jmp 0xd093
subq %rax, %r14
shrq $0x6, %r14
movb $0x0, 0x78(%rbx,%r14)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/mpc.c
// Function: mpc_input_getc
static char mpc_input_getc(mpc_input_t *i) {

  char c = '\0';

  switch (i->type) {

    case MPC_INPUT_STRING: return i->string[i->state.pos];
    case MPC_INPUT_FILE: c = fgetc(i->file); return c;
    case MPC_INPUT_PIPE:

      if (!i->buffer) { c = getc(i->file); return c; }

      if (i->buffer && mpc_input_buffer_in_range(i)) {
        c = mpc_input_buffer_get(i);
        return c;
      } else {
        c = getc(i->file);
        return c;
      }

    default: return c;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x2, %eax
je 0xd0d1
cmpl $0x1, %eax
je 0xd0c6
testl %eax, %eax
jne 0xd0fe
movq 0x10(%rbx), %rax
movq 0x30(%rbx), %rcx
movb (%rcx,%rax), %al
jmp 0xd10b
movq 0x40(%rbx), %rdi
callq 0x4230
jmp 0xd10b
movq 0x38(%rbx), %r14
testq %r14, %r14
je 0xd102
movq 0x10(%rbx), %r15
movq %r14, %rdi
callq 0x4120
movq 0x58(%rbx), %rcx
movq (%rcx), %rcx
addq %rcx, %rax
cmpq %rax, %r15
jge 0xd102
subq %rcx, %r15
movb (%r14,%r15), %al
jmp 0xd10b
xorl %eax, %eax
jmp 0xd10b
movq 0x40(%rbx), %rdi
callq 0x4540
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/mpc.c
// Function: mpc_input_success
static int mpc_input_success(mpc_input_t *i, char c, char **o) {

  if (i->type == MPC_INPUT_PIPE
  &&  i->buffer && !mpc_input_buffer_in_range(i)) {
    i->buffer = realloc(i->buffer, strlen(i->buffer) + 2);
    i->buffer[strlen(i->buffer) + 1] = '\0';
    i->buffer[strlen(i->buffer) + 0] = c;
  }

  i->last = c;
  i->state.pos++;
  i->state.col++;

  if (c == '\n') {
    i->state.col = 0;
    i->state.row++;
  }

  if (o) {
    (*o) = mpc_malloc(i, 2);
    (*o)[0] = c;
    (*o)[1] = '\0';
  }

  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
cmpl $0x2, (%rdi)
jne 0xd17a
movq 0x38(%r14), %r15
testq %r15, %r15
je 0xd17a
movq 0x10(%r14), %r12
movq %r15, %rdi
callq 0x4120
movq 0x58(%r14), %rcx
movq (%rcx), %rcx
addq %rax, %rcx
cmpq %rcx, %r12
jl 0xd17a
addq $0x2, %rax
movq %r15, %rdi
movq %rax, %rsi
callq 0x4400
movq %rax, %r15
movq %rax, 0x38(%r14)
movq %rax, %rdi
callq 0x4120
movb $0x0, 0x1(%r15,%rax)
movq %r15, %rdi
callq 0x4120
movb %bpl, (%r15,%rax)
movb %bpl, 0x68(%r14)
incq 0x10(%r14)
incq 0x20(%r14)
cmpb $0xa, %bpl
jne 0xd198
movq $0x0, 0x20(%r14)
incq 0x18(%r14)
testq %rbx, %rbx
je 0xd1b7
movl $0x2, %esi
movq %r14, %rdi
callq 0xc6fc
movq %rax, (%rbx)
movb %bpl, (%rax)
movq (%rbx), %rax
movb $0x0, 0x1(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/mpc.c
// Function: mpc_input_peekc
static char mpc_input_peekc(mpc_input_t *i) {

  char c = '\0';

  switch (i->type) {
    case MPC_INPUT_STRING: return i->string[i->state.pos];
    case MPC_INPUT_FILE:

      c = fgetc(i->file);
      if (feof(i->file)) { return '\0'; }

      fseek(i->file, -1, SEEK_CUR);
      return c;

    case MPC_INPUT_PIPE:

      if (!i->buffer) {
        c = getc(i->file);
        if (feof(i->file)) { return '\0'; }
        ungetc(c, i->file);
        return c;
      }

      if (i->buffer && mpc_input_buffer_in_range(i)) {
        return mpc_input_buffer_get(i);
      } else {
        c = getc(i->file);
        if (feof(i->file)) { return '\0'; }
        ungetc(c, i->file);
        return c;
      }

    default: return c;
  }

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x2, %eax
je 0xd21b
cmpl $0x1, %eax
je 0xd1ec
testl %eax, %eax
jne 0xd260
movq 0x10(%rbx), %rax
movq 0x30(%rbx), %rcx
movb (%rcx,%rax), %bpl
jmp 0xd262
movq 0x40(%rbx), %rdi
callq 0x4230
movl %eax, %ebp
movq 0x40(%rbx), %rdi
callq 0x4310
testl %eax, %eax
jne 0xd260
movq 0x40(%rbx), %rdi
movq $-0x1, %rsi
movl $0x1, %edx
callq 0x43f0
jmp 0xd262
movq 0x38(%rbx), %r14
testq %r14, %r14
je 0xd248
movq 0x10(%rbx), %r15
movq %r14, %rdi
callq 0x4120
movq 0x58(%rbx), %rcx
movq (%rcx), %rcx
addq %rcx, %rax
cmpq %rax, %r15
jge 0xd248
subq %rcx, %r15
movb (%r14,%r15), %bpl
jmp 0xd262
movq 0x40(%rbx), %rdi
callq 0x4540
movl %eax, %ebp
movq 0x40(%rbx), %rdi
callq 0x4310
testl %eax, %eax
je 0xd26f
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movsbl %bpl, %edi
movq 0x40(%rbx), %rsi
callq 0x43d0
jmp 0xd262
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/mpc.c
// Function: mpc_input_failure
static int mpc_input_failure(mpc_input_t *i, char c) {

  switch (i->type) {
    case MPC_INPUT_STRING: { break; }
    case MPC_INPUT_FILE: fseek(i->file, -1, SEEK_CUR); { break; }
    case MPC_INPUT_PIPE: {

      if (!i->buffer) { ungetc(c, i->file); break; }

      if (i->buffer && mpc_input_buffer_in_range(i)) {
        break;
      } else {
        ungetc(c, i->file);
      }
    }
    default: { break; }
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x2, %eax
je 0xd2aa
cmpl $0x1, %eax
jne 0xd2ca
movq 0x40(%rbx), %rdi
movq $-0x1, %rsi
movl $0x1, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x43f0
movl %esi, %ebp
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0xd2cf
movq 0x10(%rbx), %r14
callq 0x4120
movq 0x58(%rbx), %rcx
addq (%rcx), %rax
cmpq %rax, %r14
jge 0xd2cf
popq %rbx
popq %r14
popq %rbp
retq
movsbl %bpl, %edi
movq 0x40(%rbx), %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x43d0
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/mpc.c
// Function: mpc_realloc
static void *mpc_realloc(mpc_input_t *i, void *p, size_t n) {

  char *q = NULL;

  if (!mpc_mem_ptr(i, p)) { return realloc(p, n); }

  if (n > sizeof(mpc_mem_t)) {
    q = malloc(n);
    memcpy(q, p, sizeof(mpc_mem_t));
    mpc_free(i, p);
    return q;
  }

  return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
leaq 0x278(%rdi), %r12
cmpq %rsi, %r12
seta %al
leaq 0x8278(%rdi), %r13
cmpq %rsi, %r13
setbe %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0xd321
movq %rbx, %rdi
movq %rdx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4400
cmpq $0x41, %rdx
jb 0xd370
movq %rdi, %r14
movq %rdx, %rdi
callq 0x43a0
movq %rax, %r15
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups 0x20(%rbx), %xmm2
movups 0x30(%rbx), %xmm3
movups %xmm0, (%rax)
movups %xmm1, 0x10(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm3, 0x30(%rax)
cmpq %rbx, %r12
seta %al
cmpq %rbx, %r13
setbe %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0xd375
movq %rbx, %rdi
callq 0x4580
jmp 0xd382
movq %rbx, %r15
jmp 0xd382
subq %r12, %rbx
shrq $0x6, %rbx
movb $0x0, 0x78(%r14,%rbx)
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/mpc.c
// Function: mpcf_input_strfold
static mpc_val_t *mpcf_input_strfold(mpc_input_t *i, int n, mpc_val_t **xs) {
  int j;
  size_t l = 0;
  if (n == 0) { return mpc_calloc(i, 1, 1); }
  for (j = 0; j < n; j++) { l += strlen(xs[j]); }
  xs[0] = mpc_realloc(i, xs[0], l + 1);
  for (j = 1; j < n; j++) { strcat(xs[0], xs[j]); mpc_free(i, xs[j]); }
  return xs[0];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
je 0xd3ca
movq %rdx, %r14
movl %esi, %ebp
movl %esi, %r12d
jle 0xd3dc
xorl %r13d, %r13d
xorl %r15d, %r15d
movq (%r14,%r13,8), %rdi
callq 0x4120
addq %rax, %r15
incq %r13
cmpq %r13, %r12
jne 0xd3b1
incq %r15
jmp 0xd3e2
movl $0x1, %esi
movq %rbx, %rdi
callq 0xc6fc
movb $0x0, (%rax)
jmp 0xd44c
movl $0x1, %r15d
movq (%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0xd2e0
movq %rax, (%r14)
cmpl $0x2, %ebp
jl 0xd449
leaq 0x278(%rbx), %r15
leaq 0x8278(%rbx), %r13
movl $0x1, %ebp
movq (%r14), %rdi
movq (%r14,%rbp,8), %rsi
callq 0x44c0
movq (%r14,%rbp,8), %rdi
cmpq %rdi, %r15
seta %al
cmpq %rdi, %r13
setbe %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0xd435
callq 0x4580
jmp 0xd441
subq %r15, %rdi
shrq $0x6, %rdi
movb $0x0, 0x78(%rbx,%rdi)
incq %rbp
cmpq %rbp, %r12
jne 0xd40b
movq (%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/mpc.c
// Function: mpcf_input_state_ast
static mpc_val_t *mpcf_input_state_ast(mpc_input_t *i, int n, mpc_val_t **xs) {
  mpc_state_t *s = ((mpc_state_t**)xs)[0];
  mpc_ast_t *a = ((mpc_ast_t**)xs)[1];
  a = mpc_ast_state(a, *s);
  mpc_free(i, s);
  (void) n;
  return a;
}

// Assembly:
pushq %rbx
movq %rdi, %rax
movq (%rsi), %rdi
movq 0x8(%rsi), %rbx
testq %rbx, %rbx
je 0xd47a
movups (%rdi), %xmm0
movups 0x10(%rdi), %xmm1
movups %xmm1, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
leaq 0x278(%rax), %rcx
cmpq %rdi, %rcx
seta %dl
leaq 0x8278(%rax), %rsi
cmpq %rdi, %rsi
setbe %sil
orb %dl, %sil
cmpb $0x1, %sil
jne 0xd4a5
callq 0x4580
jmp 0xd4b1
subq %rcx, %rdi
shrq $0x6, %rdi
movb $0x0, 0x78(%rax,%rdi)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/mpc.c
// Function: mpca_stmt_fold
static mpc_val_t *mpca_stmt_fold(int n, mpc_val_t **xs) {

  int i;
  mpca_stmt_t **stmts = malloc(sizeof(mpca_stmt_t*) * (n+1));

  for (i = 0; i < n; i++) {
    stmts[i] = xs[i];
  }
  stmts[n] = NULL;

  return stmts;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movslq %edi, %r15
leaq 0x8(,%r15,8), %rdi
callq 0x43a0
movq %rax, %r14
testl %r15d, %r15d
jle 0xd9e4
movl %ebp, %edx
shlq $0x3, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4350
movq $0x0, (%r14,%r15,8)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/mpc.c
// Function: mpca_stmt_list_delete
static void mpca_stmt_list_delete(mpc_val_t *x) {

  mpca_stmt_t **stmts = x;

  while(*stmts) {
    mpca_stmt_t *stmt = *stmts;
    free(stmt->ident);
    free(stmt->name);
    mpc_soft_delete(stmt->grammar);
    free(stmt);
    stmts++;
  }
  free(x);

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0xda3e
leaq 0x8(%rbx), %r15
movq (%r14), %rdi
callq 0x4580
movq 0x8(%r14), %rdi
callq 0x4580
movq 0x10(%r14), %rdi
xorl %esi, %esi
callq 0x6075
movq %r14, %rdi
callq 0x4580
movq (%r15), %r14
addq $0x8, %r15
testq %r14, %r14
jne 0xda0e
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x4580
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/mpc.c
// Function: mpca_stmt_list_apply_to
static mpc_val_t *mpca_stmt_list_apply_to(mpc_val_t *x, void *s) {

  mpca_grammar_st_t *st = s;
  mpca_stmt_t *stmt;
  mpca_stmt_t **stmts = x;
  mpc_parser_t *left;

  while(*stmts) {
    stmt = *stmts;
    left = mpca_grammar_find_parser(stmt->ident, st);
    if (st->flags & MPCA_LANG_PREDICTIVE) { stmt->grammar = mpc_predictive(stmt->grammar); }
    if (stmt->name) { stmt->grammar = mpc_expect(stmt->grammar, stmt->name); }
    mpc_optimise(stmt->grammar);
    mpc_define(left, stmt->grammar);
    free(stmt->ident);
    free(stmt->name);
    free(stmt);
    stmts++;
  }

  free(x);

  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r15
testq %r15, %r15
je 0xdb03
movq %rsi, %r14
leaq 0x8(%rbx), %r13
movq (%r15), %rdi
movq %r14, %rsi
callq 0xd7c5
movq %rax, %r12
testb $0x1, 0x18(%r14)
je 0xdaa9
movq 0x10(%r15), %rbp
movl $0x1, %edi
movl $0x38, %esi
callq 0x4280
movq $0x0, (%rax)
movw $0x11, 0x30(%rax)
movq %rbp, 0x8(%rax)
movq %rax, 0x10(%r15)
movq 0x8(%r15), %rsi
testq %rsi, %rsi
je 0xdabf
movq 0x10(%r15), %rdi
callq 0x4520
movq %rax, 0x10(%r15)
movq 0x10(%r15), %rdi
movl $0x1, %esi
callq 0xc0b6
movq 0x10(%r15), %rsi
movq %r12, %rdi
callq 0x40c0
movq (%r15), %rdi
callq 0x4580
movq 0x8(%r15), %rdi
callq 0x4580
movq %r15, %rdi
callq 0x4580
movq (%r13), %r15
addq $0x8, %r13
testq %r15, %r15
jne 0xda6c
movq %rbx, %rdi
callq 0x4580
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/mpc.c
// Function: mpca_stmt_afold
static mpc_val_t *mpca_stmt_afold(int n, mpc_val_t **xs) {
  mpca_stmt_t *stmt = malloc(sizeof(mpca_stmt_t));
  stmt->ident = ((char**)xs)[0];
  stmt->name = ((char**)xs)[1];
  stmt->grammar = ((mpc_parser_t**)xs)[3];
  (void) n;
  free(((char**)xs)[2]);
  free(((char**)xs)[4]);

  return stmt;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl $0x18, %edi
callq 0x43a0
movq %rax, %r14
movq (%rbx), %rax
movq %rax, (%r14)
movq 0x8(%rbx), %rax
movq %rax, 0x8(%r14)
movq 0x18(%rbx), %rax
movq %rax, 0x10(%r14)
movq 0x10(%rbx), %rdi
callq 0x4580
movq 0x20(%rbx), %rdi
callq 0x4580
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/aap[P]rx-0/common/fe.c
// Function: panic
void
panic(char *fmt, ...)
{
	va_list ap;
	va_start(ap, fmt);
	vfprintf(stderr, fmt, ap);
	fprintf(stderr, "\n");
	va_end(ap);
	quit();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %r10
leaq -0xd0(%rbp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x2680
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
leaq -0x20(%rbp), %rdx
movq %rdi, 0x10(%rdx)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
movq 0x5954(%rip), %rbx      # 0x7ff8
movq (%rbx), %rdi
movq %r10, %rsi
callq 0x2310
movq (%rbx), %rsi
movl $0xa, %edi
callq 0x2160
callq 0x26c1
// File: /workspace/github_c_makefile_star2_O1/aap[P]rx-0/common/fe.c
// Function: quit
void
quit(void)
{
	reset(0);
	putchar('\n');

	deinitmach();
	exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x279a
movl $0xa, %edi
callq 0x2050
callq 0x4c68
xorl %edi, %edi
callq 0x2340
// File: /workspace/github_c_makefile_star2_O1/aap[P]rx-0/common/fe.c
// Function: raw
int
raw(int fd)
{
	struct termios tio;
	if(tcgetattr(fd, &tio) < 0) return -1;
	tiosaved = tio;
	cfmakeraw(&tio);
//	tio.c_iflag |= ICRNL;
	tio.c_oflag |= OPOST | ONLCR;
	if(tcsetattr(fd, TCSAFLUSH, &tio) < 0) return -1;
	canreset = 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %edi, %r14d
leaq -0x54(%rbp), %rsi
callq 0x22c0
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testl %eax, %eax
js 0x278d
leaq -0x54(%rbp), %r15
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups 0x2c(%r15), %xmm3
movups %xmm3, 0xab21(%rip)     # 0xd26c
movups %xmm2, 0xab0e(%rip)     # 0xd260
movups %xmm1, 0xaaf7(%rip)     # 0xd250
movups %xmm0, 0xaae0(%rip)     # 0xd240
movq %r15, %rdi
callq 0x2250
orb $0x5, 0x4(%r15)
movl %r14d, %edi
movl $0x2, %esi
movq %r15, %rdx
callq 0x22d0
testl %eax, %eax
js 0x278d
movl $0x1, 0xaaf1(%rip)      # 0xd27c
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/aap[P]rx-0/common/fe.c
// Function: tyo
void
tyo(char c)
{
	static char *alt = "◊";
	static char *ctrl = "↑";

	if(c < 040){
		switch(c){
		case ALT:
			write(1, alt, strlen(alt));
			return;
		case CTL('J'):
		case CTL('M'):
		case CTL('H'):
		case CTL('I'):
			write(1, &c, 1);
			break;
		default:
			write(1, ctrl, strlen(ctrl));
			c += 0100;
			write(1, &c, 1);
		}
	}else
		write(1, &c, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
movb %bl, -0x9(%rbp)
cmpb $0x1f, %bl
jg 0x284f
movsbl %bl, %eax
leal -0x8(%rax), %ecx
cmpl $0x3, %ecx
jb 0x284f
cmpl $0xd, %eax
je 0x284f
cmpl $0x1b, %eax
jne 0x2869
leaq 0x291b(%rip), %rsi      # 0x5155
movl $0x3, %edx
movl $0x1, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x20d0
leaq -0x9(%rbp), %rsi
movl $0x1, %edx
movl $0x1, %edi
callq 0x20d0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x28e9(%rip), %rsi      # 0x5159
movl $0x3, %edx
movl $0x1, %edi
callq 0x20d0
addb $0x40, %bl
leaq -0x9(%rbp), %rsi
movb %bl, (%rsi)
jmp 0x2853
// File: /workspace/github_c_makefile_star2_O1/aap[P]rx-0/common/fe.c
// Function: typenum
void
typenum(Word n)
{
	Word d;
	d = n % base;
	n /= base;
	if(n)
		typenum(n);
	tyo(d + '0');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
movl 0x598e(%rip), %r14d     # 0x8228
cmpl %edi, %r14d
ja 0x28ad
movl %ebx, %eax
xorl %edx, %edx
divl %r14d
movl %eax, %edi
callq 0x288a
movl %ebx, %eax
xorl %edx, %edx
divl %r14d
addb $0x30, %dl
movsbl %dl, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x280e
// File: /workspace/github_c_makefile_star2_O1/aap[P]rx-0/common/fe.c
// Function: parsenum
Word
parsenum(void)
{
	Word w;
	char *c;

	w = 0;
	for(c = bufstart; c < &buf[nbuf]; c++){
		if(*c >= '0' && *c <= '9')
			w = w*base + *c-'0';
		else
			return BUF_ERR;
		w &= WORDMASK;
	}
	return w;
}

// Assembly:
movq 0x582f(%rip), %rcx      # 0x8220
movslq 0xaa2c(%rip), %rax      # 0xd424
leaq 0xa881(%rip), %rdx      # 0xd280
addq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
jae 0x2a41
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movl 0x5813(%rip), %esi      # 0x8228
movzbl (%rcx), %edi
leal -0x30(%rdi), %r8d
cmpb $0x9, %r8b
ja 0x2a3b
imull %esi, %eax
addl %edi, %eax
addl $0x3ffd0, %eax          # imm = 0x3FFD0
andl $0x3ffff, %eax          # imm = 0x3FFFF
incq %rcx
cmpq %rdx, %rcx
jb 0x2a15
jmp 0x2a40
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/aap[P]rx-0/common/fe.c
// Function: defsym
void
defsym(char *sym, Word val)
{
	int i;
	for(i = 0; i < SYMTABSIZE; i++)
		if(symtab[i].sym[0] == '\0')
			goto found;
	err("?SYMTAB? ");
found:
	strncpy(symtab[i].sym, sym, 12);
	symtab[i].sym[11] = '\0';
	symtab[i].value = val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %rsi
xorl %r14d, %r14d
leaq 0x57d5(%rip), %r15      # 0x8230
cmpb $0x0, (%r14,%r15)
je 0x2a89
addq $0x14, %r14
cmpq $0x5000, %r14           # imm = 0x5000
jne 0x2a5b
leaq 0x26e7(%rip), %rdi      # 0x515d
callq 0x28c3
leaq 0xa8ce(%rip), %rdi      # 0xd350
xorl %esi, %esi
callq 0x2290
leaq (%r15,%r14), %rdi
movl $0xc, %edx
callq 0x2080
movb $0x0, 0xb(%r14,%r15)
movl %ebx, 0x10(%r14,%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/aap[P]rx-0/common/fe.c
// Function: findsym
char*
findsym(Word val)
{
	int i;
	for(i = 0; i < SYMTABSIZE; i++)
		if(symtab[i].sym[0] &&
		   !(symtab[i].flags & SYM_HALFKILL) &&
		   symtab[i].value == val)
			return symtab[i].sym;
	return nil;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
leaq 0x5776(%rip), %rcx      # 0x8230
xorl %edx, %edx
cmpb $0x0, (%rdx,%rcx)
je 0x2acf
testb $0x1, 0xc(%rdx,%rcx)
jne 0x2acf
cmpl %edi, 0x10(%rdx,%rcx)
je 0x2ade
addq $0x14, %rdx
cmpq $0x5000, %rdx           # imm = 0x5000
jne 0x2abc
jmp 0x2ae4
addq %rdx, %rcx
movq %rcx, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/aap[P]rx-0/common/fe.c
// Function: parsesym
Word
parsesym(void)
{
	Word i;

	if(strcmp(bufstart, ".") == 0)
		return dot;

	for(i = 0; i < SYMTABSIZE; i++)
		if(symtab[i].sym[0] && strcasecmp(bufstart, symtab[i].sym) == 0)
			return symtab[i].value;
	return BUF_ERR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x5729(%rip), %rbx      # 0x8220
leaq 0x2669(%rip), %rsi      # 0x5167
movq %rbx, %rdi
callq 0x21c0
testl %eax, %eax
je 0x2b3f
xorl %r14d, %r14d
leaq 0x571c(%rip), %r15      # 0x8230
cmpb $0x0, (%r14,%r15)
je 0x2b2b
leaq (%r15,%r14), %rsi
movq %rbx, %rdi
callq 0x2060
testl %eax, %eax
je 0x2b48
addq $0x14, %r14
cmpq $0x5000, %r14           # imm = 0x5000
jne 0x2b14
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x2b4d
movzwl 0xa8e2(%rip), %eax      # 0xd428
jmp 0x2b4d
movl 0x10(%r14,%r15), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/aap[P]rx-0/common/fe.c
// Function: parse
int
parse(Word *t)
{
	Word w;

	w = parsenum();
	if(bufstart >= &buf[nbuf])
		return 0;
	if((w = parsenum()) == BUF_ERR && (w = parsesym()) == BUF_ERR)
		err("?U? ");
	nbuf = 0;
	*t = w;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x56bb(%rip), %rcx      # 0x8220
movslq 0xa8b8(%rip), %rax      # 0xd424
leaq 0xa70d(%rip), %rdx      # 0xd280
addq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
jae 0x2bd3
movq %rdi, %rbx
xorl %eax, %eax
movl 0x56a0(%rip), %esi      # 0x8228
movzbl (%rcx), %edi
leal -0x30(%rdi), %r8d
cmpb $0x9, %r8b
ja 0x2bae
imull %esi, %eax
addl %edi, %eax
addl $0x3ffd0, %eax          # imm = 0x3FFD0
andl $0x3ffff, %eax          # imm = 0x3FFFF
incq %rcx
cmpq %rdx, %rcx
jb 0x2b88
jmp 0x2bb3
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $-0x1, %eax
jne 0x2bc2
callq 0x2ae6
cmpl $-0x1, %eax
je 0x2bda
movl $0x0, 0xa858(%rip)      # 0xd424
movl %eax, (%rbx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2588(%rip), %rdi      # 0x5169
callq 0x28c3
leaq 0xa763(%rip), %rdi      # 0xd350
xorl %esi, %esi
callq 0x2290