LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: read_with_symbol_returns_symbol
TEST read_with_symbol_returns_symbol(void) {
  char *input = "hello?+-*=>";
  ASTNode *node = Reader_read(input);
  ASSERT_IS_SYM_EQ(node, "hello?+-*=>");
  AST_heap_free(node);
  PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0xf04d(%rip), %rax      # 0x15bac
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 0x6b87
jmp 0x6b9f
movq 0x1446a(%rip), %rax     # 0x1aff8
movq (%rax), %rdi
leaq 0xf020(%rip), %rsi      # 0x15bb8
movb $0x0, %al
callq 0x1100
jmp 0x6ba1
movl 0x1459d(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x14594(%rip)     # 0x1b144
movq -0x20(%rbp), %rdi
callq 0x1a90
testb $0x1, %al
jne 0x6c05
jmp 0x6bbf
leaq 0xdadd(%rip), %rax      # 0x146a3
movq %rax, 0x14583(%rip)     # 0x1b150
movl $0x54f, 0x14571(%rip)   # imm = 0x54F
leaq 0xefff(%rip), %rax      # 0x15bdd
movq %rax, 0x14573(%rip)     # 0x1b158
movzbl 0x14514(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x6bf9
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6d0a
jmp 0x6c07
jmp 0x6c09
jmp 0x6c0b
leaq 0x144c6(%rip), %rax     # 0x1b0d8
movq %rax, -0x28(%rbp)
movl 0x14528(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x1451f(%rip)     # 0x1b144
movq -0x20(%rbp), %rdi
callq 0x1ab0
movq %rax, %rdi
movq -0x28(%rbp), %rdx
leaq 0xef70(%rip), %rsi      # 0x15bac
xorl %eax, %eax
movl %eax, %ecx
callq 0x11f00
cmpl $0x0, %eax
jne 0x6ce9
cmpq $0x0, -0x28(%rbp)
je 0x6c5f
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x6ca4
jmp 0x6c61
leaq 0xda3b(%rip), %rax      # 0x146a3
movq %rax, 0x144e1(%rip)     # 0x1b150
movl $0x54f, 0x144cf(%rip)   # imm = 0x54F
leaq 0xee5d(%rip), %rax      # 0x15add
movq %rax, 0x144d1(%rip)     # 0x1b158
movzbl 0x14472(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x6c9b
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6d0a
jmp 0x6ca6
leaq 0xd9f6(%rip), %rax      # 0x146a3
movq %rax, 0x1449c(%rip)     # 0x1b150
movl $0x54f, 0x1448a(%rip)   # imm = 0x54F
leaq 0xef2d(%rip), %rax      # 0x15bf2
movq %rax, 0x1448c(%rip)     # 0x1b158
movzbl 0x1442d(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x6ce0
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6d0a
jmp 0x6ceb
jmp 0x6ced
jmp 0x6cef
movq -0x18(%rbp), %rdi
callq 0x1800
movq $0x0, 0x14455(%rip) # 0x1b158
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: read_with_symbol_with_trailing_digits
TEST read_with_symbol_with_trailing_digits(void) {
  char *input = "add1 1";
  ASTNode *node = Reader_read(input);
  ASSERT_IS_SYM_EQ(node, "add1");
  AST_heap_free(node);
  PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0xeeeb(%rip), %rax      # 0x15c1a
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 0x6d57
jmp 0x6d6f
movq 0x1429a(%rip), %rax     # 0x1aff8
movq (%rax), %rdi
leaq 0xee50(%rip), %rsi      # 0x15bb8
movb $0x0, %al
callq 0x1100
jmp 0x6d71
movl 0x143cd(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x143c4(%rip)     # 0x1b144
movq -0x20(%rbp), %rdi
callq 0x1a90
testb $0x1, %al
jne 0x6dd5
jmp 0x6d8f
leaq 0xd90d(%rip), %rax      # 0x146a3
movq %rax, 0x143b3(%rip)     # 0x1b150
movl $0x557, 0x143a1(%rip)   # imm = 0x557
leaq 0xee2f(%rip), %rax      # 0x15bdd
movq %rax, 0x143a3(%rip)     # 0x1b158
movzbl 0x14344(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x6dc9
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6eda
jmp 0x6dd7
jmp 0x6dd9
jmp 0x6ddb
leaq 0x142f6(%rip), %rax     # 0x1b0d8
movq %rax, -0x28(%rbp)
movl 0x14358(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x1434f(%rip)     # 0x1b144
movq -0x20(%rbp), %rdi
callq 0x1ab0
movq %rax, %rdi
movq -0x28(%rbp), %rdx
leaq 0xe1c0(%rip), %rsi      # 0x14fcc
xorl %eax, %eax
movl %eax, %ecx
callq 0x11f00
cmpl $0x0, %eax
jne 0x6eb9
cmpq $0x0, -0x28(%rbp)
je 0x6e2f
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x6e74
jmp 0x6e31
leaq 0xd86b(%rip), %rax      # 0x146a3
movq %rax, 0x14311(%rip)     # 0x1b150
movl $0x557, 0x142ff(%rip)   # imm = 0x557
leaq 0xec8d(%rip), %rax      # 0x15add
movq %rax, 0x14301(%rip)     # 0x1b158
movzbl 0x142a2(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x6e6b
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6eda
jmp 0x6e76
leaq 0xd826(%rip), %rax      # 0x146a3
movq %rax, 0x142cc(%rip)     # 0x1b150
movl $0x557, 0x142ba(%rip)   # imm = 0x557
leaq 0xed8c(%rip), %rax      # 0x15c21
movq %rax, 0x142bc(%rip)     # 0x1b158
movzbl 0x1425d(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x6eb0
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6eda
jmp 0x6ebb
jmp 0x6ebd
jmp 0x6ebf
movq -0x18(%rbp), %rdi
callq 0x1800
movq $0x0, 0x14285(%rip) # 0x1b158
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: read_with_nil_returns_nil
TEST read_with_nil_returns_nil(void) {
  char *input = "()";
  ASTNode *node = Reader_read(input);
  ASSERT(AST_is_nil(node));
  AST_heap_free(node);
  PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0xf26b(%rip), %rax      # 0x1616a
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4e40
movq %rax, -0x18(%rbp)
movl 0x1422e(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x14225(%rip)     # 0x1b144
movq -0x18(%rbp), %rdi
callq 0x1700
testb $0x1, %al
jne 0x6f71
jmp 0x6f2e
leaq 0xd76e(%rip), %rax      # 0x146a3
movq %rax, 0x14214(%rip)     # 0x1b150
movl $0x573, 0x14202(%rip)   # imm = 0x573
leaq 0xecf5(%rip), %rax      # 0x15c42
movq %rax, 0x14204(%rip)     # 0x1b158
movzbl 0x141a5(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x6f68
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6f8e
jmp 0x6f73
movq -0x18(%rbp), %rdi
callq 0x1800
movq $0x0, 0x141d1(%rip) # 0x1b158
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: buffer_tests
SUITE(buffer_tests) {
  RUN_BUFFER_TEST(buffer_write8_increases_length);
  RUN_TEST(buffer_write8_expands_buffer);
  RUN_TEST(buffer_write32_expands_buffer);
  RUN_BUFFER_TEST(buffer_write32_writes_little_endian);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x1b80
leaq 0xcccd(%rip), %rdi      # 0x14eda
callq 0x5240
cmpl $0x1, %eax
jne 0x8247
leaq 0x12ee2(%rip), %rdi     # 0x1b100
addq $0x1c0, %rdi            # imm = 0x1C0
callq 0x10d0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x823f
leaq -0x20(%rbp), %rdi
callq 0x8340
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %edi
callq 0x5570
jmp 0x8249
leaq -0x20(%rbp), %rdi
callq 0x1c00
jmp 0x8254
leaq 0xcc9e(%rip), %rdi      # 0x14ef9
callq 0x5240
cmpl $0x1, %eax
jne 0x8291
leaq 0x12e94(%rip), %rdi     # 0x1b100
addq $0x1c0, %rdi            # imm = 0x1C0
callq 0x10d0
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jne 0x8289
callq 0x84b0
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %edi
callq 0x5570
jmp 0x8293
jmp 0x8295
leaq 0xcc7a(%rip), %rdi      # 0x14f16
callq 0x5240
cmpl $0x1, %eax
jne 0x82d2
leaq 0x12e53(%rip), %rdi     # 0x1b100
addq $0x1c0, %rdi            # imm = 0x1C0
callq 0x10d0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x82ca
callq 0x8690
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %edi
callq 0x5570
jmp 0x82d4
jmp 0x82d6
leaq -0x50(%rbp), %rdi
movl $0x1, %esi
callq 0x1b80
leaq 0xcc49(%rip), %rdi      # 0x14f34
callq 0x5240
cmpl $0x1, %eax
jne 0x8325
leaq 0x12e04(%rip), %rdi     # 0x1b100
addq $0x1c0, %rdi            # imm = 0x1C0
callq 0x10d0
movl %eax, -0x54(%rbp)
cmpl $0x0, -0x54(%rbp)
jne 0x831d
leaq -0x50(%rbp), %rdi
callq 0x8860
movl %eax, -0x54(%rbp)
movl -0x54(%rbp), %edi
callq 0x5570
jmp 0x8327
leaq -0x50(%rbp), %rdi
callq 0x1c00
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: buffer_write8_increases_length
TEST buffer_write8_increases_length(Buffer *buf) {
  ASSERT_EQ(buf->len, 0);
  Buffer_write8(buf, 0xdb);
  ASSERT_EQ(Buffer_at8(buf, 0), 0xdb);
  ASSERT_EQ(buf->len, 1);
  PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movl 0x12df2(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x12de9(%rip)     # 0x1b144
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x83ae
jmp 0x8368
leaq 0xc334(%rip), %rax      # 0x146a3
movq %rax, 0x12dda(%rip)     # 0x1b150
movl $0x597, 0x12dc8(%rip)   # imm = 0x597
leaq 0xdc11(%rip), %rax      # 0x15f98
movq %rax, 0x12dca(%rip)     # 0x1b158
movzbl 0x12d6b(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x83a2
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x84a2
jmp 0x83b0
movq -0x10(%rbp), %rdi
movl $0xdb, %esi
callq 0x1e70
movl 0x12d80(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x12d77(%rip)     # 0x1b144
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1cb0
movzbl %al, %eax
cmpl $0xdb, %eax
je 0x8429
jmp 0x83e6
leaq 0xc2b6(%rip), %rax      # 0x146a3
movq %rax, 0x12d5c(%rip)     # 0x1b150
movl $0x599, 0x12d4a(%rip)   # imm = 0x599
leaq 0xdba1(%rip), %rax      # 0x15fa6
movq %rax, 0x12d4c(%rip)     # 0x1b158
movzbl 0x12ced(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x8420
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x84a2
jmp 0x842b
jmp 0x842d
movl 0x12d11(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x12d08(%rip)     # 0x1b144
movq -0x10(%rbp), %rax
cmpq $0x1, 0x10(%rax)
je 0x848c
jmp 0x8449
leaq 0xc253(%rip), %rax      # 0x146a3
movq %rax, 0x12cf9(%rip)     # 0x1b150
movl $0x59a, 0x12ce7(%rip)   # imm = 0x59A
leaq 0xdb59(%rip), %rax      # 0x15fc1
movq %rax, 0x12ce9(%rip)     # 0x1b158
movzbl 0x12c8a(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x8483
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x84a2
jmp 0x848e
jmp 0x8490
movq $0x0, 0x12cbd(%rip) # 0x1b158
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: buffer_write8_expands_buffer
TEST buffer_write8_expands_buffer(void) {
  Buffer buf;
  Buffer_init(&buf, 1);
  ASSERT_EQ(buf.capacity, 1);
  ASSERT_EQ(buf.len, 0);
  Buffer_write8(&buf, 0xdb);
  Buffer_write8(&buf, 0xef);
  ASSERT(buf.capacity > 1);
  ASSERT_EQ(buf.len, 2);
  Buffer_deinit(&buf);
  PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x1b80
movl 0x12c78(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x12c6f(%rip)     # 0x1b144
cmpq $0x1, -0x10(%rbp)
je 0x8524
jmp 0x84de
leaq 0xc1be(%rip), %rax      # 0x146a3
movq %rax, 0x12c64(%rip)     # 0x1b150
movl $0x5a1, 0x12c52(%rip)   # imm = 0x5A1
leaq 0xdad2(%rip), %rax      # 0x15fcf
movq %rax, 0x12c54(%rip)     # 0x1b158
movzbl 0x12bf5(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x8518
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x867b
jmp 0x8526
jmp 0x8528
movl 0x12c16(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x12c0d(%rip)     # 0x1b144
cmpq $0x0, -0x18(%rbp)
je 0x8586
jmp 0x8540
leaq 0xc15c(%rip), %rax      # 0x146a3
movq %rax, 0x12c02(%rip)     # 0x1b150
movl $0x5a2, 0x12bf0(%rip)   # imm = 0x5A2
leaq 0xda82(%rip), %rax      # 0x15fe1
movq %rax, 0x12bf2(%rip)     # 0x1b158
movzbl 0x12b93(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x857a
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x867b
jmp 0x8588
leaq -0x28(%rbp), %rdi
movl $0xdb, %esi
callq 0x1e70
leaq -0x28(%rbp), %rdi
movl $0xef, %esi
callq 0x1e70
movl 0x12b9a(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x12b91(%rip)     # 0x1b144
cmpq $0x1, -0x10(%rbp)
ja 0x85ff
jmp 0x85bc
leaq 0xc0e0(%rip), %rax      # 0x146a3
movq %rax, 0x12b86(%rip)     # 0x1b150
movl $0x5a5, 0x12b74(%rip)   # imm = 0x5A5
leaq 0xda13(%rip), %rax      # 0x15fee
movq %rax, 0x12b76(%rip)     # 0x1b158
movzbl 0x12b17(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x85f6
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x867b
jmp 0x8601
jmp 0x8603
movl 0x12b3b(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x12b32(%rip)     # 0x1b144
cmpq $0x2, -0x18(%rbp)
je 0x865e
jmp 0x861b
leaq 0xc081(%rip), %rax      # 0x146a3
movq %rax, 0x12b27(%rip)     # 0x1b150
movl $0x5a6, 0x12b15(%rip)   # imm = 0x5A6
leaq 0xd9c5(%rip), %rax      # 0x15fff
movq %rax, 0x12b17(%rip)     # 0x1b158
movzbl 0x12ab8(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x8655
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x867b
jmp 0x8660
leaq -0x28(%rbp), %rdi
callq 0x1c00
movq $0x0, 0x12ae4(%rip) # 0x1b158
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: buffer_write32_expands_buffer
TEST buffer_write32_expands_buffer(void) {
  Buffer buf;
  Buffer_init(&buf, 1);
  ASSERT_EQ(buf.capacity, 1);
  ASSERT_EQ(buf.len, 0);
  Buffer_write32(&buf, 0xdeadbeef);
  ASSERT(buf.capacity > 1);
  ASSERT_EQ(buf.len, 4);
  Buffer_deinit(&buf);
  PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x1b80
movl 0x12a98(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x12a8f(%rip)     # 0x1b144
cmpq $0x1, -0x10(%rbp)
je 0x8704
jmp 0x86be
leaq 0xbfde(%rip), %rax      # 0x146a3
movq %rax, 0x12a84(%rip)     # 0x1b150
movl $0x5ae, 0x12a72(%rip)   # imm = 0x5AE
leaq 0xd8f2(%rip), %rax      # 0x15fcf
movq %rax, 0x12a74(%rip)     # 0x1b158
movzbl 0x12a15(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x86f8
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x884d
jmp 0x8706
jmp 0x8708
movl 0x12a36(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x12a2d(%rip)     # 0x1b144
cmpq $0x0, -0x18(%rbp)
je 0x8766
jmp 0x8720
leaq 0xbf7c(%rip), %rax      # 0x146a3
movq %rax, 0x12a22(%rip)     # 0x1b150
movl $0x5af, 0x12a10(%rip)   # imm = 0x5AF
leaq 0xd8a2(%rip), %rax      # 0x15fe1
movq %rax, 0x12a12(%rip)     # 0x1b158
movzbl 0x129b3(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x875a
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x884d
jmp 0x8768
leaq -0x28(%rbp), %rdi
movl $0xdeadbeef, %esi       # imm = 0xDEADBEEF
callq 0x1ec0
movl 0x129c8(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x129bf(%rip)     # 0x1b144
cmpq $0x1, -0x10(%rbp)
ja 0x87d1
jmp 0x878e
leaq 0xbf0e(%rip), %rax      # 0x146a3
movq %rax, 0x129b4(%rip)     # 0x1b150
movl $0x5b1, 0x129a2(%rip)   # imm = 0x5B1
leaq 0xd841(%rip), %rax      # 0x15fee
movq %rax, 0x129a4(%rip)     # 0x1b158
movzbl 0x12945(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x87c8
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x884d
jmp 0x87d3
jmp 0x87d5
movl 0x12969(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x12960(%rip)     # 0x1b144
cmpq $0x4, -0x18(%rbp)
je 0x8830
jmp 0x87ed
leaq 0xbeaf(%rip), %rax      # 0x146a3
movq %rax, 0x12955(%rip)     # 0x1b150
movl $0x5b2, 0x12943(%rip)   # imm = 0x5B2
leaq 0xd800(%rip), %rax      # 0x1600c
movq %rax, 0x12945(%rip)     # 0x1b158
movzbl 0x128e6(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x8827
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x884d
jmp 0x8832
leaq -0x28(%rbp), %rdi
callq 0x1c00
movq $0x0, 0x12912(%rip) # 0x1b158
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: buffer_write32_writes_little_endian
TEST buffer_write32_writes_little_endian(Buffer *buf) {
  Buffer_write32(buf, 0xdeadbeef);
  ASSERT_EQ(Buffer_at8(buf, 0), 0xef);
  ASSERT_EQ(Buffer_at8(buf, 1), 0xbe);
  ASSERT_EQ(Buffer_at8(buf, 2), 0xad);
  ASSERT_EQ(Buffer_at8(buf, 3), 0xde);
  PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0xdeadbeef, %esi       # imm = 0xDEADBEEF
callq 0x1ec0
movl 0x128c4(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x128bb(%rip)     # 0x1b144
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1cb0
movzbl %al, %eax
cmpl $0xef, %eax
je 0x88e8
jmp 0x88a2
leaq 0xbdfa(%rip), %rax      # 0x146a3
movq %rax, 0x128a0(%rip)     # 0x1b150
movl $0x5b9, 0x1288e(%rip)   # imm = 0x5B9
leaq 0xd758(%rip), %rax      # 0x16019
movq %rax, 0x12890(%rip)     # 0x1b158
movzbl 0x12831(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x88dc
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8a54
jmp 0x88ea
jmp 0x88ec
movl 0x12852(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x12849(%rip)     # 0x1b144
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x1cb0
movzbl %al, %eax
cmpl $0xbe, %eax
je 0x895b
jmp 0x8915
leaq 0xbd87(%rip), %rax      # 0x146a3
movq %rax, 0x1282d(%rip)     # 0x1b150
movl $0x5ba, 0x1281b(%rip)   # imm = 0x5BA
leaq 0xd700(%rip), %rax      # 0x16034
movq %rax, 0x1281d(%rip)     # 0x1b158
movzbl 0x127be(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x894f
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8a54
jmp 0x895d
jmp 0x895f
movl 0x127df(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x127d6(%rip)     # 0x1b144
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x1cb0
movzbl %al, %eax
cmpl $0xad, %eax
je 0x89ce
jmp 0x8988
leaq 0xbd14(%rip), %rax      # 0x146a3
movq %rax, 0x127ba(%rip)     # 0x1b150
movl $0x5bb, 0x127a8(%rip)   # imm = 0x5BB
leaq 0xd6a8(%rip), %rax      # 0x1604f
movq %rax, 0x127aa(%rip)     # 0x1b158
movzbl 0x1274b(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x89c2
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8a54
jmp 0x89d0
jmp 0x89d2
movl 0x1276c(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x12763(%rip)     # 0x1b144
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0x1cb0
movzbl %al, %eax
cmpl $0xde, %eax
je 0x8a3e
jmp 0x89fb
leaq 0xbca1(%rip), %rax      # 0x146a3
movq %rax, 0x12747(%rip)     # 0x1b150
movl $0x5bc, 0x12735(%rip)   # imm = 0x5BC
leaq 0xd650(%rip), %rax      # 0x1606a
movq %rax, 0x12737(%rip)     # 0x1b158
movzbl 0x126d8(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x8a35
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8a54
jmp 0x8a40
jmp 0x8a42
movq $0x0, 0x1270b(%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: compile_positive_integer
TEST compile_positive_integer(Buffer *buf) {
  word value = 123;
  ASTNode *node = AST_new_integer(value);
  int compile_result = Compile_entry(buf, node);
  ASSERT_EQ(compile_result, 0);
  // mov eax, imm(123)
  byte expected[] = {0x48, 0xc7, 0xc0, 0xec, 0x01, 0x00, 0x00};
  EXPECT_ENTRY_CONTAINS_CODE(buf, expected);
  Buffer_make_executable(buf);
  uword result = Testing_execute_expr(buf);
  ASSERT_EQ(result, Object_encode_integer(value));
  PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq $0x7b, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x15c0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4690
movl %eax, -0x24(%rbp)
movl 0x10cfd(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x10cf4(%rip)     # 0x1b144
cmpl $0x0, -0x24(%rbp)
je 0xa49e
jmp 0xa458
leaq 0xa244(%rip), %rax      # 0x146a3
movq %rax, 0x10cea(%rip)     # 0x1b150
movl $0x5c4, 0x10cd8(%rip)   # imm = 0x5C4
leaq 0xbc0e(%rip), %rax      # 0x16085
movq %rax, 0x10cda(%rip)     # 0x1b158
movzbl 0x10c7b(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xa492
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa582
jmp 0xa4a0
movl 0x9d42(%rip), %eax      # 0x141e8
movl %eax, -0x2b(%rbp)
movw 0x9d3c(%rip), %ax       # 0x141ec
movw %ax, -0x27(%rbp)
movb 0x9d34(%rip), %al       # 0x141ee
movb %al, -0x25(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x2b(%rbp), %rsi
movl $0x7, %edx
callq 0x12d40
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
je 0xa4e3
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xa582
jmp 0xa4e5
movq -0x10(%rbp), %rdi
callq 0x1c50
movq -0x10(%rbp), %rdi
callq 0x4f20
movq %rax, -0x38(%rbp)
movl 0x10c43(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x10c3a(%rip)     # 0x1b144
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1290
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
je 0xa56c
jmp 0xa529
leaq 0xa173(%rip), %rax      # 0x146a3
movq %rax, 0x10c19(%rip)     # 0x1b150
movl $0x5ca, 0x10c07(%rip)   # imm = 0x5CA
leaq 0xbb51(%rip), %rax      # 0x16099
movq %rax, 0x10c09(%rip)     # 0x1b158
movzbl 0x10baa(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xa563
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa582
jmp 0xa56e
jmp 0xa570
movq $0x0, 0x10bdd(%rip) # 0x1b158
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: compile_negative_integer
TEST compile_negative_integer(Buffer *buf) {
  word value = -123;
  ASTNode *node = AST_new_integer(value);
  int compile_result = Compile_entry(buf, node);
  ASSERT_EQ(compile_result, 0);
  // mov eax, imm(-123)
  byte expected[] = {0x48, 0xc7, 0xc0, 0x14, 0xfe, 0xff, 0xff};
  EXPECT_ENTRY_CONTAINS_CODE(buf, expected);
  Buffer_make_executable(buf);
  uword result = Testing_execute_expr(buf);
  ASSERT_EQ(result, Object_encode_integer(value));
  PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq $-0x7b, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x15c0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4690
movl %eax, -0x24(%rbp)
movl 0x10b7d(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x10b74(%rip)     # 0x1b144
cmpl $0x0, -0x24(%rbp)
je 0xa61e
jmp 0xa5d8
leaq 0xa0c4(%rip), %rax      # 0x146a3
movq %rax, 0x10b6a(%rip)     # 0x1b150
movl $0x5d2, 0x10b58(%rip)   # imm = 0x5D2
leaq 0xba8e(%rip), %rax      # 0x16085
movq %rax, 0x10b5a(%rip)     # 0x1b158
movzbl 0x10afb(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xa612
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa702
jmp 0xa620
movl 0x9bc9(%rip), %eax      # 0x141ef
movl %eax, -0x2b(%rbp)
movw 0x9bc3(%rip), %ax       # 0x141f3
movw %ax, -0x27(%rbp)
movb 0x9bbb(%rip), %al       # 0x141f5
movb %al, -0x25(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x2b(%rbp), %rsi
movl $0x7, %edx
callq 0x12d40
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
je 0xa663
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xa702
jmp 0xa665
movq -0x10(%rbp), %rdi
callq 0x1c50
movq -0x10(%rbp), %rdi
callq 0x4f20
movq %rax, -0x38(%rbp)
movl 0x10ac3(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x10aba(%rip)     # 0x1b144
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1290
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
je 0xa6ec
jmp 0xa6a9
leaq 0x9ff3(%rip), %rax      # 0x146a3
movq %rax, 0x10a99(%rip)     # 0x1b150
movl $0x5d8, 0x10a87(%rip)   # imm = 0x5D8
leaq 0xb9d1(%rip), %rax      # 0x16099
movq %rax, 0x10a89(%rip)     # 0x1b158
movzbl 0x10a2a(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xa6e3
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa702
jmp 0xa6ee
jmp 0xa6f0
movq $0x0, 0x10a5d(%rip) # 0x1b158
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: compile_char
TEST compile_char(Buffer *buf) {
  char value = 'a';
  ASTNode *node = AST_new_char(value);
  int compile_result = Compile_entry(buf, node);
  ASSERT_EQ(compile_result, 0);
  // mov eax, imm('a')
  byte expected[] = {0x48, 0xc7, 0xc0, 0x0f, 0x61, 0x00, 0x00};
  EXPECT_ENTRY_CONTAINS_CODE(buf, expected);
  Buffer_make_executable(buf);
  uword result = Testing_execute_expr(buf);
  ASSERT_EQ(result, Object_encode_char(value));
  PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movb $0x61, -0x11(%rbp)
movsbl -0x11(%rbp), %edi
callq 0x1620
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4690
movl %eax, -0x24(%rbp)
movl 0x10a01(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x109f8(%rip)     # 0x1b144
cmpl $0x0, -0x24(%rbp)
je 0xa79a
jmp 0xa754
leaq 0x9f48(%rip), %rax      # 0x146a3
movq %rax, 0x109ee(%rip)     # 0x1b150
movl $0x5e0, 0x109dc(%rip)   # imm = 0x5E0
leaq 0xb912(%rip), %rax      # 0x16085
movq %rax, 0x109de(%rip)     # 0x1b158
movzbl 0x1097f(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xa78e
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa87e
jmp 0xa79c
movl 0x9a54(%rip), %eax      # 0x141f6
movl %eax, -0x2b(%rbp)
movw 0x9a4e(%rip), %ax       # 0x141fa
movw %ax, -0x27(%rbp)
movb 0x9a46(%rip), %al       # 0x141fc
movb %al, -0x25(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x2b(%rbp), %rsi
movl $0x7, %edx
callq 0x12d40
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
je 0xa7df
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xa87e
jmp 0xa7e1
movq -0x10(%rbp), %rdi
callq 0x1c50
movq -0x10(%rbp), %rdi
callq 0x4f20
movq %rax, -0x38(%rbp)
movl 0x10947(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x1093e(%rip)     # 0x1b144
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movsbl -0x11(%rbp), %edi
callq 0x1360
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
je 0xa868
jmp 0xa825
leaq 0x9e77(%rip), %rax      # 0x146a3
movq %rax, 0x1091d(%rip)     # 0x1b150
movl $0x5e6, 0x1090b(%rip)   # imm = 0x5E6
leaq 0xb8d4(%rip), %rax      # 0x16118
movq %rax, 0x1090d(%rip)     # 0x1b158
movzbl 0x108ae(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xa85f
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa87e
jmp 0xa86a
jmp 0xa86c
movq $0x0, 0x108e1(%rip) # 0x1b158
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: compile_true
TEST compile_true(Buffer *buf) {
  ASTNode *node = AST_new_bool(true);
  int compile_result = Compile_entry(buf, node);
  ASSERT_EQ(compile_result, 0);
  // mov eax, imm(true)
  byte expected[] = {0x48, 0xc7, 0xc0, 0x9f, 0x0, 0x0, 0x0};
  EXPECT_ENTRY_CONTAINS_CODE(buf, expected);
  Buffer_make_executable(buf);
  uword result = Testing_execute_expr(buf);
  ASSERT_EQ(result, Object_true());
  PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, %edi
callq 0x1680
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4690
movl %eax, -0x1c(%rbp)
movl 0x10884(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x1087b(%rip)     # 0x1b144
cmpl $0x0, -0x1c(%rbp)
je 0xa917
jmp 0xa8d1
leaq 0x9dcb(%rip), %rax      # 0x146a3
movq %rax, 0x10871(%rip)     # 0x1b150
movl $0x5ed, 0x1085f(%rip)   # imm = 0x5ED
leaq 0xb795(%rip), %rax      # 0x16085
movq %rax, 0x10861(%rip)     # 0x1b158
movzbl 0x10802(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xa90b
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa9f7
jmp 0xa919
movl 0x98de(%rip), %eax      # 0x141fd
movl %eax, -0x23(%rbp)
movw 0x98d8(%rip), %ax       # 0x14201
movw %ax, -0x1f(%rbp)
movb 0x98d0(%rip), %al       # 0x14203
movb %al, -0x1d(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x23(%rbp), %rsi
movl $0x7, %edx
callq 0x12d40
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0xa95c
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xa9f7
jmp 0xa95e
movq -0x10(%rbp), %rdi
callq 0x1c50
movq -0x10(%rbp), %rdi
callq 0x4f20
movq %rax, -0x30(%rbp)
movl 0x107ca(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x107c1(%rip)     # 0x1b144
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x1400
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
je 0xa9e1
jmp 0xa99e
leaq 0x9cfe(%rip), %rax      # 0x146a3
movq %rax, 0x107a4(%rip)     # 0x1b150
movl $0x5f3, 0x10792(%rip)   # imm = 0x5F3
leaq 0xb77f(%rip), %rax      # 0x1613c
movq %rax, 0x10794(%rip)     # 0x1b158
movzbl 0x10735(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xa9d8
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa9f7
jmp 0xa9e3
jmp 0xa9e5
movq $0x0, 0x10768(%rip) # 0x1b158
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: compile_false
TEST compile_false(Buffer *buf) {
  ASTNode *node = AST_new_bool(false);
  int compile_result = Compile_entry(buf, node);
  ASSERT_EQ(compile_result, 0);
  // mov eax, imm(false)
  byte expected[] = {0x48, 0xc7, 0xc0, 0x1f, 0x00, 0x00, 0x00};
  EXPECT_ENTRY_CONTAINS_CODE(buf, expected);
  Buffer_make_executable(buf);
  uword result = Testing_execute_expr(buf);
  ASSERT_EQ(result, Object_false());
  PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
xorl %edi, %edi
callq 0x1680
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4690
movl %eax, -0x1c(%rbp)
movl 0x10717(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x1070e(%rip)     # 0x1b144
cmpl $0x0, -0x1c(%rbp)
je 0xaa84
jmp 0xaa3e
leaq 0x9c5e(%rip), %rax      # 0x146a3
movq %rax, 0x10704(%rip)     # 0x1b150
movl $0x5fa, 0x106f2(%rip)   # imm = 0x5FA
leaq 0xb628(%rip), %rax      # 0x16085
movq %rax, 0x106f4(%rip)     # 0x1b158
movzbl 0x10695(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xaa78
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xab64
jmp 0xaa86
movl 0x9778(%rip), %eax      # 0x14204
movl %eax, -0x23(%rbp)
movw 0x9772(%rip), %ax       # 0x14208
movw %ax, -0x1f(%rbp)
movb 0x976a(%rip), %al       # 0x1420a
movb %al, -0x1d(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x23(%rbp), %rsi
movl $0x7, %edx
callq 0x12d40
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0xaac9
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xab64
jmp 0xaacb
movq -0x10(%rbp), %rdi
callq 0x1c50
movq -0x10(%rbp), %rdi
callq 0x4f20
movq %rax, -0x30(%rbp)
movl 0x1065d(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x10654(%rip)     # 0x1b144
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x1410
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
je 0xab4e
jmp 0xab0b
leaq 0x9b91(%rip), %rax      # 0x146a3
movq %rax, 0x10637(%rip)     # 0x1b150
movl $0x600, 0x10625(%rip)   # imm = 0x600
leaq 0xb62a(%rip), %rax      # 0x16154
movq %rax, 0x10627(%rip)     # 0x1b158
movzbl 0x105c8(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xab45
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xab64
jmp 0xab50
jmp 0xab52
movq $0x0, 0x105fb(%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_nil
TEST compile_nil(Buffer *buf) {
  ASTNode *node = AST_nil();
  int compile_result = Compile_entry(buf, node);
  ASSERT_EQ(compile_result, 0);
  // mov eax, imm(nil)
  byte expected[] = {0x48, 0xc7, 0xc0, 0x2f, 0x00, 0x00, 0x00};
  EXPECT_ENTRY_CONTAINS_CODE(buf, expected);
  Buffer_make_executable(buf);
  uword result = Testing_execute_expr(buf);
  ASSERT_EQ(result, Object_nil());
  PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
callq 0x1730
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4690
movl %eax, -0x1c(%rbp)
movl 0x105a9(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x105a0(%rip)     # 0x1b144
cmpl $0x0, -0x1c(%rbp)
je 0xabf2
jmp 0xabac
leaq 0x9af0(%rip), %rax      # 0x146a3
movq %rax, 0x10596(%rip)     # 0x1b150
movl $0x607, 0x10584(%rip)   # imm = 0x607
leaq 0xb4ba(%rip), %rax      # 0x16085
movq %rax, 0x10586(%rip)     # 0x1b158
movzbl 0x10527(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xabe6
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xacd2
jmp 0xabf4
movl 0x9611(%rip), %eax      # 0x1420b
movl %eax, -0x23(%rbp)
movw 0x960b(%rip), %ax       # 0x1420f
movw %ax, -0x1f(%rbp)
movb 0x9603(%rip), %al       # 0x14211
movb %al, -0x1d(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x23(%rbp), %rsi
movl $0x7, %edx
callq 0x12d40
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0xac37
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xacd2
jmp 0xac39
movq -0x10(%rbp), %rdi
callq 0x1c50
movq -0x10(%rbp), %rdi
callq 0x4f20
movq %rax, -0x30(%rbp)
movl 0x104ef(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x104e6(%rip)     # 0x1b144
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x1420
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
je 0xacbc
jmp 0xac79
leaq 0x9a23(%rip), %rax      # 0x146a3
movq %rax, 0x104c9(%rip)     # 0x1b150
movl $0x60d, 0x104b7(%rip)   # imm = 0x60D
leaq 0xb4d5(%rip), %rax      # 0x1616d
movq %rax, 0x104b9(%rip)     # 0x1b158
movzbl 0x1045a(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xacb3
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xacd2
jmp 0xacbe
jmp 0xacc0
movq $0x0, 0x1048d(%rip) # 0x1b158
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: compile_unary_add1
TEST compile_unary_add1(Buffer *buf) {
  ASTNode *node = new_unary_call("add1", AST_new_integer(123));
  int compile_result = Compile_entry(buf, node);
  ASSERT_EQ(compile_result, 0);
  // mov rax, imm(123); add rax, imm(1)
  byte expected[] = {0x48, 0xc7, 0xc0, 0xec, 0x01, 0x00, 0x00,
                     0x48, 0x05, 0x04, 0x00, 0x00, 0x00};
  EXPECT_ENTRY_CONTAINS_CODE(buf, expected);
  Buffer_make_executable(buf);
  uword result = Testing_execute_expr(buf);
  ASSERT_EQ(result, Object_encode_integer(124));
  AST_heap_free(node);
  PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl $0x7b, %edi
callq 0x15c0
movq %rax, %rsi
leaq 0xa2cc(%rip), %rdi      # 0x14fcc
callq 0x4ff0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4690
movl %eax, -0x1c(%rbp)
movl 0x10425(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x1041c(%rip)     # 0x1b144
cmpl $0x0, -0x1c(%rbp)
je 0xad76
jmp 0xad30
leaq 0x996c(%rip), %rax      # 0x146a3
movq %rax, 0x10412(%rip)     # 0x1b150
movl $0x614, 0x10400(%rip)   # imm = 0x614
leaq 0xb336(%rip), %rax      # 0x16085
movq %rax, 0x10402(%rip)     # 0x1b158
movzbl 0x103a3(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xad6a
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xae62
jmp 0xad78
movq 0x9493(%rip), %rax      # 0x14212
movq %rax, -0x29(%rbp)
movl 0x9491(%rip), %eax      # 0x1421a
movl %eax, -0x21(%rbp)
movb 0x948c(%rip), %al       # 0x1421e
movb %al, -0x1d(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x29(%rbp), %rsi
movl $0xd, %edx
callq 0x12d40
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
je 0xadbb
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xae62
jmp 0xadbd
movq -0x10(%rbp), %rdi
callq 0x1c50
movq -0x10(%rbp), %rdi
callq 0x4f20
movq %rax, -0x38(%rbp)
movl 0x1036b(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x10362(%rip)     # 0x1b144
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x7c, %edi
callq 0x1290
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
je 0xae45
jmp 0xae02
leaq 0x989a(%rip), %rax      # 0x146a3
movq %rax, 0x10340(%rip)     # 0x1b150
movl $0x61b, 0x1032e(%rip)   # imm = 0x61B
leaq 0xb363(%rip), %rax      # 0x16184
movq %rax, 0x10330(%rip)     # 0x1b158
movzbl 0x102d1(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xae3c
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xae62
jmp 0xae47
movq -0x18(%rbp), %rdi
callq 0x1800
movq $0x0, 0x102fd(%rip) # 0x1b158
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: compile_unary_add1_nested
TEST compile_unary_add1_nested(Buffer *buf) {
  ASTNode *node =
      new_unary_call("add1", new_unary_call("add1", AST_new_integer(123)));
  int compile_result = Compile_entry(buf, node);
  ASSERT_EQ(compile_result, 0);
  // mov rax, imm(123); add rax, imm(1); add rax, imm(1)
  byte expected[] = {0x48, 0xc7, 0xc0, 0xec, 0x01, 0x00, 0x00, 0x48, 0x05, 0x04,
                     0x00, 0x00, 0x00, 0x48, 0x05, 0x04, 0x00, 0x00, 0x00};
  EXPECT_ENTRY_CONTAINS_CODE(buf, expected);
  Buffer_make_executable(buf);
  uword result = Testing_execute_expr(buf);
  ASSERT_EQ(result, Object_encode_integer(125));
  AST_heap_free(node);
  PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl $0x7b, %edi
callq 0x15c0
movq %rax, %rsi
leaq 0xa13c(%rip), %rdi      # 0x14fcc
callq 0x4ff0
movq %rax, %rsi
leaq 0xa12d(%rip), %rdi      # 0x14fcc
callq 0x4ff0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4690
movl %eax, -0x1c(%rbp)
movl 0x10286(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x1027d(%rip)     # 0x1b144
cmpl $0x0, -0x1c(%rbp)
je 0xaf15
jmp 0xaecf
leaq 0x97cd(%rip), %rax      # 0x146a3
movq %rax, 0x10273(%rip)     # 0x1b150
movl $0x624, 0x10261(%rip)   # imm = 0x624
leaq 0xb197(%rip), %rax      # 0x16085
movq %rax, 0x10263(%rip)     # 0x1b158
movzbl 0x10204(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xaf09
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb00e
jmp 0xaf17
movq 0x9302(%rip), %rax      # 0x14220
movq %rax, -0x30(%rbp)
movq 0x92ff(%rip), %rax      # 0x14228
movq %rax, -0x28(%rbp)
movw 0x92fc(%rip), %ax       # 0x14230
movw %ax, -0x20(%rbp)
movb 0x92f4(%rip), %al       # 0x14232
movb %al, -0x1e(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x13, %edx
callq 0x12d40
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0xaf67
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xb00e
jmp 0xaf69
movq -0x10(%rbp), %rdi
callq 0x1c50
movq -0x10(%rbp), %rdi
callq 0x4f20
movq %rax, -0x40(%rbp)
movl 0x101bf(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x101b6(%rip)     # 0x1b144
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x7d, %edi
callq 0x1290
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
je 0xaff1
jmp 0xafae
leaq 0x96ee(%rip), %rax      # 0x146a3
movq %rax, 0x10194(%rip)     # 0x1b150
movl $0x62b, 0x10182(%rip)   # imm = 0x62B
leaq 0xb1dc(%rip), %rax      # 0x161a9
movq %rax, 0x10184(%rip)     # 0x1b158
movzbl 0x10125(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xafe8
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb00e
jmp 0xaff3
movq -0x18(%rbp), %rdi
callq 0x1800
movq $0x0, 0x10151(%rip) # 0x1b158
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: compile_unary_sub1
TEST compile_unary_sub1(Buffer *buf) {
  ASTNode *node = new_unary_call("sub1", AST_new_integer(123));
  int compile_result = Compile_entry(buf, node);
  ASSERT_EQ(compile_result, 0);
  // mov rax, imm(123); sub rax, imm(1)
  byte expected[] = {0x48, 0xc7, 0xc0, 0xec, 0x01, 0x00, 0x00,
                     0x48, 0x2d, 0x04, 0x00, 0x00, 0x00};
  EXPECT_ENTRY_CONTAINS_CODE(buf, expected);
  Buffer_make_executable(buf);
  uword result = Testing_execute_expr(buf);
  ASSERT_EQ(result, Object_encode_integer(122));
  AST_heap_free(node);
  PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl $0x7b, %edi
callq 0x15c0
movq %rax, %rsi
leaq 0x9fb9(%rip), %rdi      # 0x14ff9
callq 0x4ff0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4690
movl %eax, -0x1c(%rbp)
movl 0x100e5(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x100dc(%rip)     # 0x1b144
cmpl $0x0, -0x1c(%rbp)
je 0xb0b6
jmp 0xb070
leaq 0x962c(%rip), %rax      # 0x146a3
movq %rax, 0x100d2(%rip)     # 0x1b150
movl $0x633, 0x100c0(%rip)   # imm = 0x633
leaq 0xaff6(%rip), %rax      # 0x16085
movq %rax, 0x100c2(%rip)     # 0x1b158
movzbl 0x10063(%rip), %eax     # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xb0aa
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb1a2
jmp 0xb0b8
movq 0x9174(%rip), %rax      # 0x14233
movq %rax, -0x29(%rbp)
movl 0x9172(%rip), %eax      # 0x1423b
movl %eax, -0x21(%rbp)
movb 0x916d(%rip), %al       # 0x1423f
movb %al, -0x1d(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x29(%rbp), %rsi
movl $0xd, %edx
callq 0x12d40
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
je 0xb0fb
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xb1a2
jmp 0xb0fd
movq -0x10(%rbp), %rdi
callq 0x1c50
movq -0x10(%rbp), %rdi
callq 0x4f20
movq %rax, -0x38(%rbp)
movl 0x1002b(%rip), %eax     # 0x1b144
addl $0x1, %eax
movl %eax, 0x10022(%rip)     # 0x1b144
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x7a, %edi
callq 0x1290
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
je 0xb185
jmp 0xb142
leaq 0x955a(%rip), %rax      # 0x146a3
movq %rax, 0x10000(%rip)     # 0x1b150
movl $0x63a, 0xffee(%rip)    # imm = 0x63A
leaq 0xb06d(%rip), %rax      # 0x161ce
movq %rax, 0xfff0(%rip)      # 0x1b158
movzbl 0xff91(%rip), %eax      # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xb17c
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb1a2
jmp 0xb187
movq -0x18(%rbp), %rdi
callq 0x1800
movq $0x0, 0xffbd(%rip) # 0x1b158
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: compile_unary_integer_to_char
TEST compile_unary_integer_to_char(Buffer *buf) {
  ASTNode *node = new_unary_call("integer->char", AST_new_integer(97));
  int compile_result = Compile_entry(buf, node);
  ASSERT_EQ(compile_result, 0);
  // mov rax, imm(97); shl rax, 6; or rax, 0xf
  byte expected[] = {0x48, 0xc7, 0xc0, 0x84, 0x01, 0x00, 0x00, 0x48,
                     0xc1, 0xe0, 0x06, 0x48, 0x83, 0xc8, 0x0f};
  EXPECT_ENTRY_CONTAINS_CODE(buf, expected);
  Buffer_make_executable(buf);
  uword result = Testing_execute_expr(buf);
  ASSERT_EQ(result, Object_encode_char('a'));
  AST_heap_free(node);
  PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl $0x61, %edi
callq 0x15c0
movq %rax, %rsi
leaq 0x97ed(%rip), %rdi      # 0x149bd
callq 0x4ff0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4690
movl %eax, -0x1c(%rbp)
movl 0xff55(%rip), %eax      # 0x1b144
addl $0x1, %eax
movl %eax, 0xff4c(%rip)      # 0x1b144
cmpl $0x0, -0x1c(%rbp)
je 0xb246
jmp 0xb200
leaq 0x949c(%rip), %rax      # 0x146a3
movq %rax, 0xff42(%rip)      # 0x1b150
movl $0x642, 0xff30(%rip)    # imm = 0x642
leaq 0xae66(%rip), %rax      # 0x16085
movq %rax, 0xff32(%rip)      # 0x1b158
movzbl 0xfed3(%rip), %eax      # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xb23a
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb33d
jmp 0xb248
movq 0x8ff1(%rip), %rax      # 0x14240
movq %rax, -0x2b(%rbp)
movl 0x8fef(%rip), %eax      # 0x14248
movl %eax, -0x23(%rbp)
movw 0x8fe9(%rip), %ax       # 0x1424c
movw %ax, -0x1f(%rbp)
movb 0x8fe1(%rip), %al       # 0x1424e
movb %al, -0x1d(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x2b(%rbp), %rsi
movl $0xf, %edx
callq 0x12d40
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
je 0xb296
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xb33d
jmp 0xb298
movq -0x10(%rbp), %rdi
callq 0x1c50
movq -0x10(%rbp), %rdi
callq 0x4f20
movq %rax, -0x38(%rbp)
movl 0xfe90(%rip), %eax      # 0x1b144
addl $0x1, %eax
movl %eax, 0xfe87(%rip)      # 0x1b144
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x61, %edi
callq 0x1360
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
je 0xb320
jmp 0xb2dd
leaq 0x93bf(%rip), %rax      # 0x146a3
movq %rax, 0xfe65(%rip)      # 0x1b150
movl $0x649, 0xfe53(%rip)    # imm = 0x649
leaq 0xaef7(%rip), %rax      # 0x161f3
movq %rax, 0xfe55(%rip)      # 0x1b158
movzbl 0xfdf6(%rip), %eax      # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xb317
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb33d
jmp 0xb322
movq -0x18(%rbp), %rdi
callq 0x1800
movq $0x0, 0xfe22(%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_unary_char_to_integer
TEST compile_unary_char_to_integer(Buffer *buf) {
  ASTNode *node = new_unary_call("char->integer", AST_new_char('a'));
  int compile_result = Compile_entry(buf, node);
  ASSERT_EQ(compile_result, 0);
  // mov rax, imm('a'); shr rax, 6
  byte expected[] = {0x48, 0xc7, 0xc0, 0x0f, 0x61, 0x00,
                     0x00, 0x48, 0xc1, 0xe8, 0x06};
  EXPECT_ENTRY_CONTAINS_CODE(buf, expected);
  Buffer_make_executable(buf);
  uword result = Testing_execute_expr(buf);
  ASSERT_EQ(result, Object_encode_integer(97));
  AST_heap_free(node);
  PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl $0x61, %edi
callq 0x1620
movq %rax, %rsi
leaq 0x965b(%rip), %rdi      # 0x149cb
callq 0x4ff0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4690
movl %eax, -0x1c(%rbp)
movl 0xfdb5(%rip), %eax      # 0x1b144
addl $0x1, %eax
movl %eax, 0xfdac(%rip)      # 0x1b144
cmpl $0x0, -0x1c(%rbp)
je 0xb3e6
jmp 0xb3a0
leaq 0x92fc(%rip), %rax      # 0x146a3
movq %rax, 0xfda2(%rip)      # 0x1b150
movl $0x651, 0xfd90(%rip)    # imm = 0x651
leaq 0xacc6(%rip), %rax      # 0x16085
movq %rax, 0xfd92(%rip)      # 0x1b158
movzbl 0xfd33(%rip), %eax      # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xb3da
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb4d4
jmp 0xb3e8
movq 0x8e60(%rip), %rax      # 0x1424f
movq %rax, -0x27(%rbp)
movw 0x8e5d(%rip), %ax       # 0x14257
movw %ax, -0x1f(%rbp)
movb 0x8e55(%rip), %al       # 0x14259
movb %al, -0x1d(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x27(%rbp), %rsi
movl $0xb, %edx
callq 0x12d40
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0xb42d
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xb4d4
jmp 0xb42f
movq -0x10(%rbp), %rdi
callq 0x1c50
movq -0x10(%rbp), %rdi
callq 0x4f20
movq %rax, -0x38(%rbp)
movl 0xfcf9(%rip), %eax      # 0x1b144
addl $0x1, %eax
movl %eax, 0xfcf0(%rip)      # 0x1b144
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x61, %edi
callq 0x1290
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
je 0xb4b7
jmp 0xb474
leaq 0x9228(%rip), %rax      # 0x146a3
movq %rax, 0xfcce(%rip)      # 0x1b150
movl $0x658, 0xfcbc(%rip)    # imm = 0x658
leaq 0xad82(%rip), %rax      # 0x16215
movq %rax, 0xfcbe(%rip)      # 0x1b158
movzbl 0xfc5f(%rip), %eax      # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xb4ae
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb4d4
jmp 0xb4b9
movq -0x18(%rbp), %rdi
callq 0x1800
movq $0x0, 0xfc8b(%rip) # 0x1b158
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)