LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: Compile_if
int Compile_if(Buffer *buf, ASTNode *cond, ASTNode *consequent,
               ASTNode *alternate, word stack_index, Env *varenv, Env *labels) {
  _(Compile_expr(buf, cond, stack_index, varenv, labels));
  Emit_cmp_reg_imm32(buf, kRax, Object_false());
  word alternate_pos = Emit_jcc(buf, kEqual, kLabelPlaceholder);
  _(Compile_expr(buf, consequent, stack_index, varenv, labels));
  word end_pos = Emit_jmp(buf, kLabelPlaceholder);
  Emit_backpatch_imm32(buf, alternate_pos);
  _(Compile_expr(buf, alternate, stack_index, varenv, labels));
  Emit_backpatch_imm32(buf, end_pos);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq 0x10(%rbp), %r8
callq 0x29f0
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
je 0x3bc1
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3c83
jmp 0x3bc3
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
callq 0x1410
movq -0x68(%rbp), %rdi
movl %eax, %edx
xorl %esi, %esi
callq 0x2340
movq -0x10(%rbp), %rdi
movl $0x4, %esi
movl $0xdeadbeef, %edx       # imm = 0xDEADBEEF
callq 0x26f0
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq 0x10(%rbp), %r8
callq 0x29f0
movl %eax, -0x4c(%rbp)
cmpl $0x0, -0x4c(%rbp)
je 0x3c1e
movl -0x4c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3c83
jmp 0x3c20
movq -0x10(%rbp), %rdi
movl $0xdeadbeef, %esi       # imm = 0xDEADBEEF
callq 0x27a0
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rax
movl %eax, %esi
callq 0x27f0
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq 0x10(%rbp), %r8
callq 0x29f0
movl %eax, -0x5c(%rbp)
cmpl $0x0, -0x5c(%rbp)
je 0x3c6b
movl -0x5c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3c83
jmp 0x3c6d
movq -0x10(%rbp), %rdi
movq -0x58(%rbp), %rax
movl %eax, %esi
callq 0x27f0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: Compile_cons
int Compile_cons(Buffer *buf, ASTNode *car, ASTNode *cdr, int stack_index,
                 Env *varenv, Env *labels) {
  // Compile and store car on the stack
  _(Compile_expr(buf, car, stack_index, varenv, labels));
  Emit_store_reg_indirect(buf, Ind(kRbp, stack_index), kRax);
  // Compile and store cdr
  _(Compile_expr(buf, cdr, stack_index - kWordSize, varenv, labels));
  Emit_store_reg_indirect(buf, Ind(kHeapPointer, kCdrOffset), kRax);
  // Fetch car and store in heap
  Emit_load_reg_indirect(buf, kRax, Ind(kRbp, stack_index));
  Emit_store_reg_indirect(buf, Ind(kHeapPointer, kCarOffset), kRax);

  // Store tagged pointer in tax
  Emit_mov_reg_reg(buf, kRax, kHeapPointer);
  Emit_or_reg_imm8(buf, kRax, kPairTag);
  // Bump the heap pointer
  Emit_add_reg_imm32(buf, kHeapPointer, kPairSize);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq -0x24(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
callq 0x29f0
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
je 0x3cdf
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3df6
jmp 0x3ce1
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movl -0x24(%rbp), %eax
movl $0x5, %edi
movsbl %al, %esi
callq 0x1f60
movq -0x68(%rbp), %rdi
movq %rax, -0x44(%rbp)
movq -0x44(%rbp), %rsi
xorl %edx, %edx
callq 0x2510
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %eax
subl $0x8, %eax
movslq %eax, %rdx
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
callq 0x29f0
movl %eax, -0x48(%rbp)
cmpl $0x0, -0x48(%rbp)
je 0x3d3e
movl -0x48(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3df6
jmp 0x3d40
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movl $0x6, %edi
movl $0x8, %esi
callq 0x1f60
movq -0x80(%rbp), %rdi
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rsi
xorl %edx, %edx
callq 0x2510
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movl -0x24(%rbp), %eax
movl $0x5, %edi
movsbl %al, %esi
callq 0x1f60
movq -0x78(%rbp), %rdi
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdx
xorl %esi, %esi
callq 0x26a0
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movl $0x6, %edi
xorl %esi, %esi
callq 0x1f60
movq -0x70(%rbp), %rdi
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rsi
xorl %edx, %edx
callq 0x2510
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x6, %edx
callq 0x2850
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x2260
movq -0x10(%rbp), %rdi
movl $0x6, %esi
movl $0x10, %edx
callq 0x2080
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: list_length
word list_length(ASTNode *node) {
  if (AST_is_nil(node)) {
    return 0;
  }
  assert(AST_is_pair(node));
  return 1 + list_length(AST_pair_cdr(node));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1700
testb $0x1, %al
jne 0x3e2b
jmp 0x3e35
movq $0x0, -0x8(%rbp)
jmp 0x3e7e
movq -0x10(%rbp), %rdi
callq 0x1870
testb $0x1, %al
jne 0x3e44
jmp 0x3e46
jmp 0x3e65
leaq 0x108fb(%rip), %rdi     # 0x14748
leaq 0x1084f(%rip), %rsi     # 0x146a3
movl $0x2d6, %edx            # imm = 0x2D6
leaq 0x10a75(%rip), %rcx     # 0x148d5
callq 0x1090
movq -0x10(%rbp), %rdi
callq 0x18b0
movq %rax, %rdi
callq 0x3e10
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: Compile_labelcall
int Compile_labelcall(Buffer *buf, ASTNode *callable, ASTNode *args,
                      word stack_index, Env *varenv, Env *labels, word nargs,
                      word rsp_adjust) {
  if (AST_is_nil(args)) {
    const char *symbol = AST_symbol_cstr(callable);
    word code_address;
    if (!Env_find(labels, symbol, &code_address)) {
      return -1;
    }
    Emit_rsp_adjust(buf, rsp_adjust);
    Emit_call_imm32(buf, code_address);
    Emit_rsp_adjust(buf, -rsp_adjust);
    return 0;
  }

  assert(AST_is_pair(args));
  ASTNode *arg = AST_pair_car(args);
  _(Compile_expr(buf, arg, stack_index, varenv, labels));
  Emit_store_reg_indirect(buf, Ind(kRsp, stack_index), kRax);
  return Compile_labelcall(buf, callable, AST_pair_cdr(args),
                           stack_index - kWordSize, varenv, labels, nargs,
                           rsp_adjust);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1700
testb $0x1, %al
jne 0x3eca
jmp 0x3f2f
movq -0x18(%rbp), %rdi
callq 0x1ab0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x1550
testb $0x1, %al
jne 0x3ef8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4011
movq -0x10(%rbp), %rdi
movq 0x18(%rbp), %rsi
callq 0x28b0
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x2910
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
subq 0x18(%rbp), %rsi
callq 0x28b0
movl $0x0, -0x4(%rbp)
jmp 0x4011
movq -0x20(%rbp), %rdi
callq 0x1870
testb $0x1, %al
jne 0x3f3e
jmp 0x3f40
jmp 0x3f5f
leaq 0x109aa(%rip), %rdi     # 0x148f1
leaq 0x10755(%rip), %rsi     # 0x146a3
movl $0x2e9, %edx            # imm = 0x2E9
leaq 0x109a9(%rip), %rcx     # 0x14903
callq 0x1090
movq -0x20(%rbp), %rdi
callq 0x1890
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
callq 0x29f0
movl %eax, -0x54(%rbp)
cmpl $0x0, -0x54(%rbp)
je 0x3f96
movl -0x54(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x4011
jmp 0x3f98
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x28(%rbp), %rax
movl $0x4, %edi
movsbl %al, %esi
callq 0x1f60
movq -0x78(%rbp), %rdi
movq %rax, -0x5c(%rbp)
movq -0x5c(%rbp), %rsi
xorl %edx, %edx
callq 0x2510
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x20(%rbp), %rdi
callq 0x18b0
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq %rax, %rdx
movq -0x28(%rbp), %rcx
subq $0x8, %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
movq 0x10(%rbp), %r10
movq 0x18(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x3e90
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: Compile_compare_imm32
void Compile_compare_imm32(Buffer *buf, int32_t value) {
  Emit_cmp_reg_imm32(buf, kRax, value);
  Emit_mov_reg_imm32(buf, kRax, 0);
  Emit_setcc_imm8(buf, kEqual, kAl);
  Emit_shl_reg_imm8(buf, kRax, kBoolShift);
  Emit_or_reg_imm8(buf, kRax, kBoolTag);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
xorl %esi, %esi
callq 0x2340
movq -0x8(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x1ff0
movq -0x8(%rbp), %rdi
movl $0x4, %esi
xorl %edx, %edx
callq 0x23c0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x7, %edx
callq 0x2180
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x1f, %edx
callq 0x2260
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: Compile_code_impl
int Compile_code_impl(Buffer *buf, ASTNode *formals, ASTNode *body,
                      word stack_index, Env *varenv) {
  if (AST_is_nil(formals)) {
    _(Compile_expr(buf, body, stack_index, varenv, NULL));
    Buffer_write_arr(buf, kFunctionEpilogue, sizeof kFunctionEpilogue);
    return 0;
  }

  assert(AST_is_pair(formals));
  ASTNode *name = AST_pair_car(formals);
  assert(AST_is_symbol(name));
  Env entry = Env_bind(AST_symbol_cstr(name), stack_index, varenv);
  return Compile_code_impl(buf, AST_pair_cdr(formals), body,
                           stack_index - kWordSize, &entry);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1700
testb $0x1, %al
jne 0x429b
jmp 0x42ee
jmp 0x429d
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r8d
callq 0x29f0
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x42cb
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x43a8
jmp 0x42cd
movq -0x10(%rbp), %rdi
leaq 0xff00(%rip), %rsi      # 0x141d8
movl $0x1, %edx
callq 0x1f10
movl $0x0, -0x4(%rbp)
jmp 0x43a8
movq -0x18(%rbp), %rdi
callq 0x1870
testb $0x1, %al
jne 0x42fd
jmp 0x42ff
jmp 0x431e
leaq 0x1078d(%rip), %rdi     # 0x14a93
leaq 0x10396(%rip), %rsi     # 0x146a3
movl $0x3ab, %edx            # imm = 0x3AB
leaq 0x1078f(%rip), %rcx     # 0x14aa8
callq 0x1090
movq -0x18(%rbp), %rdi
callq 0x1890
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x1a90
testb $0x1, %al
jne 0x433a
jmp 0x433c
jmp 0x435b
leaq 0x1073c(%rip), %rdi     # 0x14a7f
leaq 0x10359(%rip), %rsi     # 0x146a3
movl $0x3ad, %edx            # imm = 0x3AD
leaq 0x10752(%rip), %rcx     # 0x14aa8
callq 0x1090
movq -0x40(%rbp), %rdi
callq 0x1ab0
movq %rax, %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
leaq -0x58(%rbp), %rdi
callq 0x1520
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
callq 0x18b0
movq -0x60(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
subq $0x8, %rcx
leaq -0x58(%rbp), %r8
callq 0x4270
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: Compile_code
int Compile_code(Buffer *buf, ASTNode *code) {
  assert(AST_is_pair(code));
  ASTNode *code_sym = AST_pair_car(code);
  assert(AST_is_symbol(code_sym));
  assert(AST_symbol_matches(code_sym, "code"));
  ASTNode *formals = AST_pair_car(AST_pair_cdr(code));
  ASTNode *code_body = AST_pair_car(AST_pair_cdr(AST_pair_cdr(code)));
  return Compile_code_impl(buf, formals, code_body, -kWordSize, NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1870
testb $0x1, %al
jne 0x43df
jmp 0x43e1
jmp 0x4400
leaq 0x10703(%rip), %rdi     # 0x14aeb
leaq 0x102b4(%rip), %rsi     # 0x146a3
movl $0x3b4, %edx            # imm = 0x3B4
leaq 0x10702(%rip), %rcx     # 0x14afd
callq 0x1090
movq -0x10(%rbp), %rdi
callq 0x1890
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1a90
testb $0x1, %al
jne 0x441c
jmp 0x441e
jmp 0x443d
leaq 0x106fe(%rip), %rdi     # 0x14b23
leaq 0x10277(%rip), %rsi     # 0x146a3
movl $0x3b6, %edx            # imm = 0x3B6
leaq 0x106c5(%rip), %rcx     # 0x14afd
callq 0x1090
movq -0x18(%rbp), %rdi
leaq 0x106f3(%rip), %rsi     # 0x14b3b
callq 0x1ad0
testb $0x1, %al
jne 0x4453
jmp 0x4455
jmp 0x4474
leaq 0x106e4(%rip), %rdi     # 0x14b40
leaq 0x10240(%rip), %rsi     # 0x146a3
movl $0x3b7, %edx            # imm = 0x3B7
leaq 0x1068e(%rip), %rcx     # 0x14afd
callq 0x1090
movq -0x10(%rbp), %rdi
callq 0x18b0
movq %rax, %rdi
callq 0x1890
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x18b0
movq %rax, %rdi
callq 0x18b0
movq %rax, %rdi
callq 0x1890
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq $-0x8, %rcx
xorl %eax, %eax
movl %eax, %r8d
callq 0x4270
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: Compile_entry
WARN_UNUSED int Compile_entry(Buffer *buf, ASTNode *node) {
  Buffer_write_arr(buf, kEntryPrologue, sizeof kEntryPrologue);
  if (AST_is_pair(node)) {
    // Assume it's (labels ...)
    ASTNode *labels_sym = AST_pair_car(node);
    if (AST_is_symbol(labels_sym) && AST_symbol_matches(labels_sym, "labels")) {
      // Jump to body
      word body_pos = Emit_jmp(buf, kLabelPlaceholder);
      ASTNode *bindings = AST_pair_car(AST_pair_cdr(node));
      assert(AST_is_pair(bindings) || AST_is_nil(bindings));
      ASTNode *body = AST_pair_car(AST_pair_cdr(AST_pair_cdr(node)));
      _(Compile_labels(buf, bindings, body, /*labels=*/NULL, body_pos));
      return 0;
    }
  }
  _(Compile_expr(buf, node, /*stack_index=*/-kWordSize, /*varenv=*/NULL,
                 /*labels=*/NULL));
  Buffer_write_arr(buf, kFunctionEpilogue, sizeof kFunctionEpilogue);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xfb2e(%rip), %rsi      # 0x141d9
movl $0x3, %edx
callq 0x1f10
movq -0x18(%rbp), %rdi
callq 0x1870
testb $0x1, %al
jne 0x46c7
jmp 0x47b7
movq -0x18(%rbp), %rdi
callq 0x1890
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1a90
testb $0x1, %al
jne 0x46e6
jmp 0x47b5
movq -0x20(%rbp), %rdi
leaq 0x10ecc(%rip), %rsi     # 0x155bd
callq 0x1ad0
testb $0x1, %al
jne 0x46ff
jmp 0x47b5
movq -0x10(%rbp), %rdi
movl $0xdeadbeef, %esi       # imm = 0xDEADBEEF
callq 0x27a0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x18b0
movq %rax, %rdi
callq 0x1890
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1870
testb $0x1, %al
jne 0x4742
movq -0x30(%rbp), %rdi
callq 0x1700
testb $0x1, %al
jne 0x4742
jmp 0x4744
jmp 0x4763
leaq 0x1045a(%rip), %rdi     # 0x14ba5
leaq 0xff51(%rip), %rsi      # 0x146a3
movl $0x3df, %edx            # imm = 0x3DF
leaq 0x10475(%rip), %rcx     # 0x14bd3
callq 0x1090
movq -0x18(%rbp), %rdi
callq 0x18b0
movq %rax, %rdi
callq 0x18b0
movq %rax, %rdi
callq 0x1890
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x28(%rbp), %r8
xorl %eax, %eax
movl %eax, %ecx
callq 0x44d0
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
je 0x47aa
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x4804
jmp 0x47ac
movl $0x0, -0x4(%rbp)
jmp 0x4804
jmp 0x47b7
jmp 0x47b9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq $-0x8, %rdx
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rcx
callq 0x29f0
movl %eax, -0x40(%rbp)
cmpl $0x0, -0x40(%rbp)
je 0x47e6
movl -0x40(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x4804
jmp 0x47e8
movq -0x10(%rbp), %rdi
leaq 0xf9e5(%rip), %rsi      # 0x141d8
movl $0x1, %edx
callq 0x1f10
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: starts_symbol
bool starts_symbol(char c) {
  switch (c) {
  case '+':
  case '-':
  case '*':
  case '<':
  case '>':
  case '=':
  case '?':
    return true;
  default:
    return isalpha(c);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x2(%rbp)
movsbl -0x2(%rbp), %eax
movl %eax, -0x8(%rbp)
addl $-0x2a, %eax
subl $0x2, %eax
jb 0x48f6
jmp 0x48df
movl -0x8(%rbp), %eax
subl $0x2d, %eax
je 0x48f6
jmp 0x48e9
movl -0x8(%rbp), %eax
addl $-0x3c, %eax
subl $0x3, %eax
ja 0x48fc
jmp 0x48f6
movb $0x1, -0x1(%rbp)
jmp 0x491f
callq 0x1180
movq (%rax), %rax
movsbl -0x2(%rbp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: read_integer
ASTNode *read_integer(char *input, word *pos, int sign) {
  char c = '\0';
  word result = 0;
  for (char c = input[*pos]; isdigit(c); c = next(input, pos)) {
    result *= 10;
    result += c - '0';
  }
  return AST_new_integer(result * sign);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movb (%rax,%rcx), %al
movb %al, -0x21(%rbp)
callq 0x1180
movq (%rax), %rax
movsbl -0x21(%rbp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x49a9
imulq $0xa, -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movsbl -0x21(%rbp), %eax
subl $0x30, %eax
cltq
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4830
movb %al, -0x21(%rbp)
jmp 0x4960
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rax
imulq %rax, %rdi
callq 0x15c0
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: read_symbol
ASTNode *read_symbol(char *input, word *pos) {
  char buf[ATOM_MAX + 1];
  word length = 0;
  for (length = 0; length < ATOM_MAX && is_symbol_char(input[*pos]); length++) {
    buf[length] = input[*pos];
    advance(pos);
  }
  buf[length] = '\0';
  return AST_new_symbol(buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rsp, %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x20, -0x20(%rbp)
movb %al, -0x51(%rbp)
jge 0x4a5a
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movsbl (%rax,%rcx), %edi
callq 0x49c0
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x4a63
jmp 0x4a90
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movb (%rax,%rcx), %cl
movq -0x20(%rbp), %rax
movb %cl, -0x50(%rbp,%rax)
movq -0x10(%rbp), %rdi
callq 0x4810
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x4a37
movq -0x20(%rbp), %rax
movb $0x0, -0x50(%rbp,%rax)
leaq -0x50(%rbp), %rdi
callq 0x19d0
movq -0x18(%rbp), %rcx
movq %rcx, %rsp
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: read_char
ASTNode *read_char(char *input, word *pos) {
  char c = input[*pos];
  if (c == '\'') {
    return AST_error();
  }
  advance(pos);
  if (input[*pos] != '\'') {
    return AST_error();
  }
  advance(pos);
  return AST_new_char(c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movb (%rax,%rcx), %al
movb %al, -0x19(%rbp)
movsbl -0x19(%rbp), %eax
cmpl $0x27, %eax
jne 0x4ae5
callq 0x1770
movq %rax, -0x8(%rbp)
jmp 0x4b23
movq -0x18(%rbp), %rdi
callq 0x4810
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x27, %eax
je 0x4b0d
callq 0x1770
movq %rax, -0x8(%rbp)
jmp 0x4b23
movq -0x18(%rbp), %rdi
callq 0x4810
movsbl -0x19(%rbp), %edi
callq 0x1620
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: read_list
ASTNode *read_list(char *input, word *pos) {
  char c = skip_whitespace(input, pos);
  if (c == ')') {
    advance(pos);
    return AST_nil();
  }
  ASTNode *car = read_rec(input, pos);
  assert(car != AST_error());
  ASTNode *cdr = read_list(input, pos);
  assert(cdr != AST_error());
  return AST_new_pair(car, cdr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4860
movb %al, -0x19(%rbp)
movsbl -0x19(%rbp), %eax
cmpl $0x29, %eax
jne 0x4b70
movq -0x18(%rbp), %rdi
callq 0x4810
callq 0x1730
movq %rax, -0x8(%rbp)
jmp 0x4c17
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4c30
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x1770
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
je 0x4b9c
jmp 0x4bbb
leaq 0x10057(%rip), %rdi     # 0x14bfa
leaq 0xfaf9(%rip), %rsi      # 0x146a3
movl $0x442, %edx            # imm = 0x442
leaq 0x10057(%rip), %rcx     # 0x14c0d
callq 0x1090
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4b30
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x1770
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
je 0x4be7
jmp 0x4c06
leaq 0x10042(%rip), %rdi     # 0x14c30
leaq 0xfaae(%rip), %rsi      # 0x146a3
movl $0x444, %edx            # imm = 0x444
leaq 0x1000c(%rip), %rcx     # 0x14c0d
callq 0x1090
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x18d0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: Testing_execute_entry
uword Testing_execute_entry(Buffer *buf, uword *heap) {
  assert(buf != NULL);
  assert(buf->address != NULL);
  assert(buf->state == kExecutable);
  // The pointer-pointer cast is allowed but the underlying
  // data-to-function-pointer back-and-forth is only guaranteed to work on
  // POSIX systems (because of eg dlsym).
  JitFunction function = *(JitFunction *)(&buf->address);
  return function(heap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4e89
jmp 0x4ea8
leaq 0xfdb3(%rip), %rdi      # 0x14c43
leaq 0xf80c(%rip), %rsi      # 0x146a3
movl $0x474, %edx            # imm = 0x474
leaq 0xfdac(%rip), %rcx      # 0x14c4f
callq 0x1090
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x4eb4
jmp 0x4ed3
leaq 0xfdc3(%rip), %rdi      # 0x14c7e
leaq 0xf7e1(%rip), %rsi      # 0x146a3
movl $0x475, %edx            # imm = 0x475
leaq 0xfd81(%rip), %rcx      # 0x14c4f
callq 0x1090
movq -0x8(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jne 0x4edf
jmp 0x4efe
leaq 0xfdad(%rip), %rdi      # 0x14c93
leaq 0xf7b6(%rip), %rsi      # 0x146a3
movl $0x476, %edx            # imm = 0x476
leaq 0xfd56(%rip), %rcx      # 0x14c4f
callq 0x1090
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
callq *%rax
cltq
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: object_tests
SUITE(object_tests) {
  RUN_TEST(encode_positive_integer);
  RUN_TEST(encode_negative_integer);
  RUN_TEST(encode_char);
  RUN_TEST(decode_char);
  RUN_TEST(encode_bool);
  RUN_TEST(decode_bool);
  RUN_TEST(address);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0xfc3e(%rip), %rdi      # 0x14cad
callq 0x5240
cmpl $0x1, %eax
jne 0x50a5
leaq 0x16080(%rip), %rdi     # 0x1b100
addq $0x1c0, %rdi            # imm = 0x1C0
callq 0x10d0
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x509d
callq 0x5410
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %edi
callq 0x5570
jmp 0x50a7
jmp 0x50a9
leaq 0xfc15(%rip), %rdi      # 0x14cc5
callq 0x5240
cmpl $0x1, %eax
jne 0x50e6
leaq 0x1603f(%rip), %rdi     # 0x1b100
addq $0x1c0, %rdi            # imm = 0x1C0
callq 0x10d0
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x50de
callq 0x56f0
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %edi
callq 0x5570
jmp 0x50e8
jmp 0x50ea
leaq 0xfbec(%rip), %rdi      # 0x14cdd
callq 0x5240
cmpl $0x1, %eax
jne 0x5127
leaq 0x15ffe(%rip), %rdi     # 0x1b100
addq $0x1c0, %rdi            # imm = 0x1C0
callq 0x10d0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x511f
callq 0x5860
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0x5570
jmp 0x5129
jmp 0x512b
leaq 0xfbb7(%rip), %rdi      # 0x14ce9
callq 0x5240
cmpl $0x1, %eax
jne 0x5168
leaq 0x15fbd(%rip), %rdi     # 0x1b100
addq $0x1c0, %rdi            # imm = 0x1C0
callq 0x10d0
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jne 0x5160
callq 0x5960
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %edi
callq 0x5570
jmp 0x516a
jmp 0x516c
leaq 0xfb82(%rip), %rdi      # 0x14cf5
callq 0x5240
cmpl $0x1, %eax
jne 0x51a9
leaq 0x15f7c(%rip), %rdi     # 0x1b100
addq $0x1c0, %rdi            # imm = 0x1C0
callq 0x10d0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x51a1
callq 0x5a60
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0x5570
jmp 0x51ab
jmp 0x51ad
leaq 0xfb4d(%rip), %rdi      # 0x14d01
callq 0x5240
cmpl $0x1, %eax
jne 0x51ea
leaq 0x15f3b(%rip), %rdi     # 0x1b100
addq $0x1c0, %rdi            # imm = 0x1C0
callq 0x10d0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x51e2
callq 0x5c20
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %edi
callq 0x5570
jmp 0x51ec
jmp 0x51ee
leaq 0x11165(%rip), %rdi     # 0x1635a
callq 0x5240
cmpl $0x1, %eax
jne 0x522b
leaq 0x15efa(%rip), %rdi     # 0x1b100
addq $0x1c0, %rdi            # imm = 0x1C0
callq 0x10d0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x5223
callq 0x5d20
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
callq 0x5570
jmp 0x522d
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: encode_positive_integer
TEST encode_positive_integer(void) {
  ASSERT_EQ(Object_encode_integer(0), 0x0);
  ASSERT_EQ(Object_encode_integer(1), 0x4);
  ASSERT_EQ(Object_encode_integer(10), 0x28);
  PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x15d26(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x15d1d(%rip)     # 0x1b144
xorl %eax, %eax
movl %eax, %edi
callq 0x1290
cmpq $0x0, %rax
je 0x547e
jmp 0x5438
leaq 0xf264(%rip), %rax      # 0x146a3
movq %rax, 0x15d0a(%rip)     # 0x1b150
movl $0x4c0, 0x15cf8(%rip)   # imm = 0x4C0
leaq 0x103df(%rip), %rax     # 0x15836
movq %rax, 0x15cfa(%rip)     # 0x1b158
movzbl 0x15c9b(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x5472
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5564
jmp 0x5480
jmp 0x5482
movl 0x15cbc(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x15cb3(%rip)     # 0x1b144
movl $0x1, %edi
callq 0x1290
cmpq $0x4, %rax
je 0x54e6
jmp 0x54a3
leaq 0xf1f9(%rip), %rax      # 0x146a3
movq %rax, 0x15c9f(%rip)     # 0x1b150
movl $0x4c1, 0x15c8d(%rip)   # imm = 0x4C1
leaq 0x10394(%rip), %rax     # 0x15856
movq %rax, 0x15c8f(%rip)     # 0x1b158
movzbl 0x15c30(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x54dd
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5564
jmp 0x54e8
jmp 0x54ea
movl 0x15c54(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x15c4b(%rip)     # 0x1b144
movl $0xa, %edi
callq 0x1290
cmpq $0x28, %rax
je 0x554e
jmp 0x550b
leaq 0xf191(%rip), %rax      # 0x146a3
movq %rax, 0x15c37(%rip)     # 0x1b150
movl $0x4c2, 0x15c25(%rip)   # imm = 0x4C2
leaq 0x1034c(%rip), %rax     # 0x15876
movq %rax, 0x15c27(%rip)     # 0x1b158
movzbl 0x15bc8(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x5545
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5564
jmp 0x5550
jmp 0x5552
movq $0x0, 0x15bfb(%rip) # 0x1b158
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: encode_negative_integer
TEST encode_negative_integer(void) {
  ASSERT_EQ(Object_encode_integer(0), 0x0);
  ASSERT_EQ(Object_encode_integer(-1), 0xfffffffffffffffc);
  ASSERT_EQ(Object_encode_integer(-10), 0xffffffffffffffd8);
  PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x15a46(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x15a3d(%rip)     # 0x1b144
xorl %eax, %eax
movl %eax, %edi
callq 0x1290
cmpq $0x0, %rax
je 0x575e
jmp 0x5718
leaq 0xef84(%rip), %rax      # 0x146a3
movq %rax, 0x15a2a(%rip)     # 0x1b150
movl $0x4c7, 0x15a18(%rip)   # imm = 0x4C7
leaq 0x100ff(%rip), %rax     # 0x15836
movq %rax, 0x15a1a(%rip)     # 0x1b158
movzbl 0x159bb(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x5752
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x584b
jmp 0x5760
jmp 0x5762
movl 0x159dc(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x159d3(%rip)     # 0x1b144
movq $-0x1, %rdi
callq 0x1290
cmpq $-0x4, %rax
je 0x57cb
jmp 0x5785
leaq 0xef17(%rip), %rax      # 0x146a3
movq %rax, 0x159bd(%rip)     # 0x1b150
movl $0x4c8, 0x159ab(%rip)   # imm = 0x4C8
leaq 0x100f4(%rip), %rax     # 0x15898
movq %rax, 0x159ad(%rip)     # 0x1b158
movzbl 0x1594e(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x57bf
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x584b
jmp 0x57cd
jmp 0x57cf
movl 0x1596f(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x15966(%rip)     # 0x1b144
movq $-0xa, %rdi
callq 0x1290
cmpq $-0x28, %rax
je 0x5835
jmp 0x57f2
leaq 0xeeaa(%rip), %rax      # 0x146a3
movq %rax, 0x15950(%rip)     # 0x1b150
movl $0x4c9, 0x1593e(%rip)   # imm = 0x4C9
leaq 0x100b7(%rip), %rax     # 0x158c8
movq %rax, 0x15940(%rip)     # 0x1b158
movzbl 0x158e1(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x582c
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x584b
jmp 0x5837
jmp 0x5839
movq $0x0, 0x15914(%rip) # 0x1b158
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: encode_bool
TEST encode_bool(void) {
  ASSERT_EQ(Object_encode_bool(true), 0x9f);
  ASSERT_EQ(Object_encode_bool(false), 0x1f);
  ASSERT_EQ(Object_true(), 0x9f);
  ASSERT_EQ(Object_false(), 0x1f);
  PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x156d6(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x156cd(%rip)     # 0x1b144
movl $0x1, %edi
callq 0x13c0
cmpq $0x9f, %rax
je 0x5ad1
jmp 0x5a8b
leaq 0xec11(%rip), %rax      # 0x146a3
movq %rax, 0x156b7(%rip)     # 0x1b150
movl $0x4da, 0x156a5(%rip)   # imm = 0x4DA
leaq 0xfed3(%rip), %rax      # 0x1597d
movq %rax, 0x156a7(%rip)     # 0x1b158
movzbl 0x15648(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x5ac5
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5c17
jmp 0x5ad3
jmp 0x5ad5
movl 0x15669(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x15660(%rip)     # 0x1b144
xorl %edi, %edi
callq 0x13c0
cmpq $0x1f, %rax
je 0x5b39
jmp 0x5af3
leaq 0xeba9(%rip), %rax      # 0x146a3
movq %rax, 0x1564f(%rip)     # 0x1b150
movl $0x4db, 0x1563d(%rip)   # imm = 0x4DB
leaq 0xfe8c(%rip), %rax      # 0x1599e
movq %rax, 0x1563f(%rip)     # 0x1b158
movzbl 0x155e0(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x5b2d
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5c17
jmp 0x5b3b
jmp 0x5b3d
movl 0x15601(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x155f8(%rip)     # 0x1b144
callq 0x1400
cmpq $0x9f, %rax
je 0x5b9e
jmp 0x5b5b
leaq 0xeb41(%rip), %rax      # 0x146a3
movq %rax, 0x155e7(%rip)     # 0x1b150
movl $0x4dc, 0x155d5(%rip)   # imm = 0x4DC
leaq 0xfe46(%rip), %rax      # 0x159c0
movq %rax, 0x155d7(%rip)     # 0x1b158
movzbl 0x15578(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x5b95
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5c17
jmp 0x5ba0
jmp 0x5ba2
movl 0x1559c(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x15593(%rip)     # 0x1b144
callq 0x1410
cmpq $0x1f, %rax
je 0x5c01
jmp 0x5bbe
leaq 0xeade(%rip), %rax      # 0x146a3
movq %rax, 0x15584(%rip)     # 0x1b150
movl $0x4dd, 0x15572(%rip)   # imm = 0x4DD
leaq 0xfdf9(%rip), %rax      # 0x159d6
movq %rax, 0x15574(%rip)     # 0x1b158
movzbl 0x15515(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x5bf8
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5c17
jmp 0x5c03
jmp 0x5c05
movq $0x0, 0x15548(%rip) # 0x1b158
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: ast_tests
SUITE(ast_tests) {
  RUN_TEST(ast_new_pair);
  RUN_TEST(ast_pair_car_returns_car);
  RUN_TEST(ast_pair_cdr_returns_cdr);
  RUN_TEST(ast_new_symbol);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xef4e(%rip), %rdi      # 0x14d0d
callq 0x5240
cmpl $0x1, %eax
jne 0x5df5
leaq 0x15330(%rip), %rdi     # 0x1b100
addq $0x1c0, %rdi            # imm = 0x1C0
callq 0x10d0
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x5ded
callq 0x5ec0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %edi
callq 0x5570
jmp 0x5df7
jmp 0x5df9
leaq 0xef1a(%rip), %rdi      # 0x14d1a
callq 0x5240
cmpl $0x1, %eax
jne 0x5e36
leaq 0x152ef(%rip), %rdi     # 0x1b100
addq $0x1c0, %rdi            # imm = 0x1C0
callq 0x10d0
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x5e2e
callq 0x5f60
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %edi
callq 0x5570
jmp 0x5e38
jmp 0x5e3a
leaq 0xeef2(%rip), %rdi      # 0x14d33
callq 0x5240
cmpl $0x1, %eax
jne 0x5e77
leaq 0x152ae(%rip), %rdi     # 0x1b100
addq $0x1c0, %rdi            # imm = 0x1C0
callq 0x10d0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x5e6f
callq 0x6080
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0x5570
jmp 0x5e79
jmp 0x5e7b
leaq 0xeeca(%rip), %rdi      # 0x14d4c
callq 0x5240
cmpl $0x1, %eax
jne 0x5eb8
leaq 0x1526d(%rip), %rdi     # 0x1b100
addq $0x1c0, %rdi            # imm = 0x1C0
callq 0x10d0
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jne 0x5eb0
callq 0x61a0
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %edi
callq 0x5570
jmp 0x5eba
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: ast_new_pair
TEST ast_new_pair(void) {
  ASTNode *node = AST_new_pair(NULL, NULL);
  ASSERT(AST_is_pair(node));
  AST_heap_free(node);
  PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x18d0
movq %rax, -0x10(%rbp)
movl 0x15266(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x1525d(%rip)     # 0x1b144
movq -0x10(%rbp), %rdi
callq 0x1870
testb $0x1, %al
jne 0x5f39
jmp 0x5ef6
leaq 0xe7a6(%rip), %rax      # 0x146a3
movq %rax, 0x1524c(%rip)     # 0x1b150
movl $0x4ee, 0x1523a(%rip)   # imm = 0x4EE
leaq 0xe833(%rip), %rax      # 0x14748
movq %rax, 0x1523c(%rip)     # 0x1b158
movzbl 0x151dd(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x5f30
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5f56
jmp 0x5f3b
movq -0x10(%rbp), %rdi
callq 0x1800
movq $0x0, 0x15209(%rip) # 0x1b158
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: ast_pair_car_returns_car
TEST ast_pair_car_returns_car(void) {
  ASTNode *node = AST_new_pair(AST_new_integer(123), NULL);
  ASTNode *car = AST_pair_car(node);
  ASSERT(AST_is_integer(car));
  ASSERT_EQ(Object_decode_integer((uword)car), 123);
  AST_heap_free(node);
  PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x7b, %edi
callq 0x15c0
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x18d0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1890
movq %rax, -0x18(%rbp)
movl 0x151af(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x151a6(%rip)     # 0x1b144
movq -0x18(%rbp), %rdi
callq 0x15e0
testb $0x1, %al
jne 0x5ff3
jmp 0x5fad
leaq 0xe6ef(%rip), %rax      # 0x146a3
movq %rax, 0x15195(%rip)     # 0x1b150
movl $0x4f6, 0x15183(%rip)   # imm = 0x4F6
leaq 0xfa8d(%rip), %rax      # 0x15a59
movq %rax, 0x15185(%rip)     # 0x1b158
movzbl 0x15126(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x5fe7
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6077
jmp 0x5ff5
jmp 0x5ff7
movl 0x15147(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x1513e(%rip)     # 0x1b144
movq -0x18(%rbp), %rdi
callq 0x1320
cmpq $0x7b, %rax
je 0x605a
jmp 0x6017
leaq 0xe685(%rip), %rax      # 0x146a3
movq %rax, 0x1512b(%rip)     # 0x1b150
movl $0x4f7, 0x15119(%rip)   # imm = 0x4F7
leaq 0xfa37(%rip), %rax      # 0x15a6d
movq %rax, 0x1511b(%rip)     # 0x1b158
movzbl 0x150bc(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x6051
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6077
jmp 0x605c
movq -0x10(%rbp), %rdi
callq 0x1800
movq $0x0, 0x150e8(%rip) # 0x1b158
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: ast_pair_cdr_returns_cdr
TEST ast_pair_cdr_returns_cdr(void) {
  ASTNode *node = AST_new_pair(NULL, AST_new_integer(123));
  ASTNode *cdr = AST_pair_cdr(node);
  ASSERT(AST_is_integer(cdr));
  ASSERT_EQ(Object_decode_integer((uword)cdr), 123);
  AST_heap_free(node);
  PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x7b, %edi
callq 0x15c0
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x18d0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x18b0
movq %rax, -0x18(%rbp)
movl 0x1508f(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x15086(%rip)     # 0x1b144
movq -0x18(%rbp), %rdi
callq 0x15e0
testb $0x1, %al
jne 0x6113
jmp 0x60cd
leaq 0xe5cf(%rip), %rax      # 0x146a3
movq %rax, 0x15075(%rip)     # 0x1b150
movl $0x4ff, 0x15063(%rip)   # imm = 0x4FF
leaq 0xf9aa(%rip), %rax      # 0x15a96
movq %rax, 0x15065(%rip)     # 0x1b158
movzbl 0x15006(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x6107
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6197
jmp 0x6115
jmp 0x6117
movl 0x15027(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x1501e(%rip)     # 0x1b144
movq -0x18(%rbp), %rdi
callq 0x1320
cmpq $0x7b, %rax
je 0x617a
jmp 0x6137
leaq 0xe565(%rip), %rax      # 0x146a3
movq %rax, 0x1500b(%rip)     # 0x1b150
movl $0x500, 0x14ff9(%rip)   # imm = 0x500
leaq 0xf954(%rip), %rax      # 0x15aaa
movq %rax, 0x14ffb(%rip)     # 0x1b158
movzbl 0x14f9c(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x6171
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6197
jmp 0x617c
movq -0x10(%rbp), %rdi
callq 0x1800
movq $0x0, 0x14fc8(%rip) # 0x1b158
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: ast_new_symbol
TEST ast_new_symbol(void) {
  const char *value = "my symbol";
  ASTNode *node = AST_new_symbol(value);
  ASSERT(AST_is_symbol(node));
  ASSERT_STR_EQ(AST_symbol_cstr(node), value);
  AST_heap_free(node);
  PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0xf924(%rip), %rax      # 0x15ad3
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x19d0
movq %rax, -0x18(%rbp)
movl 0x14f7e(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x14f75(%rip)     # 0x1b144
movq -0x18(%rbp), %rdi
callq 0x1a90
testb $0x1, %al
jne 0x6224
jmp 0x61de
leaq 0xe4be(%rip), %rax      # 0x146a3
movq %rax, 0x14f64(%rip)     # 0x1b150
movl $0x508, 0x14f52(%rip)   # imm = 0x508
leaq 0xe57a(%rip), %rax      # 0x14777
movq %rax, 0x14f54(%rip)     # 0x1b158
movzbl 0x14ef5(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x6218
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6324
jmp 0x6226
jmp 0x6228
jmp 0x622a
leaq 0x14ea7(%rip), %rax     # 0x1b0d8
movq %rax, -0x20(%rbp)
movl 0x14f09(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x14f00(%rip)     # 0x1b144
movq -0x18(%rbp), %rdi
callq 0x1ab0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x11f00
cmpl $0x0, %eax
jne 0x6305
cmpq $0x0, -0x20(%rbp)
je 0x627b
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x62c0
jmp 0x627d
leaq 0xe41f(%rip), %rax      # 0x146a3
movq %rax, 0x14ec5(%rip)     # 0x1b150
movl $0x509, 0x14eb3(%rip)   # imm = 0x509
leaq 0xf841(%rip), %rax      # 0x15add
movq %rax, 0x14eb5(%rip)     # 0x1b158
movzbl 0x14e56(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x62b7
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6324
jmp 0x62c2
leaq 0xe3da(%rip), %rax      # 0x146a3
movq %rax, 0x14e80(%rip)     # 0x1b150
movl $0x509, 0x14e6e(%rip)   # imm = 0x509
leaq 0xf81f(%rip), %rax      # 0x15b00
movq %rax, 0x14e70(%rip)     # 0x1b158
movzbl 0x14e11(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x62fc
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6324
jmp 0x6307
jmp 0x6309
movq -0x18(%rbp), %rdi
callq 0x1800
movq $0x0, 0x14e3b(%rip) # 0x1b158
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: read_with_integer_returns_integer
TEST read_with_integer_returns_integer(void) {
  char *input = "1234";
  ASTNode *node = Reader_read(input);
  ASSERT_IS_INT_EQ(node, 1234);
  AST_heap_free(node);
  PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0xf588(%rip), %rax      # 0x15ba7
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4e40
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1740
testb $0x1, %al
jne 0x6647
jmp 0x665f
movq 0x149aa(%rip), %rax     # 0x1aff8
movq (%rax), %rdi
leaq 0xf4c7(%rip), %rsi      # 0x15b1f
movb $0x0, %al
callq 0x1100
jmp 0x6661
movl 0x14add(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x14ad4(%rip)     # 0x1b144
movq -0x20(%rbp), %rdi
callq 0x15e0
testb $0x1, %al
jne 0x66c5
jmp 0x667f
leaq 0xe01d(%rip), %rax      # 0x146a3
movq %rax, 0x14ac3(%rip)     # 0x1b150
movl $0x52f, 0x14ab1(%rip)   # imm = 0x52F
leaq 0xf4a4(%rip), %rax      # 0x15b42
movq %rax, 0x14ab3(%rip)     # 0x1b158
movzbl 0x14a54(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x66b9
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x674d
jmp 0x66c7
jmp 0x66c9
movl 0x14a75(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x14a6c(%rip)     # 0x1b144
movq -0x20(%rbp), %rdi
callq 0x1600
cmpq $0x4d2, %rax            # imm = 0x4D2
je 0x672e
jmp 0x66eb
leaq 0xdfb1(%rip), %rax      # 0x146a3
movq %rax, 0x14a57(%rip)     # 0x1b150
movl $0x52f, 0x14a45(%rip)   # imm = 0x52F
leaq 0xf44e(%rip), %rax      # 0x15b58
movq %rax, 0x14a47(%rip)     # 0x1b158
movzbl 0x149e8(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x6725
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x674d
jmp 0x6730
jmp 0x6732
movq -0x18(%rbp), %rdi
callq 0x1800
movq $0x0, 0x14a12(%rip) # 0x1b158
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: read_with_negative_integer_returns_integer
TEST read_with_negative_integer_returns_integer(void) {
  char *input = "-1234";
  ASTNode *node = Reader_read(input);
  ASSERT_IS_INT_EQ(node, -1234);
  AST_heap_free(node);
  PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0xf422(%rip), %rax      # 0x15b91
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4e40
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1740
testb $0x1, %al
jne 0x6797
jmp 0x67af
movq 0x1485a(%rip), %rax     # 0x1aff8
movq (%rax), %rdi
leaq 0xf377(%rip), %rsi      # 0x15b1f
movb $0x0, %al
callq 0x1100
jmp 0x67b1
movl 0x1498d(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x14984(%rip)     # 0x1b144
movq -0x20(%rbp), %rdi
callq 0x15e0
testb $0x1, %al
jne 0x6815
jmp 0x67cf
leaq 0xdecd(%rip), %rax      # 0x146a3
movq %rax, 0x14973(%rip)     # 0x1b150
movl $0x537, 0x14961(%rip)   # imm = 0x537
leaq 0xf354(%rip), %rax      # 0x15b42
movq %rax, 0x14963(%rip)     # 0x1b158
movzbl 0x14904(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x6809
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x689d
jmp 0x6817
jmp 0x6819
movl 0x14925(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x1491c(%rip)     # 0x1b144
movq -0x20(%rbp), %rdi
callq 0x1600
cmpq $-0x4d2, %rax           # imm = 0xFB2E
je 0x687e
jmp 0x683b
leaq 0xde61(%rip), %rax      # 0x146a3
movq %rax, 0x14907(%rip)     # 0x1b150
movl $0x537, 0x148f5(%rip)   # imm = 0x537
leaq 0xf31d(%rip), %rax      # 0x15b77
movq %rax, 0x148f7(%rip)     # 0x1b158
movzbl 0x14898(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x6875
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x689d
jmp 0x6880
jmp 0x6882
movq -0x18(%rbp), %rdi
callq 0x1800
movq $0x0, 0x148c2(%rip) # 0x1b158
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: read_with_leading_whitespace_ignores_whitespace
TEST read_with_leading_whitespace_ignores_whitespace(void) {
  char *input = "   \t   \n  1234";
  ASTNode *node = Reader_read(input);
  ASSERT_IS_INT_EQ(node, 1234);
  AST_heap_free(node);
  PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0xf18e(%rip), %rax      # 0x15b9d
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4e40
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1740
testb $0x1, %al
jne 0x6a37
jmp 0x6a4f
movq 0x145ba(%rip), %rax     # 0x1aff8
movq (%rax), %rdi
leaq 0xf0d7(%rip), %rsi      # 0x15b1f
movb $0x0, %al
callq 0x1100
jmp 0x6a51
movl 0x146ed(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x146e4(%rip)     # 0x1b144
movq -0x20(%rbp), %rdi
callq 0x15e0
testb $0x1, %al
jne 0x6ab5
jmp 0x6a6f
leaq 0xdc2d(%rip), %rax      # 0x146a3
movq %rax, 0x146d3(%rip)     # 0x1b150
movl $0x547, 0x146c1(%rip)   # imm = 0x547
leaq 0xf0b4(%rip), %rax      # 0x15b42
movq %rax, 0x146c3(%rip)     # 0x1b158
movzbl 0x14664(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x6aa9
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6b3d
jmp 0x6ab7
jmp 0x6ab9
movl 0x14685(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x1467c(%rip)     # 0x1b144
movq -0x20(%rbp), %rdi
callq 0x1600
cmpq $0x4d2, %rax            # imm = 0x4D2
je 0x6b1e
jmp 0x6adb
leaq 0xdbc1(%rip), %rax      # 0x146a3
movq %rax, 0x14667(%rip)     # 0x1b150
movl $0x547, 0x14655(%rip)   # imm = 0x547
leaq 0xf05e(%rip), %rax      # 0x15b58
movq %rax, 0x14657(%rip)     # 0x1b158
movzbl 0x145f8(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x6b15
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6b3d
jmp 0x6b20
jmp 0x6b22
movq -0x18(%rbp), %rdi
callq 0x1800
movq $0x0, 0x14622(%rip) # 0x1b158
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)