LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: es_port_getc
int es_port_getc(es_val_t port)
{
  es_port_t* p = es_port_val(port);
  if (p->cur < p->tail) {
    int c = p->buf[p->cur++];
    if (p->top == 0 && p->cur == p->tail)
      p->cur = p->tail = 0;
    return port_update_pos(port, c);
  } else if (p->eof) {
    return EOF;
  } else {
    int c = getc(p->stream);
    if (EOF == c) {
      p->eof = 1;
    } else if (p->top > 0) {
      assert(p->tail < p->size);
      p->buf[p->tail] = c;
      p->cur = ++p->tail;
    } else if (p->cur == p->tail) {
      p->cur = p->tail = 0;
    }
    return port_update_pos(port, c);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x24f0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x24(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x23fe
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rdx
movl 0x24(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x24(%rdx)
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x40(%rax)
jne 0x23ea
movq -0x18(%rbp), %rax
movl 0x24(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jne 0x23ea
movq -0x18(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x24(%rax)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x2500
movl %eax, -0x4(%rbp)
jmp 0x24e0
movq -0x18(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
je 0x2414
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x24e0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1160
movl %eax, -0x20(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl -0x20(%rbp), %eax
jne 0x243e
movq -0x18(%rbp), %rax
movl $0x1, 0x2c(%rax)
jmp 0x24d1
movq -0x18(%rbp), %rax
cmpl $0x0, 0x40(%rax)
jle 0x24a7
movq -0x18(%rbp), %rax
movl 0x28(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x245a
jmp 0x2479
leaq 0x7d8b(%rip), %rdi      # 0xa1ec
leaq 0x7d96(%rip), %rsi      # 0xa1fe
movl $0x336, %edx            # imm = 0x336
leaq 0x7d90(%rip), %rcx      # 0xa204
callq 0x10b0
movl -0x20(%rbp), %eax
movb %al, %dl
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rcx
movslq 0x28(%rcx), %rcx
movb %dl, (%rax,%rcx)
movq -0x18(%rbp), %rax
movl 0x28(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rax)
movq -0x18(%rbp), %rax
movl %ecx, 0x24(%rax)
jmp 0x24cf
movq -0x18(%rbp), %rax
movl 0x24(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jne 0x24cd
movq -0x18(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x24(%rax)
jmp 0x24cf
jmp 0x24d1
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x2500
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: port_update_pos
static int port_update_pos(es_val_t port, int c)
{
  es_port_t* p = es_port_val(port);
  p->nbytes++;
  p->colnum++;
  if ('\n' == c) {
    p->linum++;
    p->colnum = 0;
  }
  return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x24f0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rax
movl 0x3c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x3c(%rax)
movl $0xa, %eax
cmpl -0xc(%rbp), %eax
jne 0x255b
movq -0x18(%rbp), %rax
movl 0x38(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x38(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x3c(%rax)
movl -0xc(%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: es_port_peekc
int es_port_peekc(es_val_t port)
{
  es_port_t* p = es_port_val(port);
  if (p->cur < p->tail) {
    return p->buf[p->cur];
  } else {
    es_port_mark(port);
    int c = es_port_getc(port);
    es_port_reset(port);
    return c;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x24f0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x24(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x25b2
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rcx
movslq 0x24(%rcx), %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x4(%rbp)
jmp 0x25d6
movq -0x10(%rbp), %rdi
callq 0x25e0
movq -0x10(%rbp), %rdi
callq 0x2370
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x26b0
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: es_port_mark
void es_port_mark(es_val_t port)
{
  es_port_t* p = es_port_val(port);
  //assert(!p->mark);
  p->state[p->top].cur    = p->cur;
  p->state[p->top].nbytes = p->nbytes;
  p->state[p->top].linum  = p->linum;
  p->state[p->top].colnum = p->colnum;
  p->top++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x24f0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x24(%rax), %ecx
movq -0x10(%rbp), %rax
addq $0x40, %rax
addq $0x8, %rax
movq -0x10(%rbp), %rdx
movslq 0x40(%rdx), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x10(%rbp), %rax
addq $0x40, %rax
addq $0x8, %rax
movq -0x10(%rbp), %rdx
movslq 0x40(%rdx), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl 0x38(%rax), %ecx
movq -0x10(%rbp), %rax
addq $0x40, %rax
addq $0x8, %rax
movq -0x10(%rbp), %rdx
movslq 0x40(%rdx), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl 0x3c(%rax), %ecx
movq -0x10(%rbp), %rax
addq $0x40, %rax
addq $0x8, %rax
movq -0x10(%rbp), %rdx
movslq 0x40(%rdx), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rax
movl 0x40(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x40(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: es_port_reset
void es_port_reset(es_val_t port)
{
  es_port_t* p = es_port_val(port);
  assert(p->top > 0);
  --p->top;
  p->cur    = p->state[p->top].cur;
  p->nbytes = p->state[p->top].nbytes;
  p->linum  = p->state[p->top].linum;
  p->colnum = p->state[p->top].colnum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x24f0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x40(%rax)
jle 0x26d5
jmp 0x26f4
leaq 0x7b43(%rip), %rdi      # 0xa21f
leaq 0x7b1b(%rip), %rsi      # 0xa1fe
movl $0x35b, %edx            # imm = 0x35B
leaq 0x7b3b(%rip), %rcx      # 0xa22a
callq 0x10b0
movq -0x10(%rbp), %rax
movl 0x40(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x40(%rax)
movq -0x10(%rbp), %rax
addq $0x40, %rax
addq $0x8, %rax
movq -0x10(%rbp), %rcx
movslq 0x40(%rcx), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x10(%rbp), %rax
addq $0x40, %rax
addq $0x8, %rax
movq -0x10(%rbp), %rcx
movslq 0x40(%rcx), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
addq $0x40, %rax
addq $0x8, %rax
movq -0x10(%rbp), %rcx
movslq 0x40(%rcx), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x38(%rax)
movq -0x10(%rbp), %rax
addq $0x40, %rax
addq $0x8, %rax
movq -0x10(%rbp), %rcx
movslq 0x40(%rcx), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x14(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x3c(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: es_make_fn
es_val_t es_make_fn(es_ctx_t* ctx, int arity, es_pfn_t pfn)
{
  es_fn_t* fn = es_alloc(ctx, ES_FN_TYPE, sizeof(es_fn_t));
  fn->arity   = arity;
  fn->pfn     = pfn;
  return es_obj_to_val(fn);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0xe, %esi
movl $0x20, %edx
callq 0x1bd0
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: es_make_proc
es_val_t es_make_proc(es_ctx_t* ctx, int arity, int rest, int addr, int end)
{
  es_proc_t* proc = es_alloc(ctx, ES_PROC_TYPE, sizeof(es_proc_t));
  proc->arity = arity;
  proc->rest  = rest;
  proc->addr  = addr;
  proc->end   = end;
  return es_obj_to_val(proc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x11, %esi
movl $0x20, %edx
callq 0x1bd0
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
movl -0x10(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x14(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x18(%rax)
movl -0x18(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x20(%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: es_make_string
es_val_t es_make_string(es_ctx_t* ctx, char* cstr)
{
  es_string_t* string;
  long length = strlen(cstr);
  string = es_alloc(ctx, ES_STRING_TYPE, sizeof(es_string_t) + length + 1);
  string->length = length;
  strcpy(string->value, cstr);
  return es_obj_to_val(string);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1070
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
addq $0x18, %rdx
addq $0x1, %rdx
movl $0x5, %esi
callq 0x1bd0
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
callq 0x1050
movq -0x18(%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: es_string_make
es_val_t es_string_make(es_ctx_t* ctx, int length, char c)
{
  es_string_t* string;
  string = es_alloc(ctx, ES_STRING_TYPE, sizeof(es_string_t) + length + 1);
  string->length = length;
  for(int i = 0; i < string->length; i++) {
    string->value[i] = c;
  }
  string->value[string->length] = '\0';
  return es_obj_to_val(string);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb %al, -0xd(%rbp)
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rdx
addq $0x18, %rdx
addq $0x1, %rdx
movl $0x5, %esi
callq 0x1bd0
movq %rax, -0x18(%rbp)
movslq -0xc(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x2d6d
movb -0xd(%rbp), %dl
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, 0x18(%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2d45
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rcx
movb $0x0, 0x18(%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: es_symbol_intern
es_val_t es_symbol_intern(es_ctx_t* ctx, const char* cstr)
{
  es_symtab_t* symtab = &ctx->symtab;
  int id = symtab_find_or_create(symtab, cstr);
  if (id < 0) {
    return es_make_error(ctx, "symtab count exceeded");
  }
  return es_make_symbol(id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x2048, %rax           # imm = 0x2048
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2f00
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x2eea
movq -0x10(%rbp), %rdi
leaq 0x7368(%rip), %rsi      # 0xa247
callq 0x1b90
movq %rax, -0x8(%rbp)
jmp 0x2ef6
movl -0x24(%rbp), %edi
callq 0x2e30
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: symtab_find_or_create
static int symtab_find_or_create(es_symtab_t* symtab, const char* cstr)
{
  int id = symtab_id_by_string(symtab, cstr);
  if (id < 0) {
    return symtab_add_string(symtab, cstr);
  }
  return id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8390
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x2f38
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8400
movl %eax, -0x4(%rbp)
jmp 0x2f3e
movl -0x1c(%rbp), %eax
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: es_make_vector
es_val_t es_make_vector(es_ctx_t* ctx, int size)
{
  assert(size >= 0);
  es_vec_t* vector = es_alloc(ctx, ES_VECTOR_TYPE, sizeof(es_vec_t) + size * sizeof(es_val_t));
  vector->length = size;
  for(int i = 0; i < size; i++)
    vector->array[i] = es_undefined;
  return es_obj_to_val(vector);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x3147
jmp 0x3166
leaq 0x710f(%rip), %rdi      # 0xa25d
leaq 0x70a9(%rip), %rsi      # 0xa1fe
movl $0x471, %edx            # imm = 0x471
leaq 0x7106(%rip), %rcx      # 0xa267
callq 0x10b0
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rdx
shlq $0x3, %rdx
addq $0x18, %rdx
movl $0xd, %esi
callq 0x1bd0
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x31b9
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq $0x53, 0x18(%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3195
movq -0x18(%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: es_vector_from_list
es_val_t es_vector_from_list(es_ctx_t* ctx, es_val_t list)
{
  es_val_t vector;
  int i, length;
  gc_root(ctx, list);
  length = es_list_length(list);
  vector = es_make_vector(ctx, length);
  for(i = 0; i < length; i++, list = es_cdr(list)) {
    es_vector_set(vector, i, es_car(list));
  }
  gc_unroot(ctx, 1);
  return vector;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rdx
movl 0x2040(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x2040(%rdx)
movslq %ecx, %rcx
leaq -0x10(%rbp), %rdx
movq %rdx, 0x40(%rax,%rcx,8)
movq -0x10(%rbp), %rdi
callq 0x3360
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x3130
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x333e
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1ef0
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %esi
movq %rax, %rdx
callq 0x3230
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1f20
movq %rax, -0x10(%rbp)
jmp 0x32f8
movq -0x8(%rbp), %rax
movl 0x2040(%rax), %ecx
subl $0x1, %ecx
movl %ecx, 0x2040(%rax)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: es_list_length
int es_list_length(es_val_t list)
{
  int i = 0;
  while(!es_is_nil(list)) {
    list = es_cdr(list);
    i++;
  }
  return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x30d0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x338a
jmp 0x33a2
movq -0x8(%rbp), %rdi
callq 0x1f20
movq %rax, -0x8(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3373
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: es_make_env
es_val_t es_make_env(es_ctx_t* ctx, int size)
{
  size_t sz = sizeof(es_env_t) + sizeof(es_slot_t) * size;
  es_env_t* env = es_alloc(ctx, ES_ENV_TYPE, sz);
  env->count = 0;
  env->size  = size;
  return es_obj_to_val(env);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movslq -0xc(%rbp), %rax
shlq $0x4, %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0xf, %esi
callq 0x1bd0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x0, 0x10(%rax)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x20(%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: es_env_loc
static int es_env_loc(es_val_t _env, es_val_t sym)
{
  es_env_t* env = es_env_val(_env);
  for(int i = 0; i < env->count; i++) {
    if (es_is_eq(env->slots[i].sym, sym)) {
      return i;
    }
  }
  return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7240
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x385a
movq -0x20(%rbp), %rax
addq $0x18, %rax
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x18a0
cmpl $0x0, %eax
je 0x384d
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3861
jmp 0x384f
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3814
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: es_make_bytecode
es_val_t es_make_bytecode(es_ctx_t* ctx)
{
  es_bytecode_t* b = es_alloc(ctx, ES_BYTECODE_TYPE, sizeof(es_bytecode_t));
  b->inst       = malloc(1024 * sizeof(es_inst_t));
  b->inst_size  = 1024;
  b->cpool_size = ES_CONST_POOL_SIZE;
  b->next_const = 0;
  b->next_inst  = 0;
  return es_obj_to_val(b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x12, %esi
movl $0x8028, %edx           # imm = 0x8028
callq 0x1bd0
movq %rax, -0x10(%rbp)
movl $0x4000, %edi           # imm = 0x4000
callq 0x10f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8018(%rax)
movq -0x10(%rbp), %rax
movl $0x400, 0x8020(%rax)    # imm = 0x400
movq -0x10(%rbp), %rax
movl $0x1000, 0x8010(%rax)   # imm = 0x1000
movq -0x10(%rbp), %rax
movl $0x0, 0x8014(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x8024(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: es_make_macro
es_val_t es_make_macro(es_ctx_t* ctx, es_val_t trans)
{
  es_macro_t* macro;
  gc_root(ctx, trans);
  macro = es_alloc(ctx, ES_MACRO_TYPE, sizeof(es_macro_t));
  macro->trans = trans;
  gc_unroot(ctx, 1);
  return es_obj_to_val(macro);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rdx
movl 0x2040(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x2040(%rdx)
movslq %ecx, %rcx
leaq -0x10(%rbp), %rdx
movq %rdx, 0x40(%rax,%rcx,8)
movq -0x8(%rbp), %rdi
movl $0x14, %esi
movl $0x18, %edx
callq 0x1bd0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl 0x2040(%rax), %ecx
subl $0x1, %ecx
movl %ecx, 0x2040(%rax)
movq -0x18(%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: es_size_of
size_t es_size_of(es_val_t val)
{
  switch(es_type_of(val)) {
  case ES_STRING_TYPE:       return es_string_size_of(val);
  case ES_PAIR_TYPE:         return sizeof(es_pair_t);
  case ES_CLOSURE_TYPE:      return sizeof(es_closure_t);
  case ES_PORT_TYPE:         return sizeof(es_port_t);
  case ES_VECTOR_TYPE:       return es_vector_size_of(val);
  case ES_FN_TYPE:           return sizeof(es_fn_t);
  case ES_BYTECODE_TYPE:     return sizeof(es_bytecode_t);
  case ES_ERROR_TYPE:        return sizeof(es_error_t);
  case ES_ENV_TYPE:          return es_env_size_of(val);
  case ES_PROC_TYPE:         return sizeof(es_proc_t);
  case ES_ARGS_TYPE:         return es_args_size_of(val);
  case ES_MACRO_TYPE:        return sizeof(es_macro_t);
  case ES_BUFFER_TYPE:       return es_buffer_size_of(val);
  case ES_INVALID_TYPE:      return -1;
  case ES_NIL_TYPE:
  case ES_BOOL_TYPE:
  case ES_FIXNUM_TYPE:
  case ES_SYMBOL_TYPE:
  case ES_CHAR_TYPE:
  case ES_EOF_OBJ_TYPE:
  case ES_UNBOUND_TYPE:
  case ES_UNDEFINED_TYPE:
  case ES_VOID_TYPE:
  case ES_CONT_TYPE:
    return sizeof(es_val_t);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1560
incl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x17, %eax
ja 0x3c73
movq -0x18(%rbp), %rax
leaq 0x650b(%rip), %rcx      # 0xa0bc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
callq 0x3c80
movq %rax, -0x8(%rbp)
jmp 0x3c73
movq $0x20, -0x8(%rbp)
jmp 0x3c73
movq $0x20, -0x8(%rbp)
jmp 0x3c73
movq $0x1848, -0x8(%rbp)     # imm = 0x1848
jmp 0x3c73
movq -0x10(%rbp), %rdi
callq 0x3cb0
movq %rax, -0x8(%rbp)
jmp 0x3c73
movq $0x20, -0x8(%rbp)
jmp 0x3c73
movq $0x8028, -0x8(%rbp)     # imm = 0x8028
jmp 0x3c73
movq $0x18, -0x8(%rbp)
jmp 0x3c73
movq -0x10(%rbp), %rdi
callq 0x3ce0
movq %rax, -0x8(%rbp)
jmp 0x3c73
movq $0x20, -0x8(%rbp)
jmp 0x3c73
movq -0x10(%rbp), %rdi
callq 0x3d10
movq %rax, -0x8(%rbp)
jmp 0x3c73
movq $0x18, -0x8(%rbp)
jmp 0x3c73
movq -0x10(%rbp), %rdi
callq 0x3d40
movq %rax, -0x8(%rbp)
jmp 0x3c73
movq $-0x1, -0x8(%rbp)
jmp 0x3c73
movq $0x8, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: es_mark_copy
void es_mark_copy(es_heap_t* heap, es_val_t* ref, char** next)
{
  assert(*next < heap->to_end);
  if (!is_obj(*ref))
    return;

  if (es_obj_is_reloc(*ref)) {
    *ref = es_obj_to_val(es_val_to_obj(*ref)->reloc); // Update stale reference to relocated object
  } else {
    size_t size = es_size_of(*ref);                // Get size of object
    *next = alignp(*next, ES_DEFAULT_ALIGNMENT); // Ensure next pointer is aligned
    memcpy(*next, (void*)*ref, size);                 // Copy object from_space from_space-space into to_space-space
    es_val_to_obj(*ref)->reloc = (es_obj_t*)*next;            // Leave forwarding pointer in old from_space-space object
    *ref = es_obj_to_val(es_val_to_obj(*ref)->reloc);                    // Update current reference to_space point to_space new object in to_space-space
    es_val_to_obj(*ref)->reloc = NULL;                        // Reset tombstone
    *next += size;                                 // Update next pointer
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x30(%rcx), %rax
jae 0x4067
jmp 0x4086
leaq 0x658c(%rip), %rdi      # 0xa5fa
leaq 0x6189(%rip), %rsi      # 0xa1fe
movl $0x1b8, %edx            # imm = 0x1B8
leaq 0x658e(%rip), %rcx      # 0xa60f
callq 0x10b0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x7a00
cmpl $0x0, %eax
jne 0x409c
jmp 0x4146
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x7a40
cmpl $0x0, %eax
je 0x40c4
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x4146
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x3b80
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x10, %rcx
subq $0x1, %rcx
andq $-0x10, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x10e0
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq $0x0, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: es_args_mark_copy
static void es_args_mark_copy(es_heap_t* heap, es_val_t pval, char** next)
{
  es_args_t* args = es_obj_to(es_args_t*, pval);
  es_mark_copy(heap, (es_val_t*)&args->parent, next);
  for(int i = 0; i < args->size; i++)
    es_mark_copy(heap, &args->args[i], next);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %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 -0x20(%rbp), %rsi
addq $0x10, %rsi
movq -0x18(%rbp), %rdx
callq 0x4040
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x435f
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x20, %rsi
movslq -0x24(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0x4040
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x4328
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_make_list
es_val_t es_make_list(es_ctx_t* ctx, ...)
{
  es_val_t list, tail, e;
  va_list argp;
  va_start(argp, ctx);
  e = va_arg(argp, es_val_t);
  if (es_val_to_obj(e) == NULL)
    return es_nil;
  tail = list = es_cons(ctx, e, es_nil);
  while(es_val_to_obj(e = va_arg(argp, es_val_t)) != NULL) {
    es_set_cdr(tail, es_cons(ctx, e, es_nil));
    tail = es_cdr(tail);
  }
  va_end(argp);
  return list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
testb %al, %al
je 0x445b
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, -0x10(%rbp)
leaq -0x40(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
leaq -0x40(%rbp), %rax
movq %rax, -0x100(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0xf4(%rbp)
cmpl $0x28, %eax
ja 0x44e1
movq -0x100(%rbp), %rcx
movl -0xf4(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x108(%rbp)
jmp 0x44fe
movq -0x100(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x108(%rbp)
movq -0x108(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, %rax
jne 0x4523
movq $0x3, -0x8(%rbp)
jmp 0x45f3
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0x3, %edx
callq 0x1e10
movq %rax, -0x18(%rbp)
movq %rax, -0x20(%rbp)
leaq -0x40(%rbp), %rax
movq %rax, -0x118(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x10c(%rbp)
cmpl $0x28, %eax
ja 0x4578
movq -0x118(%rbp), %rcx
movl -0x10c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x120(%rbp)
jmp 0x4595
movq -0x118(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x120(%rbp)
movq -0x120(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x45e7
movq -0x20(%rbp), %rax
movq %rax, -0x128(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0x3, %edx
callq 0x1e10
movq -0x128(%rbp), %rdi
movq %rax, %rsi
callq 0x1f70
movq -0x20(%rbp), %rdi
callq 0x1f20
movq %rax, -0x20(%rbp)
jmp 0x453d
leaq -0x40(%rbp), %rax
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: es_compile
es_val_t es_compile(es_ctx_t* ctx, es_val_t exp)
{
  int start;
  es_val_t b = ctx->bytecode;
  start = bytecode_label(b);
  compile(ctx, b, exp, 0, 0, es_nil);
  emit_halt(b);
  int end = bytecode_label(b);

  return es_make_proc(ctx, 0, 0, start, end);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x42060(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x46d0
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
xorl %r8d, %r8d
movl $0x3, %r9d
movl %r8d, %ecx
callq 0x4700
movq -0x20(%rbp), %rdi
callq 0x47a0
movq -0x20(%rbp), %rdi
callq 0x46d0
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %ecx
movl -0x24(%rbp), %r8d
xorl %edx, %edx
movl %edx, %esi
callq 0x2ba0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: compile
static es_val_t compile(es_ctx_t* ctx, es_val_t bc, es_val_t exp, int tail_pos, int next, es_val_t scope)
{
  if (es_is_pair(exp)) {
    compile_form(ctx, bc, exp, tail_pos, next, scope);
  } else if(es_is_symbol(exp)) {
    compile_ref(ctx, bc, exp, tail_pos, next, scope);
  } else {
    compile_const(ctx, bc, exp, tail_pos, next, scope);
  }
  return es_void;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %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 0x1ec0
cmpl $0x0, %eax
je 0x474b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movq -0x28(%rbp), %r9
callq 0x8490
jmp 0x4795
movq -0x18(%rbp), %rdi
callq 0x2e50
cmpl $0x0, %eax
je 0x4777
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movq -0x28(%rbp), %r9
callq 0x8760
jmp 0x4793
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movq -0x28(%rbp), %r9
callq 0x8850
jmp 0x4795
movl $0x5b, %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: es_load
es_val_t es_load(es_ctx_t* ctx, const char* file_name)
{
  es_val_t exp, port;
  port = es_make_port(ctx, fopen(file_name, "r"));
  es_ctx_set_oport(ctx, es_make_port(ctx, stdout));
  while(!es_is_eof_obj(exp = es_port_read(ctx, port))) {
    es_eval(ctx, exp);
  }
  es_port_close(port);
  return es_void;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x5b60(%rip), %rsi      # 0xa373
callq 0x1110
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x1fa0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq 0xa79d(%rip), %rax      # 0xefd8
movq (%rax), %rsi
callq 0x1fa0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x1490
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x20b0
movq %rax, %rdi
movq %rdi, -0x18(%rbp)
callq 0x3100
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x4876
jmp 0x4885
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x48a0
jmp 0x484f
movq -0x20(%rbp), %rdi
callq 0x2830
movl $0x5b, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: es_eval
es_val_t es_eval(es_ctx_t* ctx, es_val_t exp)
{
  struct timeval t0, t1, dt;

  es_val_t env, res;

  env = es_ctx_env(ctx);

  exp = es_macro_expand(ctx, exp, env);

  //es_printf(ctx, "expanded: %@\n", exp);

  es_val_t proc = es_compile(ctx, exp);

  gettimeofday(&t0, NULL);

  res = (es_val_t)es_vm_run(ctx, ES_VM_DISPATCH, proc);

  assert(ctx->fp == 0);

  gettimeofday(&t1, NULL);
  timeval_subtract(&dt, &t1, &t0);
  //printf("time: %f\n", dt.tv_sec * 1000.0 + dt.tv_usec / 1000.0);

  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x14b0
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x4a80
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4650
movq %rax, -0x58(%rbp)
leaq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10a0
movq -0x8(%rbp), %rdi
movq -0x58(%rbp), %rdx
movl $0x1, %esi
movb $0x0, %al
callq 0x4ca0
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x42078(%rax)
jne 0x4917
jmp 0x4936
leaq 0x5978(%rip), %rdi      # 0xa296
leaq 0x58d9(%rip), %rsi      # 0xa1fe
movl $0xa47, %edx            # imm = 0xA47
leaq 0x5972(%rip), %rcx      # 0xa2a3
callq 0x10b0
leaq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10a0
leaq -0x40(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x5ae0
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: es_macro_expand_list
es_val_t es_macro_expand_list(es_ctx_t* ctx, es_val_t lst, es_val_t env)
{
  //es_printf(ctx, "macro-expand-list: %@\n", lst);
  if (es_is_nil(lst)) {
    return lst;
  } else if (es_is_pair(es_cdr(lst))) {
    return es_cons(ctx,
      es_macro_expand(ctx, es_car(lst), env),
      es_macro_expand_list(ctx, es_cdr(lst), env));
  } else {
    return es_cons(ctx, es_macro_expand(ctx, es_car(lst), env),
      es_macro_expand(ctx, es_cdr(lst), env));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x30d0
cmpl $0x0, %eax
je 0x498f
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4a6b
movq -0x18(%rbp), %rdi
callq 0x1f20
movq %rax, %rdi
callq 0x1ec0
cmpl $0x0, %eax
je 0x4a09
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1ef0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rdx
callq 0x4a80
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1f20
movq -0x38(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rdx
callq 0x4960
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x1e10
movq %rax, -0x8(%rbp)
jmp 0x4a6b
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1ef0
movq -0x60(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rdx
callq 0x4a80
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1f20
movq -0x58(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rdx
callq 0x4a80
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq %rax, %rdx
callq 0x1e10
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: es_macro_expand
es_val_t es_macro_expand(es_ctx_t* ctx, es_val_t exp, es_val_t env)
{
  //es_printf(ctx, "macro-expand: %@\n", exp);
  if (!es_is_pair(exp)) {
    return exp;
  }
  es_val_t op = es_car(exp);
  if (es_is_symbol(op)) {
    es_val_t val = es_lookup_symbol(ctx, env, op);
    if (es_is_macro(val)) {
      es_val_t trans = es_macro_transformer(val);
      return es_macro_expand(ctx, es_apply(ctx, trans, es_cdr(exp)), env);
    } else {
      return es_macro_expand_list(ctx, exp, env);
    }
  } else {
    return es_macro_expand_list(ctx, exp, env);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1ec0
cmpl $0x0, %eax
jne 0x4aaf
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4b71
movq -0x18(%rbp), %rdi
callq 0x1ef0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2e50
cmpl $0x0, %eax
je 0x4b5c
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x3790
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3b20
cmpl $0x0, %eax
je 0x4b45
movq -0x30(%rbp), %rdi
callq 0x3b60
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1f20
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq %rax, %rdx
callq 0x4b80
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rdx
callq 0x4a80
movq %rax, -0x8(%rbp)
jmp 0x4b71
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x4960
movq %rax, -0x8(%rbp)
jmp 0x4b71
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x4960
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: es_apply
es_val_t es_apply(es_ctx_t* ctx, es_val_t proc, es_val_t args)
{
  es_val_t bc = ctx->bytecode;
  int argc = 0;
  while(!es_is_nil(args)) {
    push(ctx, es_car(args));
    args = es_cdr(args);
    argc++;
  }

  push(ctx, proc);

  int start = bytecode_label(bc);
  emit_call(bc, argc);
  emit_halt(bc);

  es_val_t thunk = es_make_proc(ctx, 0, 0, start, bytecode_label(bc));

  es_val_t res = (es_val_t)es_vm_run(ctx, ES_VM_DISPATCH, thunk);

  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x42060(%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x18(%rbp), %rdi
callq 0x30d0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x4bc1
jmp 0x4c01
movq -0x18(%rbp), %rdi
callq 0x1ef0
movq %rax, %rcx
movq -0x8(%rbp), %rdx
movq 0x42070(%rdx), %rax
movq %rax, %rsi
addq $0x8, %rsi
movq %rsi, 0x42070(%rdx)
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
callq 0x1f20
movq %rax, -0x18(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x4baa
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rdx
movq 0x42070(%rdx), %rax
movq %rax, %rsi
addq $0x8, %rsi
movq %rsi, 0x42070(%rdx)
movq %rcx, (%rax)
movq -0x20(%rbp), %rdi
callq 0x46d0
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x5bf0
movq -0x20(%rbp), %rdi
callq 0x47a0
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x20(%rbp), %rdi
callq 0x46d0
movq -0x48(%rbp), %rdi
movl -0x3c(%rbp), %ecx
movl %eax, %r8d
xorl %edx, %edx
movl %edx, %esi
callq 0x2ba0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rdx
movl $0x1, %esi
movb $0x0, %al
callq 0x4ca0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: timeval_subtract
static int
timeval_subtract (result, x, y)
      struct timeval *result, *x, *y;
 {
   /* Perform the carry for the later subtraction by updating y. */
   if (x->tv_usec < y->tv_usec) {
     int nsec = (y->tv_usec - x->tv_usec) / 1000000 + 1;
     y->tv_usec -= 1000000 * nsec;
     y->tv_sec += nsec;
   }
   if (x->tv_usec - y->tv_usec > 1000000) {
     int nsec = (x->tv_usec - y->tv_usec) / 1000000;
     y->tv_usec += 1000000 * nsec;
     y->tv_sec -= nsec;
   }

   /* Compute the time remaining to wait.
      tv_usec is certainly positive. */
   result->tv_sec = x->tv_sec - y->tv_sec;
   result->tv_usec = x->tv_usec - y->tv_usec;

   /* Return 1 if result is negative. */
   return x->tv_sec < y->tv_sec;
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jge 0x5b4a
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
subq 0x8(%rcx), %rax
movl $0xf4240, %ecx          # imm = 0xF4240
cqto
idivq %rcx
addq $0x1, %rax
movl %eax, -0x1c(%rbp)
imull $0xf4240, -0x1c(%rbp), %eax # imm = 0xF4240
movslq %eax, %rdx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x8(%rax)
movslq -0x1c(%rbp), %rcx
movq -0x18(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
subq 0x8(%rcx), %rax
cmpq $0xf4240, %rax          # imm = 0xF4240
jle 0x5ba6
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
subq 0x8(%rcx), %rax
movl $0xf4240, %ecx          # imm = 0xF4240
cqto
idivq %rcx
movl %eax, -0x20(%rbp)
imull $0xf4240, -0x20(%rbp), %eax # imm = 0xF4240
movslq %eax, %rcx
movq -0x18(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movslq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
movq (%rax), %rcx
subq %rdx, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
subq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
subq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
setl %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: main
int main()
{
  es_ctx_t* ctx = es_ctx_new(64 * MB);

  es_ctx_set_iport(ctx, es_make_port(ctx, stdin));
  es_ctx_set_oport(ctx, es_make_port(ctx, stdout));

  es_printf(ctx, ".--------------.\n");
  es_printf(ctx, "|  Eva v%s  |\n", ES_VERSION_STR);
  es_printf(ctx, "'--------------'\n\n");

  es_val_t val = es_undefined;

  es_gc(ctx);

  do {
    es_printf(ctx, "eva> ");
    val = es_read(ctx);
    val = es_eval(ctx, val);
    es_printf(ctx, "%@\n", val);
    es_gc(ctx);
  } while (!es_is_eof_obj(val));

  es_ctx_free(ctx);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl $0x3d09000, %edi        # imm = 0x3D09000
callq 0x1290
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq 0x9360(%rip), %rax      # 0xefe0
movq (%rax), %rsi
callq 0x1fa0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x1470
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq 0x9331(%rip), %rax      # 0xefd8
movq (%rax), %rsi
callq 0x1fa0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x1490
movq -0x10(%rbp), %rdi
leaq 0x4604(%rip), %rsi      # 0xa2ca
movb $0x0, %al
callq 0x1600
movq -0x10(%rbp), %rdi
leaq 0x4604(%rip), %rsi      # 0xa2dc
leaq 0x460c(%rip), %rdx      # 0xa2eb
movb $0x0, %al
callq 0x1600
movq -0x10(%rbp), %rdi
leaq 0x4600(%rip), %rsi      # 0xa2f1
movb $0x0, %al
callq 0x1600
movq $0x53, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3d60
movq -0x10(%rbp), %rdi
leaq 0x45f0(%rip), %rsi      # 0xa304
movb $0x0, %al
callq 0x1600
movq -0x10(%rbp), %rdi
callq 0x2080
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x48a0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x45c2(%rip), %rsi      # 0xa30a
movb $0x0, %al
callq 0x1600
movq -0x10(%rbp), %rdi
callq 0x3d60
movq -0x18(%rbp), %rdi
callq 0x3100
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x5d09
movq -0x10(%rbp), %rdi
callq 0x1410
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: heap_init
static void heap_init(es_heap_t* heap, size_t size)
{
  heap->requested  = size;
  heap->size       = align((size + 1) / 2, ES_DEFAULT_ALIGNMENT);
  heap->buffer     = malloc(heap->size * 2);
  heap->from_space = alignp(heap->buffer, ES_DEFAULT_ALIGNMENT);
  heap->to_space   = alignp(heap->from_space + heap->size, ES_DEFAULT_ALIGNMENT);
  heap->next       = heap->from_space;
  heap->end        = heap->from_space + size;
  heap->to_end     = heap->to_space + size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rcx
addq $0x1, %rcx
shrq %rcx
addq $0x10, %rcx
subq $0x1, %rcx
andq $-0x10, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
shlq %rdi
callq 0x10f0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x10, %rcx
subq $0x1, %rcx
andq $-0x10, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
addq 0x8(%rax), %rcx
addq $0x10, %rcx
subq $0x1, %rcx
andq $-0x10, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
addq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
addq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: fn_mem_stats
static es_val_t fn_mem_stats(es_ctx_t* ctx, int argc, es_val_t argv[])
{
  size_t used = ctx->heap.next - ctx->heap.from_space;
  printf("heap size: %ld\n", ctx->heap.size);
  printf("allocated: %ld\n", used);

  return es_void;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x4117(%rip), %rdi      # 0xa490
movb $0x0, %al
callq 0x1090
movq -0x20(%rbp), %rsi
leaq 0x4115(%rip), %rdi      # 0xa4a0
movb $0x0, %al
callq 0x1090
movl $0x5b, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: fn_compile
static es_val_t fn_compile(es_ctx_t* ctx, int argc, es_val_t argv[])
{
  es_val_t b = es_make_bytecode(ctx);
  compile(ctx, b, argv[0], 0, 0, es_nil);
  emit_halt(b);
  return b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x38e0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
xorl %r8d, %r8d
movl $0x3, %r9d
movl %r8d, %ecx
callq 0x4700
movq -0x20(%rbp), %rdi
callq 0x47a0
movq -0x20(%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: fn_close
static es_val_t fn_close(es_ctx_t* ctx, int argc, es_val_t argv[])
{
  es_port_t* port = es_port_val(argv[0]);
  fclose(port->stream);
  port->stream = NULL;
  return es_void;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x24f0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1060
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movl $0x5b, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)