LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/openshmem-org[P]openshmem-examples/c/collect32.c
// Function: show_dst
static void
show_dst(char *tag)
{
    int i;
    printf("%8s: dst[%d/%d] =", tag, me, npes);
    for (i = 0; i < DST_SIZE; i += 1) {
        printf(" %d", dst[i]);
    }
    printf("\n");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rsi
movl 0x2de0(%rip), %edx      # 0x4084
movl 0x2dd6(%rip), %ecx      # 0x4080
leaq 0xd59(%rip), %rdi       # 0x200a
movb $0x0, %al
callq 0x1030
movl $0x0, 0xc(%rsp)
cmpl $0x14, 0xc(%rsp)
jge 0x12f1
movslq 0xc(%rsp), %rcx
leaq 0x2dbd(%rip), %rax      # 0x4090
movl (%rax,%rcx,4), %esi
leaq 0xd3f(%rip), %rdi       # 0x201c
movb $0x0, %al
callq 0x1030
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x12c0
leaq 0xd28(%rip), %rdi       # 0x2020
movb $0x0, %al
callq 0x1030
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/tools/designer/designer.cpp
// Function: Designer::TimerProc()
void Designer::TimerProc()
{
	Designer_EditComponent	*object;
	Bool			 mouseOnWindow = False;

	for (Int i = 0; i < dlgs.Length(); i++)
	{
		object = dlgs.GetNth(i);

		Point	 mousePos = object->GetWindow()->GetMousePosition();

		if (mousePos.x > 0 && mousePos.y > 0 && mousePos.x < object->GetWindow()->GetWidth() && mousePos.y < object->GetWindow()->GetHeight())
		{
			mouseOnWindow = True;

			break;
		}
	}

	if (!mouseOnWindow && (statusbar->GetText() != "Ready")) statusbar->SetText("Ready");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movb $0x0, -0x11(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x50(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x54(%rbp)
addq $0x660, %rdi            # imm = 0x660
callq 0x7590
movl %eax, %ecx
movl -0x54(%rbp), %eax
cmpl %ecx, %eax
jge 0x65c3
movq -0x50(%rbp), %rdi
addq $0x660, %rdi            # imm = 0x660
movl -0x18(%rbp), %esi
callq 0x75b0
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa060
movq %rax, %rdi
callq 0x5130
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jle 0x65b3
cmpl $0x0, -0x1c(%rbp)
jle 0x65b3
movl -0x20(%rbp), %eax
movl %eax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa060
movq %rax, %rdi
callq 0x7770
movl %eax, %ecx
movl -0x58(%rbp), %eax
cmpl %ecx, %eax
jge 0x65b3
movl -0x1c(%rbp), %eax
movl %eax, -0x5c(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa060
movq %rax, %rdi
callq 0x7790
movl %eax, %ecx
movl -0x5c(%rbp), %eax
cmpl %ecx, %eax
jge 0x65b3
movb $0x1, -0x11(%rbp)
jmp 0x65c3
jmp 0x65b5
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x650f
testb $0x1, -0x11(%rbp)
jne 0x6651
movq -0x50(%rbp), %rax
movq 0x5d8(%rax), %rdi
movq (%rdi), %rax
callq *0xa8(%rax)
movq %rax, %rdi
leaq 0x5a7c(%rip), %rsi      # 0xc067
callq 0x5240
testb $0x1, %al
jne 0x65f6
jmp 0x6651
movq -0x50(%rbp), %rax
movq 0x5d8(%rax), %rax
movq %rax, -0x70(%rbp)
leaq 0x5a5b(%rip), %rsi      # 0xc067
leaq -0x38(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x5350
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq (%rdi), %rax
movq 0xa0(%rax), %rax
callq *%rax
jmp 0x662f
leaq -0x38(%rbp), %rdi
callq 0x5210
jmp 0x6651
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5210
jmp 0x6657
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x5150
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/tools/designer/designer.cpp
// Function: Designer::ExitProc()
Bool Designer::ExitProc()
{
	for (Int i = 0; i < dlgs.Length(); i++)
	{
		delete dlgs.GetNth(i);
	}

	dlgs.RemoveAll();

	return True;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
addq $0x660, %rdi            # imm = 0x660
callq 0x7590
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jge 0x6921
movq -0x18(%rbp), %rdi
addq $0x660, %rdi            # imm = 0x660
movl -0xc(%rbp), %esi
callq 0x75b0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x6914
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
jmp 0x6916
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x68cb
movq -0x18(%rbp), %rdi
addq $0x660, %rdi            # imm = 0x660
callq 0x75e0
movb $0x1, %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/tools/designer/designer.cpp
// Function: Designer::~Designer()
Designer::~Designer()
{
	timer1->Stop();

	DeleteObject(title);
	DeleteObject(wnd);
	DeleteObject(menubar);
	DeleteObject(iconbar);
	DeleteObject(statusbar);
	DeleteObject(timer1);

	delete menu_file;
	delete menu_dialog;
	delete menu_widgets;
	delete menu_widgets_add;
	delete menu_widgets_add_smooth;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x9ca5(%rip), %rcx      # 0x10600
movq %rcx, (%rax)
movq 0x608(%rax), %rdi
callq 0x51a0
jmp 0x696c
movq -0x10(%rbp), %rax
movq 0x5c0(%rax), %rdi
callq 0x53c0
jmp 0x697e
movq -0x10(%rbp), %rax
movq 0x5b8(%rax), %rdi
callq 0x53c0
jmp 0x6990
movq -0x10(%rbp), %rax
movq 0x5c8(%rax), %rdi
callq 0x53c0
jmp 0x69a2
movq -0x10(%rbp), %rax
movq 0x5d0(%rax), %rdi
callq 0x53c0
jmp 0x69b4
movq -0x10(%rbp), %rax
movq 0x5d8(%rax), %rdi
callq 0x53c0
jmp 0x69c6
movq -0x10(%rbp), %rax
movq 0x608(%rax), %rdi
callq 0x53c0
jmp 0x69d8
movq -0x10(%rbp), %rax
movq 0x5e0(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x69f7
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x5e8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x6a16
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x5f0(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x6a35
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x5f8(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x6a54
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x600(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x6a73
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x10(%rbp), %rdi
addq $0x660, %rdi            # imm = 0x660
callq 0x7540
movq -0x10(%rbp), %rdi
addq $0x618, %rdi            # imm = 0x618
callq 0x7560
movq -0x10(%rbp), %rdi
callq 0x5230
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x7580
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yurrriq[P]knrc/src/charfreq.c
// Function: prchar
void prchar(int c)
{
    switch (c) {
    case ' ':
        printf("%11s", "<space>");
        break;
    case '\b':
        printf("%11s", "<backspace>");
        break;
    case '\n':
        printf("%11s", "<newline>");
        break;
    case '\t':
        printf("%11s", "<tab>");
        break;
    default:
        /* FIXME: why can't I return this? */
        /* return ((char[2]) { (char) c, '\0' }); */
        printf("%11c", c);
        break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
addl $-0x8, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x18, %eax
ja 0x120c
movq -0x10(%rbp), %rax
leaq 0xe5d(%rip), %rcx       # 0x2004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xeb1(%rip), %rdi       # 0x2068
leaq 0xeaf(%rip), %rsi       # 0x206d
movb $0x0, %al
callq 0x1040
jmp 0x121d
leaq 0xe9a(%rip), %rdi       # 0x2068
leaq 0xea0(%rip), %rsi       # 0x2075
movb $0x0, %al
callq 0x1040
jmp 0x121d
leaq 0xe83(%rip), %rdi       # 0x2068
leaq 0xe95(%rip), %rsi       # 0x2081
movb $0x0, %al
callq 0x1040
jmp 0x121d
leaq 0xe6c(%rip), %rdi       # 0x2068
leaq 0xe88(%rip), %rsi       # 0x208b
movb $0x0, %al
callq 0x1040
jmp 0x121d
movl -0x4(%rbp), %esi
leaq 0xe7b(%rip), %rdi       # 0x2091
movb $0x0, %al
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yurrriq[P]knrc/src/charfreq.c
// Function: main
int main()
{
    int c;
    int freq[MAX_ASCII + 1] = { 0 };

    while ((c = getchar()) != EOF)
        ++freq[c];

    for (int i = 0; i <= MAX_ASCII; ++i) {
        if (!freq[i])
            continue;

        prchar(i);
        fputs(": ", stdout);
        for (int j = 0; j < freq[i]; ++j)
            putchar('#');
        putchar('\n');
    }


    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movl $0x0, -0x4(%rbp)
leaq -0x210(%rbp), %rdi
xorl %esi, %esi
movl $0x200, %edx            # imm = 0x200
callq 0x1060
callq 0x1070
movl %eax, -0x8(%rbp)
cmpl $-0x1, %eax
je 0x1279
movslq -0x8(%rbp), %rax
movl -0x210(%rbp,%rax,4), %ecx
addl $0x1, %ecx
movl %ecx, -0x210(%rbp,%rax,4)
jmp 0x1255
movl $0x0, -0x214(%rbp)
cmpl $0x7f, -0x214(%rbp)
jg 0x131d
movslq -0x214(%rbp), %rax
cmpl $0x0, -0x210(%rbp,%rax,4)
jne 0x12a3
jmp 0x1309
movl -0x214(%rbp), %edi
callq 0x1180
movq 0x2d2b(%rip), %rax      # 0x3fe0
movq (%rax), %rsi
leaq 0xdd7(%rip), %rdi       # 0x2096
callq 0x1050
movl $0x0, -0x218(%rbp)
movl -0x218(%rbp), %eax
movslq -0x214(%rbp), %rcx
cmpl -0x210(%rbp,%rcx,4), %eax
jge 0x12ff
movl $0x23, %edi
callq 0x1030
movl -0x218(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x218(%rbp)
jmp 0x12ce
movl $0xa, %edi
callq 0x1030
movl -0x214(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x214(%rbp)
jmp 0x1283
xorl %eax, %eax
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/truenas[P]binaries/src/plx_eeprom.c
// Function: plx_eeprom_read_raw
static void
plx_eeprom_read_raw(void *mem, int dfd)
{
	int i, n, error;
	uint32_t val;

	val = plx_eeprom_read(mem, 0);
	write(dfd, &val, sizeof(val));
	n = 4;
	if ((val & 0xff) == 0x5a)
		n += (val >> 16) + ((n & 0x8000) ? 4 : 0);
	n = roundup2(n, 4);
	for (i = 4; i < n; i += 4) {
		val = plx_eeprom_read(mem, i);
		write(dfd, &val, sizeof(val));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x18c0
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %edi
leaq -0x1c(%rbp), %rsi
movl $0x4, %edx
callq 0x1040
movl $0x4, -0x14(%rbp)
movl -0x1c(%rbp), %eax
andl $0xff, %eax
cmpl $0x5a, %eax
jne 0x15c6
movl -0x1c(%rbp), %eax
shrl $0x10, %eax
movl -0x14(%rbp), %esi
andl $0x8000, %esi           # imm = 0x8000
xorl %ecx, %ecx
movl $0x4, %edx
cmpl $0x0, %esi
cmovnel %edx, %ecx
addl %ecx, %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $0x3, %eax
andl $-0x4, %eax
movl %eax, -0x14(%rbp)
movl $0x4, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x160c
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x18c0
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %edi
leaq -0x1c(%rbp), %rsi
movl $0x4, %edx
callq 0x1040
movl -0x10(%rbp), %eax
addl $0x4, %eax
movl %eax, -0x10(%rbp)
jmp 0x15d9
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/truenas[P]binaries/src/plx_eeprom.c
// Function: plx_eeprom_write_raw
static void
plx_eeprom_write_raw(void *mem, int dfd)
{
	int i;
	uint32_t val, val2;

	/* Magic specific to One Stop Systems */
	write4(mem, 0x260, 0x0000A000);
	usleep(1000);
	write4(mem, 0x260, 0x00002000);
	usleep(1000);

	i = 0;
	val = 0;
	while (read(dfd, &val, 4) > 0) {
		plx_eeprom_write(mem, i, val);
		val2 = plx_eeprom_read(mem, i);
		if (val2 != val)
			errx(EX_OSERR, "EEPROM write error at %x %08x != %08x",
			    i, val2, val);
		i += 4;
		val = 0;
	}
	printf("%d dwords written\n", i / 4);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl $0x260, %esi            # imm = 0x260
movl $0xa000, %edx           # imm = 0xA000
callq 0x1280
movl $0x3e8, %edi            # imm = 0x3E8
callq 0x1150
movq -0x8(%rbp), %rdi
movl $0x260, %esi            # imm = 0x260
movl $0x2000, %edx           # imm = 0x2000
callq 0x1280
movl $0x3e8, %edi            # imm = 0x3E8
callq 0x1150
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0xc(%rbp), %edi
leaq -0x14(%rbp), %rsi
movl $0x4, %edx
callq 0x10a0
cmpq $0x0, %rax
jle 0x16e3
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x1a10
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x18c0
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0x16d1
movl -0x10(%rbp), %edx
movl -0x18(%rbp), %ecx
movl -0x14(%rbp), %r8d
movl $0x47, %edi
leaq 0xa92(%rip), %rsi       # 0x215c
movb $0x0, %al
callq 0x1060
movl -0x10(%rbp), %eax
addl $0x4, %eax
movl %eax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
jmp 0x1677
movl -0x10(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, %esi
leaq 0xa8b(%rip), %rdi       # 0x2182
movb $0x0, %al
callq 0x1070
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/truenas[P]binaries/src/plx_eeprom.c
// Function: plx_eeprom_print
static void
plx_eeprom_print(void *mem)
{
	int i, n, r;
	uint32_t *bufdw;
	uint32_t val;

	val = plx_eeprom_read(mem, 0);
	if ((val & 0xff) != 0x5a)
		return;
	n = (val >> 16);
	r = roundup2(n, 4);
	bufdw = malloc(r);
	for (i = 0; i < r; i += 4)
		bufdw[i / 4] = plx_eeprom_read(mem, 4 + i);
	plx_config_print((char *)bufdw, n);
	free(bufdw);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x18c0
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
andl $0xff, %eax
cmpl $0x5a, %eax
je 0x173c
jmp 0x17c1
movl -0x24(%rbp), %eax
shrl $0x10, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
addl $0x3, %eax
andl $-0x4, %eax
movl %eax, -0x14(%rbp)
movslq -0x14(%rbp), %rdi
callq 0x10f0
movq %rax, -0x20(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x17ac
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x4, %esi
callq 0x18c0
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl -0x34(%rbp), %edx
movl %eax, %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x4, %eax
movl %eax, -0xc(%rbp)
jmp 0x1765
movq -0x20(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x1c00
movq -0x20(%rbp), %rdi
callq 0x1030
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/truenas[P]binaries/src/plx_eeprom.c
// Function: plx_file_print
static void
plx_file_print(int fd)
{
	int i, n;
	uint32_t *bufdw;
	uint32_t val;
	struct stat st;

	if (fstat(fd, &st) < 0)
		err(EX_OSERR, "Can't fstat() file");
	n = st.st_size;
	bufdw = malloc(n);
	if (read(fd, bufdw, n) < n)
		err(EX_OSERR, "Can't read file");
	val = bufdw[0];
	if ((val & 0xff) != 0x5a) {
		err(EX_OSERR, "Wrong signature");
		return;
	}
	if ((val >> 16) + 4 > n) {
		err(EX_OSERR, "Truncated image");
		return;
	}
	n = (val >> 16);
	plx_config_print((char *)(bufdw + 1), n);
	free(bufdw);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
leaq -0xb0(%rbp), %rsi
callq 0x1140
cmpl $0x0, %eax
jge 0x1805
movl $0x47, %edi
leaq 0xa22(%rip), %rsi       # 0x2220
movb $0x0, %al
callq 0x10e0
movq -0x80(%rbp), %rax
movl %eax, -0xc(%rbp)
movslq -0xc(%rbp), %rdi
callq 0x10f0
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %edi
movq -0x18(%rbp), %rsi
movslq -0xc(%rbp), %rdx
callq 0x10a0
movslq -0xc(%rbp), %rcx
cmpq %rcx, %rax
jge 0x1845
movl $0x47, %edi
leaq 0x9f5(%rip), %rsi       # 0x2233
movb $0x0, %al
callq 0x10e0
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
andl $0xff, %eax
cmpl $0x5a, %eax
je 0x186e
movl $0x47, %edi
leaq 0x9dc(%rip), %rsi       # 0x2243
movb $0x0, %al
callq 0x10e0
movl -0x1c(%rbp), %eax
shrl $0x10, %eax
addl $0x4, %eax
cmpl -0xc(%rbp), %eax
jbe 0x188f
movl $0x47, %edi
leaq 0x9cb(%rip), %rsi       # 0x2253
movb $0x0, %al
callq 0x10e0
movl -0x1c(%rbp), %eax
shrl $0x10, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rdi
addq $0x4, %rdi
movl -0xc(%rbp), %esi
callq 0x1c00
movq -0x18(%rbp), %rdi
callq 0x1030
addq $0xb0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/truenas[P]binaries/src/plx_eeprom.c
// Function: plx_eeprom_read
static uint32_t
plx_eeprom_read(void *mem, u_int addr)
{
	uint32_t val;

	if ((addr > 0x00ffffff) || (addr & 0x3) != 0)
		errx(EX_OSERR, "Incorrect EEPROM address %x", addr);

	/* Write address byte 3. */
	val = read4(mem, 0x26c);
	write4(mem, 0x26c, (val & ~0xff) | (addr >> 24));

	/* Initiate read. */
	addr >>= 2;
	val = read4(mem, 0x260);
	val &= 0xffe00000;
	val |= ((addr & 0x2000) << 7) | (3 << 13) | (addr & 0x1fff);
	write4(mem, 0x260, val);

	/* Wait for completion. */
	val = 100;
	while ((read4(mem, 0x260) & 0x40000) != 0 && val > 0) {
		usleep(100);
		val--;
	}
	if (val == 0)
		errx(EX_OSERR, "EEPROM write timeout");

	/* Read result. */
	val = read4(mem, 0x264);
	return (val);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0xffffff, -0xc(%rbp)   # imm = 0xFFFFFF
ja 0x18e3
movl -0xc(%rbp), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0x18f9
movl -0xc(%rbp), %edx
movl $0x47, %edi
leaq 0x839(%rip), %rsi       # 0x212b
movb $0x0, %al
callq 0x1060
movq -0x8(%rbp), %rdi
movl $0x26c, %esi            # imm = 0x26C
callq 0x1260
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %edx
andl $0xffffff00, %edx       # imm = 0xFFFFFF00
movl -0xc(%rbp), %eax
shrl $0x18, %eax
orl %eax, %edx
movl $0x26c, %esi            # imm = 0x26C
callq 0x1280
movl -0xc(%rbp), %eax
shrl $0x2, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl $0x260, %esi            # imm = 0x260
callq 0x1260
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
andl $0xffe00000, %eax       # imm = 0xFFE00000
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
andl $0x2000, %eax           # imm = 0x2000
shll $0x7, %eax
orl $0x6000, %eax           # imm = 0x6000
movl -0xc(%rbp), %ecx
andl $0x1fff, %ecx           # imm = 0x1FFF
orl %ecx, %eax
orl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %edx
movl $0x260, %esi            # imm = 0x260
callq 0x1280
movl $0x64, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x260, %esi            # imm = 0x260
callq 0x1260
movl %eax, %ecx
andl $0x40000, %ecx          # imm = 0x40000
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
je 0x19b1
cmpl $0x0, -0x10(%rbp)
seta %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x19ba
jmp 0x19cf
movl $0x64, %edi
callq 0x1150
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1987
cmpl $0x0, -0x10(%rbp)
jne 0x19e8
movl $0x47, %edi
leaq 0x766(%rip), %rsi       # 0x2147
movb $0x0, %al
callq 0x1060
movq -0x8(%rbp), %rdi
movl $0x264, %esi            # imm = 0x264
callq 0x1260
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/truenas[P]binaries/src/plx_eeprom.c
// Function: plx_config_print
static void
plx_config_print(char *buf, int n)
{
	int i, r, port, error;
	uint32_t val;

	printf("   #\tPort\tReg\tValue\n");
	printf("--------------------------------\n");
	n /= 6;
	for (i = 0; i < n; i++) {
		printf(" %3d\t", i);
		val = le16dec(&buf[i * 6]);
		port = val >> 10;
		if ((port & 0x38) == 0x20)
			printf("A-LUT %d", port & 0x3);
		else if (port == 0x2c)
			printf("DMA RAM");
		else if ((port & 0x38) == 0x28)
			printf("DMA %d", port & 0x7);
		else if ((port & 0x38) == 0x30)
			printf("S%dP0", port & 0x7);
		else if ((port & 0x38) == 0x38)
			printf("NT%d %c", (port >> 1) & 0x1,
			    (port & 0x1) ? 'V' : 'L');
		else
			printf("%d", port);
		printf("\t%03x\t%08x\n",
		    (val & 0x3ff) * 4, le32dec(&buf[i * 6] + 2));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x59b(%rip), %rdi       # 0x21b1
movb $0x0, %al
callq 0x1070
leaq 0x5a2(%rip), %rdi       # 0x21c6
movb $0x0, %al
callq 0x1070
movl -0xc(%rbp), %eax
movl $0x6, %ecx
cltd
idivl %ecx
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1d94
movl -0x10(%rbp), %esi
leaq 0x592(%rip), %rdi       # 0x21e8
movb $0x0, %al
callq 0x1070
movq -0x8(%rbp), %rdi
imull $0x6, -0x10(%rbp), %eax
cltq
addq %rax, %rdi
callq 0x1da0
movzwl %ax, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
shrl $0xa, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
andl $0x38, %eax
cmpl $0x20, %eax
jne 0x1ca2
movl -0x18(%rbp), %esi
andl $0x3, %esi
leaq 0x558(%rip), %rdi       # 0x21ee
movb $0x0, %al
callq 0x1070
jmp 0x1d4f
cmpl $0x2c, -0x18(%rbp)
jne 0x1cbb
leaq 0x548(%rip), %rdi       # 0x21f7
movb $0x0, %al
callq 0x1070
jmp 0x1d4d
movl -0x18(%rbp), %eax
andl $0x38, %eax
cmpl $0x28, %eax
jne 0x1cdc
movl -0x18(%rbp), %esi
andl $0x7, %esi
leaq 0x52c(%rip), %rdi       # 0x21ff
movb $0x0, %al
callq 0x1070
jmp 0x1d4b
movl -0x18(%rbp), %eax
andl $0x38, %eax
cmpl $0x30, %eax
jne 0x1cfd
movl -0x18(%rbp), %esi
andl $0x7, %esi
leaq 0x512(%rip), %rdi       # 0x2206
movb $0x0, %al
callq 0x1070
jmp 0x1d49
movl -0x18(%rbp), %eax
andl $0x38, %eax
cmpl $0x38, %eax
jne 0x1d36
movl -0x18(%rbp), %esi
sarl %esi
andl $0x1, %esi
movl -0x18(%rbp), %ecx
andl $0x1, %ecx
movl $0x4c, %edx
movl $0x56, %eax
cmpl $0x0, %ecx
cmovnel %eax, %edx
leaq 0x4df(%rip), %rdi       # 0x220c
movb $0x0, %al
callq 0x1070
jmp 0x1d47
movl -0x18(%rbp), %esi
leaq 0x4c3(%rip), %rdi       # 0x2203
movb $0x0, %al
callq 0x1070
jmp 0x1d49
jmp 0x1d4b
jmp 0x1d4d
jmp 0x1d4f
movl -0x20(%rbp), %eax
andl $0x3ff, %eax            # imm = 0x3FF
shll $0x2, %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
imull $0x6, -0x10(%rbp), %eax
cltq
addq %rax, %rdi
addq $0x2, %rdi
callq 0x1dd0
movl -0x24(%rbp), %esi
movl %eax, %edx
leaq 0x495(%rip), %rdi       # 0x2214
movb $0x0, %al
callq 0x1070
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1c40
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/examples/doge.c
// Function: main
int main(int argc, char **argv) {

  mpc_result_t r;
  
  mpc_parser_t* Adjective = mpc_new("adjective");
  mpc_parser_t* Noun      = mpc_new("noun");
  mpc_parser_t* Phrase    = mpc_new("phrase");
  mpc_parser_t* Doge      = mpc_new("doge");

  mpca_lang(MPCA_LANG_DEFAULT,
    " adjective : \"wow\" | \"many\" | \"so\" | \"such\";                 "
    " noun      : \"lisp\" | \"language\" | \"c\" | \"book\" | \"build\"; "
    " phrase    : <adjective> <noun>;                                     "
    " doge      : /^/ <phrase>* /$/;                                      ",
    Adjective, Noun, Phrase, Doge, NULL);
  
  if (argc > 1) {
    
    if (mpc_parse_contents(argv[1], Doge, &r)) {
      mpc_ast_print(r.output);
      mpc_ast_delete(r.output);
    } else {
      mpc_err_print(r.error);
      mpc_err_delete(r.error);
    }
  
  } else {

    if (mpc_parse_pipe("<stdin>", stdin, Doge, &r)) {
      mpc_ast_print(r.output);
      mpc_ast_delete(r.output);
    } else {
      mpc_err_print(r.error);
      mpc_err_delete(r.error);
    }
  
  }

  mpc_cleanup(4, Adjective, Noun, Phrase, Doge);
  
  return 0;
  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xdd17(%rip), %rdi      # 0xf004
callq 0x3890
movq %rax, -0x20(%rbp)
leaq 0xdd11(%rip), %rdi      # 0xf00e
callq 0x3890
movq %rax, -0x28(%rbp)
leaq 0xdd06(%rip), %rdi      # 0xf013
callq 0x3890
movq %rax, -0x30(%rbp)
leaq 0xdcfd(%rip), %rdi      # 0xf01a
callq 0x3890
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
xorl %edi, %edi
leaq 0xdce0(%rip), %rsi      # 0xf01f
xorl %eax, %eax
movq $0x0, (%rsp)
movb $0x0, %al
callq 0xa4b0
cmpl $0x1, -0x8(%rbp)
jle 0x1398
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x38(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x3530
cmpl $0x0, %eax
je 0x1384
movq -0x18(%rbp), %rdi
callq 0x8530
movq -0x18(%rbp), %rdi
callq 0x7db0
jmp 0x1396
movq -0x18(%rbp), %rdi
callq 0x1490
movq -0x18(%rbp), %rdi
callq 0x1410
jmp 0x13e3
movq 0x12c41(%rip), %rax     # 0x13fe0
movq (%rax), %rsi
movq -0x38(%rbp), %rdx
leaq 0xdd75(%rip), %rdi      # 0xf122
leaq -0x18(%rbp), %rcx
callq 0x3390
cmpl $0x0, %eax
je 0x13cf
movq -0x18(%rbp), %rdi
callq 0x8530
movq -0x18(%rbp), %rdi
callq 0x7db0
jmp 0x13e1
movq -0x18(%rbp), %rdi
callq 0x1490
movq -0x18(%rbp), %rdi
callq 0x1410
jmp 0x13e3
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
movl $0x4, %edi
movb $0x0, %al
callq 0x3f90
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/flanger/flanger.c
// Function: sawtooth
static double
sawtooth(int width,int max,int offset,int index)
    {
    int spot;
    double result;

    spot = (offset + index) % width;
    //printf("spot is %d, max is %d\n",spot,max);

    if (spot < width / 2)
        result = max * spot / (width / 2.0);
    else
        result = max * (width - spot) / (width / 2.0);

    //printf("delay is %f\n",result);
    //getchar();

    return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
cltd
idivl -0x4(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x4(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jge 0x2b2e
movl -0x8(%rbp), %eax
imull -0x14(%rbp), %eax
cvtsi2sd %eax, %xmm0
cvtsi2sdl -0x4(%rbp), %xmm1
movsd 0x94f9(%rip), %xmm2     # 0xc018
divsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x2b58
movl -0x8(%rbp), %eax
movl -0x4(%rbp), %ecx
subl -0x14(%rbp), %ecx
imull %ecx, %eax
cvtsi2sd %eax, %xmm0
cvtsi2sdl -0x4(%rbp), %xmm1
movsd 0x94cd(%rip), %xmm2     # 0xc018
divsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/main.c
// Function: usage
static void
usage(const char *argv0)
{
  printf("\n");
  printf("Usage ... %s [OPTIONS] <file.bc>\n", argv0);
  printf("\n");
  printf("  -f FUNCTION         Function to diagnose [ALL]\n");
  printf("  -l                  Dump lowered function(s)\n");
  printf("  -p                  Dump parsed function(s)\n");
  printf("  -i                  List all functions\n");
  printf("  -n                  Don't try to run code\n");
  printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x3e00e(%rip), %rdi     # 0x419f1
movb $0x0, %al
callq 0x3170
movq -0x8(%rbp), %rsi
leaq 0x38731(%rip), %rdi     # 0x3c126
movb $0x0, %al
callq 0x3170
leaq 0x3dfee(%rip), %rdi     # 0x419f1
movb $0x0, %al
callq 0x3170
leaq 0x38737(%rip), %rdi     # 0x3c148
movb $0x0, %al
callq 0x3170
leaq 0x3875b(%rip), %rdi     # 0x3c17a
movb $0x0, %al
callq 0x3170
leaq 0x3877d(%rip), %rdi     # 0x3c1aa
movb $0x0, %al
callq 0x3170
leaq 0x3879e(%rip), %rdi     # 0x3c1d9
movb $0x0, %al
callq 0x3170
leaq 0x387ba(%rip), %rdi     # 0x3c203
movb $0x0, %al
callq 0x3170
leaq 0x3df9a(%rip), %rdi     # 0x419f1
movb $0x0, %al
callq 0x3170
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/main.c
// Function: dump_stats
static void
dump_stats(ir_unit_t *iu)
{
  const vmir_stats_t *s = vmir_get_stats(iu);

  printf("\n");
  printf(" Memory usage stats\n");
  printf("\n");
  printf("       VM code size: %d\n", s->vm_code_size);
  printf("      JIT code size: %d\n", s->jit_code_size);
  printf("          Data size: %d\n", s->data_size);
  printf("     Peak heap size: %d\n", s->peak_heap_size);
  printf("   Peak stack usage: %d\n", s->peak_stack_size);
  printf("\n");
  printf(" Code transformation stats\n");
  printf("\n");
  printf("       Moves killed: %d\n", s->moves_killed);
  printf("  Lea+Load combined: %d\n", s->lea_load_combined);
  printf(" Lea+Load comb-fail: %d\n", s->lea_load_combined_failed);
  printf("Cmp+Branch combined: %d\n", s->cmp_branch_combine);
  printf("Cmp+Select combined: %d\n", s->cmp_select_combine);
  printf("   Mul+Add combined: %d\n", s->mla_combine);
  printf(" Load+Cast combined: %d\n", s->load_cast_combine);
  printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x18910
movq %rax, -0x10(%rbp)
leaq 0x3df31(%rip), %rdi     # 0x419f1
movb $0x0, %al
callq 0x3170
leaq 0x38762(%rip), %rdi     # 0x3c230
movb $0x0, %al
callq 0x3170
leaq 0x3df15(%rip), %rdi     # 0x419f1
movb $0x0, %al
callq 0x3170
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq 0x38755(%rip), %rdi     # 0x3c245
movb $0x0, %al
callq 0x3170
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
leaq 0x38759(%rip), %rdi     # 0x3c25e
movb $0x0, %al
callq 0x3170
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
leaq 0x3875d(%rip), %rdi     # 0x3c277
movb $0x0, %al
callq 0x3170
movq -0x10(%rbp), %rax
movl 0xc(%rax), %esi
leaq 0x38761(%rip), %rdi     # 0x3c290
movb $0x0, %al
callq 0x3170
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
leaq 0x38765(%rip), %rdi     # 0x3c2a9
movb $0x0, %al
callq 0x3170
leaq 0x3de9f(%rip), %rdi     # 0x419f1
movb $0x0, %al
callq 0x3170
leaq 0x38762(%rip), %rdi     # 0x3c2c2
movb $0x0, %al
callq 0x3170
leaq 0x3de83(%rip), %rdi     # 0x419f1
movb $0x0, %al
callq 0x3170
movq -0x10(%rbp), %rax
movl 0x24(%rax), %esi
leaq 0x3875b(%rip), %rdi     # 0x3c2de
movb $0x0, %al
callq 0x3170
movq -0x10(%rbp), %rax
movl 0x28(%rax), %esi
leaq 0x3875f(%rip), %rdi     # 0x3c2f7
movb $0x0, %al
callq 0x3170
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %esi
leaq 0x38763(%rip), %rdi     # 0x3c310
movb $0x0, %al
callq 0x3170
movq -0x10(%rbp), %rax
movl 0x14(%rax), %esi
leaq 0x38767(%rip), %rdi     # 0x3c329
movb $0x0, %al
callq 0x3170
movq -0x10(%rbp), %rax
movl 0x18(%rax), %esi
leaq 0x3876b(%rip), %rdi     # 0x3c342
movb $0x0, %al
callq 0x3170
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %esi
leaq 0x3876f(%rip), %rdi     # 0x3c35b
movb $0x0, %al
callq 0x3170
movq -0x10(%rbp), %rax
movl 0x20(%rax), %esi
leaq 0x38773(%rip), %rdi     # 0x3c374
movb $0x0, %al
callq 0x3170
leaq 0x3dde2(%rip), %rdi     # 0x419f1
movb $0x0, %al
callq 0x3170
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_function.c
// Function: vmir_find_function
ir_function_t *
vmir_find_function(ir_unit_t *iu, const char *name)
{
  for(int i = 0; i < VECTOR_LEN(&iu->iu_functions); i++) {
    ir_function_t *f = VECTOR_ITEM(&iu->iu_functions, i);
    if(f->if_name != NULL && !strcmp(f->if_name, name))
      return f;
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x2e0(%rcx), %rax
jae 0x3cd7
movq -0x10(%rbp), %rax
movq 0x2d8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x3cca
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x32d0
cmpl $0x0, %eax
jne 0x3cca
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3cdf
jmp 0x3ccc
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3c77
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_vm.c
// Function: vmir_vm_arg_func
ir_function_t *
vmir_vm_arg_func(const void **rfp, ir_unit_t *iu)
{
  uint32_t fnid = vmir_vm_arg32(rfp);
  if(fnid >= VECTOR_LEN(&iu->iu_functions))
    return NULL;
  return VECTOR_ITEM(&iu->iu_functions, fnid);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3cf0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpq 0x2e0(%rcx), %rax
jb 0x3e66
movq $0x0, -0x8(%rbp)
jmp 0x3e7c
movq -0x18(%rbp), %rax
movq 0x2d8(%rax), %rax
movl -0x1c(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_type.c
// Function: legalize_type
static int
legalize_type(const ir_type_t *ty)
{
  if(ty->it_code == IR_TYPE_INTx) {
    if(ty->it_bits <= 8)
      return IR_TYPE_INT8;
    else if(ty->it_bits <= 16)
      return IR_TYPE_INT16;
    else if(ty->it_bits <= 32)
      return IR_TYPE_INT32;
    else if(ty->it_bits <= 64)
      return IR_TYPE_INT64;
  }
  return ty->it_code;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x7, (%rax)
jne 0x4635
movq -0x10(%rbp), %rax
cmpl $0x8, 0x8(%rax)
jg 0x45f4
movl $0x3, -0x4(%rbp)
jmp 0x463e
movq -0x10(%rbp), %rax
cmpl $0x10, 0x8(%rax)
jg 0x4607
movl $0x4, -0x4(%rbp)
jmp 0x463e
movq -0x10(%rbp), %rax
cmpl $0x20, 0x8(%rax)
jg 0x461a
movl $0x5, -0x4(%rbp)
jmp 0x463e
movq -0x10(%rbp), %rax
cmpl $0x40, 0x8(%rax)
jg 0x462d
movl $0x6, -0x4(%rbp)
jmp 0x463e
jmp 0x462f
jmp 0x4631
jmp 0x4633
jmp 0x4635
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir.c
// Function: vmir_log
static void
vmir_log(ir_unit_t *iu, vmir_log_level_t level, const char *fmt, ...)
{
  if(level > iu->iu_log_level)
    return;

  va_list ap;
  char tmp[1024];
  va_start(ap, fmt);
  vsnprintf(tmp, sizeof(tmp), fmt, ap);
  va_end(ap);

  if(iu->iu_logger) {
    iu->iu_logger(iu, level, tmp);
  } else {
    printf("%s\n", tmp);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4e0, %rsp            # imm = 0x4E0
testb %al, %al
je 0x4697
movaps %xmm0, -0x4b0(%rbp)
movaps %xmm1, -0x4a0(%rbp)
movaps %xmm2, -0x490(%rbp)
movaps %xmm3, -0x480(%rbp)
movaps %xmm4, -0x470(%rbp)
movaps %xmm5, -0x460(%rbp)
movaps %xmm6, -0x450(%rbp)
movaps %xmm7, -0x440(%rbp)
movq %r9, -0x4b8(%rbp)
movq %r8, -0x4c0(%rbp)
movq %rcx, -0x4c8(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x630(%rcx), %eax
jbe 0x46cb
jmp 0x474c
leaq -0x30(%rbp), %rax
leaq -0x4e0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
leaq -0x430(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x30(%rbp), %rcx
movl $0x400, %esi            # imm = 0x400
callq 0x3100
leaq -0x30(%rbp), %rax
movq -0x8(%rbp), %rax
cmpq $0x0, 0x628(%rax)
je 0x4737
movq -0x8(%rbp), %rax
movq 0x628(%rax), %rax
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq -0x430(%rbp), %rdx
callq *%rax
jmp 0x474c
leaq -0x430(%rbp), %rsi
leaq 0x3a95a(%rip), %rdi     # 0x3f09f
movb $0x0, %al
callq 0x3170
addq $0x4e0, %rsp            # imm = 0x4E0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_type.c
// Function: type_str
static const char *
type_str(ir_unit_t *iu, const ir_type_t *it)
{
  int len = type_print(NULL, iu, it);
  char *dst = tmpstr(iu, len);
  const char *ret = dst;
  type_print(&dst, iu, it);
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
xorl %eax, %eax
movl %eax, %edi
callq 0x18930
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x18e00
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x20(%rbp), %rdi
callq 0x18930
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_libc.c
// Function: vmir_mem_alloc
uint32_t
vmir_mem_alloc(ir_unit_t *iu, uint32_t size, void *hostaddr_)
{
  void **hostaddr = hostaddr_;
  void *p = vmir_heap_malloc(iu, size);
  if(p == NULL) {
    if(hostaddr)
      *hostaddr = NULL;
    return 0;
  }
  if(hostaddr)
    *hostaddr = p;
  return p - iu->iu_mem;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x16e00
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x480d
cmpq $0x0, -0x28(%rbp)
je 0x4804
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x4831
cmpq $0x0, -0x28(%rbp)
je 0x481f
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
subq %rcx, %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_libc.c
// Function: vmir_fd_get
intptr_t
vmir_fd_get(ir_unit_t *iu, int fd, int type)
{
  vmir_fd_t *vfd = vfd_get(iu, fd, type);
  if(vfd == NULL)
    return 0;
  return vfd->fh;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x16990
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x16976
movq $0x0, -0x8(%rbp)
jmp 0x16981
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_libc.c
// Function: vfd_get
static vmir_fd_t *
vfd_get(ir_unit_t *iu, unsigned int fd, int type)
{
  if(fd >= VECTOR_LEN(&iu->iu_vfds))
    return NULL;
  vmir_fd_t *vfd = &VECTOR_ITEM(&iu->iu_vfds, fd);
  if(vfd->type == 0 || (type != -1 && vfd->type != type))
    return NULL; // Bad/Closed fd
  return vfd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpq 0xd8(%rcx), %rax
jb 0x169b8
movq $0x0, -0x8(%rbp)
jmp 0x16a03
movq -0x10(%rbp), %rax
movq 0xd0(%rax), %rax
movl -0x14(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x0, %eax
je 0x169f1
cmpl $-0x1, -0x18(%rbp)
je 0x169fb
movq -0x20(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl -0x18(%rbp), %eax
je 0x169fb
movq $0x0, -0x8(%rbp)
jmp 0x16a03
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_libc.c
// Function: vmir_fd_create
int
vmir_fd_create(ir_unit_t *iu, intptr_t handle, int type,
               vmir_fd_release_t *relfunc)
{
  int fd = vfd_create(iu, type);
  vmir_fd_t *vfd = &VECTOR_ITEM(&iu->iu_vfds, fd);
  vfd->fh = handle;
  vfd->release = relfunc;
  return fd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x16a70
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rax
movslq -0x24(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_libc.c
// Function: vfd_create
static int
vfd_create(ir_unit_t *iu, int type)
{
  int fd = iu->iu_vfd_free;

  if(fd != -1) {
    iu->iu_vfd_free = VECTOR_ITEM(&iu->iu_vfds, fd).freelist;
  } else {
    fd = VECTOR_LEN(&iu->iu_vfds);
    vmir_fd_t vfd = {};
    VECTOR_PUSH_BACK(&iu->iu_vfds, vfd);
  }
  VECTOR_ITEM(&iu->iu_vfds, fd).type = type;
  return fd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0xe8(%rax), %eax
movl %eax, -0x10(%rbp)
cmpl $-0x1, -0x10(%rbp)
je 0x16ab9
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rax
movslq -0x10(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xe8(%rax)
jmp 0x16b82
movq -0x8(%rbp), %rax
movq 0xd8(%rax), %rax
movl %eax, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x31f0
movq -0x8(%rbp), %rax
movq 0xd8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq -0x8(%rbp), %rcx
cmpq 0xe0(%rcx), %rax
jbe 0x16b43
movq -0x30(%rbp), %rcx
addq $0x1, %rcx
shlq %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xe0(%rax)
movq -0x8(%rbp), %rax
imulq $0x18, 0xe0(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rdi
movq -0x38(%rbp), %rsi
callq 0x3390
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xd0(%rax)
movq -0x30(%rbp), %rcx
addq $0x1, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xd8(%rax)
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rax
imulq $0x18, -0x30(%rbp), %rcx
addq %rcx, %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
jmp 0x16b82
movl -0xc(%rbp), %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rax
movslq -0x10(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movb %cl, 0x10(%rax)
movl -0x10(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_libc.c
// Function: vmir_fd_close
void
vmir_fd_close(ir_unit_t *iu, int fd)
{
  vmir_fd_t *vfd = vfd_get(iu, fd, -1);
  if(vfd == NULL)
    return;
  if(vfd->release)
    vfd->release(iu, vfd->fh);
  vfd->type = 0;
  vfd->freelist = iu->iu_vfd_free;
  iu->iu_vfd_free = fd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x16990
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x16c5d
jmp 0x16ca2
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x16c7d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rcx
movq (%rcx), %rsi
callq *%rax
movq -0x18(%rbp), %rax
movb $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movl 0xe8(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xe8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_libc.c
// Function: vmir_function_tab_lookup
vm_ext_function_t *
vmir_function_tab_lookup(const char *function,
                         const vmir_function_tab_t *array, int length)
{
  for(int i = 0; i < length; i++) {
    const vmir_function_tab_t *ft = array + i;
    if(!strcmp(function, ft->name)) {
      return ft->extfunc;
    }
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x16d15
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
callq 0x32d0
cmpl $0x0, %eax
jne 0x16d08
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x16d1d
jmp 0x16d0a
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x16cca
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_libc.c
// Function: vmir_walk_fds
void
vmir_walk_fds(ir_unit_t *iu,
              void (*fn)(void *opaque, int fd, int type),
              void *opaque)
{
  for(int i = 0; i < VECTOR_LEN(&iu->iu_vfds); i++) {
    vmir_fd_t *vfd = &VECTOR_ITEM(&iu->iu_vfds, i);
    if(vfd->type != 0)
      fn(opaque, i, vfd->type);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0xd8(%rcx), %rax
jae 0x16df5
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x0, %eax
je 0x16de8
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x28(%rbp), %rcx
movzbl 0x10(%rcx), %edx
callq *%rax
jmp 0x16dea
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x16d9b
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_libc.c
// Function: vmir_heap_malloc
static void *
vmir_heap_malloc(ir_unit_t *iu, int size)
{
  heap_t *h = iu->iu_heap;
  heap_block_t *hb;
  size += sizeof(heap_block_t);
  size = VMIR_ALIGN(size, 16);

  TAILQ_FOREACH(hb, &h->h_blocks, hb_link) {
    if(hb->hb_magic != HEAP_MAGIC_FREE)
      continue;

    if(size <= hb->hb_size) {
      int remain = hb->hb_size - size;
      if(remain < sizeof(heap_block_t) * 2) {
        size = hb->hb_size;
      } else {
        heap_block_t *split = (void *)hb + size;
        split->hb_magic = HEAP_MAGIC_FREE;
        split->hb_size = remain;
        TAILQ_INSERT_AFTER(&h->h_blocks, hb, split, hb_link);
      }

      hb->hb_magic = HEAP_MAGIC_ALLOC;
      hb->hb_size = size;
      return (void *)(hb + 1);
    }
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x20(%rbp)
movslq -0x14(%rbp), %rax
addq $0x18, %rax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $0x10, %eax
subl $0x1, %eax
andl $-0x10, %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x16f40
movq -0x28(%rbp), %rax
cmpl $0xf4eef4ee, (%rax)     # imm = 0xF4EEF4EE
je 0x16e5b
jmp 0x16f2f
movl -0x14(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jg 0x16f2d
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
subl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
movslq -0x2c(%rbp), %rax
cmpq $0x30, %rax
jae 0x16e8e
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0x16f0b
movq -0x28(%rbp), %rax
movslq -0x14(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl $0xf4eef4ee, (%rax)     # imm = 0xF4EEF4EE
movl -0x2c(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x38(%rbp), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
je 0x16edd
movq -0x38(%rbp), %rcx
addq $0x8, %rcx
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
jmp 0x16eed
movq -0x38(%rbp), %rcx
addq $0x8, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
addq $0x8, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x16f0b
movq -0x28(%rbp), %rax
movl $0xa110ced, (%rax)      # imm = 0xA110CED
movl -0x14(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x28(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x8(%rbp)
jmp 0x16f48
jmp 0x16f2f
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x16e3f
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop