LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: fn_apply
static es_val_t fn_apply(es_ctx_t* ctx, int argc, es_val_t argv[])
{
  es_val_t proc = argv[0];
  es_val_t args = argv[1];

  es_val_t b = ctx->bytecode;
  int start = bytecode_label(b);
  emit_pop(b);

  int nargs = 0;
  while (!es_is_nil(args)) {
    emit_const(b, alloc_const(b, es_car(args)));
    args = es_cdr(args);
    nargs++;
  }

  emit_const(b, alloc_const(b, proc));
  emit_tail_call(b, nargs);
  save(ctx);
  ctx->ip = es_bytecode_val(b)->inst + start;

  return es_void;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x42060(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x46d0
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rdi
callq 0x6e10
movl $0x0, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0x30d0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x6aac
jmp 0x6af4
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1ef0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x6ec0
movq -0x40(%rbp), %rdi
movl %eax, %esi
callq 0x6e60
movq -0x28(%rbp), %rdi
callq 0x1f20
movq %rax, -0x28(%rbp)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x6a95
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6ec0
movq -0x50(%rbp), %rdi
movl %eax, %esi
callq 0x6e60
movq -0x30(%rbp), %rdi
movl -0x38(%rbp), %esi
callq 0x6fa0
movq -0x8(%rbp), %rax
movq 0x42088(%rax), %rcx
movq -0x8(%rbp), %rax
addq $0x4a090, %rax          # imm = 0x4A090
movq -0x8(%rbp), %rdx
movslq 0x42078(%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x42068(%rax), %rcx
movq -0x8(%rbp), %rax
addq $0x4a090, %rax          # imm = 0x4A090
movq -0x8(%rbp), %rdx
movslq 0x42078(%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x42078(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x42078(%rax)
movq -0x30(%rbp), %rdi
callq 0x7000
movq 0x8018(%rax), %rcx
movslq -0x34(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x42068(%rax)
movl $0x5b, %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: fn_string_ref
static es_val_t fn_string_ref(es_ctx_t* ctx, int argc, es_val_t argv[])
{
  es_val_t str = argv[0];
  int k = es_fixnum_val(argv[1]);
  int c = es_string_ref(str, k);
  return es_make_char(c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1cc0
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x2d90
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %edi
callq 0x1a70
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: alloc_const
static int alloc_const(es_val_t code, es_val_t v)
{
  es_bytecode_t* b = es_bytecode_val(code);
  assert(b->next_const < b->cpool_size);
  for(int i = 0; i < b->next_const; i++) {
    if (es_is_eq(v, b->consts[i]))
      return i;
  }
  b->consts[b->next_const] = v;
  return b->next_const++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7000
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x8014(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x8010(%rcx), %eax
jge 0x6ef5
jmp 0x6f14
leaq 0x35b4(%rip), %rdi      # 0xa4b0
leaq 0x32fb(%rip), %rsi      # 0xa1fe
movl $0x62c, %edx            # imm = 0x62C
leaq 0x35bf(%rip), %rcx      # 0xa4ce
callq 0x10b0
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x8014(%rcx), %eax
jge 0x6f5a
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rsi
callq 0x18a0
cmpl $0x0, %eax
je 0x6f4d
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6f8a
jmp 0x6f4f
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x6f1b
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq 0x8014(%rcx), %rcx
movq %rdx, 0x10(%rax,%rcx,8)
movq -0x20(%rbp), %rcx
movl 0x8014(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x8014(%rcx)
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: emit
static void emit(es_val_t code, es_inst_t inst)
{
  es_bytecode_t* b = es_bytecode_val(code);
  if (b->next_inst >= b->inst_size) {
    b->inst_size += b->inst_size / 2;
    b->inst = realloc(b->inst, b->inst_size);
  }

  b->inst[b->next_inst++] = inst;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7000
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x8024(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x8020(%rcx), %eax
jl 0x7094
movq -0x20(%rbp), %rax
movl 0x8020(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x20(%rbp), %rax
addl 0x8020(%rax), %ecx
movl %ecx, 0x8020(%rax)
movq -0x20(%rbp), %rax
movq 0x8018(%rax), %rdi
movq -0x20(%rbp), %rax
movslq 0x8020(%rax), %rsi
callq 0x1100
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8018(%rax)
movq -0x20(%rbp), %rax
movq 0x8018(%rax), %rax
movq -0x20(%rbp), %rdx
movl 0x8024(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x8024(%rdx)
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: heap_alloc
static void* heap_alloc(es_heap_t* heap, size_t size)
{
  char* mem = alignp(heap->next, ES_DEFAULT_ALIGNMENT);
  if (size > (heap->end - mem)) {
    return NULL;
  }
  heap->next = mem + size;
  return mem;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x10, %rax
subq $0x1, %rax
andq $-0x10, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
movq -0x20(%rbp), %rdx
subq %rdx, %rcx
cmpq %rcx, %rax
jbe 0x7126
movq $0x0, -0x8(%rbp)
jmp 0x713e
movq -0x20(%rbp), %rcx
addq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: es_char_print
static void es_char_print(es_ctx_t* ctx, es_val_t val, es_val_t port)
{
  int c = es_char_val(val);
  switch(c) {
    case ' ':  es_port_printf(ctx, port, "#\\space");   break;
    case '\n': es_port_printf(ctx, port, "#\\newline"); break;
    case '\t': es_port_printf(ctx, port, "#\\tab");     break;
    default:   es_port_printf(ctx, port, "#\\%c", c);   break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1a90
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
subl $0x9, %eax
je 0x7371
jmp 0x732d
movl -0x20(%rbp), %eax
subl $0xa, %eax
je 0x7359
jmp 0x7337
movl -0x20(%rbp), %eax
subl $0x20, %eax
jne 0x7389
jmp 0x7341
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x320b(%rip), %rdx      # 0xa55b
movb $0x0, %al
callq 0x19d0
jmp 0x73a2
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x31fb(%rip), %rdx      # 0xa563
movb $0x0, %al
callq 0x19d0
jmp 0x73a2
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x31ed(%rip), %rdx      # 0xa56d
movb $0x0, %al
callq 0x19d0
jmp 0x73a2
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %ecx
leaq 0x31d8(%rip), %rdx      # 0xa573
movb $0x0, %al
callq 0x19d0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: es_pair_print
static void es_pair_print(es_ctx_t* ctx, es_val_t val, es_val_t port)
{
  es_val_t list = val;
  es_port_printf(ctx, port, "(");
  while(es_is_pair(es_cdr(list))) {
    es_port_printf(ctx, port, "%@ ", es_car(list));
    list = es_cdr(list);
  }
  es_port_write(ctx, port, es_car(list));
  if (!es_is_nil(es_cdr(list))) {
    es_port_printf(ctx, port, " . %@", es_cdr(list));
  }
  es_port_printf(ctx, port, ")");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x3152(%rip), %rdx      # 0xa57d
movb $0x0, %al
callq 0x19d0
movq -0x20(%rbp), %rdi
callq 0x1f20
movq %rax, %rdi
callq 0x1ec0
cmpl $0x0, %eax
je 0x7489
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1ef0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rcx
leaq 0x310c(%rip), %rdx      # 0xa57f
movb $0x0, %al
callq 0x19d0
movq -0x20(%rbp), %rdi
callq 0x1f20
movq %rax, -0x20(%rbp)
jmp 0x7432
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1ef0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
callq 0x1870
movq -0x20(%rbp), %rdi
callq 0x1f20
movq %rax, %rdi
callq 0x30d0
cmpl $0x0, %eax
jne 0x74fa
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1f20
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq %rax, %rcx
leaq 0x3090(%rip), %rdx      # 0xa583
movb $0x0, %al
callq 0x19d0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x2ff9(%rip), %rdx      # 0xa502
movb $0x0, %al
callq 0x19d0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: es_vector_print
static void es_vector_print(es_ctx_t* ctx, es_val_t self, es_val_t port)
{
  int i, len;
  es_port_printf(ctx, port, "#(%@", es_vector_ref(self, 0));
  for(i = 1, len = es_vector_len(self); i < len; i++) {
    es_port_printf(ctx, port, " %@", es_vector_ref(self, i));
  }
  es_port_printf(ctx, port, ")");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x3270
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rcx
leaq 0x3028(%rip), %rdx      # 0xa589
movb $0x0, %al
callq 0x19d0
movl $0x1, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3200
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x75c3
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x3270
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rcx
leaq 0x2fd4(%rip), %rdx      # 0xa585
movb $0x0, %al
callq 0x19d0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x757b
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x2f30(%rip), %rdx      # 0xa502
movb $0x0, %al
callq 0x19d0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: es_bytecode_print
static void es_bytecode_print(es_ctx_t* ctx, es_val_t val, es_val_t port)
{
  es_bytecode_t* bc = es_bytecode_val(val);
  int i;
  i = 0;
  es_port_printf(ctx, port, "#<bytecode:\n");
  while(i < bc->next_inst) {
    es_port_printf(ctx, port, "%4d: ", i);
    print_inst(ctx, port, bc->inst + i);
    i++;
    es_port_printf(ctx, port, "\n");
  }
  es_port_printf(ctx, port, ",\n");
  es_port_printf(ctx, port,"const pool:\n");
  for(i = 0; i < bc->next_const; i++) {
    es_port_printf(ctx, port,"%4d: ", i);
    es_port_write(ctx, port, bc->consts[i]);
    es_port_printf(ctx, port, "\n");
  }
  es_port_printf(ctx, port, ">");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7000
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x2f34(%rip), %rdx      # 0xa59b
movb $0x0, %al
callq 0x19d0
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x8024(%rcx), %eax
jge 0x76da
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x24(%rbp), %ecx
leaq 0x2f19(%rip), %rdx      # 0xa5a8
movb $0x0, %al
callq 0x19d0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x8018(%rax), %rdx
movslq -0x24(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdx
callq 0x7930
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x2c31(%rip), %rdx      # 0xa302
movb $0x0, %al
callq 0x19d0
jmp 0x766e
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x2ec5(%rip), %rdx      # 0xa5ae
movb $0x0, %al
callq 0x19d0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x2eb2(%rip), %rdx      # 0xa5b1
movb $0x0, %al
callq 0x19d0
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x8014(%rcx), %eax
jge 0x7770
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x24(%rbp), %ecx
leaq 0x2e7a(%rip), %rdx      # 0xa5a8
movb $0x0, %al
callq 0x19d0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rdx
callq 0x1870
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x2ba4(%rip), %rdx      # 0xa302
movb $0x0, %al
callq 0x19d0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x770d
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x2db2(%rip), %rdx      # 0xa531
movb $0x0, %al
callq 0x19d0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: es_proc_print
static void es_proc_print(es_ctx_t* ctx, es_val_t val, es_val_t port)
{
  es_proc_t* proc = es_proc_val(val);
  es_port_printf(ctx, port,"#<compiled-procedure\n");
  es_bytecode_t* bcode = es_bytecode_val(ctx->bytecode);
  for(int i = proc->addr; i < proc->end; i++) {
    print_inst(ctx, port, bcode->inst + i);
    es_port_printf(ctx, port, "\n");
  }
  es_port_printf(ctx, port, ">");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2c10
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x2e0d(%rip), %rdx      # 0xa5cd
movb $0x0, %al
callq 0x19d0
movq -0x8(%rbp), %rax
movq 0x42060(%rax), %rdi
callq 0x7000
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jge 0x7835
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rax
movq 0x8018(%rax), %rdx
movslq -0x2c(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdx
callq 0x7930
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x2adf(%rip), %rdx      # 0xa302
movb $0x0, %al
callq 0x19d0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x77e5
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x2ced(%rip), %rdx      # 0xa531
movb $0x0, %al
callq 0x19d0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: es_env_print
static void es_env_print(es_ctx_t* ctx, es_val_t _env, es_val_t port)
{
  es_env_t* env = es_env_val(_env);
  es_port_printf(ctx, port, "#<env:\n");
  for(int i = 0; i < env->count; i++) {
    es_port_printf(ctx, port, "%4d: [%@: %@]\n",
      i, env->slots[i].sym, env->slots[i].val);
  }
  es_port_printf(ctx, port, ">");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7240
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x2d53(%rip), %rdx      # 0xa5e3
movb $0x0, %al
callq 0x19d0
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x78fb
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %rax
addq $0x18, %rax
movslq -0x24(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq 0x8(%rax), %r8
movq -0x20(%rbp), %rax
addq $0x18, %rax
movslq -0x24(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq (%rax), %r9
leaq 0x2d02(%rip), %rdx      # 0xa5eb
movb $0x0, %al
callq 0x19d0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x789e
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x2c27(%rip), %rdx      # 0xa531
movb $0x0, %al
callq 0x19d0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: print_inst
static void print_inst(es_ctx_t* ctx, es_val_t port, es_inst_t* inst)
{
  es_inst_info_t* i = es_vm_run(NULL, ES_VM_FETCH_OPCODE, inst->opcode);
  switch(i->arity) {
  case 0:
    es_port_printf(ctx, port, "%s", i->name);
    break;
  case 1:
    es_port_printf(ctx, port, "%s %d", i->name, inst->operand1);
    break;
  case 2:
    es_port_printf(ctx, port, "%s %d %d", i->name, inst->operand1, inst->operand2);
    break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdx
xorl %esi, %esi
movl %esi, %edi
movb %sil, %al
callq 0x4ca0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0x797f
jmp 0x796b
movl -0x24(%rbp), %eax
subl $0x1, %eax
je 0x799f
jmp 0x7975
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0x79c8
jmp 0x79f8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
leaq 0x2bc2(%rip), %rdx      # 0xa558
movb $0x0, %al
callq 0x19d0
jmp 0x79f8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movswl 0x8(%rax), %r8d
leaq 0x2bff(%rip), %rdx      # 0xa5be
movb $0x0, %al
callq 0x19d0
jmp 0x79f8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movswl 0x8(%rax), %r8d
movq -0x18(%rbp), %rax
movswl 0xa(%rax), %r9d
leaq 0x2bd3(%rip), %rdx      # 0xa5c4
movb $0x0, %al
callq 0x19d0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: peek
static es_token_t peek(es_val_t port, char* pbuf)
{
  es_port_mark(port);
  es_token_t t = next(port, pbuf);
  es_port_reset(port);
  return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x25e0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7a90
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x26b0
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: reverse
static es_val_t reverse(es_val_t lst)
{
  es_val_t res = es_nil;
  while(!es_is_nil(lst)) {
    es_val_t next = es_cdr(lst);
    es_pair_set_tail(lst, res);
    res = lst;
    lst = next;
  }
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x3, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x30d0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x7e4b
jmp 0x7e77
movq -0x8(%rbp), %rdi
callq 0x1f20
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1f70
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7e34
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: parse_list
static es_val_t parse_list(es_ctx_t* ctx, es_val_t port)
{
  char buf[1024];
  if (peek(port, buf) == tk_rpar) {
    next(port, buf);
    return es_nil;
  }
  es_val_t e = es_parse(ctx, port);
  if (es_is_error(e)) return e;
  es_val_t lst = es_cons(ctx, e, es_nil);
  es_val_t node = lst;
  while(peek(port, buf) != tk_rpar) {
    if (peek(port, buf) == tk_dot) {
      next(port, buf);
      es_set_cdr(node, es_parse(ctx, port));
      if (peek(port, buf) != tk_rpar) {
        printf("error syntax dotted list [Line %d, Column: %d]\n", es_port_linum(port), es_port_colnum(port));
        eat_line(port);
        return es_make_error(ctx, "syntax dotted list");
      }
      next(port, buf);
      return lst;
    }
    es_set_cdr(node, es_cons(ctx, es_parse(ctx, port), es_nil));
    node = es_cdr(node);
  }
  next(port, buf);
  return lst;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x460, %rsp            # imm = 0x460
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x420(%rbp), %rsi
callq 0x7de0
cmpl $0x3, %eax
jne 0x7ed5
movq -0x18(%rbp), %rdi
leaq -0x420(%rbp), %rsi
callq 0x7a90
movq $0x3, -0x8(%rbp)
jmp 0x809e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x20e0
movq %rax, -0x428(%rbp)
movq -0x428(%rbp), %rdi
callq 0x1c40
cmpl $0x0, %eax
je 0x7f0a
movq -0x428(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x809e
movq -0x10(%rbp), %rdi
movq -0x428(%rbp), %rsi
movl $0x3, %edx
callq 0x1e10
movq %rax, -0x430(%rbp)
movq -0x430(%rbp), %rax
movq %rax, -0x438(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x420(%rbp), %rsi
callq 0x7de0
cmpl $0x3, %eax
je 0x8083
movq -0x18(%rbp), %rdi
leaq -0x420(%rbp), %rsi
callq 0x7de0
cmpl $0x9, %eax
jne 0x8022
movq -0x18(%rbp), %rdi
leaq -0x420(%rbp), %rsi
callq 0x7a90
movq -0x438(%rbp), %rax
movq %rax, -0x440(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x20e0
movq -0x440(%rbp), %rdi
movq %rax, %rsi
callq 0x1f70
movq -0x18(%rbp), %rdi
leaq -0x420(%rbp), %rsi
callq 0x7de0
cmpl $0x3, %eax
je 0x8005
movq -0x18(%rbp), %rdi
callq 0x2870
movl %eax, -0x444(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2890
movl -0x444(%rbp), %esi
movl %eax, %edx
leaq 0x2687(%rip), %rdi      # 0xa663
movb $0x0, %al
callq 0x1090
movq -0x18(%rbp), %rdi
callq 0x8360
movq -0x10(%rbp), %rdi
leaq 0x269c(%rip), %rsi      # 0xa693
callq 0x1b90
movq %rax, -0x8(%rbp)
jmp 0x809e
movq -0x18(%rbp), %rdi
leaq -0x420(%rbp), %rsi
callq 0x7a90
movq -0x430(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x809e
movq -0x438(%rbp), %rax
movq %rax, -0x450(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x458(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x20e0
movq -0x458(%rbp), %rdi
movq %rax, %rsi
movl $0x3, %edx
callq 0x1e10
movq -0x450(%rbp), %rdi
movq %rax, %rsi
callq 0x1f70
movq -0x438(%rbp), %rdi
callq 0x1f20
movq %rax, -0x438(%rbp)
jmp 0x7f34
movq -0x18(%rbp), %rdi
leaq -0x420(%rbp), %rsi
callq 0x7a90
movq -0x430(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x460, %rsp            # imm = 0x460
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: escape
static int escape(int c)
{
  switch(c) {
  case 'a': return '\a';
  case 'b': return '\b';
  case 'f': return '\f';
  case 'n': return '\n';
  case 'r': return '\r';
  case 't': return '\t';
  case 'v': return '\v';
  default:  return c;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
addl $-0x61, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x15, %eax
ja 0x816b
movq -0x10(%rbp), %rax
leaq 0x2035(%rip), %rcx      # 0xa158
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x7, -0x4(%rbp)
jmp 0x8171
movl $0x8, -0x4(%rbp)
jmp 0x8171
movl $0xc, -0x4(%rbp)
jmp 0x8171
movl $0xa, -0x4(%rbp)
jmp 0x8171
movl $0xd, -0x4(%rbp)
jmp 0x8171
movl $0x9, -0x4(%rbp)
jmp 0x8171
movl $0xb, -0x4(%rbp)
jmp 0x8171
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: step
static lstate_t step(lstate_t s, int c)
{
  if (s == lstate_start) {
    if (strchr("+-", c)) s = lstate_sign;
    else if (isdigit(c)) s = lstate_int;
    else if ('.' == c)   s = lstate_dot;
    else                 s = lstate_sym;
  } else if (s == lstate_sign) {
    s = isdigit(c) ? lstate_int : lstate_sym;
  } else if (s == lstate_int) {
    if (!isdigit(c) && !eot(c)) s = lstate_sym;
  } else if (s == lstate_dot && !eot(c)) {
    s = lstate_sym;
  }
  return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x81f8
movl -0x8(%rbp), %esi
leaq 0x24c2(%rip), %rdi      # 0xa660
callq 0x1080
cmpq $0x0, %rax
je 0x81b2
movl $0x1, -0x4(%rbp)
jmp 0x81f3
callq 0x1180
movq (%rax), %rax
movslq -0x8(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x81d5
movl $0x2, -0x4(%rbp)
jmp 0x81f1
movl $0x2e, %eax
cmpl -0x8(%rbp), %eax
jne 0x81e8
movl $0x3, -0x4(%rbp)
jmp 0x81ef
movl $0x4, -0x4(%rbp)
jmp 0x81f1
jmp 0x81f3
jmp 0x829b
cmpl $0x1, -0x4(%rbp)
jne 0x8229
callq 0x1180
movq (%rax), %rax
movslq -0x8(%rbp), %rcx
movzwl (%rax,%rcx,2), %edx
andl $0x800, %edx            # imm = 0x800
movl $0x4, %eax
movl $0x2, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x8299
cmpl $0x2, -0x4(%rbp)
jne 0x826d
callq 0x1180
movq (%rax), %rax
movslq -0x8(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0x826b
movl -0x8(%rbp), %esi
leaq 0x23ff(%rip), %rdi      # 0xa652
callq 0x1080
cmpq $0x0, %rax
jne 0x826b
cmpl $-0x1, -0x8(%rbp)
je 0x826b
movl $0x4, -0x4(%rbp)
jmp 0x8297
cmpl $0x3, -0x4(%rbp)
jne 0x8295
movl -0x8(%rbp), %esi
leaq 0x23d5(%rip), %rdi      # 0xa652
callq 0x1080
cmpq $0x0, %rax
jne 0x8295
cmpl $-0x1, -0x8(%rbp)
je 0x8295
movl $0x4, -0x4(%rbp)
jmp 0x8297
jmp 0x8299
jmp 0x829b
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: eat_ws
static int eat_ws(es_val_t port)
{
  int res = 0;
  while(isspace(ppeekc(port))) {
    pgetc(port);
    res = 1;
  }
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
callq 0x1180
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2570
movl %eax, %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x8301
movq -0x8(%rbp), %rdi
callq 0x2370
movl $0x1, -0xc(%rbp)
jmp 0x82c3
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: symtab_id_by_string
static int symtab_id_by_string(es_symtab_t* symtab, const char* cstr)
{
  for(int i = 0; i < symtab->next_id; i++) {
    if (strcmp(symtab->table[i], cstr) == 0) {
      return i;
    }
  }
  return -1;
}

// 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 0x40000(%rcx), %eax
jge 0x83e5
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
callq 0x10d0
cmpl $0x0, %eax
jne 0x83d8
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x83ec
jmp 0x83da
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x83a7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: symtab_add_string
static int symtab_add_string(es_symtab_t* symtab, const char* cstr)
{
  if (symtab->next_id >= ES_SYMTAB_SIZE) {
    return -1;
  }

  char* newstr = malloc(strlen(cstr) + 1);
  strcpy(newstr, cstr);
  symtab->table[symtab->next_id] = newstr;
  return symtab->next_id++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x8000, 0x40000(%rax)  # imm = 0x8000
jl 0x8429
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x847e
movq -0x18(%rbp), %rdi
callq 0x1070
movq %rax, %rdi
addq $0x1, %rdi
callq 0x10f0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1050
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0x40000(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rcx
movl 0x40000(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x40000(%rcx)
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: compile_ref
static es_val_t compile_ref(es_ctx_t* ctx, es_val_t bc, es_val_t sym, int tail_pos, int next, es_val_t scope)
{
  int idx, depth;
  if (arg_idx(scope, sym, &idx, &depth)) {
    if (depth == 0) {
      emit_arg_ref(bc, idx);
    } else {
      emit_closed_ref(bc, depth, idx);
    }
  } else {
    emit_global_ref(bc, env_reserve_loc(ctx, es_ctx_env(ctx), sym, es_unbound));
  }
  if (tail_pos) emit(bc, (es_inst_t){ opcode(next) });
  return es_void;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0x9380
cmpl $0x0, %eax
je 0x87be
cmpl $0x0, -0x30(%rbp)
jne 0x87ad
movq -0x10(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x9670
jmp 0x87bc
movq -0x10(%rbp), %rdi
movl -0x30(%rbp), %esi
movl -0x2c(%rbp), %edx
callq 0x96d0
jmp 0x87f7
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
callq 0x14b0
movq -0x50(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
movl $0x4b, %ecx
callq 0x3450
movq -0x48(%rbp), %rdi
movl %eax, %esi
callq 0x9730
cmpl $0x0, -0x1c(%rbp)
je 0x8839
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0x20(%rbp), %edx
xorl %eax, %eax
movl %eax, %edi
xorl %esi, %esi
movb $0x0, %al
callq 0x4ca0
movq -0x58(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movw $0x0, -0x38(%rbp)
movw $0x0, -0x36(%rbp)
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x7010
movl $0x5b, %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: compile_if
static es_val_t compile_if(es_ctx_t* ctx, es_val_t bc, es_val_t exp, int tail_pos, int next, es_val_t scope)
{
  es_val_t cond = es_cadr(exp);
  es_val_t bthen = es_caddr(exp);
  compile(ctx, bc, cond, 0, 0, scope);
  int label1 = bytecode_label(bc);
  emit_bf(bc, -1);
  compile(ctx, bc, bthen, tail_pos, next, scope);
  int label2 = bytecode_label(bc);
  if (!tail_pos) emit_jmp(bc, -1);
  int label3 = bytecode_label(bc);
  if (!es_is_nil(es_cdddr(exp))) {
    es_val_t belse = es_cadddr(exp);
    compile(ctx, bc, belse, tail_pos, next, scope);
  } else {
    emit_const(bc, alloc_const(bc, es_undefined));
  }
  int label4 = bytecode_label(bc);
  es_bytecode_val(bc)->inst[label1].operand1 = label3 - label1;
  if (!tail_pos) es_bytecode_val(bc)->inst[label2].operand1 = label4 - label2;
  return es_void;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1f20
movq %rax, %rdi
callq 0x1ef0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1f20
movq %rax, %rdi
callq 0x1f20
movq %rax, %rdi
callq 0x1ef0
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %r9
xorl %r8d, %r8d
movl %r8d, %ecx
callq 0x4700
movq -0x10(%rbp), %rdi
callq 0x46d0
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x90f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x38(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movq -0x28(%rbp), %r9
callq 0x4700
movq -0x10(%rbp), %rdi
callq 0x46d0
movl %eax, -0x40(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x8bb2
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x9150
movq -0x10(%rbp), %rdi
callq 0x46d0
movl %eax, -0x44(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1f20
movq %rax, %rdi
callq 0x1f20
movq %rax, %rdi
callq 0x1f20
movq %rax, %rdi
callq 0x30d0
cmpl $0x0, %eax
jne 0x8c27
movq -0x18(%rbp), %rdi
callq 0x1f20
movq %rax, %rdi
callq 0x1f20
movq %rax, %rdi
callq 0x1f20
movq %rax, %rdi
callq 0x1ef0
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x50(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movq -0x28(%rbp), %r9
callq 0x4700
jmp 0x8c48
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
movl $0x53, %esi
callq 0x6ec0
movq -0x60(%rbp), %rdi
movl %eax, %esi
callq 0x6e60
movq -0x10(%rbp), %rdi
callq 0x46d0
movl %eax, -0x54(%rbp)
movl -0x44(%rbp), %eax
subl -0x3c(%rbp), %eax
movw %ax, -0x62(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7000
movw -0x62(%rbp), %cx
movq 0x8018(%rax), %rax
movslq -0x3c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movw %cx, 0x8(%rax)
cmpl $0x0, -0x1c(%rbp)
jne 0x8cb4
movl -0x54(%rbp), %eax
subl -0x40(%rbp), %eax
movw %ax, -0x64(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7000
movw -0x64(%rbp), %cx
movq 0x8018(%rax), %rax
movslq -0x40(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movw %cx, 0x8(%rax)
movl $0x5b, %eax
addq $0x70, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: compile_lambda
static es_val_t compile_lambda(es_ctx_t* ctx, es_val_t bc, es_val_t formals, es_val_t body, int tail_pos, int next, es_val_t scope)
{
  int label1 = bytecode_label(bc);
  emit_jmp(bc, -1);
  int label2 = bytecode_label(bc);
  scope = make_scope(ctx, formals, scope);
  compile_seq(ctx, bc, body, 1, RETURN, scope);
  int label3 = bytecode_label(bc);
  int rest;
  int arity = lambda_arity(formals, &rest);
  es_val_t proc = es_make_proc(ctx, arity, rest, label2, label3);
  emit_closure(bc, alloc_const(bc, proc));
  es_bytecode_val(bc)->inst[label1].operand1 = label3 - label1;
  if (tail_pos) emit(bc, (es_inst_t){ opcode(next) });
  return es_void;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x46d0
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x9150
movq -0x10(%rbp), %rdi
callq 0x46d0
movl %eax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq 0x10(%rbp), %rdx
callq 0x91b0
movq %rax, 0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq 0x10(%rbp), %r9
movl $0x1, %ecx
movl $0xd, %r8d
callq 0x8e10
movq -0x10(%rbp), %rdi
callq 0x46d0
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x91f0
movl %eax, -0x3c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x3c(%rbp), %esi
movl -0x38(%rbp), %edx
movl -0x30(%rbp), %ecx
movl -0x34(%rbp), %r8d
callq 0x2ba0
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x6ec0
movq -0x68(%rbp), %rdi
movl %eax, %esi
callq 0x9280
movl -0x34(%rbp), %eax
subl -0x2c(%rbp), %eax
movw %ax, -0x5a(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7000
movw -0x5a(%rbp), %cx
movq 0x8018(%rax), %rax
movslq -0x2c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movw %cx, 0x8(%rax)
cmpl $0x0, -0x24(%rbp)
je 0x8e04
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movl -0x28(%rbp), %edx
xorl %eax, %eax
movl %eax, %edi
xorl %esi, %esi
movb $0x0, %al
callq 0x4ca0
movq -0x70(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movw $0x0, -0x50(%rbp)
movw $0x0, -0x4e(%rbp)
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0x7010
movl $0x5b, %eax
addq $0x70, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: compile_seq
static es_val_t compile_seq(es_ctx_t* ctx, es_val_t bc, es_val_t seq, int tail_pos, int next, es_val_t scope)
{
  while(!es_is_nil(es_cdr(seq))) {
    compile(ctx, bc, es_car(seq), 0, 0, scope);
    emit_pop(bc);
    seq = es_cdr(seq);
  }
  compile(ctx, bc, es_car(seq), tail_pos, next, scope);
  return es_void;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1f20
movq %rax, %rdi
callq 0x30d0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x8e4e
jmp 0x8e99
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1ef0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
movq -0x28(%rbp), %r9
xorl %r8d, %r8d
movl %r8d, %ecx
callq 0x4700
movq -0x10(%rbp), %rdi
callq 0x6e10
movq -0x18(%rbp), %rdi
callq 0x1f20
movq %rax, -0x18(%rbp)
jmp 0x8e2f
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1ef0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %rax, %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movq -0x28(%rbp), %r9
callq 0x4700
movl $0x5b, %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: compile_set
static es_val_t compile_set(es_ctx_t* ctx, es_val_t bc, es_val_t sym, es_val_t exp, int tail_pos, int next, es_val_t scope)
{
  compile(ctx, bc, exp, 0, 0, scope);
  int idx, depth;
  if (arg_idx(scope, sym, &idx, &depth)) {
    depth == 0 ? emit_arg_set(bc, idx) : emit_closed_set(bc, depth, idx);
  } else {
    emit_global_set(bc, env_reserve_loc(ctx, es_ctx_env(ctx), sym, es_unbound));
  }
  if (tail_pos) emit(bc, (es_inst_t){ opcode(next) });
  return es_void;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq 0x10(%rbp), %r9
xorl %r8d, %r8d
movl %r8d, %ecx
callq 0x4700
movq 0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0x9380
cmpl $0x0, %eax
je 0x8f5e
cmpl $0x0, -0x30(%rbp)
jne 0x8f4d
movq -0x10(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x9450
jmp 0x8f5c
movq -0x10(%rbp), %rdi
movl -0x30(%rbp), %esi
movl -0x2c(%rbp), %edx
callq 0x94b0
jmp 0x8f97
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
callq 0x14b0
movq -0x50(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
movl $0x4b, %ecx
callq 0x3450
movq -0x48(%rbp), %rdi
movl %eax, %esi
callq 0x9090
cmpl $0x0, -0x24(%rbp)
je 0x8fd9
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0x28(%rbp), %edx
xorl %eax, %eax
movl %eax, %edi
xorl %esi, %esi
movb $0x0, %al
callq 0x4ca0
movq -0x58(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movw $0x0, -0x38(%rbp)
movw $0x0, -0x36(%rbp)
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x7010
movl $0x5b, %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: compile_call
static es_val_t compile_call(es_ctx_t* ctx, es_val_t bc, es_val_t exp, int tail_pos, int next, es_val_t scope)
{
  es_val_t op   = es_car(exp);
  es_val_t args = es_cdr(exp);
  int argc      = es_list_length(args);
  compile_args(ctx, bc, args, scope);
  compile(ctx, bc, op, 0, 0, scope);
  if (tail_pos) {
    emit_tail_call(bc, argc);
  } else {
    emit_call(bc, argc);
  }
  return es_void;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1ef0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1f20
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x3360
movl %eax, -0x3c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x95d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %r9
xorl %r8d, %r8d
movl %r8d, %ecx
callq 0x4700
cmpl $0x0, -0x1c(%rbp)
je 0x9079
movq -0x10(%rbp), %rdi
movl -0x3c(%rbp), %esi
callq 0x6fa0
jmp 0x9085
movq -0x10(%rbp), %rdi
movl -0x3c(%rbp), %esi
callq 0x5bf0
movl $0x5b, %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: lambda_arity
static int lambda_arity(es_val_t formals, int* rest)
{
  int arity = 0;
  if (es_is_symbol(formals)) {
    *rest = 1;
    return arity;
  } else {
    while(es_is_pair(formals)) {
      arity++;
      formals = es_cdr(formals);
    }
    *rest = es_is_nil(formals) ? 0 : 1;
    return arity;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2e50
cmpl $0x0, %eax
je 0x9227
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x9273
jmp 0x9229
movq -0x10(%rbp), %rdi
callq 0x1ec0
cmpl $0x0, %eax
je 0x924f
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1f20
movq %rax, -0x10(%rbp)
jmp 0x9229
movq -0x10(%rbp), %rdi
callq 0x30d0
movl %eax, %edx
movl $0x1, %ecx
xorl %eax, %eax
cmpl $0x0, %edx
cmovnel %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: flatten_args
static es_val_t flatten_args(es_ctx_t* ctx, es_val_t args)
{
  if (es_is_nil(args)) {
    return es_nil;
  } else if (es_is_symbol(args)) {
    return es_cons(ctx, args, es_nil);
  } else {
    return es_cons(ctx, es_car(args), flatten_args(ctx, es_cdr(args)));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x30d0
cmpl $0x0, %eax
je 0x9308
movq $0x3, -0x8(%rbp)
jmp 0x9374
movq -0x18(%rbp), %rdi
callq 0x2e50
cmpl $0x0, %eax
je 0x932e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x3, %edx
callq 0x1e10
movq %rax, -0x8(%rbp)
jmp 0x9374
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1ef0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1f20
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x92e0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq %rax, %rdx
callq 0x1e10
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: arg_idx
static int arg_idx(es_val_t scope, es_val_t symbol, int* pidx, int* pdepth)
{
  int idx   = -1;
  int depth = 0;

  while(!es_is_nil(scope)
    && (idx = index_of(scope_args(scope), symbol)) == -1
    && !es_is_nil((scope = scope_parent(scope)))
  ) {
    depth++;
  }
  if (idx == -1) return 0;
  *pidx   = idx;
  *pdepth = depth;
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30d0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x31(%rbp)
jne 0x93ff
movq -0x10(%rbp), %rdi
callq 0x9590
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x9510
movl %eax, %ecx
movl %ecx, -0x2c(%rbp)
xorl %eax, %eax
cmpl $-0x1, %ecx
movb %al, -0x31(%rbp)
jne 0x93ff
movq -0x10(%rbp), %rdi
callq 0x95b0
movq %rax, %rdi
movq %rdi, -0x10(%rbp)
callq 0x30d0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x9408
jmp 0x9413
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x93a6
cmpl $-0x1, -0x2c(%rbp)
jne 0x9422
movl $0x0, -0x4(%rbp)
jmp 0x943b
movl -0x2c(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl -0x30(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: index_of
static int index_of(es_val_t lst, es_val_t e)
{
  for(int i = 0; !es_is_nil(lst); i++, lst = es_cdr(lst)) {
    if (es_is_eq(es_car(lst), e))
      return i;
  }
  return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30d0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x953e
jmp 0x957a
movq -0x10(%rbp), %rdi
callq 0x1ef0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x18a0
cmpl $0x0, %eax
je 0x9560
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x9581
jmp 0x9562
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1f20
movq %rax, -0x10(%rbp)
jmp 0x9527
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: compile_args
static es_val_t compile_args(es_ctx_t* ctx, es_val_t bc, es_val_t args, es_val_t scope)
{
  if (!es_is_nil(args)) {
    compile(ctx, bc, es_car(args), 0, 0, scope);
    compile_args(ctx, bc, es_cdr(args), scope);
  }
  return es_void;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x30d0
cmpl $0x0, %eax
jne 0x9656
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1ef0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
movq -0x20(%rbp), %r9
xorl %r8d, %r8d
movl %r8d, %ecx
callq 0x4700
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1f20
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
movq -0x20(%rbp), %rcx
callq 0x95d0
movl $0x5b, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: env_set
static es_val_t env_set(es_ctx_t* ctx, es_val_t env, int slot, es_val_t val)
{
  es_env_t* e = es_env_val(env);
  if (es_is_unbound(e->slots[slot].val)) {
    return es_make_error(ctx, "unbound symbol");
  }
  e->slots[slot].val = val;
  return es_void;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7240
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x18, %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x3010
cmpl $0x0, %eax
je 0x980a
movq -0x10(%rbp), %rdi
leaq 0xcf3(%rip), %rsi       # 0xa4f2
callq 0x1b90
movq %rax, -0x8(%rbp)
jmp 0x982c
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
addq $0x18, %rax
movslq -0x1c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq $0x5b, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)