LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: compile_unary_integerp_with_integer_returns_true
TEST compile_unary_integerp_with_integer_returns_true(Buffer *buf) {
  ASTNode *node = new_unary_call("integer?", AST_new_integer(5));
  int compile_result = Compile_entry(buf, node);
  ASSERT_EQ(compile_result, 0);
  // 0:  48 c7 c0 14 00 00 00    mov    rax,0x14
  // 7:  48 83 e0 03             and    rax,0x3
  // b:  48 3d 00 00 00 00       cmp    rax,0x00000000
  // 11: 48 c7 c0 00 00 00 00    mov    rax,0x0
  // 18: 0f 94 c0                sete   al
  // 1b: 48 c1 e0 07             shl    rax,0x7
  // 1f: 48 83 c8 1f             or     rax,0x1f
  byte expected[] = {0x48, 0xc7, 0xc0, 0x14, 0x00, 0x00, 0x00, 0x48, 0x83,
                     0xe0, 0x03, 0x48, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x48,
                     0xc7, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x94, 0xc0,
                     0x48, 0xc1, 0xe0, 0x07, 0x48, 0x83, 0xc8, 0x1f};
  EXPECT_ENTRY_CONTAINS_CODE(buf, expected);
  Buffer_make_executable(buf);
  uword result = Testing_execute_expr(buf);
  ASSERT_EQ(result, Object_true());
  AST_heap_free(node);
  PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl $0x5, %edi
callq 0x15c0
movq %rax, %rsi
leaq 0x8ac8(%rip), %rdi      # 0x149e8
callq 0x4ff0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4690
movl %eax, -0x1c(%rbp)
movl 0xf205(%rip), %eax      # 0x1b144
addl $0x1, %eax
movl %eax, 0xf1fc(%rip)      # 0x1b144
cmpl $0x0, -0x1c(%rbp)
je 0xbf96
jmp 0xbf50
leaq 0x874c(%rip), %rax      # 0x146a3
movq %rax, 0xf1f2(%rip)      # 0x1b150
movl $0x6e4, 0xf1e0(%rip)    # imm = 0x6E4
leaq 0xa116(%rip), %rax      # 0x16085
movq %rax, 0xf1e2(%rip)      # 0x1b158
movzbl 0xf183(%rip), %eax      # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xbf8a
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc075
jmp 0xbf98
leaq -0x40(%rbp), %rdi
leaq 0x837d(%rip), %rsi      # 0x14320
movl $0x23, %edx
callq 0x1110
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movl $0x23, %edx
callq 0x12d40
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
je 0xbfd3
movl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xc075
jmp 0xbfd5
movq -0x10(%rbp), %rdi
callq 0x1c50
movq -0x10(%rbp), %rdi
callq 0x4f20
movq %rax, -0x50(%rbp)
movl 0xf153(%rip), %eax      # 0x1b144
addl $0x1, %eax
movl %eax, 0xf14a(%rip)      # 0x1b144
movq -0x50(%rbp), %rax
movq %rax, -0x58(%rbp)
callq 0x1400
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
je 0xc058
jmp 0xc015
leaq 0x8687(%rip), %rax      # 0x146a3
movq %rax, 0xf12d(%rip)      # 0x1b150
movl $0x6f3, 0xf11b(%rip)    # imm = 0x6F3
leaq 0xa108(%rip), %rax      # 0x1613c
movq %rax, 0xf11d(%rip)      # 0x1b158
movzbl 0xf0be(%rip), %eax      # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xc04f
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc075
jmp 0xc05a
movq -0x18(%rbp), %rdi
callq 0x1800
movq $0x0, 0xf0ea(%rip) # 0x1b158
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: compile_unary_integerp_with_non_integer_returns_false
TEST compile_unary_integerp_with_non_integer_returns_false(Buffer *buf) {
  ASTNode *node = new_unary_call("integer?", AST_nil());
  int compile_result = Compile_entry(buf, node);
  ASSERT_EQ(compile_result, 0);
  // 0:  48 c7 c0 2f 00 00 00    mov    rax,0x2f
  // 7:  48 83 e0 03             and    rax,0x3
  // b:  48 3d 00 00 00 00       cmp    rax,0x00000000
  // 11: 48 c7 c0 00 00 00 00    mov    rax,0x0
  // 18: 0f 94 c0                sete   al
  // 1b: 48 c1 e0 07             shl    rax,0x7
  // 1f: 48 83 c8 1f             or     rax,0x1f
  byte expected[] = {0x48, 0xc7, 0xc0, 0x2f, 0x00, 0x00, 0x00, 0x48, 0x83,
                     0xe0, 0x03, 0x48, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x48,
                     0xc7, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x94, 0xc0,
                     0x48, 0xc1, 0xe0, 0x07, 0x48, 0x83, 0xc8, 0x1f};
  EXPECT_ENTRY_CONTAINS_CODE(buf, expected);
  Buffer_make_executable(buf);
  uword result = Testing_execute_expr(buf);
  ASSERT_EQ(result, Object_false());
  AST_heap_free(node);
  PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
callq 0x1730
movq %rax, %rsi
leaq 0x894d(%rip), %rdi      # 0x149e8
callq 0x4ff0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4690
movl %eax, -0x1c(%rbp)
movl 0xf08a(%rip), %eax      # 0x1b144
addl $0x1, %eax
movl %eax, 0xf081(%rip)      # 0x1b144
cmpl $0x0, -0x1c(%rbp)
je 0xc111
jmp 0xc0cb
leaq 0x85d1(%rip), %rax      # 0x146a3
movq %rax, 0xf077(%rip)      # 0x1b150
movl $0x6fb, 0xf065(%rip)    # imm = 0x6FB
leaq 0x9f9b(%rip), %rax      # 0x16085
movq %rax, 0xf067(%rip)      # 0x1b158
movzbl 0xf008(%rip), %eax      # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xc105
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc1f0
jmp 0xc113
leaq -0x40(%rbp), %rdi
leaq 0x8232(%rip), %rsi      # 0x14350
movl $0x23, %edx
callq 0x1110
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movl $0x23, %edx
callq 0x12d40
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
je 0xc14e
movl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xc1f0
jmp 0xc150
movq -0x10(%rbp), %rdi
callq 0x1c50
movq -0x10(%rbp), %rdi
callq 0x4f20
movq %rax, -0x50(%rbp)
movl 0xefd8(%rip), %eax      # 0x1b144
addl $0x1, %eax
movl %eax, 0xefcf(%rip)      # 0x1b144
movq -0x50(%rbp), %rax
movq %rax, -0x58(%rbp)
callq 0x1410
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
je 0xc1d3
jmp 0xc190
leaq 0x850c(%rip), %rax      # 0x146a3
movq %rax, 0xefb2(%rip)      # 0x1b150
movl $0x70a, 0xefa0(%rip)    # imm = 0x70A
leaq 0x9fa5(%rip), %rax      # 0x16154
movq %rax, 0xefa2(%rip)      # 0x1b158
movzbl 0xef43(%rip), %eax      # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xc1ca
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc1f0
jmp 0xc1d5
movq -0x18(%rbp), %rdi
callq 0x1800
movq $0x0, 0xef6f(%rip) # 0x1b158
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: compile_unary_booleanp_with_boolean_returns_true
TEST compile_unary_booleanp_with_boolean_returns_true(Buffer *buf) {
  ASTNode *node = new_unary_call("boolean?", AST_new_bool(true));
  int compile_result = Compile_entry(buf, node);
  ASSERT_EQ(compile_result, 0);
  // 0:  48 c7 c0 9f 00 00 00    mov    rax,0x9f
  // 7:  48 83 e0 3f             and    rax,0x3f
  // b:  48 3d 1f 00 00 00       cmp    rax,0x0000001f
  // 11: 48 c7 c0 00 00 00 00    mov    rax,0x0
  // 18: 0f 94 c0                sete   al
  // 1b: 48 c1 e0 07             shl    rax,0x7
  // 1f: 48 83 c8 1f             or     rax,0x1f
  byte expected[] = {0x48, 0xc7, 0xc0, 0x9f, 0x00, 0x00, 0x00, 0x48, 0x83,
                     0xe0, 0x3f, 0x48, 0x3d, 0x1f, 0x00, 0x00, 0x00, 0x48,
                     0xc7, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x94, 0xc0,
                     0x48, 0xc1, 0xe0, 0x07, 0x48, 0x83, 0xc8, 0x1f};
  EXPECT_ENTRY_CONTAINS_CODE(buf, expected);
  Buffer_make_executable(buf);
  uword result = Testing_execute_expr(buf);
  ASSERT_EQ(result, Object_true());
  AST_heap_free(node);
  PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, %edi
callq 0x1680
movq %rax, %rsi
leaq 0x87d1(%rip), %rdi      # 0x149f1
callq 0x4ff0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4690
movl %eax, -0x1c(%rbp)
movl 0xef05(%rip), %eax      # 0x1b144
addl $0x1, %eax
movl %eax, 0xeefc(%rip)      # 0x1b144
cmpl $0x0, -0x1c(%rbp)
je 0xc296
jmp 0xc250
leaq 0x844c(%rip), %rax      # 0x146a3
movq %rax, 0xeef2(%rip)      # 0x1b150
movl $0x712, 0xeee0(%rip)    # imm = 0x712
leaq 0x9e16(%rip), %rax      # 0x16085
movq %rax, 0xeee2(%rip)      # 0x1b158
movzbl 0xee83(%rip), %eax      # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xc28a
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc375
jmp 0xc298
leaq -0x40(%rbp), %rdi
leaq 0x80dd(%rip), %rsi      # 0x14380
movl $0x23, %edx
callq 0x1110
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movl $0x23, %edx
callq 0x12d40
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
je 0xc2d3
movl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xc375
jmp 0xc2d5
movq -0x10(%rbp), %rdi
callq 0x1c50
movq -0x10(%rbp), %rdi
callq 0x4f20
movq %rax, -0x50(%rbp)
movl 0xee53(%rip), %eax      # 0x1b144
addl $0x1, %eax
movl %eax, 0xee4a(%rip)      # 0x1b144
movq -0x50(%rbp), %rax
movq %rax, -0x58(%rbp)
callq 0x1400
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
je 0xc358
jmp 0xc315
leaq 0x8387(%rip), %rax      # 0x146a3
movq %rax, 0xee2d(%rip)      # 0x1b150
movl $0x721, 0xee1b(%rip)    # imm = 0x721
leaq 0x9e08(%rip), %rax      # 0x1613c
movq %rax, 0xee1d(%rip)      # 0x1b158
movzbl 0xedbe(%rip), %eax      # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xc34f
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc375
jmp 0xc35a
movq -0x18(%rbp), %rdi
callq 0x1800
movq $0x0, 0xedea(%rip) # 0x1b158
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: compile_unary_booleanp_with_non_boolean_returns_false
TEST compile_unary_booleanp_with_non_boolean_returns_false(Buffer *buf) {
  ASTNode *node = new_unary_call("boolean?", AST_new_integer(5));
  int compile_result = Compile_entry(buf, node);
  ASSERT_EQ(compile_result, 0);
  // 0:  48 c7 c0 14 00 00 00    mov    rax,0x14
  // 7:  48 83 e0 3f             and    rax,0x3f
  // b:  48 3d 1f 00 00 00       cmp    rax,0x0000001f
  // 11: 48 c7 c0 00 00 00 00    mov    rax,0x0
  // 18: 0f 94 c0                sete   al
  // 1b: 48 c1 e0 07             shl    rax,0x7
  // 1f: 48 83 c8 1f             or     rax,0x1f
  byte expected[] = {0x48, 0xc7, 0xc0, 0x14, 0x00, 0x00, 0x00, 0x48, 0x83,
                     0xe0, 0x3f, 0x48, 0x3d, 0x1f, 0x00, 0x00, 0x00, 0x48,
                     0xc7, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x94, 0xc0,
                     0x48, 0xc1, 0xe0, 0x07, 0x48, 0x83, 0xc8, 0x1f};
  EXPECT_ENTRY_CONTAINS_CODE(buf, expected);
  Buffer_make_executable(buf);
  uword result = Testing_execute_expr(buf);
  ASSERT_EQ(result, Object_false());
  AST_heap_free(node);
  PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl $0x5, %edi
callq 0x15c0
movq %rax, %rsi
leaq 0x8651(%rip), %rdi      # 0x149f1
callq 0x4ff0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4690
movl %eax, -0x1c(%rbp)
movl 0xed85(%rip), %eax      # 0x1b144
addl $0x1, %eax
movl %eax, 0xed7c(%rip)      # 0x1b144
cmpl $0x0, -0x1c(%rbp)
je 0xc416
jmp 0xc3d0
leaq 0x82cc(%rip), %rax      # 0x146a3
movq %rax, 0xed72(%rip)      # 0x1b150
movl $0x729, 0xed60(%rip)    # imm = 0x729
leaq 0x9c96(%rip), %rax      # 0x16085
movq %rax, 0xed62(%rip)      # 0x1b158
movzbl 0xed03(%rip), %eax      # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xc40a
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc4f5
jmp 0xc418
leaq -0x40(%rbp), %rdi
leaq 0x7f8d(%rip), %rsi      # 0x143b0
movl $0x23, %edx
callq 0x1110
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movl $0x23, %edx
callq 0x12d40
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
je 0xc453
movl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xc4f5
jmp 0xc455
movq -0x10(%rbp), %rdi
callq 0x1c50
movq -0x10(%rbp), %rdi
callq 0x4f20
movq %rax, -0x50(%rbp)
movl 0xecd3(%rip), %eax      # 0x1b144
addl $0x1, %eax
movl %eax, 0xecca(%rip)      # 0x1b144
movq -0x50(%rbp), %rax
movq %rax, -0x58(%rbp)
callq 0x1410
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
je 0xc4d8
jmp 0xc495
leaq 0x8207(%rip), %rax      # 0x146a3
movq %rax, 0xecad(%rip)      # 0x1b150
movl $0x738, 0xec9b(%rip)    # imm = 0x738
leaq 0x9ca0(%rip), %rax      # 0x16154
movq %rax, 0xec9d(%rip)      # 0x1b158
movzbl 0xec3e(%rip), %eax      # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xc4cf
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc4f5
jmp 0xc4da
movq -0x18(%rbp), %rdi
callq 0x1800
movq $0x0, 0xec6a(%rip) # 0x1b158
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: compile_binary_plus
TEST compile_binary_plus(Buffer *buf) {
  ASTNode *node = new_binary_call("+", AST_new_integer(5), AST_new_integer(8));
  int compile_result = Compile_entry(buf, node);
  ASSERT_EQ(compile_result, 0);
  // clang-format off
  byte expected[] = {
      // mov    rax,0x20
      0x48, 0xc7, 0xc0, 0x20, 0x00, 0x00, 0x00,
      // mov    QWORD PTR [rsp-0x8],rax
      0x48, 0x89, 0x44, 0x24, 0xf8,
      // mov    rax,0x14
      0x48, 0xc7, 0xc0, 0x14, 0x00, 0x00, 0x00,
      // add    rax,QWORD PTR [rbp-0x8]
      0x48, 0x03, 0x44, 0x24, 0xf8};
  // clang-format on
  EXPECT_ENTRY_CONTAINS_CODE(buf, expected);
  Buffer_make_executable(buf);
  uword result = Testing_execute_expr(buf);
  ASSERT_EQ(result, Object_encode_integer(13));
  AST_heap_free(node);
  PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl $0x5, %edi
callq 0x15c0
movq %rax, -0x58(%rbp)
movl $0x8, %edi
callq 0x15c0
movq -0x58(%rbp), %rsi
movq %rax, %rdx
leaq 0x84c8(%rip), %rdi      # 0x149fa
callq 0x5020
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4690
movl %eax, -0x1c(%rbp)
movl 0xebf3(%rip), %eax      # 0x1b144
addl $0x1, %eax
movl %eax, 0xebea(%rip)      # 0x1b144
cmpl $0x0, -0x1c(%rbp)
je 0xc5a8
jmp 0xc562
leaq 0x813a(%rip), %rax      # 0x146a3
movq %rax, 0xebe0(%rip)      # 0x1b150
movl $0x740, 0xebce(%rip)    # imm = 0x740
leaq 0x9b04(%rip), %rax      # 0x16085
movq %rax, 0xebd0(%rip)      # 0x1b158
movzbl 0xeb71(%rip), %eax      # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xc59c
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc698
jmp 0xc5aa
movq 0x7e2f(%rip), %rax      # 0x143e0
movq %rax, -0x40(%rbp)
movq 0x7e2c(%rip), %rax      # 0x143e8
movq %rax, -0x38(%rbp)
movq 0x7e29(%rip), %rax      # 0x143f0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movl $0x18, %edx
callq 0x12d40
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
je 0xc5f1
movl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xc698
jmp 0xc5f3
movq -0x10(%rbp), %rdi
callq 0x1c50
movq -0x10(%rbp), %rdi
callq 0x4f20
movq %rax, -0x50(%rbp)
movl 0xeb35(%rip), %eax      # 0x1b144
addl $0x1, %eax
movl %eax, 0xeb2c(%rip)      # 0x1b144
movq -0x50(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0xd, %edi
callq 0x1290
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
je 0xc67b
jmp 0xc638
leaq 0x8064(%rip), %rax      # 0x146a3
movq %rax, 0xeb0a(%rip)      # 0x1b150
movl $0x74f, 0xeaf8(%rip)    # imm = 0x74F
leaq 0x9be2(%rip), %rax      # 0x16239
movq %rax, 0xeafa(%rip)      # 0x1b158
movzbl 0xea9b(%rip), %eax      # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xc672
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc698
jmp 0xc67d
movq -0x18(%rbp), %rdi
callq 0x1800
movq $0x0, 0xeac7(%rip) # 0x1b158
movl $0x0, -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_binary_minus
TEST compile_binary_minus(Buffer *buf) {
  ASTNode *node = new_binary_call("-", AST_new_integer(5), AST_new_integer(8));
  int compile_result = Compile_entry(buf, node);
  ASSERT_EQ(compile_result, 0);
  // clang-format off
  byte expected[] = {
      // mov    rax,0x20
      0x48, 0xc7, 0xc0, 0x20, 0x00, 0x00, 0x00,
      // mov    QWORD PTR [rsp-0x8],rax
      0x48, 0x89, 0x44, 0x24, 0xf8,
      // mov    rax,0x14
      0x48, 0xc7, 0xc0, 0x14, 0x00, 0x00, 0x00,
      // add    rax,QWORD PTR [rsp-0x8]
      0x48, 0x2b, 0x44, 0x24, 0xf8};
  // clang-format on 
  EXPECT_ENTRY_CONTAINS_CODE(buf, expected);
  Buffer_make_executable(buf);
  uword result = Testing_execute_expr(buf);
  ASSERT_EQ(result, Object_encode_integer(-3));
  AST_heap_free(node);
  PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl $0x5, %edi
callq 0x15c0
movq %rax, -0x58(%rbp)
movl $0x8, %edi
callq 0x15c0
movq -0x58(%rbp), %rsi
movq %rax, %rdx
leaq 0xa0d3(%rip), %rdi      # 0x169a5
callq 0x5020
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4690
movl %eax, -0x1c(%rbp)
movl 0xe853(%rip), %eax      # 0x1b144
addl $0x1, %eax
movl %eax, 0xe84a(%rip)      # 0x1b144
cmpl $0x0, -0x1c(%rbp)
je 0xc948
jmp 0xc902
leaq 0x7d9a(%rip), %rax      # 0x146a3
movq %rax, 0xe840(%rip)      # 0x1b150
movl $0x77c, 0xe82e(%rip)    # imm = 0x77C
leaq 0x9764(%rip), %rax      # 0x16085
movq %rax, 0xe830(%rip)      # 0x1b158
movzbl 0xe7d1(%rip), %eax      # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xc93c
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xca3a
jmp 0xc94a
movq 0x7aef(%rip), %rax      # 0x14440
movq %rax, -0x40(%rbp)
movq 0x7aec(%rip), %rax      # 0x14448
movq %rax, -0x38(%rbp)
movq 0x7ae9(%rip), %rax      # 0x14450
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movl $0x18, %edx
callq 0x12d40
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
je 0xc991
movl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xca3a
jmp 0xc993
movq -0x10(%rbp), %rdi
callq 0x1c50
movq -0x10(%rbp), %rdi
callq 0x4f20
movq %rax, -0x50(%rbp)
movl 0xe795(%rip), %eax      # 0x1b144
addl $0x1, %eax
movl %eax, 0xe78c(%rip)      # 0x1b144
movq -0x50(%rbp), %rax
movq %rax, -0x60(%rbp)
movq $-0x3, %rdi
callq 0x1290
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
je 0xca1d
jmp 0xc9da
leaq 0x7cc2(%rip), %rax      # 0x146a3
movq %rax, 0xe768(%rip)      # 0x1b150
movl $0x78b, 0xe756(%rip)    # imm = 0x78B
leaq 0x9888(%rip), %rax      # 0x16281
movq %rax, 0xe758(%rip)      # 0x1b158
movzbl 0xe6f9(%rip), %eax      # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xca14
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xca3a
jmp 0xca1f
movq -0x18(%rbp), %rdi
callq 0x1800
movq $0x0, 0xe725(%rip) # 0x1b158
movl $0x0, -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_binary_mul
TEST compile_binary_mul(Buffer *buf) {
  ASTNode *node = new_binary_call("*", AST_new_integer(5), AST_new_integer(8));
  int compile_result = Compile_entry(buf, node);
  ASSERT_EQ(compile_result, 0);
  Buffer_make_executable(buf);
  uword result = Testing_execute_expr(buf);
  ASSERT_EQ_FMT(Object_encode_integer(40), result, "0x%lx");
  AST_heap_free(node);
  PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl $0x5, %edi
callq 0x15c0
movq %rax, -0x30(%rbp)
movl $0x8, %edi
callq 0x15c0
movq -0x30(%rbp), %rsi
movq %rax, %rdx
leaq 0x7d8a(%rip), %rdi      # 0x149fc
callq 0x5020
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4690
movl %eax, -0x1c(%rbp)
movl 0xe4b3(%rip), %eax      # 0x1b144
addl $0x1, %eax
movl %eax, 0xe4aa(%rip)      # 0x1b144
cmpl $0x0, -0x1c(%rbp)
je 0xcce8
jmp 0xcca2
leaq 0x79fa(%rip), %rax      # 0x146a3
movq %rax, 0xe4a0(%rip)      # 0x1b150
movl $0x7b8, 0xe48e(%rip)    # imm = 0x7B8
leaq 0x93c4(%rip), %rax      # 0x16085
movq %rax, 0xe490(%rip)      # 0x1b158
movzbl 0xe431(%rip), %eax      # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xccdc
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xce14
jmp 0xccea
movq -0x10(%rbp), %rdi
callq 0x1c50
movq -0x10(%rbp), %rdi
callq 0x4f20
movq %rax, -0x28(%rbp)
movl 0xe43e(%rip), %eax      # 0x1b144
addl $0x1, %eax
movl %eax, 0xe435(%rip)      # 0x1b144
movl $0x28, %edi
callq 0x1290
cmpq -0x28(%rbp), %rax
je 0xcdf7
movq 0xe2a6(%rip), %rax      # 0x1afd0
movq (%rax), %rdi
leaq 0x89fa(%rip), %rsi      # 0x1572e
movb $0x0, %al
callq 0x1100
movq 0xe28e(%rip), %rax      # 0x1afd0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movl $0x28, %edi
callq 0x1290
movq -0x38(%rbp), %rdi
movq %rax, %rdx
leaq 0x9567(%rip), %rsi      # 0x162c8
movb $0x0, %al
callq 0x1100
movq 0xe261(%rip), %rax      # 0x1afd0
movq (%rax), %rdi
leaq 0x89c1(%rip), %rsi      # 0x1573a
movb $0x0, %al
callq 0x1100
movq 0xe249(%rip), %rax      # 0x1afd0
movq (%rax), %rdi
movq -0x28(%rbp), %rdx
leaq 0x9533(%rip), %rsi      # 0x162c8
movb $0x0, %al
callq 0x1100
movq 0xe22d(%rip), %rax      # 0x1afd0
movq (%rax), %rdi
leaq 0x9c0f(%rip), %rsi      # 0x169bc
movb $0x0, %al
callq 0x1100
leaq 0x78e8(%rip), %rax      # 0x146a3
movq %rax, 0xe38e(%rip)      # 0x1b150
movl $0x7bb, 0xe37c(%rip)    # imm = 0x7BB
leaq 0x94fb(%rip), %rax      # 0x162ce
movq %rax, 0xe37e(%rip)      # 0x1b158
movzbl 0xe31f(%rip), %eax      # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xcdee
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xce14
jmp 0xcdf9
movq -0x18(%rbp), %rdi
callq 0x1800
movq $0x0, 0xe34b(%rip) # 0x1b158
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: compile_binary_eq_with_same_address_returns_true
TEST compile_binary_eq_with_same_address_returns_true(Buffer *buf) {
  ASTNode *node = new_binary_call("=", AST_new_integer(5), AST_new_integer(5));
  int compile_result = Compile_entry(buf, node);
  ASSERT_EQ(compile_result, 0);
  Buffer_make_executable(buf);
  uword result = Testing_execute_expr(buf);
  ASSERT_EQ_FMT(Object_true(), result, "0x%lx");
  AST_heap_free(node);
  PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl $0x5, %edi
callq 0x15c0
movq %rax, -0x30(%rbp)
movl $0x5, %edi
callq 0x15c0
movq -0x30(%rbp), %rsi
movq %rax, %rdx
leaq 0x798c(%rip), %rdi      # 0x149fe
callq 0x5020
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4690
movl %eax, -0x1c(%rbp)
movl 0xe0b3(%rip), %eax      # 0x1b144
addl $0x1, %eax
movl %eax, 0xe0aa(%rip)      # 0x1b144
cmpl $0x0, -0x1c(%rbp)
je 0xd0e8
jmp 0xd0a2
leaq 0x75fa(%rip), %rax      # 0x146a3
movq %rax, 0xe0a0(%rip)      # 0x1b150
movl $0x7d0, 0xe08e(%rip)    # imm = 0x7D0
leaq 0x8fc4(%rip), %rax      # 0x16085
movq %rax, 0xe090(%rip)      # 0x1b158
movzbl 0xe031(%rip), %eax      # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xd0dc
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xd20a
jmp 0xd0ea
movq -0x10(%rbp), %rdi
callq 0x1c50
movq -0x10(%rbp), %rdi
callq 0x4f20
movq %rax, -0x28(%rbp)
movl 0xe03e(%rip), %eax      # 0x1b144
addl $0x1, %eax
movl %eax, 0xe035(%rip)      # 0x1b144
callq 0x1400
cmpq -0x28(%rbp), %rax
je 0xd1ed
movq 0xdeab(%rip), %rax      # 0x1afd0
movq (%rax), %rdi
leaq 0x85ff(%rip), %rsi      # 0x1572e
movb $0x0, %al
callq 0x1100
movq 0xde93(%rip), %rax      # 0x1afd0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
callq 0x1400
movq -0x38(%rbp), %rdi
movq %rax, %rdx
leaq 0x9171(%rip), %rsi      # 0x162c8
movb $0x0, %al
callq 0x1100
movq 0xde6b(%rip), %rax      # 0x1afd0
movq (%rax), %rdi
leaq 0x85cb(%rip), %rsi      # 0x1573a
movb $0x0, %al
callq 0x1100
movq 0xde53(%rip), %rax      # 0x1afd0
movq (%rax), %rdi
movq -0x28(%rbp), %rdx
leaq 0x913d(%rip), %rsi      # 0x162c8
movb $0x0, %al
callq 0x1100
movq 0xde37(%rip), %rax      # 0x1afd0
movq (%rax), %rdi
leaq 0x9819(%rip), %rsi      # 0x169bc
movb $0x0, %al
callq 0x1100
leaq 0x74f2(%rip), %rax      # 0x146a3
movq %rax, 0xdf98(%rip)      # 0x1b150
movl $0x7d3, 0xdf86(%rip)    # imm = 0x7D3
leaq 0x914d(%rip), %rax      # 0x16316
movq %rax, 0xdf88(%rip)      # 0x1b158
movzbl 0xdf29(%rip), %eax      # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xd1e4
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xd20a
jmp 0xd1ef
movq -0x18(%rbp), %rdi
callq 0x1800
movq $0x0, 0xdf55(%rip) # 0x1b158
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: compile_binary_eq_with_different_address_returns_false
TEST compile_binary_eq_with_different_address_returns_false(Buffer *buf) {
  ASTNode *node = new_binary_call("=", AST_new_integer(5), AST_new_integer(4));
  int compile_result = Compile_entry(buf, node);
  ASSERT_EQ(compile_result, 0);
  Buffer_make_executable(buf);
  uword result = Testing_execute_expr(buf);
  ASSERT_EQ_FMT(Object_false(), result, "0x%lx");
  AST_heap_free(node);
  PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl $0x5, %edi
callq 0x15c0
movq %rax, -0x30(%rbp)
movl $0x4, %edi
callq 0x15c0
movq -0x30(%rbp), %rsi
movq %rax, %rdx
leaq 0x77ac(%rip), %rdi      # 0x149fe
callq 0x5020
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4690
movl %eax, -0x1c(%rbp)
movl 0xded3(%rip), %eax      # 0x1b144
addl $0x1, %eax
movl %eax, 0xdeca(%rip)      # 0x1b144
cmpl $0x0, -0x1c(%rbp)
je 0xd2c8
jmp 0xd282
leaq 0x741a(%rip), %rax      # 0x146a3
movq %rax, 0xdec0(%rip)      # 0x1b150
movl $0x7db, 0xdeae(%rip)    # imm = 0x7DB
leaq 0x8de4(%rip), %rax      # 0x16085
movq %rax, 0xdeb0(%rip)      # 0x1b158
movzbl 0xde51(%rip), %eax      # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xd2bc
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xd3ea
jmp 0xd2ca
movq -0x10(%rbp), %rdi
callq 0x1c50
movq -0x10(%rbp), %rdi
callq 0x4f20
movq %rax, -0x28(%rbp)
movl 0xde5e(%rip), %eax      # 0x1b144
addl $0x1, %eax
movl %eax, 0xde55(%rip)      # 0x1b144
callq 0x1410
cmpq -0x28(%rbp), %rax
je 0xd3cd
movq 0xdccb(%rip), %rax      # 0x1afd0
movq (%rax), %rdi
leaq 0x841f(%rip), %rsi      # 0x1572e
movb $0x0, %al
callq 0x1100
movq 0xdcb3(%rip), %rax      # 0x1afd0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
callq 0x1410
movq -0x38(%rbp), %rdi
movq %rax, %rdx
leaq 0x8f91(%rip), %rsi      # 0x162c8
movb $0x0, %al
callq 0x1100
movq 0xdc8b(%rip), %rax      # 0x1afd0
movq (%rax), %rdi
leaq 0x83eb(%rip), %rsi      # 0x1573a
movb $0x0, %al
callq 0x1100
movq 0xdc73(%rip), %rax      # 0x1afd0
movq (%rax), %rdi
movq -0x28(%rbp), %rdx
leaq 0x8f5d(%rip), %rsi      # 0x162c8
movb $0x0, %al
callq 0x1100
movq 0xdc57(%rip), %rax      # 0x1afd0
movq (%rax), %rdi
leaq 0x9639(%rip), %rsi      # 0x169bc
movb $0x0, %al
callq 0x1100
leaq 0x7312(%rip), %rax      # 0x146a3
movq %rax, 0xddb8(%rip)      # 0x1b150
movl $0x7de, 0xdda6(%rip)    # imm = 0x7DE
leaq 0x8f85(%rip), %rax      # 0x1632e
movq %rax, 0xdda8(%rip)      # 0x1b158
movzbl 0xdd49(%rip), %eax      # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xd3c4
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xd3ea
jmp 0xd3cf
movq -0x18(%rbp), %rdi
callq 0x1800
movq $0x0, 0xdd75(%rip) # 0x1b158
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: compile_binary_lt_with_left_less_than_right_returns_true
TEST compile_binary_lt_with_left_less_than_right_returns_true(Buffer *buf) {
  ASTNode *node = new_binary_call("<", AST_new_integer(-5), AST_new_integer(5));
  int compile_result = Compile_entry(buf, node);
  ASSERT_EQ(compile_result, 0);
  Buffer_make_executable(buf);
  uword result = Testing_execute_expr(buf);
  ASSERT_EQ_FMT(Object_true(), result, "0x%lx");
  AST_heap_free(node);
  PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq $-0x5, %rdi
callq 0x15c0
movq %rax, -0x30(%rbp)
movl $0x5, %edi
callq 0x15c0
movq -0x30(%rbp), %rsi
movq %rax, %rdx
leaq 0x75cc(%rip), %rdi      # 0x14a00
callq 0x5020
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4690
movl %eax, -0x1c(%rbp)
movl 0xdcf1(%rip), %eax      # 0x1b144
addl $0x1, %eax
movl %eax, 0xdce8(%rip)      # 0x1b144
cmpl $0x0, -0x1c(%rbp)
je 0xd4aa
jmp 0xd464
leaq 0x7238(%rip), %rax      # 0x146a3
movq %rax, 0xdcde(%rip)      # 0x1b150
movl $0x7e6, 0xdccc(%rip)    # imm = 0x7E6
leaq 0x8c02(%rip), %rax      # 0x16085
movq %rax, 0xdcce(%rip)      # 0x1b158
movzbl 0xdc6f(%rip), %eax      # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xd49e
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xd5cc
jmp 0xd4ac
movq -0x10(%rbp), %rdi
callq 0x1c50
movq -0x10(%rbp), %rdi
callq 0x4f20
movq %rax, -0x28(%rbp)
movl 0xdc7c(%rip), %eax      # 0x1b144
addl $0x1, %eax
movl %eax, 0xdc73(%rip)      # 0x1b144
callq 0x1400
cmpq -0x28(%rbp), %rax
je 0xd5af
movq 0xdae9(%rip), %rax      # 0x1afd0
movq (%rax), %rdi
leaq 0x823d(%rip), %rsi      # 0x1572e
movb $0x0, %al
callq 0x1100
movq 0xdad1(%rip), %rax      # 0x1afd0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
callq 0x1400
movq -0x38(%rbp), %rdi
movq %rax, %rdx
leaq 0x8daf(%rip), %rsi      # 0x162c8
movb $0x0, %al
callq 0x1100
movq 0xdaa9(%rip), %rax      # 0x1afd0
movq (%rax), %rdi
leaq 0x8209(%rip), %rsi      # 0x1573a
movb $0x0, %al
callq 0x1100
movq 0xda91(%rip), %rax      # 0x1afd0
movq (%rax), %rdi
movq -0x28(%rbp), %rdx
leaq 0x8d7b(%rip), %rsi      # 0x162c8
movb $0x0, %al
callq 0x1100
movq 0xda75(%rip), %rax      # 0x1afd0
movq (%rax), %rdi
leaq 0x9457(%rip), %rsi      # 0x169bc
movb $0x0, %al
callq 0x1100
leaq 0x7130(%rip), %rax      # 0x146a3
movq %rax, 0xdbd6(%rip)      # 0x1b150
movl $0x7e9, 0xdbc4(%rip)    # imm = 0x7E9
leaq 0x8d8b(%rip), %rax      # 0x16316
movq %rax, 0xdbc6(%rip)      # 0x1b158
movzbl 0xdb67(%rip), %eax      # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xd5a6
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xd5cc
jmp 0xd5b1
movq -0x18(%rbp), %rdi
callq 0x1800
movq $0x0, 0xdb93(%rip) # 0x1b158
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: compile_binary_lt_with_left_equal_to_right_returns_false
TEST compile_binary_lt_with_left_equal_to_right_returns_false(Buffer *buf) {
  ASTNode *node = new_binary_call("<", AST_new_integer(5), AST_new_integer(5));
  int compile_result = Compile_entry(buf, node);
  ASSERT_EQ(compile_result, 0);
  Buffer_make_executable(buf);
  uword result = Testing_execute_expr(buf);
  ASSERT_EQ_FMT(Object_false(), result, "0x%lx");
  AST_heap_free(node);
  PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl $0x5, %edi
callq 0x15c0
movq %rax, -0x30(%rbp)
movl $0x5, %edi
callq 0x15c0
movq -0x30(%rbp), %rsi
movq %rax, %rdx
leaq 0x73ee(%rip), %rdi      # 0x14a00
callq 0x5020
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4690
movl %eax, -0x1c(%rbp)
movl 0xdb13(%rip), %eax      # 0x1b144
addl $0x1, %eax
movl %eax, 0xdb0a(%rip)      # 0x1b144
cmpl $0x0, -0x1c(%rbp)
je 0xd688
jmp 0xd642
leaq 0x705a(%rip), %rax      # 0x146a3
movq %rax, 0xdb00(%rip)      # 0x1b150
movl $0x7f1, 0xdaee(%rip)    # imm = 0x7F1
leaq 0x8a24(%rip), %rax      # 0x16085
movq %rax, 0xdaf0(%rip)      # 0x1b158
movzbl 0xda91(%rip), %eax      # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xd67c
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xd7aa
jmp 0xd68a
movq -0x10(%rbp), %rdi
callq 0x1c50
movq -0x10(%rbp), %rdi
callq 0x4f20
movq %rax, -0x28(%rbp)
movl 0xda9e(%rip), %eax      # 0x1b144
addl $0x1, %eax
movl %eax, 0xda95(%rip)      # 0x1b144
callq 0x1410
cmpq -0x28(%rbp), %rax
je 0xd78d
movq 0xd90b(%rip), %rax      # 0x1afd0
movq (%rax), %rdi
leaq 0x805f(%rip), %rsi      # 0x1572e
movb $0x0, %al
callq 0x1100
movq 0xd8f3(%rip), %rax      # 0x1afd0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
callq 0x1410
movq -0x38(%rbp), %rdi
movq %rax, %rdx
leaq 0x8bd1(%rip), %rsi      # 0x162c8
movb $0x0, %al
callq 0x1100
movq 0xd8cb(%rip), %rax      # 0x1afd0
movq (%rax), %rdi
leaq 0x802b(%rip), %rsi      # 0x1573a
movb $0x0, %al
callq 0x1100
movq 0xd8b3(%rip), %rax      # 0x1afd0
movq (%rax), %rdi
movq -0x28(%rbp), %rdx
leaq 0x8b9d(%rip), %rsi      # 0x162c8
movb $0x0, %al
callq 0x1100
movq 0xd897(%rip), %rax      # 0x1afd0
movq (%rax), %rdi
leaq 0x9279(%rip), %rsi      # 0x169bc
movb $0x0, %al
callq 0x1100
leaq 0x6f52(%rip), %rax      # 0x146a3
movq %rax, 0xd9f8(%rip)      # 0x1b150
movl $0x7f4, 0xd9e6(%rip)    # imm = 0x7F4
leaq 0x8bc5(%rip), %rax      # 0x1632e
movq %rax, 0xd9e8(%rip)      # 0x1b158
movzbl 0xd989(%rip), %eax      # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xd784
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xd7aa
jmp 0xd78f
movq -0x18(%rbp), %rdi
callq 0x1800
movq $0x0, 0xd9b5(%rip) # 0x1b158
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: compile_binary_lt_with_left_greater_than_right_returns_false
TEST compile_binary_lt_with_left_greater_than_right_returns_false(Buffer *buf) {
  ASTNode *node = new_binary_call("<", AST_new_integer(6), AST_new_integer(5));
  int compile_result = Compile_entry(buf, node);
  ASSERT_EQ(compile_result, 0);
  Buffer_make_executable(buf);
  uword result = Testing_execute_expr(buf);
  ASSERT_EQ_FMT(Object_false(), result, "0x%lx");
  AST_heap_free(node);
  PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl $0x6, %edi
callq 0x15c0
movq %rax, -0x30(%rbp)
movl $0x5, %edi
callq 0x15c0
movq -0x30(%rbp), %rsi
movq %rax, %rdx
leaq 0x720e(%rip), %rdi      # 0x14a00
callq 0x5020
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4690
movl %eax, -0x1c(%rbp)
movl 0xd933(%rip), %eax      # 0x1b144
addl $0x1, %eax
movl %eax, 0xd92a(%rip)      # 0x1b144
cmpl $0x0, -0x1c(%rbp)
je 0xd868
jmp 0xd822
leaq 0x6e7a(%rip), %rax      # 0x146a3
movq %rax, 0xd920(%rip)      # 0x1b150
movl $0x7fc, 0xd90e(%rip)    # imm = 0x7FC
leaq 0x8844(%rip), %rax      # 0x16085
movq %rax, 0xd910(%rip)      # 0x1b158
movzbl 0xd8b1(%rip), %eax      # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xd85c
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xd98a
jmp 0xd86a
movq -0x10(%rbp), %rdi
callq 0x1c50
movq -0x10(%rbp), %rdi
callq 0x4f20
movq %rax, -0x28(%rbp)
movl 0xd8be(%rip), %eax      # 0x1b144
addl $0x1, %eax
movl %eax, 0xd8b5(%rip)      # 0x1b144
callq 0x1410
cmpq -0x28(%rbp), %rax
je 0xd96d
movq 0xd72b(%rip), %rax      # 0x1afd0
movq (%rax), %rdi
leaq 0x7e7f(%rip), %rsi      # 0x1572e
movb $0x0, %al
callq 0x1100
movq 0xd713(%rip), %rax      # 0x1afd0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
callq 0x1410
movq -0x38(%rbp), %rdi
movq %rax, %rdx
leaq 0x89f1(%rip), %rsi      # 0x162c8
movb $0x0, %al
callq 0x1100
movq 0xd6eb(%rip), %rax      # 0x1afd0
movq (%rax), %rdi
leaq 0x7e4b(%rip), %rsi      # 0x1573a
movb $0x0, %al
callq 0x1100
movq 0xd6d3(%rip), %rax      # 0x1afd0
movq (%rax), %rdi
movq -0x28(%rbp), %rdx
leaq 0x89bd(%rip), %rsi      # 0x162c8
movb $0x0, %al
callq 0x1100
movq 0xd6b7(%rip), %rax      # 0x1afd0
movq (%rax), %rdi
leaq 0x9099(%rip), %rsi      # 0x169bc
movb $0x0, %al
callq 0x1100
leaq 0x6d72(%rip), %rax      # 0x146a3
movq %rax, 0xd818(%rip)      # 0x1b150
movl $0x7ff, 0xd806(%rip)    # imm = 0x7FF
leaq 0x89e5(%rip), %rax      # 0x1632e
movq %rax, 0xd808(%rip)      # 0x1b158
movzbl 0xd7a9(%rip), %eax      # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xd964
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xd98a
jmp 0xd96f
movq -0x18(%rbp), %rdi
callq 0x1800
movq $0x0, 0xd7d5(%rip) # 0x1b158
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: compile_symbol_not_in_env_raises_compile_error
TEST compile_symbol_not_in_env_raises_compile_error(Buffer *buf) {
  ASTNode *node = AST_new_symbol("hello");
  int compile_result = Compile_expr(buf, node, -kWordSize, NULL, NULL);
  ASSERT_EQ(compile_result, -1);
  AST_heap_free(node);
  PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x7f66(%rip), %rdi      # 0x15d19
callq 0x19d0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq $-0x8, %rdx
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rcx
callq 0x29f0
movl %eax, -0x1c(%rbp)
movl 0xd363(%rip), %eax      # 0x1b144
addl $0x1, %eax
movl %eax, 0xd35a(%rip)      # 0x1b144
cmpl $-0x1, -0x1c(%rbp)
je 0xde35
jmp 0xddf2
leaq 0x68aa(%rip), %rax      # 0x146a3
movq %rax, 0xd350(%rip)      # 0x1b150
movl $0x827, 0xd33e(%rip)    # imm = 0x827
leaq 0x8551(%rip), %rax      # 0x16362
movq %rax, 0xd340(%rip)      # 0x1b158
movzbl 0xd2e1(%rip), %eax      # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xde2c
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xde52
jmp 0xde37
movq -0x18(%rbp), %rdi
callq 0x1800
movq $0x0, 0xd30d(%rip) # 0x1b158
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: compile_let_with_no_bindings
TEST compile_let_with_no_bindings(Buffer *buf) {
  ASTNode *node = Reader_read("(let () (+ 1 2))");
  int compile_result = Compile_entry(buf, node);
  ASSERT_EQ(compile_result, 0);
  Buffer_make_executable(buf);
  uword result = Testing_execute_expr(buf);
  ASSERT_EQ_FMT(Object_encode_integer(3), result, "0x%lx");
  AST_heap_free(node);
  PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x8504(%rip), %rdi      # 0x16377
callq 0x4e40
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4690
movl %eax, -0x1c(%rbp)
movl 0xd2b2(%rip), %eax      # 0x1b144
addl $0x1, %eax
movl %eax, 0xd2a9(%rip)      # 0x1b144
cmpl $0x0, -0x1c(%rbp)
je 0xdee9
jmp 0xdea3
leaq 0x67f9(%rip), %rax      # 0x146a3
movq %rax, 0xd29f(%rip)      # 0x1b150
movl $0x82f, 0xd28d(%rip)    # imm = 0x82F
leaq 0x81c3(%rip), %rax      # 0x16085
movq %rax, 0xd28f(%rip)      # 0x1b158
movzbl 0xd230(%rip), %eax      # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xdedd
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe015
jmp 0xdeeb
movq -0x10(%rbp), %rdi
callq 0x1c50
movq -0x10(%rbp), %rdi
callq 0x4f20
movq %rax, -0x28(%rbp)
movl 0xd23d(%rip), %eax      # 0x1b144
addl $0x1, %eax
movl %eax, 0xd234(%rip)      # 0x1b144
movl $0x3, %edi
callq 0x1290
cmpq -0x28(%rbp), %rax
je 0xdff8
movq 0xd0a5(%rip), %rax      # 0x1afd0
movq (%rax), %rdi
leaq 0x77f9(%rip), %rsi      # 0x1572e
movb $0x0, %al
callq 0x1100
movq 0xd08d(%rip), %rax      # 0x1afd0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl $0x3, %edi
callq 0x1290
movq -0x30(%rbp), %rdi
movq %rax, %rdx
leaq 0x8366(%rip), %rsi      # 0x162c8
movb $0x0, %al
callq 0x1100
movq 0xd060(%rip), %rax      # 0x1afd0
movq (%rax), %rdi
leaq 0x77c0(%rip), %rsi      # 0x1573a
movb $0x0, %al
callq 0x1100
movq 0xd048(%rip), %rax      # 0x1afd0
movq (%rax), %rdi
movq -0x28(%rbp), %rdx
leaq 0x8332(%rip), %rsi      # 0x162c8
movb $0x0, %al
callq 0x1100
movq 0xd02c(%rip), %rax      # 0x1afd0
movq (%rax), %rdi
leaq 0x8a0e(%rip), %rsi      # 0x169bc
movb $0x0, %al
callq 0x1100
leaq 0x66e7(%rip), %rax      # 0x146a3
movq %rax, 0xd18d(%rip)      # 0x1b150
movl $0x832, 0xd17b(%rip)    # imm = 0x832
leaq 0x83b4(%rip), %rax      # 0x16388
movq %rax, 0xd17d(%rip)      # 0x1b158
movzbl 0xd11e(%rip), %eax      # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xdfef
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe015
jmp 0xdffa
movq -0x18(%rbp), %rdi
callq 0x1800
movq $0x0, 0xd14a(%rip) # 0x1b158
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: compile_let_with_one_binding
TEST compile_let_with_one_binding(Buffer *buf) {
  ASTNode *node = Reader_read("(let ((a 1)) (+ a 2))");
  int compile_result = Compile_entry(buf, node);
  ASSERT_EQ(compile_result, 0);
  Buffer_make_executable(buf);
  uword result = Testing_execute_expr(buf);
  ASSERT_EQ_FMT(Object_encode_integer(3), result, "0x%lx");
  AST_heap_free(node);
  PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x8378(%rip), %rdi      # 0x163ab
callq 0x4e40
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4690
movl %eax, -0x1c(%rbp)
movl 0xd0f2(%rip), %eax      # 0x1b144
addl $0x1, %eax
movl %eax, 0xd0e9(%rip)      # 0x1b144
cmpl $0x0, -0x1c(%rbp)
je 0xe0a9
jmp 0xe063
leaq 0x6639(%rip), %rax      # 0x146a3
movq %rax, 0xd0df(%rip)      # 0x1b150
movl $0x83a, 0xd0cd(%rip)    # imm = 0x83A
leaq 0x8003(%rip), %rax      # 0x16085
movq %rax, 0xd0cf(%rip)      # 0x1b158
movzbl 0xd070(%rip), %eax      # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xe09d
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe1d5
jmp 0xe0ab
movq -0x10(%rbp), %rdi
callq 0x1c50
movq -0x10(%rbp), %rdi
callq 0x4f20
movq %rax, -0x28(%rbp)
movl 0xd07d(%rip), %eax      # 0x1b144
addl $0x1, %eax
movl %eax, 0xd074(%rip)      # 0x1b144
movl $0x3, %edi
callq 0x1290
cmpq -0x28(%rbp), %rax
je 0xe1b8
movq 0xcee5(%rip), %rax      # 0x1afd0
movq (%rax), %rdi
leaq 0x7639(%rip), %rsi      # 0x1572e
movb $0x0, %al
callq 0x1100
movq 0xcecd(%rip), %rax      # 0x1afd0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl $0x3, %edi
callq 0x1290
movq -0x30(%rbp), %rdi
movq %rax, %rdx
leaq 0x81a6(%rip), %rsi      # 0x162c8
movb $0x0, %al
callq 0x1100
movq 0xcea0(%rip), %rax      # 0x1afd0
movq (%rax), %rdi
leaq 0x7600(%rip), %rsi      # 0x1573a
movb $0x0, %al
callq 0x1100
movq 0xce88(%rip), %rax      # 0x1afd0
movq (%rax), %rdi
movq -0x28(%rbp), %rdx
leaq 0x8172(%rip), %rsi      # 0x162c8
movb $0x0, %al
callq 0x1100
movq 0xce6c(%rip), %rax      # 0x1afd0
movq (%rax), %rdi
leaq 0x884e(%rip), %rsi      # 0x169bc
movb $0x0, %al
callq 0x1100
leaq 0x6527(%rip), %rax      # 0x146a3
movq %rax, 0xcfcd(%rip)      # 0x1b150
movl $0x83d, 0xcfbb(%rip)    # imm = 0x83D
leaq 0x81f4(%rip), %rax      # 0x16388
movq %rax, 0xcfbd(%rip)      # 0x1b158
movzbl 0xcf5e(%rip), %eax      # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xe1af
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe1d5
jmp 0xe1ba
movq -0x18(%rbp), %rdi
callq 0x1800
movq $0x0, 0xcf8a(%rip) # 0x1b158
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: compile_let_with_multiple_bindings
TEST compile_let_with_multiple_bindings(Buffer *buf) {
  ASTNode *node = Reader_read("(let ((a 1) (b 2)) (+ a b))");
  int compile_result = Compile_entry(buf, node);
  ASSERT_EQ(compile_result, 0);
  Buffer_make_executable(buf);
  uword result = Testing_execute_expr(buf);
  ASSERT_EQ_FMT(Object_encode_integer(3), result, "0x%lx");
  AST_heap_free(node);
  PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x81ce(%rip), %rdi      # 0x163c1
callq 0x4e40
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4690
movl %eax, -0x1c(%rbp)
movl 0xcf32(%rip), %eax      # 0x1b144
addl $0x1, %eax
movl %eax, 0xcf29(%rip)      # 0x1b144
cmpl $0x0, -0x1c(%rbp)
je 0xe269
jmp 0xe223
leaq 0x6479(%rip), %rax      # 0x146a3
movq %rax, 0xcf1f(%rip)      # 0x1b150
movl $0x845, 0xcf0d(%rip)    # imm = 0x845
leaq 0x7e43(%rip), %rax      # 0x16085
movq %rax, 0xcf0f(%rip)      # 0x1b158
movzbl 0xceb0(%rip), %eax      # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xe25d
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe395
jmp 0xe26b
movq -0x10(%rbp), %rdi
callq 0x1c50
movq -0x10(%rbp), %rdi
callq 0x4f20
movq %rax, -0x28(%rbp)
movl 0xcebd(%rip), %eax      # 0x1b144
addl $0x1, %eax
movl %eax, 0xceb4(%rip)      # 0x1b144
movl $0x3, %edi
callq 0x1290
cmpq -0x28(%rbp), %rax
je 0xe378
movq 0xcd25(%rip), %rax      # 0x1afd0
movq (%rax), %rdi
leaq 0x7479(%rip), %rsi      # 0x1572e
movb $0x0, %al
callq 0x1100
movq 0xcd0d(%rip), %rax      # 0x1afd0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl $0x3, %edi
callq 0x1290
movq -0x30(%rbp), %rdi
movq %rax, %rdx
leaq 0x7fe6(%rip), %rsi      # 0x162c8
movb $0x0, %al
callq 0x1100
movq 0xcce0(%rip), %rax      # 0x1afd0
movq (%rax), %rdi
leaq 0x7440(%rip), %rsi      # 0x1573a
movb $0x0, %al
callq 0x1100
movq 0xccc8(%rip), %rax      # 0x1afd0
movq (%rax), %rdi
movq -0x28(%rbp), %rdx
leaq 0x7fb2(%rip), %rsi      # 0x162c8
movb $0x0, %al
callq 0x1100
movq 0xccac(%rip), %rax      # 0x1afd0
movq (%rax), %rdi
leaq 0x868e(%rip), %rsi      # 0x169bc
movb $0x0, %al
callq 0x1100
leaq 0x6367(%rip), %rax      # 0x146a3
movq %rax, 0xce0d(%rip)      # 0x1b150
movl $0x848, 0xcdfb(%rip)    # imm = 0x848
leaq 0x8034(%rip), %rax      # 0x16388
movq %rax, 0xcdfd(%rip)      # 0x1b158
movzbl 0xcd9e(%rip), %eax      # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xe36f
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe395
jmp 0xe37a
movq -0x18(%rbp), %rdi
callq 0x1800
movq $0x0, 0xcdca(%rip) # 0x1b158
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: compile_nested_let
TEST compile_nested_let(Buffer *buf) {
  ASTNode *node = Reader_read("(let ((a 1)) (let ((b 2)) (+ a b)))");
  int compile_result = Compile_entry(buf, node);
  ASSERT_EQ(compile_result, 0);
  Buffer_make_executable(buf);
  uword result = Testing_execute_expr(buf);
  ASSERT_EQ_FMT(Object_encode_integer(3), result, "0x%lx");
  AST_heap_free(node);
  PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x802a(%rip), %rdi      # 0x163dd
callq 0x4e40
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4690
movl %eax, -0x1c(%rbp)
movl 0xcd72(%rip), %eax      # 0x1b144
addl $0x1, %eax
movl %eax, 0xcd69(%rip)      # 0x1b144
cmpl $0x0, -0x1c(%rbp)
je 0xe429
jmp 0xe3e3
leaq 0x62b9(%rip), %rax      # 0x146a3
movq %rax, 0xcd5f(%rip)      # 0x1b150
movl $0x850, 0xcd4d(%rip)    # imm = 0x850
leaq 0x7c83(%rip), %rax      # 0x16085
movq %rax, 0xcd4f(%rip)      # 0x1b158
movzbl 0xccf0(%rip), %eax      # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xe41d
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe555
jmp 0xe42b
movq -0x10(%rbp), %rdi
callq 0x1c50
movq -0x10(%rbp), %rdi
callq 0x4f20
movq %rax, -0x28(%rbp)
movl 0xccfd(%rip), %eax      # 0x1b144
addl $0x1, %eax
movl %eax, 0xccf4(%rip)      # 0x1b144
movl $0x3, %edi
callq 0x1290
cmpq -0x28(%rbp), %rax
je 0xe538
movq 0xcb65(%rip), %rax      # 0x1afd0
movq (%rax), %rdi
leaq 0x72b9(%rip), %rsi      # 0x1572e
movb $0x0, %al
callq 0x1100
movq 0xcb4d(%rip), %rax      # 0x1afd0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl $0x3, %edi
callq 0x1290
movq -0x30(%rbp), %rdi
movq %rax, %rdx
leaq 0x7e26(%rip), %rsi      # 0x162c8
movb $0x0, %al
callq 0x1100
movq 0xcb20(%rip), %rax      # 0x1afd0
movq (%rax), %rdi
leaq 0x7280(%rip), %rsi      # 0x1573a
movb $0x0, %al
callq 0x1100
movq 0xcb08(%rip), %rax      # 0x1afd0
movq (%rax), %rdi
movq -0x28(%rbp), %rdx
leaq 0x7df2(%rip), %rsi      # 0x162c8
movb $0x0, %al
callq 0x1100
movq 0xcaec(%rip), %rax      # 0x1afd0
movq (%rax), %rdi
leaq 0x84ce(%rip), %rsi      # 0x169bc
movb $0x0, %al
callq 0x1100
leaq 0x61a7(%rip), %rax      # 0x146a3
movq %rax, 0xcc4d(%rip)      # 0x1b150
movl $0x853, 0xcc3b(%rip)    # imm = 0x853
leaq 0x7e74(%rip), %rax      # 0x16388
movq %rax, 0xcc3d(%rip)      # 0x1b158
movzbl 0xcbde(%rip), %eax      # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xe52f
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe555
jmp 0xe53a
movq -0x18(%rbp), %rdi
callq 0x1800
movq $0x0, 0xcc0a(%rip) # 0x1b158
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop