LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/token.c
// Function: start_with
static bool start_with(char* s1, char* s2) {
  while (*s1 != '\0' && *s2 != '\0') {
    if (*s1 == *s2) {
      s1++;
      s2++;
    } else {
      return false;
    }
  }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0xf59d
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xf5a6
jmp 0xf5da
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movq -0x18(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0xf5d2
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xf5d8
movb $0x0, -0x1(%rbp)
jmp 0xf5de
jmp 0xf57c
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/token.c
// Function: new_token
static Token* new_token(enum TokenTag tag, char* start) {
  Token* t = calloc(1, sizeof(Token));
  t->tag = tag;
  t->source = src;
  t->start = start;
  t->bol = bol;
  return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, %edi
movl $0x38, %esi
callq 0x20d0
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq 0x80b5(%rip), %rcx      # 0x176d8
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movb 0x7cf3(%rip), %cl       # 0x17330
movq -0x18(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x30(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/token.c
// Function: read_include_path
static char* read_include_path(void) {
  StringBuilder* sb = new_sb();

  if (*cur != '"' && *cur != '<') {
    print_line(src, cur);
    error("expected \" or <, but actual %c\n", *cur);
  }
  consume();

  while (*cur != '"' && *cur != '>') {
    sb_putc(sb, *cur);
    consume();
  }

  consume();
  return sb_run(sb);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0xfcd0
movq %rax, -0x8(%rbp)
movq 0x8068(%rip), %rax      # 0x176e0
movsbl (%rax), %eax
cmpl $0x22, %eax
je 0xf6ba
movq 0x8059(%rip), %rax      # 0x176e0
movsbl (%rax), %eax
cmpl $0x3c, %eax
je 0xf6ba
movq 0x8042(%rip), %rdi      # 0x176d8
movq 0x8043(%rip), %rsi      # 0x176e0
callq 0xec40
movq 0x8037(%rip), %rax      # 0x176e0
movsbl (%rax), %esi
leaq 0x400b(%rip), %rdi      # 0x136be
movb $0x0, %al
callq 0xfb50
callq 0xf970
movq 0x801a(%rip), %rax      # 0x176e0
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x22, %ecx
movb %al, -0x9(%rbp)
je 0xf6e6
movq 0x8006(%rip), %rax      # 0x176e0
movsbl (%rax), %eax
cmpl $0x3e, %eax
setne %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0xf6ef
jmp 0xf709
movq -0x8(%rbp), %rdi
movq 0x7fe6(%rip), %rax      # 0x176e0
movsbl (%rax), %esi
callq 0xfd30
callq 0xf970
jmp 0xf6bf
callq 0xf970
movq -0x8(%rbp), %rdi
callq 0xfe20
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/token.c
// Function: integer
static Token* integer(char* start) {
  Token* t = new_token(TINT, start);
  t->integer = 0;
  while (isdigit(*cur)) {
    t->integer = t->integer * 10 + (*cur - '0');
    consume();
  }
  return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
xorl %edi, %edi
callq 0xf5f0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, 0xc(%rax)
callq 0x2170
movq (%rax), %rax
movq 0x7f8b(%rip), %rcx      # 0x176e0
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0xf78e
movq -0x10(%rbp), %rax
imull $0xa, 0xc(%rax), %ecx
movq 0x7f68(%rip), %rax      # 0x176e0
movsbl (%rax), %eax
subl $0x30, %eax
addl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
callq 0xf970
jmp 0xf746
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/token.c
// Function: read_char
static char read_char(void) {
  char c;
  if (*cur == '\\') {
    consume();
    switch (*cur) {
    case 'a':
      c = '\a';
      break;
    case 'b':
      c = '\b';
      break;
    case 'f':
      c = '\f';
      break;
    case 'n':
      c = '\n';
      break;
    case 'r':
      c = '\r';
      break;
    case 't':
      c = '\t';
      break;
    case 'v':
      c = '\v';
      break;
    case '\\':
      c = '\\';
      break;
    case '\'':
      c = '\'';
      break;
    case '\"':
      c = '\"';
      break;
    case '0':
      c = '\0';
      break;
    default:
      print_line(src, cur);
      error("invalid escape sequence: %c\n", *cur);
    }
  } else {
    c = *cur;
  }
  consume();
  return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x7ef1(%rip), %rax      # 0x176e0
movsbl (%rax), %eax
cmpl $0x5c, %eax
jne 0xf89b
callq 0xf970
movq 0x7ed9(%rip), %rax      # 0x176e0
movsbl (%rax), %eax
addl $-0x22, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x54, %eax
ja 0xf86e
movq -0x10(%rbp), %rax
leaq 0x3c9d(%rip), %rcx      # 0x134c0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x7, -0x1(%rbp)
jmp 0xf899
movb $0x8, -0x1(%rbp)
jmp 0xf899
movb $0xc, -0x1(%rbp)
jmp 0xf899
movb $0xa, -0x1(%rbp)
jmp 0xf899
movb $0xd, -0x1(%rbp)
jmp 0xf899
movb $0x9, -0x1(%rbp)
jmp 0xf899
movb $0xb, -0x1(%rbp)
jmp 0xf899
movb $0x5c, -0x1(%rbp)
jmp 0xf899
movb $0x27, -0x1(%rbp)
jmp 0xf899
movb $0x22, -0x1(%rbp)
jmp 0xf899
movb $0x0, -0x1(%rbp)
jmp 0xf899
movq 0x7e63(%rip), %rdi      # 0x176d8
movq 0x7e64(%rip), %rsi      # 0x176e0
callq 0xec40
movq 0x7e58(%rip), %rax      # 0x176e0
movsbl (%rax), %esi
leaq 0x3f2f(%rip), %rdi      # 0x137c1
movb $0x0, %al
callq 0xfb50
jmp 0xf8a7
movq 0x7e3e(%rip), %rax      # 0x176e0
movb (%rax), %al
movb %al, -0x1(%rbp)
callq 0xf970
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/token.c
// Function: ident
static Token* ident(char* start) {
  Token* t = new_token(TIDENT, start);
  StringBuilder* sb = new_sb();
  while (isalnum(*cur) || *cur == '_') {
    sb_putc(sb, *cur);
    consume();
  }
  t->ident = sb_run(sb);
  return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movl $0x2, %edi
callq 0xf5f0
movq %rax, -0x10(%rbp)
callq 0xfcd0
movq %rax, -0x18(%rbp)
callq 0x2170
movq (%rax), %rax
movq 0x7dea(%rip), %rcx      # 0x176e0
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %ecx
andl $0x8, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
jne 0xf920
movq 0x7dcc(%rip), %rax      # 0x176e0
movsbl (%rax), %eax
cmpl $0x5f, %eax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xf929
jmp 0xf943
movq -0x18(%rbp), %rdi
movq 0x7dac(%rip), %rax      # 0x176e0
movsbl (%rax), %esi
callq 0xfd30
callq 0xf970
jmp 0xf8e7
movq -0x18(%rbp), %rdi
callq 0xfe20
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/token.c
// Function: consume
static void consume() {
  if (*cur == '\n' || *cur == '\r') {
    bol = true;
  } else if (!(*cur == ' ' || *cur == '\t')) {
    bol = false;
  }
  cur++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x7d65(%rip), %rax      # 0x176e0
movsbl (%rax), %eax
cmpl $0xa, %eax
je 0xf992
movq 0x7d56(%rip), %rax      # 0x176e0
movsbl (%rax), %eax
cmpl $0xd, %eax
jne 0xf99b
movb $0x1, 0x7997(%rip)      # 0x17330
jmp 0xf9c2
movq 0x7d3e(%rip), %rax      # 0x176e0
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0xf9c0
movq 0x7d2f(%rip), %rax      # 0x176e0
movsbl (%rax), %eax
cmpl $0x9, %eax
je 0xf9c0
movb $0x0, 0x7970(%rip)      # 0x17330
jmp 0xf9c2
movq 0x7d17(%rip), %rax      # 0x176e0
addq $0x1, %rax
movq %rax, 0x7d0c(%rip)      # 0x176e0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/utils.c
// Function: format
char* format(const char *fmt, ...) {
#endif
  char* buf = calloc(2048, sizeof(char));
  va_list ap;
  va_start(ap, fmt);
  vsnprintf(buf, 2048, fmt, ap);
  va_end(ap);
  return realloc(buf, sizeof(char) * (strlen(buf) + 1));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0xfaa8
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rsi, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movl $0x800, %edi            # imm = 0x800
movq %rdi, -0xf0(%rbp)
movl $0x1, %esi
callq 0x20d0
movq -0xf0(%rbp), %rsi
movq %rax, -0x10(%rbp)
leaq -0xe0(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x8, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0x2050
movq -0x10(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x2070
movq -0xe8(%rbp), %rdi
movq %rax, %rsi
incq %rsi
callq 0x2120
addq $0xf0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/utils.c
// Function: error
void error(const char *fmt, ...) {
#endif
  va_list ap;
  va_start(ap, fmt);
  vfprintf(stderr, fmt, ap);
  va_end(ap);
  exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0xfb85
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)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x7421(%rip), %rax      # 0x16ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x2150
leaq -0x20(%rbp), %rax
movl $0x1, %edi
callq 0x2160
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/utils.c
// Function: new_sb
StringBuilder* new_sb(void) {
  StringBuilder* sb = calloc(1, sizeof(StringBuilder));
  sb->buf = calloc(8, sizeof(char));
  sb->capacity = 8;
  sb->length = 0;
  return sb;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
movl $0x18, %esi
callq 0x20d0
movq %rax, -0x8(%rbp)
movl $0x8, %edi
movl $0x1, %esi
callq 0x20d0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq $0x8, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/utils.c
// Function: sb_putc
void sb_putc(StringBuilder* sb, char c) {
  while (sb->length >= sb->capacity) {
    sb->capacity += 8;
    sb->buf = realloc(sb->buf, sizeof(char) * sb->capacity);
  }
  sb->buf[sb->length] = c;
  sb->length++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jb 0xfd88
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x8, %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
shlq $0x0, %rsi
callq 0x2120
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0xfd42
movb -0x9(%rbp), %dl
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/utils.c
// Function: sb_run
char* sb_run(StringBuilder* sb) {
  sb_putc(sb, '\0');
  char* ret = sb->buf;
  sb_destory(sb);
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0xfd30
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xfe60
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/utils.c
// Function: dump_token
void dump_token(Token* tok) {
  switch (tok->tag) {
  case TINT: {
    eprintf("%d", tok->integer);
    break;
  }
  case TSTRING: {
    eprintf("\"%s\"", tok->str);
    break;
  }
  case TIDENT: {
    eprintf("%s", tok->ident);
    break;
  }
  case TRESERVED: {
    eprintf("_%s_", tok->ident);
    break;
  }
  case TDIRECTIVE: {
    eprintf("#%s", tok->ident);
    break;
  }
  }
  if (tok->next != NULL) {
    eprintf(" ");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movq %rax, -0x10(%rbp)
subq $0x4, %rax
ja 0xff7a
movq -0x10(%rbp), %rax
leaq 0x38e4(%rip), %rcx      # 0x137e0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movl 0xc(%rax), %esi
leaq 0x2aa0(%rip), %rdi      # 0x129b3
movb $0x0, %al
callq 0xfc00
jmp 0xff7a
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
leaq 0x3985(%rip), %rdi      # 0x138b0
movb $0x0, %al
callq 0xfc00
jmp 0xff7a
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x3137(%rip), %rdi      # 0x1307a
movb $0x0, %al
callq 0xfc00
jmp 0xff7a
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x395a(%rip), %rdi      # 0x138b5
movb $0x0, %al
callq 0xfc00
jmp 0xff7a
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x3947(%rip), %rdi      # 0x138ba
movb $0x0, %al
callq 0xfc00
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0xff92
leaq 0x2298(%rip), %rdi      # 0x12223
movb $0x0, %al
callq 0xfc00
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/utils.c
// Function: show_type_
static void show_type_(StringBuilder* sb, Type* ty) {
  if (ty == NULL) {
    sb_puts(sb, "NULL");
    return;
  }

  switch (ty->ty) {
  case TY_VOID:
    sb_puts(sb, "void");
    break;
  case TY_CHAR:
    sb_puts(sb, "char");
    break;
  case TY_INT:
    sb_puts(sb, "int");
    break;
  case TY_LONG:
    sb_puts(sb, "long");
    break;
  case TY_PTR:
    if (ty->array_size) {
      sb_puts(sb, "array(");
      show_type_(sb, ty->ptr_to);
      sb_puts(sb, format(", %zu)", ty->array_size));
    } else {
      sb_puts(sb, "ptr(");
      show_type_(sb, ty->ptr_to);
      sb_puts(sb, ")");
    }
    break;
  case TY_STRUCT: {
    if (ty->tag) {
      sb_puts(sb, format("struct %s", ty->tag));
    } else {
      sb_puts(sb, "struct");
    }

    // 以下のコードは無限ループを引き起こす
    /* sb_puts(sb, format("struct %s {", ty->tag)); */
    /* for (Field* f = ty->fields; f != NULL; f = f->next) { */
    /*   sb_puts(sb, format("%s(+%zu) : ", f->name, f->offset)); */
    /*   show_type_(sb, f->type, ty->tag); */
    /*   sb_puts(sb, ","); */
    /* } */
    /* sb_puts(sb, "}"); */
    break;
  }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1000c
movq -0x8(%rbp), %rdi
leaq 0x39b6(%rip), %rsi      # 0x139b8
callq 0xfdc0
jmp 0x1015c
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x18(%rbp)
subq $0x5, %rax
ja 0x1015c
movq -0x18(%rbp), %rax
leaq 0x37c9(%rip), %rcx      # 0x137f4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
leaq 0x31cf(%rip), %rsi      # 0x1320e
callq 0xfdc0
jmp 0x1015c
movq -0x8(%rbp), %rdi
leaq 0x31bf(%rip), %rsi      # 0x13213
callq 0xfdc0
jmp 0x1015c
movq -0x8(%rbp), %rdi
leaq 0x31af(%rip), %rsi      # 0x13218
callq 0xfdc0
jmp 0x1015c
movq -0x8(%rbp), %rdi
leaq 0x319e(%rip), %rsi      # 0x1321c
callq 0xfdc0
jmp 0x1015c
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x100e0
movq -0x8(%rbp), %rdi
leaq 0x391f(%rip), %rsi      # 0x139bd
callq 0xfdc0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0xffe0
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
leaq 0x38f9(%rip), %rdi      # 0x139c4
movb $0x0, %al
callq 0xfa70
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0xfdc0
jmp 0x10111
movq -0x8(%rbp), %rdi
leaq 0x38e0(%rip), %rsi      # 0x139cb
callq 0xfdc0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0xffe0
movq -0x8(%rbp), %rdi
leaq 0x31f6(%rip), %rsi      # 0x13302
callq 0xfdc0
jmp 0x1015c
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x1014a
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
leaq 0x389b(%rip), %rdi      # 0x139d0
movb $0x0, %al
callq 0xfa70
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0xfdc0
jmp 0x1015a
movq -0x8(%rbp), %rdi
leaq 0x30f6(%rip), %rsi      # 0x1324b
callq 0xfdc0
jmp 0x1015c
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/utils.c
// Function: dump_function
void dump_function(Function* func) {
  eprintf("%s ", func->name);
  eprintf("(");
  for (size_t i = 0; i < func->params->length; i++) {
    if (i != 0)
      eprintf(", ");
    dump_type(((Node*)func->params->ptr[i])->type);
    eprintf(" %s", ((Node*)func->params->ptr[i])->name);
  }
  eprintf(")\n");

  if (func->body)
    dump_node(func->body, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq 0x23d1(%rip), %rdi      # 0x133cb
movb $0x0, %al
callq 0xfc00
leaq 0x29c6(%rip), %rdi      # 0x139ce
movb $0x0, %al
callq 0xfc00
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x10(%rcx), %rax
jae 0x1108d
cmpq $0x0, -0x10(%rbp)
je 0x1103e
leaq 0x297e(%rip), %rdi      # 0x139b5
movb $0x0, %al
callq 0xfc00
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rdi
callq 0x10170
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x40(%rax), %rsi
leaq 0x2001(%rip), %rdi      # 0x13079
movb $0x0, %al
callq 0xfc00
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x11017
leaq 0x2912(%rip), %rdi      # 0x139a6
movb $0x0, %al
callq 0xfc00
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x110b8
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl $0x1, %esi
callq 0x101a0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/codeplea[P]tinyexpr/smoke.c
// Function: test_combinatorics
void test_combinatorics() {
    test_case cases[] = {
            {"fac(0)", 1},
            {"fac(0.2)", 1},
            {"fac(1)", 1},
            {"fac(2)", 2},
            {"fac(3)", 6},
            {"fac(4.8)", 24},
            {"fac(10)", 3628800},

            {"ncr(0,0)", 1},
            {"ncr(10,1)", 10},
            {"ncr(10,0)", 1},
            {"ncr(10,10)", 1},
            {"ncr(16,7)", 11440},
            {"ncr(16,9)", 11440},
            {"ncr(100,95)", 75287520},

            {"npr(0,0)", 1},
            {"npr(10,1)", 10},
            {"npr(10,0)", 1},
            {"npr(10,10)", 3628800},
            {"npr(20,5)", 1860480},
            {"npr(100,4)", 94109400},
    };


    int i;
    for (i = 0; i < sizeof(cases) / sizeof(test_case); ++i) {
        const char *expr = cases[i].expr;
        const double answer = cases[i].answer;

        int err;
        const double ev = te_interp(expr, &err);
        lok(!err);
        lfequal(ev, answer);

        if (err) {
            printf("FAILED: %s (%d)\n", expr, err);
        }
    }
}

// Assembly:
subq $0x178, %rsp            # imm = 0x178
leaq 0x30(%rsp), %rdi
leaq 0x74ed(%rip), %rsi      # 0xe970
movl $0x140, %edx            # imm = 0x140
callq 0x30e0
movl $0x0, 0x2c(%rsp)
movslq 0x2c(%rsp), %rax
cmpq $0x14, %rax
jae 0x75e6
movslq 0x2c(%rsp), %rcx
leaq 0x30(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movslq 0x2c(%rsp), %rcx
leaq 0x30(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x14(%rsp), %rsi
callq 0x9300
movsd %xmm0, 0x8(%rsp)
movl 0x7c08(%rip), %eax      # 0xf0fc
addl $0x1, %eax
movl %eax, 0x7bff(%rip)      # 0xf0fc
cmpl $0x0, 0x14(%rsp)
je 0x752d
movl 0x7bf6(%rip), %eax      # 0xf100
addl $0x1, %eax
movl %eax, 0x7bed(%rip)      # 0xf100
leaq 0x3e93(%rip), %rdi      # 0xb3ad
leaq 0x3e9a(%rip), %rsi      # 0xb3bb
movl $0x2ab, %edx            # imm = 0x2AB
movb $0x0, %al
callq 0x3080
jmp 0x752f
jmp 0x7531
movl 0x7bc5(%rip), %eax      # 0xf0fc
addl $0x1, %eax
movl %eax, 0x7bbc(%rip)      # 0xf0fc
movsd 0x8(%rsp), %xmm0
subsd 0x18(%rsp), %xmm0
movaps 0x3b2d(%rip), %xmm1     # 0xb080
pand %xmm1, %xmm0
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm0
movsd 0x3a9f(%rip), %xmm1     # 0xb008
ucomisd %xmm1, %xmm0
ja 0x757f
movsd (%rsp), %xmm0
ucomisd (%rsp), %xmm0
jne 0x757f
jp 0x757f
jmp 0x75b4
movl 0x7b7b(%rip), %eax      # 0xf100
addl $0x1, %eax
movl %eax, 0x7b72(%rip)      # 0xf100
movsd 0x8(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
leaq 0x3e22(%rip), %rdi      # 0xb3c3
leaq 0x3e13(%rip), %rsi      # 0xb3bb
movl $0x2ac, %edx            # imm = 0x2AC
movb $0x2, %al
callq 0x3080
jmp 0x75b6
cmpl $0x0, 0x14(%rsp)
je 0x75d4
movq 0x20(%rsp), %rsi
movl 0x14(%rsp), %edx
leaq 0x3e08(%rip), %rdi      # 0xb3d5
movb $0x0, %al
callq 0x3080
jmp 0x75d6
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x7495
addq $0x178, %rsp            # imm = 0x178
retq
nop
// File: /workspace/github_c_makefile_star2_O0/codeplea[P]tinyexpr/tinyexpr.c
// Function: te_free_parameters
void te_free_parameters(te_expr *n) {
    if (!n) return;
    switch (TYPE_MASK(n->type)) {
        case TE_FUNCTION7: case TE_CLOSURE7: te_free(n->parameters[6]);     /* Falls through. */
        case TE_FUNCTION6: case TE_CLOSURE6: te_free(n->parameters[5]);     /* Falls through. */
        case TE_FUNCTION5: case TE_CLOSURE5: te_free(n->parameters[4]);     /* Falls through. */
        case TE_FUNCTION4: case TE_CLOSURE4: te_free(n->parameters[3]);     /* Falls through. */
        case TE_FUNCTION3: case TE_CLOSURE3: te_free(n->parameters[2]);     /* Falls through. */
        case TE_FUNCTION2: case TE_CLOSURE2: te_free(n->parameters[1]);     /* Falls through. */
        case TE_FUNCTION1: case TE_CLOSURE1: te_free(n->parameters[0]);
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x7da6
jmp 0x7e36
movq 0x10(%rsp), %rax
movl (%rax), %eax
andl $0x1f, %eax
addl $-0x9, %eax
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
subl $0xe, %eax
ja 0x7e36
movq 0x8(%rsp), %rax
leaq 0x3b59(%rip), %rcx      # 0xb924
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x7e40
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x7e40
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x7e40
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x7e40
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x7e40
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x7e40
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x7e40
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/codeplea[P]tinyexpr/tinyexpr.c
// Function: find_lookup
static const te_variable *find_lookup(const state *s, const char *name, int len) {
    int iters;
    const te_variable *var;
    if (!s->lookup) return 0;

    for (var = s->lookup, iters = s->lookup_len; iters; ++var, --iters) {
        if (strncmp(name, var->name, len) == 0 && var->name[len] == '\0') {
            return var;
        }
    }
    return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movq 0x18(%rsp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x8239
movq $0x0, 0x20(%rsp)
jmp 0x82b8
movq 0x18(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
movl 0x30(%rax), %eax
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x8(%rsp)
je 0x82af
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movq (%rax), %rsi
movslq 0xc(%rsp), %rdx
callq 0x3040
cmpl $0x0, %eax
jne 0x8294
movq (%rsp), %rax
movq (%rax), %rax
movslq 0xc(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x8294
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x82b8
jmp 0x8296
movq (%rsp), %rax
addq $0x20, %rax
movq %rax, (%rsp)
movl 0x8(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x8252
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/codeplea[P]tinyexpr/tinyexpr.c
// Function: find_builtin
static const te_variable *find_builtin(const char *name, int len) {
    int imin = 0;
    int imax = sizeof(functions) / sizeof(te_variable) - 2;

    /*Binary search.*/
    while (imax >= imin) {
        const int i = (imin + ((imax-imin)/2));
        int c = strncmp(name, functions[i].name, len);
        if (!c) c = '\0' - functions[i].name[len];
        if (c == 0) {
            return functions + i;
        } else if (c > 0) {
            imin = i + 1;
        } else {
            imax = i - 1;
        }
    }

    return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movl $0x17, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x10(%rsp), %eax
jl 0x83bb
movl 0x10(%rsp), %eax
movl %eax, (%rsp)
movl 0xc(%rsp), %eax
subl 0x10(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl (%rsp), %eax
addl %ecx, %eax
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movslq 0x8(%rsp), %rcx
leaq 0x6782(%rip), %rax      # 0xeab0
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rsi
movslq 0x14(%rsp), %rdx
callq 0x3040
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0x8374
movslq 0x8(%rsp), %rcx
leaq 0x6757(%rip), %rax      # 0xeab0
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rax
movslq 0x14(%rsp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0x8395
movslq 0x8(%rsp), %rcx
leaq 0x6729(%rip), %rax      # 0xeab0
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
jmp 0x83c4
cmpl $0x0, 0x4(%rsp)
jle 0x83a9
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x83b4
movl 0x8(%rsp), %eax
subl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x83b6
jmp 0x82ed
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/codeplea[P]tinyexpr/tinyexpr.c
// Function: te_compile
te_expr *te_compile(const char *expression, const te_variable *variables, int var_count, int *error) {
    state s;
    s.start = s.next = expression;
    s.lookup = variables;
    s.lookup_len = var_count;

    next_token(&s);
    te_expr *root = list(&s);
    if (root == NULL) {
        if (error) *error = -1;
        return NULL;
    }

    if (s.type != TOK_END) {
        te_free(root);
        if (error) {
            *error = (s.next - s.start);
            if (*error == 0) *error = 1;
        }
        return 0;
    } else {
        optimize(root);
        if (error) *error = 0;
        return root;
    }
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movl %edx, 0x4c(%rsp)
movq %rcx, 0x40(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x30(%rsp)
movl 0x4c(%rsp), %eax
movl %eax, 0x38(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x7e70
leaq 0x8(%rsp), %rdi
callq 0x90f0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x9065
cmpq $0x0, 0x40(%rsp)
je 0x905a
movq 0x40(%rsp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq $0x0, 0x60(%rsp)
jmp 0x90da
cmpl $0x1a, 0x18(%rsp)
je 0x90b5
movq (%rsp), %rdi
callq 0x7e40
cmpq $0x0, 0x40(%rsp)
je 0x90aa
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq 0x40(%rsp), %rax
movl %ecx, (%rax)
movq 0x40(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x90a8
movq 0x40(%rsp), %rax
movl $0x1, (%rax)
jmp 0x90aa
movq $0x0, 0x60(%rsp)
jmp 0x90da
movq (%rsp), %rdi
callq 0x91f0
cmpq $0x0, 0x40(%rsp)
je 0x90d1
movq 0x40(%rsp), %rax
movl $0x0, (%rax)
movq (%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/codeplea[P]tinyexpr/tinyexpr.c
// Function: list
static te_expr *list(state *s) {
    /* <list>      =    <expr> {"," <expr>} */
    te_expr *ret = expr(s);
    CHECK_NULL(ret);

    while (s->type == TOK_SEP) {
        next_token(s);
        te_expr *e = expr(s);
        CHECK_NULL(e, te_free(ret));

        te_expr *prev = ret;
        ret = NEW_EXPR(TE_FUNCTION2 | TE_FLAG_PURE, ret, e);
        CHECK_NULL(ret, te_free(e), te_free(prev));

        ret->function = comma;
    }

    return ret;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x9810
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x911e
movq $0x0, 0x30(%rsp)
jmp 0x91da
jmp 0x9120
movq 0x28(%rsp), %rax
cmpl $0x1b, 0x10(%rax)
jne 0x91d0
movq 0x28(%rsp), %rdi
callq 0x7e70
movq 0x28(%rsp), %rdi
callq 0x9810
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x9165
movq 0x20(%rsp), %rdi
callq 0x7e40
movq $0x0, 0x30(%rsp)
jmp 0x91da
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %rsp, %rsi
movl $0x2a, %edi
callq 0x9960
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x91bb
movq 0x18(%rsp), %rdi
callq 0x7e40
movq 0x10(%rsp), %rdi
callq 0x7e40
movq $0x0, 0x30(%rsp)
jmp 0x91da
movq 0x20(%rsp), %rax
leaq 0x889(%rip), %rcx       # 0x9a50
movq %rcx, 0x8(%rax)
jmp 0x9120
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/codeplea[P]tinyexpr/tinyexpr.c
// Function: optimize
static void optimize(te_expr *n) {
    /* Evaluates as much as possible. */
    if (n->type == TE_CONSTANT) return;
    if (n->type == TE_VARIABLE) return;

    /* Only optimize out functions flagged as pure. */
    if (IS_PURE(n->type)) {
        const int arity = ARITY(n->type);
        int known = 1;
        int i;
        for (i = 0; i < arity; ++i) {
            optimize(n->parameters[i]);
            if (((te_expr*)(n->parameters[i]))->type != TE_CONSTANT) {
                known = 0;
            }
        }
        if (known) {
            const double value = te_eval(n);
            te_free_parameters(n);
            n->type = TE_CONSTANT;
            n->value = value;
        }
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpl $0x1, (%rax)
jne 0x9208
jmp 0x92f0
movq 0x20(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x9217
jmp 0x92f0
movq 0x20(%rsp), %rax
movl (%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x92f0
movq 0x20(%rsp), %rax
movl (%rax), %eax
andl $0x18, %eax
cmpl $0x0, %eax
je 0x9249
movq 0x20(%rsp), %rax
movl (%rax), %eax
andl $0x7, %eax
movl %eax, 0x4(%rsp)
jmp 0x9251
xorl %eax, %eax
movl %eax, 0x4(%rsp)
jmp 0x9251
movl 0x4(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl $0x1, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x92b2
movq 0x20(%rsp), %rax
movslq 0x14(%rsp), %rcx
movq 0x10(%rax,%rcx,8), %rdi
callq 0x91f0
movq 0x20(%rsp), %rax
movslq 0x14(%rsp), %rcx
movq 0x10(%rax,%rcx,8), %rax
cmpl $0x1, (%rax)
je 0x92a3
movl $0x0, 0x18(%rsp)
jmp 0x92a5
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x9269
cmpl $0x0, 0x18(%rsp)
je 0x92ee
movq 0x20(%rsp), %rdi
callq 0x8450
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x7d90
movq 0x20(%rsp), %rax
movl $0x1, (%rax)
movsd 0x8(%rsp), %xmm0
movq 0x20(%rsp), %rax
movsd %xmm0, 0x8(%rax)
jmp 0x92f0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/codeplea[P]tinyexpr/tinyexpr.c
// Function: te_interp
double te_interp(const char *expression, int *error) {
    te_expr *n = te_compile(expression, 0, 0, error);

    double ret;
    if (n) {
        ret = te_eval(n);
        te_free(n);
    } else {
        ret = NAN;
    }
    return ret;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rcx
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x8ff0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x934c
movq 0x10(%rsp), %rdi
callq 0x8450
movsd %xmm0, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x7e40
jmp 0x935a
movsd 0x2864(%rip), %xmm0     # 0xbbb8
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/codeplea[P]tinyexpr/tinyexpr.c
// Function: pn
static void pn (const te_expr *n, int depth) {
    int i, arity;
    printf("%*s", depth, "");

    switch(TYPE_MASK(n->type)) {
    case TE_CONSTANT: printf("%f\n", n->value); break;
    case TE_VARIABLE: printf("bound %p\n", n->bound); break;

    case TE_FUNCTION0: case TE_FUNCTION1: case TE_FUNCTION2: case TE_FUNCTION3:
    case TE_FUNCTION4: case TE_FUNCTION5: case TE_FUNCTION6: case TE_FUNCTION7:
    case TE_CLOSURE0: case TE_CLOSURE1: case TE_CLOSURE2: case TE_CLOSURE3:
    case TE_CLOSURE4: case TE_CLOSURE5: case TE_CLOSURE6: case TE_CLOSURE7:
         arity = ARITY(n->type);
         printf("f%d", arity);
         for(i = 0; i < arity; i++) {
             printf(" %p", n->parameters[i]);
         }
         printf("\n");
         for(i = 0; i < arity; i++) {
             pn(n->parameters[i], depth + 1);
         }
         break;
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl 0x1c(%rsp), %esi
leaq 0x28b1(%rip), %rdi      # 0xbc59
leaq 0x200b(%rip), %rdx      # 0xb3ba
xorl %eax, %eax
callq 0x3080
movq 0x20(%rsp), %rax
movl (%rax), %eax
andl $0x1f, %eax
movl %eax, 0x10(%rsp)
je 0x9401
jmp 0x93c8
movl 0x10(%rsp), %eax
subl $0x1, %eax
je 0x93e4
jmp 0x93d3
movl 0x10(%rsp), %eax
addl $-0x8, %eax
subl $0x10, %eax
jb 0x941d
jmp 0x94e4
movq 0x20(%rsp), %rax
movsd 0x8(%rax), %xmm0
leaq 0x2868(%rip), %rdi      # 0xbc5d
movb $0x1, %al
callq 0x3080
jmp 0x94e4
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rsi
leaq 0x2850(%rip), %rdi      # 0xbc61
movb $0x0, %al
callq 0x3080
jmp 0x94e4
movq 0x20(%rsp), %rax
movl (%rax), %eax
andl $0x18, %eax
cmpl $0x0, %eax
je 0x943c
movq 0x20(%rsp), %rax
movl (%rax), %eax
andl $0x7, %eax
movl %eax, 0xc(%rsp)
jmp 0x9444
xorl %eax, %eax
movl %eax, 0xc(%rsp)
jmp 0x9444
movl 0xc(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %esi
leaq 0x2814(%rip), %rdi      # 0xbc6b
movb $0x0, %al
callq 0x3080
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0x949a
movq 0x20(%rsp), %rax
movslq 0x18(%rsp), %rcx
movq 0x10(%rax,%rcx,8), %rsi
leaq 0x27e9(%rip), %rdi      # 0xbc6f
movb $0x0, %al
callq 0x3080
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x9466
leaq 0x1f18(%rip), %rdi      # 0xb3b9
movb $0x0, %al
callq 0x3080
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0x94e2
movq 0x20(%rsp), %rax
movslq 0x18(%rsp), %rcx
movq 0x10(%rax,%rcx,8), %rdi
movl 0x1c(%rsp), %esi
addl $0x1, %esi
callq 0x9390
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x94b0
jmp 0x94e4
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/codeplea[P]tinyexpr/tinyexpr.c
// Function: fac
static double fac(double a) {/* simplest version of fac */
    if (a < 0.0)
        return NAN;
    if (a > UINT_MAX)
        return INFINITY;
    unsigned int ua = (unsigned int)(a);
    unsigned long int result = 1, i;
    for (i = 1; i <= ua; i++) {
        if (i > ULONG_MAX / result)
            return INFINITY;
        result *= i;
    }
    return (double)result;
}

// Assembly:
movsd %xmm0, -0x10(%rsp)
xorps %xmm0, %xmm0
ucomisd -0x10(%rsp), %xmm0
jbe 0x9524
movsd 0x269f(%rip), %xmm0     # 0xbbb8
movsd %xmm0, -0x8(%rsp)
jmp 0x95fb
movsd -0x10(%rsp), %xmm0
movsd 0x2696(%rip), %xmm1     # 0xbbc8
ucomisd %xmm1, %xmm0
jbe 0x954b
movsd 0x2690(%rip), %xmm0     # 0xbbd0
movsd %xmm0, -0x8(%rsp)
jmp 0x95fb
cvttsd2si -0x10(%rsp), %rax
movl %eax, -0x14(%rsp)
movq $0x1, -0x20(%rsp)
movq $0x1, -0x28(%rsp)
movq -0x28(%rsp), %rax
movl -0x14(%rsp), %ecx
cmpq %rcx, %rax
ja 0x95cd
movq -0x28(%rsp), %rax
movq %rax, -0x30(%rsp)
movq $-0x1, %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x20(%rsp)
movq %rax, %rcx
movq -0x30(%rsp), %rax
cmpq %rcx, %rax
jbe 0x95ad
movsd 0x262b(%rip), %xmm0     # 0xbbd0
movsd %xmm0, -0x8(%rsp)
jmp 0x95fb
movq -0x28(%rsp), %rax
imulq -0x20(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rsp)
jmp 0x9568
movaps 0x260c(%rip), %xmm1     # 0xbbe0
movq -0x20(%rsp), %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x260a(%rip), %xmm1     # 0xbbf0
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rsp)
movsd -0x8(%rsp), %xmm0
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/codeplea[P]tinyexpr/tinyexpr.c
// Function: ncr
static double ncr(double n, double r) {
    if (n < 0.0 || r < 0.0 || n < r) return NAN;
    if (n > UINT_MAX || r > UINT_MAX) return INFINITY;
    unsigned long int un = (unsigned int)(n), ur = (unsigned int)(r), i;
    unsigned long int result = 1;
    if (ur > un / 2) ur = un - ur;
    for (i = 1; i <= ur; i++) {
        if (result > ULONG_MAX / (un - ur + i))
            return INFINITY;
        result *= un - ur + i;
        result /= i;
    }
    return result;
}

// Assembly:
movsd %xmm0, -0x10(%rsp)
movsd %xmm1, -0x18(%rsp)
xorps %xmm0, %xmm0
ucomisd -0x10(%rsp), %xmm0
ja 0x9644
xorps %xmm0, %xmm0
ucomisd -0x18(%rsp), %xmm0
ja 0x9644
movsd -0x10(%rsp), %xmm1
movsd -0x18(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x9657
movsd 0x256c(%rip), %xmm0     # 0xbbb8
movsd %xmm0, -0x8(%rsp)
jmp 0x97a2
movsd -0x10(%rsp), %xmm0
movsd 0x2563(%rip), %xmm1     # 0xbbc8
ucomisd %xmm1, %xmm0
ja 0x967f
movsd -0x18(%rsp), %xmm0
movsd 0x254f(%rip), %xmm1     # 0xbbc8
ucomisd %xmm1, %xmm0
jbe 0x9692
movsd 0x2549(%rip), %xmm0     # 0xbbd0
movsd %xmm0, -0x8(%rsp)
jmp 0x97a2
cvttsd2si -0x10(%rsp), %rax
movl %eax, %eax
movq %rax, -0x20(%rsp)
cvttsd2si -0x18(%rsp), %rax
movl %eax, %eax
movq %rax, -0x28(%rsp)
movq $0x1, -0x38(%rsp)
movq -0x28(%rsp), %rax
movq -0x20(%rsp), %rcx
shrq %rcx
cmpq %rcx, %rax
jbe 0x96d8
movq -0x20(%rsp), %rax
subq -0x28(%rsp), %rax
movq %rax, -0x28(%rsp)
movq $0x1, -0x30(%rsp)
movq -0x30(%rsp), %rax
cmpq -0x28(%rsp), %rax
ja 0x9774
movq -0x38(%rsp), %rax
movq %rax, -0x40(%rsp)
movq -0x20(%rsp), %rcx
subq -0x28(%rsp), %rcx
addq -0x30(%rsp), %rcx
movq $-0x1, %rax
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq -0x40(%rsp), %rax
cmpq %rcx, %rax
jbe 0x9733
movsd 0x24a5(%rip), %xmm0     # 0xbbd0
movsd %xmm0, -0x8(%rsp)
jmp 0x97a2
movq -0x20(%rsp), %rax
subq -0x28(%rsp), %rax
addq -0x30(%rsp), %rax
imulq -0x38(%rsp), %rax
movq %rax, -0x38(%rsp)
movq -0x30(%rsp), %rcx
movq -0x38(%rsp), %rax
xorl %edx, %edx
divq %rcx
movq %rax, -0x38(%rsp)
movq -0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rsp)
jmp 0x96e1
movaps 0x2465(%rip), %xmm1     # 0xbbe0
movq -0x38(%rsp), %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x2463(%rip), %xmm1     # 0xbbf0
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rsp)
movsd -0x8(%rsp), %xmm0
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/codeplea[P]tinyexpr/tinyexpr.c
// Function: expr
static te_expr *expr(state *s) {
    /* <expr>      =    <term> {("+" | "-") <term>} */
    te_expr *ret = term(s);
    CHECK_NULL(ret);

    while (s->type == TOK_INFIX && (s->function == add || s->function == sub)) {
        te_fun2 t = s->function;
        next_token(s);
        te_expr *te = term(s);
        CHECK_NULL(te, te_free(ret));

        te_expr *prev = ret;
        ret = NEW_EXPR(TE_FUNCTION2 | TE_FLAG_PURE, ret, te);
        CHECK_NULL(ret, te_free(te), te_free(prev));

        ret->function = t;
    }

    return ret;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x9a70
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x983e
movq $0x0, 0x40(%rsp)
jmp 0x994f
jmp 0x9840
movq 0x38(%rsp), %rcx
xorl %eax, %eax
cmpl $0x20, 0x10(%rcx)
movb %al, 0x7(%rsp)
jne 0x9888
movq 0x38(%rsp), %rcx
movb $0x1, %al
leaq -0x148f(%rip), %rdx     # 0x83d0
cmpq %rdx, 0x18(%rcx)
movb %al, 0x6(%rsp)
je 0x9880
movq 0x38(%rsp), %rax
leaq -0x1485(%rip), %rcx     # 0x83f0
cmpq %rcx, 0x18(%rax)
sete %al
movb %al, 0x6(%rsp)
movb 0x6(%rsp), %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x9895
jmp 0x9945
movq 0x38(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rdi
callq 0x7e70
movq 0x38(%rsp), %rdi
callq 0x9a70
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x98d9
movq 0x30(%rsp), %rdi
callq 0x7e40
movq $0x0, 0x40(%rsp)
jmp 0x994f
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x8(%rsp), %rsi
movl $0x2a, %edi
callq 0x9960
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x9932
movq 0x20(%rsp), %rdi
callq 0x7e40
movq 0x18(%rsp), %rdi
callq 0x7e40
movq $0x0, 0x40(%rsp)
jmp 0x994f
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0x9840
movq 0x30(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/codeplea[P]tinyexpr/tinyexpr.c
// Function: new_expr
static te_expr *new_expr(const int type, const te_expr *parameters[]) {
    const int arity = ARITY(type);
    const int psize = sizeof(void*) * arity;
    const int size = (sizeof(te_expr) - sizeof(void*)) + psize + (IS_CLOSURE(type) ? sizeof(void*) : 0);
    te_expr *ret = malloc(size);
    CHECK_NULL(ret);

    memset(ret, 0, size);
    if (arity && parameters) {
        memcpy(ret->parameters, parameters, psize);
    }
    ret->type = type;
    ret->bound = 0;
    return ret;
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x2c(%rsp)
movq %rsi, 0x20(%rsp)
movl 0x2c(%rsp), %eax
andl $0x18, %eax
cmpl $0x0, %eax
je 0x9986
movl 0x2c(%rsp), %eax
andl $0x7, %eax
movl %eax, 0x4(%rsp)
jmp 0x998e
xorl %eax, %eax
movl %eax, 0x4(%rsp)
jmp 0x998e
movl 0x4(%rsp), %eax
movl %eax, 0x1c(%rsp)
movslq 0x1c(%rsp), %rax
shlq $0x3, %rax
movl %eax, 0x18(%rsp)
movslq 0x18(%rsp), %rax
addq $0x10, %rax
movl 0x2c(%rsp), %esi
andl $0x10, %esi
xorl %ecx, %ecx
movl $0x8, %edx
cmpl $0x0, %esi
cmovneq %rdx, %rcx
addq %rcx, %rax
movl %eax, 0x14(%rsp)
movslq 0x14(%rsp), %rdi
callq 0x3110
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x99ea
movq $0x0, 0x30(%rsp)
jmp 0x9a44
movq 0x8(%rsp), %rdi
movslq 0x14(%rsp), %rdx
xorl %esi, %esi
callq 0x3090
cmpl $0x0, 0x1c(%rsp)
je 0x9a22
cmpq $0x0, 0x20(%rsp)
je 0x9a22
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movq 0x20(%rsp), %rsi
movslq 0x18(%rsp), %rdx
callq 0x30e0
movl 0x2c(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/codeplea[P]tinyexpr/tinyexpr.c
// Function: term
static te_expr *term(state *s) {
    /* <term>      =    <factor> {("*" | "/" | "%") <factor>} */
    te_expr *ret = factor(s);
    CHECK_NULL(ret);

    while (s->type == TOK_INFIX && (s->function == mul || s->function == divide || s->function == fmod)) {
        te_fun2 t = s->function;
        next_token(s);
        te_expr *f = factor(s);
        CHECK_NULL(f, te_free(ret));

        te_expr *prev = ret;
        ret = NEW_EXPR(TE_FUNCTION2 | TE_FLAG_PURE, ret, f);
        CHECK_NULL(ret, te_free(f), te_free(prev));

        ret->function = t;
    }

    return ret;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x9be0
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x9a9e
movq $0x0, 0x40(%rsp)
jmp 0x9bc7
jmp 0x9aa0
movq 0x38(%rsp), %rcx
xorl %eax, %eax
cmpl $0x20, 0x10(%rcx)
movb %al, 0x7(%rsp)
jne 0x9b00
movq 0x38(%rsp), %rcx
movb $0x1, %al
leaq -0x16af(%rip), %rdx     # 0x8410
cmpq %rdx, 0x18(%rcx)
movb %al, 0x6(%rsp)
je 0x9af8
movq 0x38(%rsp), %rcx
movb $0x1, %al
leaq -0x16a7(%rip), %rdx     # 0x8430
cmpq %rdx, 0x18(%rcx)
movb %al, 0x6(%rsp)
je 0x9af8
movq 0x38(%rsp), %rax
movq 0x54f3(%rip), %rcx      # 0xefe0
cmpq %rcx, 0x18(%rax)
sete %al
movb %al, 0x6(%rsp)
movb 0x6(%rsp), %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x9b0d
jmp 0x9bbd
movq 0x38(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rdi
callq 0x7e70
movq 0x38(%rsp), %rdi
callq 0x9be0
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x9b51
movq 0x30(%rsp), %rdi
callq 0x7e40
movq $0x0, 0x40(%rsp)
jmp 0x9bc7
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x8(%rsp), %rsi
movl $0x2a, %edi
callq 0x9960
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x9baa
movq 0x20(%rsp), %rdi
callq 0x7e40
movq 0x18(%rsp), %rdi
callq 0x7e40
movq $0x0, 0x40(%rsp)
jmp 0x9bc7
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0x9aa0
movq 0x30(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/codeplea[P]tinyexpr/tinyexpr.c
// Function: power
static te_expr *power(state *s) {
    /* <power>     =    {("-" | "+")} <base> */
    int sign = 1;
    while (s->type == TOK_INFIX && (s->function == add || s->function == sub)) {
        if (s->function == sub) sign = -sign;
        next_token(s);
    }

    te_expr *ret;

    if (sign == 1) {
        ret = base(s);
    } else {
        te_expr *b = base(s);
        CHECK_NULL(b);

        ret = NEW_EXPR(TE_FUNCTION1 | TE_FLAG_PURE, b);
        CHECK_NULL(ret, te_free(b));

        ret->function = negate;
    }

    return ret;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl $0x1, 0x24(%rsp)
movq 0x28(%rsp), %rcx
xorl %eax, %eax
cmpl $0x20, 0x10(%rcx)
movb %al, 0x7(%rsp)
jne 0x9f59
movq 0x28(%rsp), %rcx
movb $0x1, %al
leaq -0x1b60(%rip), %rdx     # 0x83d0
cmpq %rdx, 0x18(%rcx)
movb %al, 0x6(%rsp)
je 0x9f51
movq 0x28(%rsp), %rax
leaq -0x1b56(%rip), %rcx     # 0x83f0
cmpq %rcx, 0x18(%rax)
sete %al
movb %al, 0x6(%rsp)
movb 0x6(%rsp), %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x9f63
jmp 0x9f8b
movq 0x28(%rsp), %rax
leaq -0x1b7f(%rip), %rcx     # 0x83f0
cmpq %rcx, 0x18(%rax)
jne 0x9f7f
xorl %eax, %eax
subl 0x24(%rsp), %eax
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rdi
callq 0x7e70
jmp 0x9f11
cmpl $0x1, 0x24(%rsp)
jne 0x9fa3
movq 0x28(%rsp), %rdi
callq 0xa060
movq %rax, 0x18(%rsp)
jmp 0xa010
movq 0x28(%rsp), %rdi
callq 0xa060
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x9fc5
movq $0x0, 0x30(%rsp)
jmp 0xa01a
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x8(%rsp), %rsi
movl $0x29, %edi
callq 0x9960
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0xa000
movq 0x10(%rsp), %rdi
callq 0x7e40
movq $0x0, 0x30(%rsp)
jmp 0xa01a
movq 0x18(%rsp), %rax
leaq 0x24(%rip), %rcx        # 0xa030
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)