LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpc_stack_parsers_reserve_more
static void mpc_stack_parsers_reserve_more(mpc_stack_t *s) {
  if (s->parsers_num > s->parsers_slots) {
    s->parsers_slots = ceil((s->parsers_slots+1) * 1.5);
    s->parsers = realloc(s->parsers, sizeof(mpc_parser_t*) * s->parsers_slots);
    s->states = realloc(s->states, sizeof(int) * s->parsers_slots);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jle 0x1358d
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
addl $0x1, %eax
cvtsi2sd %eax, %xmm0
movsd 0x7867(%rip), %xmm1     # 0x1ad98
mulsd %xmm1, %xmm0
callq 0x2350
cvttsd2si %xmm0, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x4(%rax), %rsi
shlq $0x3, %rsi
callq 0x22a0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x4(%rax), %rsi
shlq $0x2, %rsi
callq 0x22a0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpc_stack_parsers_reserve_less
static void mpc_stack_parsers_reserve_less(mpc_stack_t *s) {
  if (s->parsers_slots > pow(s->parsers_num+1, 1.5)) {
    s->parsers_slots = floor((s->parsers_slots-1) * (1.0/1.5));
    s->parsers = realloc(s->parsers, sizeof(mpc_parser_t*) * s->parsers_slots);
    s->states = realloc(s->states, sizeof(int) * s->parsers_slots);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cvtsi2sdl 0x4(%rax), %xmm0
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
addl $0x1, %eax
cvtsi2sd %eax, %xmm0
movsd 0x77c9(%rip), %xmm1     # 0x1ad98
callq 0x20d0
movaps %xmm0, %xmm1
movsd -0x10(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x13654
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
subl $0x1, %eax
cvtsi2sd %eax, %xmm0
movsd 0x77a8(%rip), %xmm1     # 0x1ada0
mulsd %xmm1, %xmm0
callq 0x2300
cvttsd2si %xmm0, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x4(%rax), %rsi
shlq $0x3, %rsi
callq 0x22a0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x4(%rax), %rsi
shlq $0x2, %rsi
callq 0x22a0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpc_stack_results_reserve_more
static void mpc_stack_results_reserve_more(mpc_stack_t *s) {
  if (s->results_num > s->results_slots) {
    s->results_slots = ceil((s->results_slots + 1) * 1.5);
    s->results = realloc(s->results, sizeof(mpc_result_t) * s->results_slots);
    s->returns = realloc(s->returns, sizeof(int) * s->results_slots);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jle 0x136ee
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
addl $0x1, %eax
cvtsi2sd %eax, %xmm0
movsd 0x7706(%rip), %xmm1     # 0x1ad98
mulsd %xmm1, %xmm0
callq 0x2350
cvttsd2si %xmm0, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x1c(%rax), %rsi
shlq $0x3, %rsi
callq 0x22a0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x1c(%rax), %rsi
shlq $0x2, %rsi
callq 0x22a0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpc_input_getc
static char mpc_input_getc(mpc_input_t *i) {
  
  char c;
  switch (i->type) {
    
    case MPC_INPUT_STRING: c = i->string[i->state.pos]; break;
    case MPC_INPUT_FILE: c = fgetc(i->file); break;
    case MPC_INPUT_PIPE:
    
      if (!i->buffer) { c = getc(i->file); break; }
      
      if (i->buffer && mpc_input_buffer_in_range(i)) {
        c = mpc_input_buffer_get(i);
      } else {
        c = getc(i->file);
      }
    
    break;
    
  }
  
  return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x10(%rbp)
testl %eax, %eax
je 0x13732
jmp 0x1371b
movl -0x10(%rbp), %eax
subl $0x1, %eax
je 0x1374a
jmp 0x13725
movl -0x10(%rbp), %eax
subl $0x2, %eax
je 0x1375c
jmp 0x137b2
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x10(%rcx), %rcx
movb (%rax,%rcx), %al
movb %al, -0x9(%rbp)
jmp 0x137b2
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x2170
movb %al, -0x9(%rbp)
jmp 0x137b2
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x13779
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x2360
movb %al, -0x9(%rbp)
jmp 0x137b2
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x137a0
movq -0x8(%rbp), %rdi
callq 0x13910
cmpl $0x0, %eax
je 0x137a0
movq -0x8(%rbp), %rdi
callq 0x13960
movb %al, -0x9(%rbp)
jmp 0x137b0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x2360
movb %al, -0x9(%rbp)
jmp 0x137b2
movb -0x9(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpc_input_terminated
static int mpc_input_terminated(mpc_input_t *i) {
  if (i->type == MPC_INPUT_STRING && i->state.pos == strlen(i->string)) { return 1; }
  if (i->type == MPC_INPUT_FILE && feof(i->file)) { return 1; }
  if (i->type == MPC_INPUT_PIPE && feof(i->file)) { return 1; }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x13803
movq -0x10(%rbp), %rax
movslq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x20f0
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jne 0x13803
movl $0x1, -0x4(%rbp)
jmp 0x13852
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x13827
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x2200
cmpl $0x0, %eax
je 0x13827
movl $0x1, -0x4(%rbp)
jmp 0x13852
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x1384b
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x2200
cmpl $0x0, %eax
je 0x1384b
movl $0x1, -0x4(%rbp)
jmp 0x13852
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/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); 
      }
      
  }
  
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x10(%rbp)
testl %eax, %eax
je 0x13895
jmp 0x13881
movl -0x10(%rbp), %eax
subl $0x1, %eax
je 0x13897
jmp 0x1388b
movl -0x10(%rbp), %eax
subl $0x2, %eax
je 0x138b2
jmp 0x138fe
jmp 0x138fe
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movq $-0x1, %rsi
movl $0x1, %edx
callq 0x2290
jmp 0x138fe
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x138d0
movsbl -0x9(%rbp), %edi
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x2280
jmp 0x138fe
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x138eb
movq -0x8(%rbp), %rdi
callq 0x13910
cmpl $0x0, %eax
je 0x138eb
jmp 0x138fe
movsbl -0x9(%rbp), %edi
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x2280
jmp 0x138fe
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/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) = malloc(2);
    (*o)[0] = c;
    (*o)[1] = '\0';
  }
  
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x13a59
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x13a59
movq -0x8(%rbp), %rdi
callq 0x13910
cmpl $0x0, %eax
jne 0x13a59
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x20f0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
addq $0x2, %rsi
callq 0x22a0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x20f0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movb $0x0, 0x1(%rax,%rcx)
movb -0x9(%rbp), %al
movb %al, -0x21(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x20f0
movb -0x21(%rbp), %dl
movq %rax, %rcx
movq -0x20(%rbp), %rax
movb %dl, (%rax,%rcx)
movb -0x9(%rbp), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x50(%rax)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
movsbl -0x9(%rbp), %eax
cmpl $0xa, %eax
jne 0x13a9e
movq -0x8(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
cmpq $0x0, -0x18(%rbp)
je 0x13ad0
movl $0x2, %edi
callq 0x2250
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movb -0x9(%rbp), %cl
movq -0x18(%rbp), %rax
movq (%rax), %rax
movb %cl, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movb $0x0, 0x1(%rax)
movl $0x1, %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpc_stack_results_reserve_less
static void mpc_stack_results_reserve_less(mpc_stack_t *s) {
  if ( s->results_slots > pow(s->results_num+1, 1.5)) {
    s->results_slots = floor((s->results_slots-1) * (1.0/1.5));
    s->results = realloc(s->results, sizeof(mpc_result_t) * s->results_slots);
    s->returns = realloc(s->returns, sizeof(int) * s->results_slots);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cvtsi2sdl 0x1c(%rax), %xmm0
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
addl $0x1, %eax
cvtsi2sd %eax, %xmm0
movsd 0x7288(%rip), %xmm1     # 0x1ad98
callq 0x20d0
movaps %xmm0, %xmm1
movsd -0x10(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x13b95
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
subl $0x1, %eax
cvtsi2sd %eax, %xmm0
movsd 0x7267(%rip), %xmm1     # 0x1ada0
mulsd %xmm1, %xmm0
callq 0x2300
cvttsd2si %xmm0, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x1c(%rax), %rsi
shlq $0x3, %rsi
callq 0x22a0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x1c(%rax), %rsi
shlq $0x2, %rsi
callq 0x22a0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpc_err_contains_expected
static int mpc_err_contains_expected(mpc_err_t *x, char *expected) {
  
  int i;
  for (i = 0; i < x->expected_num; i++) {
    if (strcmp(x->expected[i], expected) == 0) { return 1; }
  }
  
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x13e57
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
callq 0x21d0
cmpl $0x0, %eax
jne 0x13e4a
movl $0x1, -0x4(%rbp)
jmp 0x13e5e
jmp 0x13e4c
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x13e17
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpc_err_add_expected
static void mpc_err_add_expected(mpc_err_t *x, char *expected) {
  
  x->expected_num++;
  x->expected = realloc(x->expected, sizeof(char*) * x->expected_num);
  x->expected[x->expected_num-1] = malloc(strlen(expected) + 1);
  strcpy(x->expected[x->expected_num-1], expected);
  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0xc(%rax), %rsi
shlq $0x3, %rsi
callq 0x22a0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rdi
callq 0x20f0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x2250
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0xc(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0xc(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
callq 0x2070
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpc_stack_popr_n
static void mpc_stack_popr_n(mpc_stack_t *s, int n) {
  mpc_result_t x;
  while (n) {
    mpc_stack_popr(s, &x);
    n--;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x13f3d
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xcd80
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x13f1f
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpc_err_clear_expected
static void mpc_err_clear_expected(mpc_err_t *x, char *expected) {
  
  int i;
  for (i = 0; i < x->expected_num; i++) {
    free(x->expected[i]);
  }
  x->expected_num = 1;
  x->expected = realloc(x->expected, sizeof(char*) * x->expected_num);
  x->expected[0] = malloc(strlen(expected) + 1);
  strcpy(x->expected[0], expected);
  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x141e3
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x23a0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x141b7
movq -0x8(%rbp), %rax
movl $0x1, 0xc(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0xc(%rax), %rsi
shlq $0x3, %rsi
callq 0x22a0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rdi
callq 0x20f0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x2250
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x2070
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/parser.c
// Function: awlval_parse
bool awlval_parse(const char* input, awlval** v, char** err) {
    mpc_result_t r;
    if (mpc_parse("<stdin>", input, Awl, &r)) {
        *v = awlval_read(r.output);
        mpc_ast_delete(r.output);
        return true;
    } else {
        *err = mpc_err_string(r.error);
        mpc_err_delete(r.error);
        return false;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movq 0xd4f1(%rip), %rdx      # 0x223c0
leaq 0x6964(%rip), %rdi      # 0x1b83a
leaq -0x28(%rbp), %rcx
callq 0xd3f0
cmpl $0x0, %eax
je 0x14f06
movq -0x28(%rbp), %rdi
callq 0x14f40
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rdi
callq 0x113b0
movb $0x1, -0x1(%rbp)
jmp 0x14f26
movq -0x28(%rbp), %rdi
callq 0xa480
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rdi
callq 0xa380
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/parser.c
// Function: awlval_parse_file
bool awlval_parse_file(const char* file, awlval** v, char** err) {
    mpc_result_t r;
    if (mpc_parse_contents(file, Awl, &r)) {
        *v = awlval_read(r.output);
        mpc_ast_delete(r.output);
        return true;
    } else {
        *err = mpc_err_string(r.error);
        mpc_err_delete(r.error);
        return false;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq 0xd081(%rip), %rsi      # 0x223c0
leaq -0x28(%rbp), %rdx
callq 0xd870
cmpl $0x0, %eax
je 0x1536f
movq -0x28(%rbp), %rdi
callq 0x14f40
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rdi
callq 0x113b0
movb $0x1, -0x1(%rbp)
jmp 0x1538f
movq -0x28(%rbp), %rdi
callq 0xa480
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rdi
callq 0xa380
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/parser.c
// Function: awlval_read_string
static awlval* awlval_read_string(const mpc_ast_t* t) {
    t->contents[strlen(t->contents) - 1] = '\0';

    char* unescaped = safe_malloc(strlen(t->contents + 1) + 1);
    strcpy(unescaped, t->contents + 1);

    unescaped = mpcf_unescape(unescaped);
    awlval* str = awlval_str(unescaped);

    free(unescaped);
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x20f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
addq $0x1, %rdi
callq 0x20f0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x157f0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
addq $0x1, %rsi
callq 0x2070
movq -0x10(%rbp), %rdi
callq 0x10740
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x168c0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x23a0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/parser.c
// Function: awlval_read_qsym
static awlval* awlval_read_qsym(const mpc_ast_t* t) {
    if (strstr(t->children[1]->tag, "symbol")) {
        return awlval_qsym(t->children[1]->contents);
    }

    // Handle qsym string form (:'sym')
    t->children[1]->contents[strlen(t->children[1]->contents) - 1] = '\0';

    char* unescaped = safe_malloc(strlen(t->children[1]->contents + 1) + 1);
    strcpy(unescaped, t->children[1]->contents + 1);
    unescaped = mpcf_unescape(unescaped);
    awlval* qsym = awlval_qsym(unescaped);

    free(unescaped);
    return qsym;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
leaq 0x5184(%rip), %rsi      # 0x1a716
callq 0x2370
cmpq $0x0, %rax
je 0x155bb
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x16890
movq %rax, -0x8(%rbp)
jmp 0x15664
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x20f0
movq %rax, %rcx
movq -0x28(%rbp), %rax
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
addq $0x1, %rdi
callq 0x20f0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x157f0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
addq $0x1, %rsi
callq 0x2070
movq -0x18(%rbp), %rdi
callq 0x10740
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x16890
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x23a0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/parser.c
// Function: awlval_read_dict
static awlval* awlval_read_dict(const mpc_ast_t* t) {
    awlval* x = awlval_dict();

    bool new_dict_item = true;
    awlval* qsym;
    awlval* val;

    for (int i = 0; i < t->children_num; i++) {
        if (streq(t->children[i]->contents, "[")) { continue; }
        if (streq(t->children[i]->contents, "]")) { continue; }
        if (streq(t->children[i]->tag, "regex")) { continue; }
        if (strstr(t->children[i]->tag, "comment")) { continue; }

        if (new_dict_item) {
            qsym = awlval_read(t->children[i]);
            new_dict_item = false;
        } else {
            val = awlval_read(t->children[i]);
            x = awlval_add_dict(x, qsym, val);
            new_dict_item = true;

            awlval_del(qsym);
            awlval_del(val);
        }
    }

    return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
callq 0x16b10
movq %rax, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jge 0x157e0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rdi
leaq 0x5976(%rip), %rsi      # 0x1b051
callq 0x18d50
testb $0x1, %al
jne 0x156e6
jmp 0x156eb
jmp 0x157d2
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rdi
leaq 0x5b36(%rip), %rsi      # 0x1b23c
callq 0x18d50
testb $0x1, %al
jne 0x15711
jmp 0x15716
jmp 0x157d2
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rdi
leaq 0x5915(%rip), %rsi      # 0x1b045
callq 0x18d50
testb $0x1, %al
jne 0x1573b
jmp 0x15740
jmp 0x157d2
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rdi
leaq 0x5b6f(%rip), %rsi      # 0x1b2c9
callq 0x2370
cmpq $0x0, %rax
je 0x15767
jmp 0x157d2
testb $0x1, -0x11(%rbp)
je 0x1578c
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x14f40
movq %rax, -0x20(%rbp)
movb $0x0, -0x11(%rbp)
jmp 0x157d0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x14f40
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x16f90
movq %rax, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
movq -0x20(%rbp), %rdi
callq 0x16cf0
movq -0x28(%rbp), %rdi
callq 0x16cf0
jmp 0x157d2
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x156b0
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/print.c
// Function: awl_printf
void awl_printf(const char* format, ...) {
    /* TODO: Make it similar to stringbuilder_t? */
    char* buffer = safe_malloc(BUFSIZE);
    va_list arguments;
    va_start(arguments, format);

    vsnprintf(buffer, BUFSIZE, format, arguments);
    print_fn(buffer);

    va_end(arguments);
    free(buffer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x158e8
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 $0x1000, %edi           # imm = 0x1000
movq %rdi, -0xe8(%rbp)
callq 0x15980
movq -0xe8(%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 0x20a0
movq 0xca64(%rip), %rax      # 0x223c8
movq -0x10(%rbp), %rdi
callq *%rax
movq -0x10(%rbp), %rdi
callq 0x23a0
addq $0xf0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/print.c
// Function: awlval_to_str
char* awlval_to_str(const awlval* v) {
    stringbuilder_t* sb = stringbuilder_new();
    awlval_write_sb(sb, v);
    char* str = stringbuilder_to_str(sb);
    stringbuilder_del(sb);
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x18aa0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x15a90
movq -0x10(%rbp), %rdi
callq 0x18cd0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x18d20
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/print.c
// Function: awlval_print_str
static void awlval_print_str(stringbuilder_t* sb, const awlval* v) {
    char* escaped = safe_malloc(strlen(v->str) + 1);
    strcpy(escaped, v->str);

    escaped = mpcf_escape(escaped);
    stringbuilder_write(sb, "\"%s\"", escaped);

    free(escaped);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x20f0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x15980
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x2070
movq -0x18(%rbp), %rdi
callq 0x105c0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x5176(%rip), %rsi      # 0x1aee0
movb $0x0, %al
callq 0x18b40
movq -0x18(%rbp), %rdi
callq 0x23a0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/print.c
// Function: awlval_dict_print
static void awlval_dict_print(stringbuilder_t* sb, const dict* d) {
    stringbuilder_write(sb, "[");

    int count = dict_count(d);
    char** keys = dict_all_keys(d);
    awlval** vals = (awlval**)dict_all_vals(d);

    for (int i = 0; i < count; i++) {
        stringbuilder_write(sb, ":'%s'", keys[i]);
        stringbuilder_write(sb, " ");
        awlval_write_sb(sb, vals[i]);

        if (i != (count - 1)) {
            stringbuilder_write(sb, " ");
        }
    }

    free(keys);
    free(vals);

    stringbuilder_write(sb, "]");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x52b6(%rip), %rsi      # 0x1b051
movb $0x0, %al
callq 0x18b40
movq -0x10(%rbp), %rdi
callq 0x7470
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7490
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7520
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x15e48
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x5acf(%rip), %rsi      # 0x1b8bd
movb $0x0, %al
callq 0x18b40
movq -0x8(%rbp), %rdi
leaq 0x5a38(%rip), %rsi      # 0x1b838
movb $0x0, %al
callq 0x18b40
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x15a90
movl -0x2c(%rbp), %eax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
je 0x15e3b
movq -0x8(%rbp), %rdi
leaq 0x5a04(%rip), %rsi      # 0x1b838
movb $0x0, %al
callq 0x18b40
jmp 0x15e3d
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x15dcf
movq -0x20(%rbp), %rdi
callq 0x23a0
movq -0x28(%rbp), %rdi
callq 0x23a0
movq -0x8(%rbp), %rdi
leaq 0x53d7(%rip), %rsi      # 0x1b23c
movb $0x0, %al
callq 0x18b40
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/print.c
// Function: awlval_expr_print
static void awlval_expr_print(stringbuilder_t* sb, const awlval* v, const char* open, const char* close) {
    stringbuilder_write(sb, open);
    for (int i = 0; i < v->count; i++) {
        awlval_write_sb(sb, v->cell[i]);

        if (i != (v->count - 1)) {
            stringbuilder_write(sb, " ");
        }
    }
    stringbuilder_write(sb, close);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movb $0x0, %al
callq 0x18b40
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x15f03
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x15a90
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
je 0x15ef6
movq -0x8(%rbp), %rdi
leaq 0x5949(%rip), %rsi      # 0x1b838
movb $0x0, %al
callq 0x18b40
jmp 0x15ef8
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x15eae
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movb $0x0, %al
callq 0x18b40
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/repl.c
// Function: eval_repl
awlval* eval_repl(awlenv* e, awlval* v) {
    if (v->count == 0) {
        awlval_del(v);
        return awlval_qexpr();
    }
    if (v->count != 1) {
        awlval_del(v);
        return awlval_err("too many expressions in REPL; only one is allowed");
    }
    return awlval_eval(e, awlval_take(v, 0));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x15fbe
movq -0x18(%rbp), %rdi
callq 0x16cf0
callq 0x16c00
movq %rax, -0x8(%rbp)
jmp 0x16008
movq -0x18(%rbp), %rax
cmpl $0x1, 0x4(%rax)
je 0x15fe5
movq -0x18(%rbp), %rdi
callq 0x16cf0
leaq 0x5914(%rip), %rdi      # 0x1b8ec
movb $0x0, %al
callq 0x16600
movq %rax, -0x8(%rbp)
jmp 0x16008
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x17560
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x7770
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/repl.c
// Function: eval_repl_str
void eval_repl_str(awlenv* e, const char* input) {
    awlval* v;
    char* err;
    if (awlval_parse(input, &v, &err)) {
        awlval* x = eval_repl(e, v);
        if (!is_awlval_empty_qexpr(x)) {
            awlval_println(x);
        }
        awlval_del(x);
    } else {
        awl_printf("%s", err);
        free(err);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x14eb0
testb $0x1, %al
jne 0x16047
jmp 0x16079
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15f90
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x18330
testb $0x1, %al
jne 0x1606e
movq -0x28(%rbp), %rdi
callq 0x159d0
movq -0x28(%rbp), %rdi
callq 0x16cf0
jmp 0x16094
movq -0x20(%rbp), %rsi
leaq 0x44ad(%rip), %rdi      # 0x1a531
movb $0x0, %al
callq 0x158b0
movq -0x20(%rbp), %rdi
callq 0x23a0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/repl.c
// Function: run_repl
void run_repl(awlenv* e) {
    setup_sigint_handler();

    awl_printf("awl %s\n", get_awl_version());
    awl_printf("Ctrl+D to exit\n\n");

    load_history();

    while (!repl_aborted) {
        errno = 0;
        char* input = get_input("awl> ");
        if (!input) {
            if (errno == EAGAIN) {
                continue;
            } else {
                awl_printf("\n");
                break;
            }
        }
        add_history(input);
        eval_repl_str(e, input);
        free(input);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x16160
callq 0x2560
movq %rax, %rsi
leaq 0x584e(%rip), %rdi      # 0x1b91e
movb $0x0, %al
callq 0x158b0
leaq 0x5848(%rip), %rdi      # 0x1b926
movb $0x0, %al
callq 0x158b0
callq 0x15f40
movb 0xc2e0(%rip), %al       # 0x223d0
xorb $-0x1, %al
testb $0x1, %al
jne 0x160f8
jmp 0x16157
callq 0x2050
movl $0x0, (%rax)
leaq 0x582d(%rip), %rdi      # 0x1b937
callq 0x15f20
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x16136
callq 0x2050
cmpl $0xb, (%rax)
jne 0x16126
jmp 0x160ea
leaq 0x5808(%rip), %rdi      # 0x1b935
movb $0x0, %al
callq 0x158b0
jmp 0x16157
movq -0x10(%rbp), %rdi
callq 0x15f60
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x16020
movq -0x10(%rbp), %rdi
callq 0x23a0
jmp 0x160ea
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/types.c
// Function: awlval_type_name
char* awlval_type_name(awlval_type_t t) {
    switch (t) {
        case AWLVAL_ERR: return "Error";
        case AWLVAL_INT: return "Integer";
        case AWLVAL_FLOAT: return "Float";
        case AWLVAL_BUILTIN: return "Builtin";
        case AWLVAL_FN: return "Function";
        case AWLVAL_MACRO: return "Macro";
        case AWLVAL_SYM: return "Symbol";
        case AWLVAL_QSYM: return "Q-Symbol";
        case AWLVAL_STR: return "String";
        case AWLVAL_BOOL: return "Boolean";
        case AWLVAL_DICT: return "Dictionary";
        case AWLVAL_SEXPR: return "S-Expression";
        case AWLVAL_QEXPR: return "Q-Expression";
        case AWLVAL_EEXPR: return "E-Expression";
        case AWLVAL_CEXPR: return "C-Expression";
        default: return "Unknown";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0xe, %rax
ja 0x162a1
movq -0x18(%rbp), %rax
leaq 0x577d(%rip), %rcx      # 0x1b940
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x4f80(%rip), %rax      # 0x1b153
movq %rax, -0x8(%rbp)
jmp 0x162ac
leaq 0x58a5(%rip), %rax      # 0x1ba88
movq %rax, -0x8(%rbp)
jmp 0x162ac
leaq 0x589d(%rip), %rax      # 0x1ba90
movq %rax, -0x8(%rbp)
jmp 0x162ac
leaq 0x5893(%rip), %rax      # 0x1ba96
movq %rax, -0x8(%rbp)
jmp 0x162ac
leaq 0x588b(%rip), %rax      # 0x1ba9e
movq %rax, -0x8(%rbp)
jmp 0x162ac
leaq 0x5884(%rip), %rax      # 0x1baa7
movq %rax, -0x8(%rbp)
jmp 0x162ac
leaq 0x587c(%rip), %rax      # 0x1baaf
movq %rax, -0x8(%rbp)
jmp 0x162ac
leaq 0x586d(%rip), %rax      # 0x1baad
movq %rax, -0x8(%rbp)
jmp 0x162ac
leaq 0x5869(%rip), %rax      # 0x1bab6
movq %rax, -0x8(%rbp)
jmp 0x162ac
leaq 0x5863(%rip), %rax      # 0x1babd
movq %rax, -0x8(%rbp)
jmp 0x162ac
leaq 0x585e(%rip), %rax      # 0x1bac5
movq %rax, -0x8(%rbp)
jmp 0x162ac
leaq 0x585c(%rip), %rax      # 0x1bad0
movq %rax, -0x8(%rbp)
jmp 0x162ac
leaq 0x585c(%rip), %rax      # 0x1badd
movq %rax, -0x8(%rbp)
jmp 0x162ac
leaq 0x585c(%rip), %rax      # 0x1baea
movq %rax, -0x8(%rbp)
jmp 0x162ac
leaq 0x585c(%rip), %rax      # 0x1baf7
movq %rax, -0x8(%rbp)
jmp 0x162ac
leaq 0x585c(%rip), %rax      # 0x1bb04
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/types.c
// Function: awlval_type_sysname
char* awlval_type_sysname(awlval_type_t t) {
    switch (t) {
        case AWLVAL_ERR: return "err";
        case AWLVAL_INT: return "int";
        case AWLVAL_FLOAT: return "float";
        case AWLVAL_BUILTIN: return "builtin";
        case AWLVAL_FN: return "fn";
        case AWLVAL_MACRO: return "macro";
        case AWLVAL_SYM: return "sym";
        case AWLVAL_QSYM: return "qsym";
        case AWLVAL_STR: return "str";
        case AWLVAL_BOOL: return "bool";
        case AWLVAL_DICT: return "dict";
        case AWLVAL_SEXPR: return "sexpr";
        case AWLVAL_QEXPR: return "qexpr";
        case AWLVAL_EEXPR: return "eexpr";
        case AWLVAL_CEXPR: return "cexpr";
        default: return "unknown";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0xe, %rax
ja 0x163c1
movq -0x18(%rbp), %rax
leaq 0x5699(%rip), %rcx      # 0x1b97c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x5819(%rip), %rax      # 0x1bb0c
movq %rax, -0x8(%rbp)
jmp 0x163cc
leaq 0x4fbd(%rip), %rax      # 0x1b2c0
movq %rax, -0x8(%rbp)
jmp 0x163cc
leaq 0x4d20(%rip), %rax      # 0x1b033
movq %rax, -0x8(%rbp)
jmp 0x163cc
leaq 0x57ed(%rip), %rax      # 0x1bb10
movq %rax, -0x8(%rbp)
jmp 0x163cc
leaq 0x4115(%rip), %rax      # 0x1a448
movq %rax, -0x8(%rbp)
jmp 0x163cc
leaq 0x4196(%rip), %rax      # 0x1a4d9
movq %rax, -0x8(%rbp)
jmp 0x163cc
leaq 0x57c6(%rip), %rax      # 0x1bb19
movq %rax, -0x8(%rbp)
jmp 0x163cc
leaq 0x57b8(%rip), %rax      # 0x1bb18
movq %rax, -0x8(%rbp)
jmp 0x163cc
leaq 0x57b0(%rip), %rax      # 0x1bb1d
movq %rax, -0x8(%rbp)
jmp 0x163cc
leaq 0x4f4a(%rip), %rax      # 0x1b2c4
movq %rax, -0x8(%rbp)
jmp 0x163cc
leaq 0x4f5e(%rip), %rax      # 0x1b2e5
movq %rax, -0x8(%rbp)
jmp 0x163cc
leaq 0x4f45(%rip), %rax      # 0x1b2d9
movq %rax, -0x8(%rbp)
jmp 0x163cc
leaq 0x4f3e(%rip), %rax      # 0x1b2df
movq %rax, -0x8(%rbp)
jmp 0x163cc
leaq 0x4f3c(%rip), %rax      # 0x1b2ea
movq %rax, -0x8(%rbp)
jmp 0x163cc
leaq 0x4f35(%rip), %rax      # 0x1b2f0
movq %rax, -0x8(%rbp)
jmp 0x163cc
leaq 0x5759(%rip), %rax      # 0x1bb21
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/types.c
// Function: awlval_err
awlval* awlval_err(const char* fmt, ...) {
    awlval* v = safe_malloc(sizeof(awlval));
    v->type = AWLVAL_ERR;

    va_list va;
    va_start(va, fmt);

    v->err = safe_malloc(512);
    vsnprintf(v->err, 512, fmt, va);

    unsigned int l = strlen(v->err) + 1;
    v->err = realloc(v->err, l);
    v->err[l - 1] = '\0';

    va_end(va);

    return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0x1663b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rsi, -0xe8(%rbp)
movq %rdi, -0x8(%rbp)
movl $0x38, %edi
callq 0x16720
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x2, (%rax)
leaq -0xf0(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x8, -0x30(%rbp)
movl $0x200, %edi            # imm = 0x200
movq %rdi, -0xf8(%rbp)
callq 0x16720
movq -0xf8(%rbp), %rsi
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0x20a0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x20f0
incl %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0x34(%rbp), %eax
movl %eax, %esi
callq 0x22a0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x34(%rbp), %ecx
decl %ecx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/types.c
// Function: awlval_int
awlval* awlval_int(long x) {
    awlval* v = safe_malloc(sizeof(awlval));
    v->type = AWLVAL_INT;
    v->lng = x;
    return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x38, %edi
callq 0x16720
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/types.c
// Function: awlval_float
awlval* awlval_float(double x) {
    awlval* v = safe_malloc(sizeof(awlval));
    v->type = AWLVAL_FLOAT;
    v->dbl = x;
    return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movsd %xmm0, -0x8(%rbp)
movl $0x38, %edi
callq 0x16720
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
movsd -0x8(%rbp), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/types.c
// Function: awlval_sym_base
static awlval* awlval_sym_base(const char* s) {
    awlval* v = safe_malloc(sizeof(awlval));
    v->length = strlen(s);
    v->sym = safe_malloc(strlen(s) + 1);
    strcpy(v->sym, s);
    return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x38, %edi
callq 0x16720
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20f0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rdi
callq 0x20f0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x16720
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x2070
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/types.c
// Function: awlval_str
awlval* awlval_str(const char* s) {
    awlval* v = safe_malloc(sizeof(awlval));
    v->type = AWLVAL_STR;
    v->length = strlen(s);
    v->str = safe_malloc(v->length + 1);
    strcpy(v->str, s);
    return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x38, %edi
callq 0x16720
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x5, (%rax)
movq -0x8(%rbp), %rdi
callq 0x20f0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x16720
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x2070
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/types.c
// Function: awlval_bool
awlval* awlval_bool(bool b) {
    awlval* v = safe_malloc(sizeof(awlval));
    v->type = AWLVAL_BOOL;
    v->bln = b;
    return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movl $0x38, %edi
callq 0x16720
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x6, (%rax)
movb -0x1(%rbp), %cl
movq -0x10(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x18(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/types.c
// Function: awlval_fun
awlval* awlval_fun(const awlbuiltin builtin, const char* builtin_name) {
    awlval* v = safe_malloc(sizeof(awlval));
    v->type = AWLVAL_BUILTIN;
    v->builtin = builtin;
    v->builtin_name = safe_malloc(strlen(builtin_name) + 1);
    strcpy(v->builtin_name, builtin_name);
    return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x38, %edi
callq 0x16720
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x7, (%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0x20f0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x16720
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x2070
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/types.c
// Function: awlval_lambda
awlval* awlval_lambda(awlenv* closure, awlval* formals, awlval* body) {
    awlval* v = safe_malloc(sizeof(awlval));
    v->type = AWLVAL_FN;
    v->env = awlenv_new();
    v->env->parent = closure;
    v->env->parent->references++;
    v->formals = formals;
    v->body = body;
    v->called = false;
    return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x38, %edi
callq 0x16720
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x8, (%rax)
callq 0x16a70
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rax
movb $0x0, 0x30(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/types.c
// Function: awlenv_new
awlenv* awlenv_new(void) {
    awlenv* e = safe_malloc(sizeof(awlenv));
    e->parent = NULL;
    e->internal_dict = dict_new(awlval_copy_proxy, awlval_del_proxy);
    e->top_level = false;
    e->references = 1;
    return e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x18, %edi
callq 0x16720
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
leaq 0xd8(%rip), %rdi        # 0x16b70
leaq 0xf1(%rip), %rsi        # 0x16b90
callq 0x6d50
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x14(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/types.c
// Function: awlval_dict
awlval* awlval_dict(void) {
    awlval* v = safe_malloc(sizeof(awlval));
    v->type = AWLVAL_DICT;
    v->count = 0;
    v->length = 0;
    v->d = dict_new(awlval_copy_proxy, awlval_del_proxy);
    return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x38, %edi
callq 0x16720
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0xa, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
leaq 0x23(%rip), %rdi        # 0x16b70
leaq 0x3c(%rip), %rsi        # 0x16b90
callq 0x6d50
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/types.c
// Function: awlval_sexpr
awlval* awlval_sexpr(void) {
    awlval* v = safe_malloc(sizeof(awlval));
    v->type = AWLVAL_SEXPR;
    v->count = 0;
    v->length = 0;
    v->cell = NULL;
    return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x38, %edi
callq 0x16720
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0xb, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/types.c
// Function: awlval_qexpr
awlval* awlval_qexpr(void) {
    awlval* v = safe_malloc(sizeof(awlval));
    v->type = AWLVAL_QEXPR;
    v->count = 0;
    v->length = 0;
    v->cell = NULL;
    return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x38, %edi
callq 0x16720
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0xc, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)