LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
leaq 0x32f2(%rip), %rsi      # 0xe284
leaq 0x8337(%rip), %rdx      # 0x132d0
callq 0x90fa
movq %rax, %rbx
movq %r15, %rdi
callq 0x4580
movb 0x18(%r14), %bpl
movq %rbx, %rdi
callq 0x42a0
movq %rax, %r14
testb $0x2, %bpl
jne 0xafe6
callq 0x4340
movq 0x7f8e(%rip), %rsi      # 0x12f58
movq 0x8027(%rip), %r8       # 0x12ff8
movl $0x2, %edi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x4140
movq %rax, %r14
movq %rbx, %rdi
callq 0x4580
movq 0x7f2b(%rip), %rbx      # 0x12f20
movl $0x1, %edi
movl $0x38, %esi
callq 0x4280
movq %rax, %r15
movb $0xf, 0x30(%rax)
movq %r14, 0x8(%rax)
movq 0x7f72(%rip), %rax      # 0x12f88
movq %rax, 0x10(%r15)
movl $0x1, %edi
movl $0x38, %esi
callq 0x4280
movq %rax, %r14
movb $0x10, 0x30(%rax)
movq %r15, 0x8(%rax)
movq 0x7f2d(%rip), %rax      # 0x12f68
movq %rax, 0x10(%r14)
leaq 0x3527(%rip), %rax      # 0xe56d
movq %rax, 0x18(%r14)
movl $0x1, %edi
movl $0x38, %esi
callq 0x4280
movb $0x7, 0x30(%rax)
movq 0x7efc(%rip), %rsi      # 0x12f60
movl $0x2, %edi
movq %rax, %rdx
movq %r14, %rcx
movq %rbx, %r8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4140
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
leaq 0x31ed(%rip), %rsi      # 0xe284
leaq 0x8232(%rip), %rdx      # 0x132d0
callq 0x90fa
movq %rax, %rbx
movq %r15, %rdi
callq 0x4580
movb 0x18(%r14), %r15b
movsbl (%rbx), %ebp
movl $0x1, %edi
movl $0x38, %esi
callq 0x4280
movb $0x9, 0x30(%rax)
movb %bpl, 0x8(%rax)
leaq 0x32f2(%rip), %rsi      # 0xe3c5
movq %rax, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x4290
movq %rax, %r14
testb $0x2, %r15b
jne 0xb110
callq 0x4340
movq 0x7e64(%rip), %rsi      # 0x12f58
movq 0x7efd(%rip), %r8       # 0x12ff8
movl $0x2, %edi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x4140
movq %rax, %r14
movq %rbx, %rdi
callq 0x4580
movq 0x7e01(%rip), %rbx      # 0x12f20
movl $0x1, %edi
movl $0x38, %esi
callq 0x4280
movq %rax, %r15
movb $0xf, 0x30(%rax)
movq %r14, 0x8(%rax)
movq 0x7e48(%rip), %rax      # 0x12f88
movq %rax, 0x10(%r15)
movl $0x1, %edi
movl $0x38, %esi
callq 0x4280
movq %rax, %r14
movb $0x10, 0x30(%rax)
movq %r15, 0x8(%rax)
movq 0x7e03(%rip), %rax      # 0x12f68
movq %rax, 0x10(%r14)
leaq 0x33f8(%rip), %rax      # 0xe568
movq %rax, 0x18(%r14)
movl $0x1, %edi
movl $0x38, %esi
callq 0x4280
movb $0x7, 0x30(%rax)
movq 0x7dd2(%rip), %rsi      # 0x12f60
movl $0x2, %edi
movq %rax, %rdx
movq %r14, %rcx
movq %rbx, %r8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4140
// File: /workspace/github_c_makefile_star2_O3/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), %r15
movq 0x8(%rsi), %rbx
movq 0x10(%rsi), %r12
movq %rbx, %rdi
movl $0x6d, %esi
callq 0x4180
xorl %r14d, %r14d
testq %rax, %rax
setne %r14b
movq %rbx, %rdi
movl $0x73, %esi
callq 0x4180
leal 0x2(%r14), %ebp
testq %rax, %rax
cmovel %r14d, %ebp
leaq 0x3099(%rip), %rsi      # 0xe28f
leaq 0x8133(%rip), %rdx      # 0x13330
movq %r15, %rdi
callq 0x90fa
movq %rax, %r14
movq %r15, %rdi
callq 0x4580
movb 0x18(%r12), %r12b
movq %r14, %rdi
movl %ebp, %esi
callq 0x4410
movq %rax, %r15
testb $0x2, %r12b
jne 0xb250
callq 0x4340
movq 0x7d24(%rip), %rsi      # 0x12f58
movq 0x7dbd(%rip), %r8       # 0x12ff8
movl $0x2, %edi
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x4140
movq %rax, %r15
movq %r14, %rdi
callq 0x4580
movq 0x7cc1(%rip), %r14      # 0x12f20
movq %rbx, %rdi
callq 0x4580
movl $0x1, %edi
movl $0x38, %esi
callq 0x4280
movq %rax, %rbx
movb $0xf, 0x30(%rax)
movq %r15, 0x8(%rax)
movq 0x7d00(%rip), %rax      # 0x12f88
movq %rax, 0x10(%rbx)
movl $0x1, %edi
movl $0x38, %esi
callq 0x4280
movq %rax, %r15
movb $0x10, 0x30(%rax)
movq %rbx, 0x8(%rax)
movq 0x7cbb(%rip), %rax      # 0x12f68
movq %rax, 0x10(%r15)
leaq 0x32bc(%rip), %rax      # 0xe574
movq %rax, 0x18(%r15)
movl $0x1, %edi
movl $0x38, %esi
callq 0x4280
movb $0x7, 0x30(%rax)
movq 0x7c8a(%rip), %rsi      # 0x12f60
movl $0x2, %edi
movq %rax, %rdx
movq %r15, %rcx
movq %r14, %r8
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4140
// File: /workspace/github_c_makefile_star2_O3/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 0xd667
movq %rax, %r14
movq %rbx, %rdi
callq 0x4580
movq (%r14), %r15
movl $0x1, %edi
movl $0x38, %esi
callq 0x4280
movq %rax, %rbx
testq %r15, %r15
je 0xb358
movb $0x10, 0x30(%rbx)
movq %r14, 0x8(%rbx)
movq 0x7c84(%rip), %rax      # 0x12fb8
movq %rax, 0x10(%rbx)
movq %r15, 0x18(%rbx)
movl $0x1, %edi
movl $0x38, %esi
callq 0x4280
movb $0xf, 0x30(%rax)
movq %rbx, 0x8(%rax)
movq %rax, %rbx
jmp 0xb360
movb $0xf, 0x30(%rbx)
movq %r14, 0x8(%rbx)
movq 0x7c49(%rip), %rax      # 0x12fb0
movq %rax, 0x10(%rbx)
movl $0x1, %edi
movl $0x38, %esi
callq 0x4280
movb $0x7, 0x30(%rax)
movq 0x7bdb(%rip), %rsi      # 0x12f60
movq 0x7b94(%rip), %r8       # 0x12f20
movl $0x2, %edi
movq %rax, %rdx
movq %rbx, %rcx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x4140
// File: /workspace/github_c_makefile_star2_O3/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 0xb4c4
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 0x3119(%rip), %rdi      # 0xe61e
callq 0x5de1
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0xb53c
movq %rax, %r15
movq %r14, %rdi
callq 0x5c78
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_O3/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 0xbbf6
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 0x29f8(%rip), %rdi      # 0xe62f
callq 0x5ea9
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0xb53c
movq %rax, %r15
movq %r14, %rdi
callq 0x5c78
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_O3/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 0xbcd0
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 0x292f(%rip), %rdi      # 0xe640
callq 0x5bb6
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0xb53c
movq %rax, %r15
movq %r14, %rdi
callq 0x5c78
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_O3/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 0xbdab
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 0x25a3(%rip), %rsi      # 0xe355
movq %r14, %rdi
callq 0x4470
testq %rax, %rax
je 0xbe52
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 0x5de1
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0xb53c
movq %rax, %r12
movq %r14, %rdi
callq 0x5c78
movq 0x10(%r15), %rdi
callq 0x4580
movq %rbx, %rdi
callq 0x4120
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 0x5fb5
// File: /workspace/github_c_makefile_star2_O3/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 0xc5f6
movq 0x70(%rdi), %rax
movq %rax, %rcx
cmpb $0x0, 0x78(%rdi,%rcx)
je 0xc5fe
incl %ecx
andl $0x1ff, %ecx            # imm = 0x1FF
movq %rcx, 0x70(%rdi)
cmpq %rcx, %rax
jne 0xc5de
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_O3/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 0xd0ea
testb %al, %al
je 0xc653
movq %r14, %rdi
callq 0xcfcb
movsbl %al, %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0xd03b
movl $0x1, %eax
jmp 0xc655
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xd0ea
xorl %ebx, %ebx
testb %al, %al
je 0xc6a5
movq %r15, %rdi
callq 0xcfcb
cmpb %bpl, %al
jne 0xc69a
movsbl %bpl, %esi
movq %r15, %rdi
movq %r14, %rdx
callq 0xd03b
movl $0x1, %ebx
jmp 0xc6a5
movsbl %al, %esi
movq %r15, %rdi
callq 0xd1a8
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xd0ea
xorl %ebx, %ebx
testb %al, %al
je 0xc702
movq %r15, %rdi
callq 0xcfcb
cmpb %r12b, %al
setl %cl
cmpb %bpl, %al
setg %dl
movsbl %al, %esi
movq %r15, %rdi
orb %cl, %dl
je 0xc6f5
callq 0xd1a8
jmp 0xc702
movq %r14, %rdx
callq 0xd03b
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xd0ea
xorl %ebx, %ebx
testb %al, %al
je 0xc75c
movq %r15, %rdi
callq 0xcfcb
movsbl %al, %ebp
movq %r12, %rdi
movl %ebp, %esi
callq 0x4180
movq %r15, %rdi
movl %ebp, %esi
testq %rax, %rax
je 0xc757
movq %r14, %rdx
callq 0xd03b
movl $0x1, %ebx
jmp 0xc75c
callq 0xd1a8
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xd0ea
xorl %ebx, %ebx
testb %al, %al
je 0xc80a
movq %r15, %rdi
callq 0xcfcb
movsbl %al, %ebp
movl %ebp, %edi
callq *%r12
movq %r15, %rdi
movl %ebp, %esi
testl %eax, %eax
je 0xc805
movq %r14, %rdx
callq 0xd03b
movl $0x1, %ebx
jmp 0xc80a
callq 0xd1a8
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xcb31
movb (%rbx), %al
testb %al, %al
je 0xc851
leaq 0x1(%rbx), %r12
movsbl %al, %esi
movq %r15, %rdi
xorl %edx, %edx
callq 0xc65d
testl %eax, %eax
je 0xc882
movb (%r12), %al
incq %r12
testb %al, %al
jne 0xc835
movq %r15, %rdi
callq 0xcc1f
movq %rbx, %rdi
callq 0x4130
leaq 0x1(%rax), %rsi
movq %r15, %rdi
callq 0xc5d1
movq %rax, (%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x40b0
movl $0x1, %eax
jmp 0xc88c
movq %r15, %rdi
callq 0xcbce
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xca88
xorl %ebx, %ebx
jmp 0xcb22
movq %rsi, %r15
movq %rdi, %r14
movl $0x48, %edi
callq 0x43a0
movq %rax, %rbx
movq 0x8(%r14), %rdi
callq 0x4130
leaq 0x1(%rax), %rsi
movq %r14, %rdi
callq 0xc5d1
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 0xc5d1
movq %rax, %r12
movq %rax, 0x38(%rbx)
movq %r15, %rdi
callq 0x4130
leaq 0x1(%rax), %rsi
movq %r14, %rdi
callq 0xc5d1
movq %rax, (%r12)
movq %rax, %rdi
movq %r15, %rsi
callq 0x40b0
movq $0x0, 0x30(%rbx)
movq %r14, %rdi
callq 0xd0ea
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_O3/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 0xcbcd
pushq %rbx
movq %rdi, %rbx
movl 0x54(%rdi), %ecx
leal 0x1(%rcx), %eax
movl %eax, 0x54(%rdi)
cmpl 0x50(%rdi), %ecx
jl 0xcb83
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 0x43f0
movq %rax, 0x58(%rbx)
movq 0x60(%rbx), %rdi
movslq 0x50(%rbx), %rsi
callq 0x43f0
movq %rax, 0x60(%rbx)
movl 0x54(%rbx), %eax
movq 0x58(%rbx), %rcx
cltq
shlq $0x5, %rax
movups 0x10(%rbx), %xmm0
movups 0x20(%rbx), %xmm1
movups %xmm1, -0x10(%rcx,%rax)
movups %xmm0, -0x20(%rcx,%rax)
movb 0x68(%rbx), %al
movq 0x60(%rbx), %rcx
movslq 0x54(%rbx), %rdx
movb %al, -0x1(%rcx,%rdx)
cmpl $0x2, (%rbx)
jne 0xcbcc
cmpl $0x1, 0x54(%rbx)
jne 0xcbcc
movl $0x1, %edi
movl $0x1, %esi
callq 0x4280
movq %rax, 0x38(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xcc1e
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 0xcc18
movq 0x10(%rbx), %rsi
movq 0x40(%rbx), %rdi
xorl %edx, %edx
callq 0x43e0
movq %rbx, %rdi
popq %rbx
jmp 0xcc1f
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xccd8
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 0xcc84
movl %eax, %esi
shrl $0x1f, %esi
addl %ecx, %esi
decl %esi
sarl %esi
addl %ecx, %esi
decl %esi
cmpl %esi, %edx
jle 0xcc84
cmpl $0x22, %ecx
movl $0x20, %esi
cmovgel %eax, %esi
movl %esi, 0x50(%rbx)
movq 0x58(%rbx), %rdi
shlq $0x5, %rsi
callq 0x43f0
movq %rax, 0x58(%rbx)
movq 0x60(%rbx), %rdi
movslq 0x50(%rbx), %rsi
callq 0x43f0
movq %rax, 0x60(%rbx)
cmpl $0x2, (%rbx)
jne 0xccd1
cmpl $0x0, 0x54(%rbx)
jne 0xccd1
movq 0x38(%rbx), %r14
movq %r14, %rdi
callq 0x4130
decl %eax
js 0xccc1
movl %eax, %r14d
incq %r14
movq 0x38(%rbx), %rax
movq 0x40(%rbx), %rsi
movsbl -0x1(%rax,%r14), %edi
callq 0x43c0
decq %r14
jne 0xcca5
movq 0x38(%rbx), %r14
movq %r14, %rdi
callq 0x4580
movq $0x0, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xccfc
pushq %rbx
movq %rdx, %rbx
movl $0x30, %esi
callq 0xc5d1
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups %xmm0, (%rax)
movups %xmm1, 0x10(%rax)
popq %rbx
retq
jl 0xcd10
movl %esi, %edx
shrl %edx
addl %esi, %edx
shlq $0x3, %rdx
movq %rcx, %rsi
jmp 0xd20a
movq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc5d1
testq %rax, %rax
je 0xcfab
movq %rax, %r14
leaq 0x1798(%rip), %rsi      # 0xe6fb
movq %rax, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x44c0
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xd3da
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 0xcfb0
movq %r14, %rdi
callq 0x4580
jmp 0xcfbd
xorl %r15d, %r15d
jmp 0xcfbd
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_O3/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 0xcffb
cmpl $0x1, %eax
je 0xcff0
testl %eax, %eax
jne 0xd028
movq 0x10(%rbx), %rax
movq 0x30(%rbx), %rcx
movb (%rcx,%rax), %al
jmp 0xd035
movq 0x40(%rbx), %rdi
callq 0x4230
jmp 0xd035
movq 0x38(%rbx), %r14
testq %r14, %r14
je 0xd02c
movq 0x10(%rbx), %r15
movq %r14, %rdi
callq 0x4130
movq 0x58(%rbx), %rcx
movq (%rcx), %rcx
addq %rcx, %rax
cmpq %rax, %r15
jge 0xd02c
subq %rcx, %r15
movb (%r14,%r15), %al
jmp 0xd035
xorl %eax, %eax
jmp 0xd035
movq 0x40(%rbx), %rdi
callq 0x4540
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xd0a4
movq 0x38(%r14), %r15
testq %r15, %r15
je 0xd0a4
movq 0x10(%r14), %r12
movq %r15, %rdi
callq 0x4130
movq 0x58(%r14), %rcx
movq (%rcx), %rcx
addq %rax, %rcx
cmpq %rcx, %r12
jl 0xd0a4
addq $0x2, %rax
movq %r15, %rdi
movq %rax, %rsi
callq 0x43f0
movq %rax, %r15
movq %rax, 0x38(%r14)
movq %rax, %rdi
callq 0x4130
movb $0x0, 0x1(%r15,%rax)
movq %r15, %rdi
callq 0x4130
movb %bpl, (%r15,%rax)
movb %bpl, 0x68(%r14)
incq 0x10(%r14)
incq 0x20(%r14)
cmpb $0xa, %bpl
jne 0xd0c2
movq $0x0, 0x20(%r14)
incq 0x18(%r14)
testq %rbx, %rbx
je 0xd0e1
movl $0x2, %esi
movq %r14, %rdi
callq 0xc5d1
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_O3/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 0xd145
cmpl $0x1, %eax
je 0xd116
testl %eax, %eax
jne 0xd18a
movq 0x10(%rbx), %rax
movq 0x30(%rbx), %rcx
movb (%rcx,%rax), %bpl
jmp 0xd18c
movq 0x40(%rbx), %rdi
callq 0x4230
movl %eax, %ebp
movq 0x40(%rbx), %rdi
callq 0x4310
testl %eax, %eax
jne 0xd18a
movq 0x40(%rbx), %rdi
movq $-0x1, %rsi
movl $0x1, %edx
callq 0x43e0
jmp 0xd18c
movq 0x38(%rbx), %r14
testq %r14, %r14
je 0xd172
movq 0x10(%rbx), %r15
movq %r14, %rdi
callq 0x4130
movq 0x58(%rbx), %rcx
movq (%rcx), %rcx
addq %rcx, %rax
cmpq %rax, %r15
jge 0xd172
subq %rcx, %r15
movb (%r14,%r15), %bpl
jmp 0xd18c
movq 0x40(%rbx), %rdi
callq 0x4540
movl %eax, %ebp
movq 0x40(%rbx), %rdi
callq 0x4310
testl %eax, %eax
je 0xd199
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 0x43c0
jmp 0xd18c
// File: /workspace/github_c_makefile_star2_O3/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 0xd1d4
cmpl $0x1, %eax
jne 0xd1f4
movq 0x40(%rbx), %rdi
movq $-0x1, %rsi
movl $0x1, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x43e0
movl %esi, %ebp
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0xd1f9
movq 0x10(%rbx), %r14
callq 0x4130
movq 0x58(%rbx), %rcx
addq (%rcx), %rax
cmpq %rax, %r14
jge 0xd1f9
popq %rbx
popq %r14
popq %rbp
retq
movsbl %bpl, %edi
movq 0x40(%rbx), %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x43c0
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rsi, %rbx
leaq 0x278(%rdi), %r15
cmpq %rsi, %r15
seta %al
leaq 0x8278(%rdi), %rcx
cmpq %rsi, %rcx
setbe %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0xd243
movq %rbx, %rdi
movq %rdx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x43f0
cmpq $0x41, %rdx
jb 0xd282
movq %rdi, %r14
movq %rdx, %rdi
callq 0x43a0
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)
subq %r15, %rbx
shrq $0x6, %rbx
movb $0x0, 0x78(%r14,%rbx)
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xd2c6
movq %rdx, %r14
movl %esi, %ebp
movl %esi, %r12d
jle 0xd2d8
xorl %r13d, %r13d
xorl %r15d, %r15d
movq (%r14,%r13,8), %rdi
callq 0x4130
addq %rax, %r15
incq %r13
cmpq %r13, %r12
jne 0xd2ad
incq %r15
jmp 0xd2de
movl $0x1, %esi
movq %rbx, %rdi
callq 0xc5d1
movb $0x0, (%rax)
jmp 0xd348
movl $0x1, %r15d
movq (%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0xd20a
movq %rax, (%r14)
cmpl $0x2, %ebp
jl 0xd348
leaq 0x278(%rbx), %r15
leaq 0x8278(%rbx), %r13
movl $0x1, %ebp
movq (%r14), %rdi
movq (%r14,%rbp,8), %rsi
callq 0x44b0
movq (%r14,%rbp,8), %rdi
cmpq %rdi, %r15
seta %al
cmpq %rdi, %r13
setbe %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0xd331
callq 0x4580
jmp 0xd33d
subq %r15, %rdi
shrq $0x6, %rdi
movb $0x0, 0x78(%rbx,%rdi)
incq %rbp
cmpq %rbp, %r12
jne 0xd307
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_O3/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 0xd8bb
leaq 0x8(%rbx), %r15
movq (%r14), %rdi
callq 0x4580
movq 0x8(%r14), %rdi
callq 0x4580
movq 0x10(%r14), %rdi
xorl %esi, %esi
callq 0x606a
movq %r14, %rdi
callq 0x4580
movq (%r15), %r14
addq $0x8, %r15
testq %r14, %r14
jne 0xd88b
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x4580
// File: /workspace/github_c_makefile_star2_O3/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 0xd976
movq %rsi, %r14
leaq 0x8(%rbx), %r13
movq (%r15), %rdi
movq %r14, %rsi
callq 0xd667
movq %rax, %r12
testb $0x1, 0x18(%r14)
je 0xd91d
movq 0x10(%r15), %rbp
movl $0x1, %edi
movl $0x38, %esi
callq 0x4280
movb $0x11, 0x30(%rax)
movq %rbp, 0x8(%rax)
movq %rax, 0x10(%r15)
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdi
testq %rsi, %rsi
je 0xd936
callq 0x4520
movq %rax, %rdi
movq %rax, 0x10(%r15)
movl $0x1, %esi
callq 0xbfc5
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 0xd8e9
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_O3/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
movups (%rbx), %xmm0
movups %xmm0, (%rax)
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_O3/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 0x267a
movl $0xa, %edi
callq 0x2050
callq 0x4c1e
xorl %edi, %edi
callq 0x2330
// File: /workspace/github_c_makefile_star2_O3/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 0x22b0
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testl %eax, %eax
js 0x266d
leaq -0x54(%rbp), %r15
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups 0x2c(%r15), %xmm3
movups %xmm3, 0xac41(%rip)     # 0xd26c
movups %xmm2, 0xac2e(%rip)     # 0xd260
movups %xmm1, 0xac17(%rip)     # 0xd250
movups %xmm0, 0xac00(%rip)     # 0xd240
movq %r15, %rdi
callq 0x2240
orb $0x5, 0x4(%r15)
movl %r14d, %edi
movl $0x2, %esi
movq %r15, %rdx
callq 0x22c0
testl %eax, %eax
js 0x266d
movl $0x1, 0xac11(%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_O3/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 0x272f
movsbl %bl, %eax
leal -0x8(%rax), %ecx
cmpl $0x3, %ecx
jb 0x272f
cmpl $0xd, %eax
je 0x272f
cmpl $0x1b, %eax
jne 0x2749
leaq 0x2a3b(%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 0x2a09(%rip), %rsi      # 0x5159
movl $0x3, %edx
movl $0x1, %edi
callq 0x20d0
addb $0x40, %bl
leaq -0x9(%rbp), %rsi
movb %bl, (%rsi)
jmp 0x2733
// File: /workspace/github_c_makefile_star2_O3/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 0x5aae(%rip), %r14d     # 0x8228
cmpl %edi, %r14d
ja 0x278d
movl %ebx, %eax
xorl %edx, %edx
divl %r14d
movl %eax, %edi
callq 0x276a
movl %ebx, %eax
xorl %edx, %edx
divl %r14d
addb $0x30, %dl
movsbl %dl, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x26ee
// File: /workspace/github_c_makefile_star2_O3/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 0x594f(%rip), %rcx      # 0x8220
movslq 0xab4c(%rip), %rax      # 0xd424
leaq 0xa9a1(%rip), %rdx      # 0xd280
addq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
jae 0x2921
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movl 0x5933(%rip), %esi      # 0x8228
movzbl (%rcx), %edi
leal -0x30(%rdi), %r8d
cmpb $0x9, %r8b
ja 0x291b
imull %esi, %eax
addl %edi, %eax
addl $0x3ffd0, %eax          # imm = 0x3FFD0
andl $0x3ffff, %eax          # imm = 0x3FFFF
incq %rcx
cmpq %rdx, %rcx
jb 0x28f5
jmp 0x2920
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x58f5(%rip), %r15      # 0x8230
cmpb $0x0, (%r14,%r15)
je 0x2969
addq $0x14, %r14
cmpq $0x5000, %r14           # imm = 0x5000
jne 0x293b
leaq 0x2807(%rip), %rdi      # 0x515d
callq 0x27a3
leaq 0xa9ee(%rip), %rdi      # 0xd350
xorl %esi, %esi
callq 0x2280
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_O3/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 0x5896(%rip), %rcx      # 0x8230
xorl %edx, %edx
cmpb $0x0, (%rdx,%rcx)
je 0x29af
testb $0x1, 0xc(%rdx,%rcx)
jne 0x29af
cmpl %edi, 0x10(%rdx,%rcx)
je 0x29be
addq $0x14, %rdx
cmpq $0x5000, %rdx           # imm = 0x5000
jne 0x299c
jmp 0x29c4
addq %rdx, %rcx
movq %rcx, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5849(%rip), %rbx      # 0x8220
cmpb $0x2e, (%rbx)
jne 0x29e2
cmpb $0x0, 0x1(%rbx)
je 0x2a1e
xorl %r14d, %r14d
leaq 0x5844(%rip), %r15      # 0x8230
cmpb $0x0, (%r14,%r15)
je 0x2a03
leaq (%r15,%r14), %rsi
movq %rbx, %rdi
callq 0x2060
testl %eax, %eax
je 0x2a17
addq $0x14, %r14
cmpq $0x5000, %r14           # imm = 0x5000
jne 0x29ec
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x2a25
movl 0x10(%r14,%r15), %eax
jmp 0x2a25
movzwl 0xaa03(%rip), %eax      # 0xd428
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x57e3(%rip), %rcx      # 0x8220
movslq 0xa9e0(%rip), %rax      # 0xd424
leaq 0xa835(%rip), %rdx      # 0xd280
addq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
jae 0x2aa1
movq %rdi, %rbx
xorl %eax, %eax
movl 0x57c8(%rip), %esi      # 0x8228
movzbl (%rcx), %edi
leal -0x30(%rdi), %r8d
cmpb $0x9, %r8b
ja 0x2a86
imull %esi, %eax
addl %edi, %eax
addl $0x3ffd0, %eax          # imm = 0x3FFD0
andl $0x3ffff, %eax          # imm = 0x3FFFF
incq %rcx
cmpq %rdx, %rcx
jb 0x2a60
jmp 0x2a90
callq 0x29c6
cmpl $-0x1, %eax
je 0x2aa8
movl $0x0, 0xa98a(%rip)      # 0xd424
movl %eax, (%rbx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x26b8(%rip), %rdi      # 0x5167
callq 0x27a3
leaq 0xa895(%rip), %rdi      # 0xd350
xorl %esi, %esi
callq 0x2280
// File: /workspace/github_c_makefile_star2_O3/aap[P]rx-0/common/fe.c
// Function: combine
void
combine(Word t)
{
	switch(as.op){
	case '+':
	default:
		as.exp += t;
		break;
	case '-':
		as.exp += ~t;
		break;
	case '*':
		as.exp *= t;
		break;
	case '|':
		as.exp /= t;
		break;
	}
	as.gotexp = 1;
	as.op = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0xa949(%rip), %eax      # 0xd430
cmpl $0x2a, %eax
je 0x2b0e
cmpl $0x2d, %eax
je 0x2b04
cmpl $0x7c, %eax
jne 0x2b06
movl 0xa930(%rip), %eax      # 0xd42c
xorl %edx, %edx
divl %edi
movl %eax, %edi
jmp 0x2b15
notl %edi
addl 0xa920(%rip), %edi      # 0xd42c
jmp 0x2b15
imull 0xa917(%rip), %edi      # 0xd42c
movl %edi, 0xa911(%rip)      # 0xd42c
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0xa904(%rip)      # 0xd430
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/aap[P]rx-0/common/fe.c
// Function: endword
int
endword(Word *w)
{
	Word t;

	if(!parse(&t)){
		if(!as.gotexp)
			return 0;
		t = 0;
	}
	combine(t);
	t = as.exp;
	t &= WORDMASK;
	*w = t;
	resetexp();
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq -0xc(%rbp), %rdi
callq 0x2a30
testl %eax, %eax
je 0x2b49
movl -0xc(%rbp), %eax
jmp 0x2b54
xorl %eax, %eax
cmpl $0x0, 0xa8e2(%rip)      # 0xd434
je 0x2b82
movl %eax, %edi
callq 0x2add
movl $0x3ffff, %eax          # imm = 0x3FFFF
andl 0xa8c6(%rip), %eax      # 0xd42c
movl %eax, (%rbx)
movq $0x0, 0xa8b9(%rip) # 0xd42c
movl $0x0, 0xa8b7(%rip)      # 0xd434
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/aap[P]rx-0/common/fe.c
// Function: prword
void
prword(int mode, Word wd)
{
	switch(mode){
	case MODE_SYM:
		typestr(disasm(wd));
		break;

	default:
		typenum(wd);
	}
}

// Assembly:
cmpl $0x2, %edi
jne 0x2bbf
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %esi, %edi
callq 0x4207
movq %rax, %rbx
movb (%rax), %al
testb %al, %al
je 0x2bb8
incq %rbx
movsbl %al, %edi
callq 0x26ee
movb (%rbx), %al
incq %rbx
testb %al, %al
jne 0x2ba7
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl %esi, %edi
jmp 0x276a
// File: /workspace/github_c_makefile_star2_O3/aap[P]rx-0/common/fe.c
// Function: symaddr
char*
symaddr(Addr a)
{
	static char s[100];
	char *p, *sym;
	p = s;
	memset(s, 0, 100);
	sym = a == 0 ? nil : findsym(a);
	if(sym)
		p += sprintf(p, "%s", sym);
	else
		p += sprintf(p, "%o", a);
	return s;
}

// Assembly:
movl %edi, %edx
xorps %xmm0, %xmm0
movaps %xmm0, 0xa8be(%rip)     # 0xd490
movaps %xmm0, 0xa8a7(%rip)     # 0xd480
movaps %xmm0, 0xa890(%rip)     # 0xd470
movaps %xmm0, 0xa879(%rip)     # 0xd460
movaps %xmm0, 0xa862(%rip)     # 0xd450
movaps %xmm0, 0xa84b(%rip)     # 0xd440
movl $0x0, 0xa8a1(%rip)      # 0xd4a0
testl %edi, %edi
je 0x2c2b
xorl %eax, %eax
leaq 0x5624(%rip), %rsi      # 0x8230
cmpb $0x0, (%rax,%rsi)
je 0x2c1f
testb $0x1, 0xc(%rax,%rsi)
jne 0x2c1f
cmpl %edx, 0x10(%rax,%rsi)
je 0x2c53
addq $0x14, %rax
cmpq $0x5000, %rax           # imm = 0x5000
jne 0x2c0c
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0xa808(%rip), %rbx      # 0xd440
leaq 0x2660(%rip), %rsi      # 0x529f
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2320
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
addq %rax, %rsi
leaq 0xa7e3(%rip), %rdi      # 0xd440
jmp 0x2090