LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Cyan4973[P]FiniteStateEntropy/programs/probaGenerator.c
// Function: generate
static void generate(void* buffer, size_t buffSize, double p)
{
    char table[PROBATABLESIZE] = { 0 };
    int remaining = PROBATABLESIZE;
    unsigned pos = 0;
    unsigned s = 0;
    char* op = (char*) buffer;
    char* oend = op + buffSize;
    unsigned seed = 1;

    if (p==0.0) p=0.005;
    DISPLAY("Generating %u KB with P=%.2f%%\n", (unsigned)(buffSize >> 10), p*100);

    /* Build Table */
    while (remaining)
    {
        unsigned n = (unsigned)(remaining * p);
        unsigned end;
        if (!n) n=1;
        end = pos + n;
        while (pos<end) table[pos++]=(char)s;
        s++;
        remaining -= n;
    }

    /* Fill buffer */
    while (op<oend)
    {
        const unsigned r = GEN_rand(&seed) & (PROBATABLESIZE-1);
        *op++ = table[r];
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1050, %rsp           # imm = 0x1050
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
leaq -0x1020(%rbp), %rdi
xorl %esi, %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0x1050
movl $0x1000, -0x1024(%rbp)  # imm = 0x1000
movl $0x0, -0x1028(%rbp)
movl $0x0, -0x102c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1038(%rbp)
movq -0x1038(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x1040(%rbp)
movl $0x1, -0x1044(%rbp)
movsd -0x18(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x130d
jp 0x130d
movsd 0xd00(%rip), %xmm0      # 0x2008
movsd %xmm0, -0x18(%rbp)
movq 0x2ce4(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
shrq $0xa, %rax
movl %eax, %edx
movsd 0xce7(%rip), %xmm0      # 0x2010
mulsd -0x18(%rbp), %xmm0
leaq 0xd31(%rip), %rsi       # 0x2066
movb $0x1, %al
callq 0x1070
cmpl $0x0, -0x1024(%rbp)
je 0x13e4
cvtsi2sdl -0x1024(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
movl %eax, -0x1048(%rbp)
cmpl $0x0, -0x1048(%rbp)
jne 0x1378
movl $0x1, -0x1048(%rbp)
movl -0x1028(%rbp), %eax
addl -0x1048(%rbp), %eax
movl %eax, -0x104c(%rbp)
movl -0x1028(%rbp), %eax
cmpl -0x104c(%rbp), %eax
jae 0x13bc
movl -0x102c(%rbp), %eax
movb %al, %cl
movl -0x1028(%rbp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, -0x1028(%rbp)
movl %eax, %eax
movb %cl, -0x1020(%rbp,%rax)
jmp 0x138a
movl -0x102c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x102c(%rbp)
movl -0x1048(%rbp), %ecx
movl -0x1024(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x1024(%rbp)
jmp 0x133c
jmp 0x13e6
movq -0x1038(%rbp), %rax
cmpq -0x1040(%rbp), %rax
jae 0x1433
leaq -0x1044(%rbp), %rdi
callq 0x15d0
andl $0xfff, %eax            # imm = 0xFFF
movl %eax, -0x1050(%rbp)
movl -0x1050(%rbp), %eax
movb -0x1020(%rbp,%rax), %cl
movq -0x1038(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x1038(%rbp)
movb %cl, (%rax)
jmp 0x13e6
addq $0x1050, %rsp           # imm = 0x1050
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Cyan4973[P]FiniteStateEntropy/programs/probaGenerator.c
// Function: main
int main(int argc, char** argv)
{
    char* n;
    double proba = 0.;
    char  filename[] = "proba.bin";

    g_programName = argv[0];
    DISPLAY("Binary file generator\n");
    if (argc<2) badusage();

    n = argv[1];
    if ((*n>='0') && (*n<='9')) { proba += *n-'0'; n++; }
    if ((*n>='0') && (*n<='9')) { proba*=10; proba += *n-'0'; n++; }
    proba /= 100;

    createSampleFile(filename, proba);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movq 0xbe0(%rip), %rax       # 0x2045
movq %rax, -0x2a(%rbp)
movw 0xbdd(%rip), %ax        # 0x204d
movw %ax, -0x22(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, 0x2c06(%rip)      # 0x4088
movq 0x2b6f(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xbbc(%rip), %rsi       # 0x204f
movb $0x0, %al
callq 0x1070
cmpl $0x2, -0x8(%rbp)
jge 0x14a5
callq 0x1570
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0x14ed
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
jg 0x14ed
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
subl $0x30, %eax
cvtsi2sd %eax, %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0x153b
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
jg 0x153b
movsd 0xb0b(%rip), %xmm0      # 0x2018
mulsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
subl $0x30, %eax
cvtsi2sd %eax, %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movsd -0x20(%rbp), %xmm0
movsd 0xac8(%rip), %xmm1      # 0x2010
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
leaq -0x2a(%rbp), %rdi
movsd -0x20(%rbp), %xmm0
callq 0x11d0
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cyan4973[P]FiniteStateEntropy/programs/probaGenerator.c
// Function: badusage
static int badusage(void)
{
    DISPLAYLEVEL(1, "Incorrect parameters\n");
    if (displayLevel >= 1) usage();
    DISPLAY("Press enter to exit \n");
    getchar();
    exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x1, 0x2afd(%rip)      # 0x4078
jl 0x1595
movq 0x2a74(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xaf8(%rip), %rsi       # 0x2086
movb $0x0, %al
callq 0x1070
cmpl $0x1, 0x2adc(%rip)      # 0x4078
jl 0x15a3
callq 0x1600
movq 0x2a4e(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xae8(%rip), %rsi       # 0x209c
movb $0x0, %al
callq 0x1070
callq 0x1060
movl $0x1, %edi
callq 0x10b0
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cyan4973[P]FiniteStateEntropy/programs/probaGenerator.c
// Function: usage
static int usage(void)
{
    DISPLAY("Usage :\n");
    DISPLAY("%s P%%\n", g_programName);
    DISPLAY("Example :\n");
    DISPLAY("%s 70%%\n", g_programName);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x29ed(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xa9d(%rip), %rsi       # 0x20b2
movb $0x0, %al
callq 0x1070
movq 0x29d5(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq 0x2a5b(%rip), %rdx      # 0x4088
leaq 0xa87(%rip), %rsi       # 0x20bb
movb $0x0, %al
callq 0x1070
movq 0x29b6(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xa77(%rip), %rsi       # 0x20c3
movb $0x0, %al
callq 0x1070
movq 0x299e(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq 0x2a24(%rip), %rdx      # 0x4088
leaq 0xa63(%rip), %rsi       # 0x20ce
movb $0x0, %al
callq 0x1070
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/truenas[P]binaries/src/ixnvdimm.c
// Function: usage
static void
usage(const char *progname)
{

	fprintf(stderr, "usage: %s {nvdimm}\n", progname);
	fprintf(stderr, "       %s -F {nvdimm}\n", progname);
	fprintf(stderr, "       %s -d {nvdimm}\n", progname);
	fprintf(stderr, "       %s -f {firmware} [-I] {nvdimm}\n", progname);
	fprintf(stderr, "       %s -r [-h] {nvdimm} [{page} [{off}] | {reg}]\n", progname);
	fprintf(stderr, "       %s -w [-h] {nvdimm} ({page} {off} | {reg}) {val}\n", progname);
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x74f5(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x3643(%rip), %rsi      # 0x6154
movb $0x0, %al
callq 0x2110
movq 0x74d9(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x363b(%rip), %rsi      # 0x6168
movb $0x0, %al
callq 0x2110
movq 0x74bd(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x3636(%rip), %rsi      # 0x617f
movb $0x0, %al
callq 0x2110
movq 0x74a1(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x3631(%rip), %rsi      # 0x6196
movb $0x0, %al
callq 0x2110
movq 0x7485(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x363c(%rip), %rsi      # 0x61bd
movb $0x0, %al
callq 0x2110
movq 0x7469(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x3655(%rip), %rsi      # 0x61f2
movb $0x0, %al
callq 0x2110
movl $0x1, %edi
callq 0x2190
nop
// File: /workspace/github_c_makefile_star2_O0/truenas[P]binaries/src/ixnvdimm.c
// Function: getinfo
static int
getinfo(int fd, struct ixnvdimm_info *info)
{
	uint16_t t16;

	/*
	 * Linux converts all the values from big-endian.
	 * I am not sure what is right, just stay consistent.
	 */
	t16 = readsysfs("vendor");
	info->VendorId = be16dec(&t16);
	t16 = readsysfs("device");
	info->DeviceId = be16dec(&t16);
	t16 = readsysfs("rev_id");
	info->RevisionId = be16dec(&t16);
	t16 = readsysfs("subsystem_vendor");
	info->SubsystemVendorId = be16dec(&t16);
	t16 = readsysfs("subsystem_device");
	info->SubsystemDeviceId = be16dec(&t16);
	t16 = readsysfs("subsystem_rev_id");
	info->SubsystemRevisionId = be16dec(&t16);
	info->SerialNumber = readsysfs("serial");
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x361f(%rip), %rdi      # 0x6235
callq 0x2d10
movw %ax, -0x12(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x5240
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, (%rax)
leaq 0x360d(%rip), %rdi      # 0x6246
callq 0x2d10
movw %ax, -0x12(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x5240
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x2(%rax)
leaq 0x35fa(%rip), %rdi      # 0x6257
callq 0x2d10
movw %ax, -0x12(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x5240
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x4(%rax)
leaq 0x35aa(%rip), %rdi      # 0x622b
callq 0x2d10
movw %ax, -0x12(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x5240
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x6(%rax)
leaq 0x3597(%rip), %rdi      # 0x623c
callq 0x2d10
movw %ax, -0x12(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x5240
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x8(%rax)
leaq 0x3584(%rip), %rdi      # 0x624d
callq 0x2d10
movw %ax, -0x12(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x5240
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0xa(%rax)
leaq 0x3571(%rip), %rdi      # 0x625e
callq 0x2d10
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/truenas[P]binaries/src/ixnvdimm.c
// Function: readsysfs
static uint32_t
readsysfs(const char *attr)
{
	char path[256];
	char buf[16];
	int fd, n;

	snprintf(path, sizeof(path), "/sys/bus/nd/devices/%s/nfit/%s",
	    nmem, attr);
	fd = open(path, O_RDONLY|O_CLOEXEC);
	if (fd < 0)
		err(EX_NOINPUT, "Can't open %s", path);
	n = read(fd, buf, sizeof(buf));
	close(fd);
	if (n < 0 || n >= sizeof(buf))
		err(EX_NOINPUT, "failed to read %s\n", path);
	buf[n] = 0;
	if (n && buf[n - 1] == '\n')
		buf[n - 1] = 0;
        return (strtoul(buf, NULL, 0));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
leaq -0x110(%rbp), %rdi
movq 0x802b(%rip), %rcx      # 0xad58
movq -0x8(%rbp), %r8
movl $0x100, %esi            # imm = 0x100
leaq 0x3528(%rip), %rdx      # 0x6265
movb $0x0, %al
callq 0x20a0
leaq -0x110(%rbp), %rdi
movl $0x80000, %esi          # imm = 0x80000
movb $0x0, %al
callq 0x2160
movl %eax, -0x124(%rbp)
cmpl $0x0, -0x124(%rbp)
jge 0x2d80
leaq -0x110(%rbp), %rdx
movl $0x42, %edi
leaq 0x335c(%rip), %rsi      # 0x60d5
movb $0x0, %al
callq 0x2140
movl -0x124(%rbp), %edi
leaq -0x120(%rbp), %rsi
movl $0x10, %edx
callq 0x20f0
movl %eax, -0x128(%rbp)
movl -0x124(%rbp), %edi
callq 0x20e0
cmpl $0x0, -0x128(%rbp)
jl 0x2dbe
movslq -0x128(%rbp), %rax
cmpq $0x10, %rax
jb 0x2dd8
leaq -0x110(%rbp), %rdx
movl $0x42, %edi
leaq 0x34b3(%rip), %rsi      # 0x6284
movb $0x0, %al
callq 0x2140
movslq -0x128(%rbp), %rax
movb $0x0, -0x120(%rbp,%rax)
cmpl $0x0, -0x128(%rbp)
je 0x2e1b
movl -0x128(%rbp), %eax
subl $0x1, %eax
cltq
movsbl -0x120(%rbp,%rax), %eax
cmpl $0xa, %eax
jne 0x2e1b
movl -0x128(%rbp), %eax
subl $0x1, %eax
cltq
movb $0x0, -0x120(%rbp,%rax)
leaq -0x120(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x2180
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/truenas[P]binaries/src/ixnvdimm.c
// Function: i2c_read
static uint8_t
i2c_read(int fd, uint8_t page, uint8_t off)
{
	uint8_t in_buf[2], out_buf[5];
	uint32_t status;

	in_buf[0] = page;
	in_buf[1] = off;
	if (calldsm(fd, 27, in_buf, sizeof(in_buf), out_buf, sizeof(out_buf)) < 5)
		err(EX_IOERR, "Can't read i2c (%0x, %0x)", page, off);
	status = le32dec(&out_buf[0]);
	if (status != 0)
		errx(EX_IOERR, "i2c read error (%0x, %0x): %x", page, off, status);
	return (out_buf[4]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movb %sil, %cl
movl %edi, -0x4(%rbp)
movb %cl, -0x5(%rbp)
movb %al, -0x6(%rbp)
movb -0x5(%rbp), %al
movb %al, -0x8(%rbp)
movb -0x6(%rbp), %al
movb %al, -0x7(%rbp)
movl -0x4(%rbp), %edi
leaq -0x8(%rbp), %rdx
leaq -0xd(%rbp), %r8
movl $0x1b, %esi
movl $0x2, %ecx
movl $0x5, %r9d
callq 0x5270
cmpq $0x5, %rax
jge 0x2ea3
movzbl -0x5(%rbp), %edx
movzbl -0x6(%rbp), %ecx
movl $0x4a, %edi
leaq 0x33fb(%rip), %rsi      # 0x6297
movb $0x0, %al
callq 0x2140
leaq -0xd(%rbp), %rdi
callq 0x5370
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x2ed4
movzbl -0x5(%rbp), %edx
movzbl -0x6(%rbp), %ecx
movl -0x14(%rbp), %r8d
movl $0x4a, %edi
leaq 0x33e4(%rip), %rsi      # 0x62b1
movb $0x0, %al
callq 0x2070
movb -0x9(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/truenas[P]binaries/src/ixnvdimm.c
// Function: factory_default
static void
factory_default(int fd)
{
	uint8_t status[4];

	/* Factory default via DSM. */
	i2c_write(fd, 0, NVDIMM_MGT_CMD1, 1 << 1);
	memset(&status, 0xff, sizeof(status));
	if (calldsm(fd, 21, NULL, 0, status, sizeof(status)) != 4)
		err(EX_NOINPUT, "Can't call Reset to Factory Defaults DSM");
	if (le32dec(&status[0]) != 0)
		errx(EX_NOINPUT, "Reset to Factory Defaults DSM failed: %x",
		    le32dec(&status[0]));
	printf("Reset to Factory Defaults succeeded\n");
	fflush(stdout);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
xorl %esi, %esi
movl $0x41, %edx
movl $0x2, %ecx
callq 0x4280
leaq -0x8(%rbp), %rdi
movl $0xff, %esi
movl $0x4, %edx
callq 0x20c0
movl -0x4(%rbp), %edi
leaq -0x8(%rbp), %r8
movl $0x15, %esi
xorl %eax, %eax
movl %eax, %ecx
movl $0x4, %r9d
movq %rcx, %rdx
callq 0x5270
cmpq $0x4, %rax
je 0x2f49
movl $0x42, %edi
leaq 0x338d(%rip), %rsi      # 0x62cf
movb $0x0, %al
callq 0x2140
leaq -0x8(%rbp), %rdi
callq 0x5370
cmpl $0x0, %eax
je 0x2f75
leaq -0x8(%rbp), %rdi
callq 0x5370
movl %eax, %edx
movl $0x42, %edi
leaq 0x338a(%rip), %rsi      # 0x62f8
movb $0x0, %al
callq 0x2070
leaq 0x33a5(%rip), %rdi      # 0x6321
movb $0x0, %al
callq 0x2080
movq 0x703e(%rip), %rax      # 0x9fc8
movq (%rax), %rdi
callq 0x2150
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/truenas[P]binaries/src/ixnvdimm.c
// Function: reg_parse
static int
reg_parse(const char *name, int *page, int *off, int *size)
{
	int i, l, o = -1;

	for (i = 0; regs[i].name != NULL; i++) {
		l = strlen(regs[i].name);
		if (strncmp(name, regs[i].name, l) != 0)
			continue;
		if (name[l] == 0)
			break;
		if (name[l] - '0' < regs[i].size) {
			o = name[l] - '0';
			break;
		}
	}
	if (regs[i].name == NULL)
		return (0);
	*page = regs[i].page;
	if (o >= 0) {
		*off = regs[i].off + o;
		*size = 1;
	} else {
		*off = regs[i].off;
		*size = regs[i].size;
	}
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0xffffffff, -0x34(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x2c(%rbp)
movslq -0x2c(%rbp), %rcx
leaq 0x604f(%rip), %rax      # 0xa0f0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x10(%rax)
je 0x4158
movslq -0x2c(%rbp), %rcx
leaq 0x6032(%rip), %rax      # 0xa0f0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
callq 0x2060
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x2c(%rbp), %rcx
leaq 0x6010(%rip), %rax      # 0xa0f0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rsi
movslq -0x30(%rbp), %rdx
callq 0x2040
cmpl $0x0, %eax
je 0x40fb
jmp 0x414a
movq -0x10(%rbp), %rax
movslq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x410e
jmp 0x4158
movq -0x10(%rbp), %rax
movslq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %eax
subl $0x30, %eax
movslq -0x2c(%rbp), %rdx
leaq 0x5fc8(%rip), %rcx      # 0xa0f0
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x8(%rcx), %eax
jge 0x4148
movq -0x10(%rbp), %rax
movslq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %eax
subl $0x30, %eax
movl %eax, -0x34(%rbp)
jmp 0x4158
jmp 0x414a
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x4096
movslq -0x2c(%rbp), %rcx
leaq 0x5f8d(%rip), %rax      # 0xa0f0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x10(%rax)
jne 0x417d
movl $0x0, -0x4(%rbp)
jmp 0x4204
movslq -0x2c(%rbp), %rcx
leaq 0x5f68(%rip), %rax      # 0xa0f0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
cmpl $0x0, -0x34(%rbp)
jl 0x41c7
movslq -0x2c(%rbp), %rcx
leaq 0x5f48(%rip), %rax      # 0xa0f0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %ecx
addl -0x34(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movl $0x1, (%rax)
jmp 0x41fd
movslq -0x2c(%rbp), %rcx
leaq 0x5f1e(%rip), %rax      # 0xa0f0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movslq -0x2c(%rbp), %rcx
leaq 0x5f03(%rip), %rax      # 0xa0f0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/truenas[P]binaries/src/ixnvdimm.c
// Function: i2c_write
static void
i2c_write(int fd, uint8_t page, uint8_t off, uint8_t val)
{
	uint8_t in_buf[3], out_buf[4];
	uint32_t status;

	in_buf[0] = page;
	in_buf[1] = off;
	in_buf[2] = val;
	if (calldsm(fd, 28, in_buf, sizeof(in_buf), out_buf, sizeof(out_buf)) < 4)
		err(EX_IOERR, "Can't write i2c (%0x, %0x)", page, off);
	status = le32dec(&out_buf[0]);
	if (status != 0)
		errx(EX_IOERR, "i2c write error (%0x, %0x): %x", page, off, status);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movb %dl, %cl
movb %sil, %dl
movl %edi, -0x4(%rbp)
movb %dl, -0x5(%rbp)
movb %cl, -0x6(%rbp)
movb %al, -0x7(%rbp)
movb -0x5(%rbp), %al
movb %al, -0xa(%rbp)
movb -0x6(%rbp), %al
movb %al, -0x9(%rbp)
movb -0x7(%rbp), %al
movb %al, -0x8(%rbp)
movl -0x4(%rbp), %edi
leaq -0xa(%rbp), %rdx
leaq -0xe(%rbp), %r8
movl $0x1c, %esi
movl $0x3, %ecx
movl $0x4, %r9d
callq 0x5270
cmpq $0x4, %rax
jge 0x42ee
movzbl -0x5(%rbp), %edx
movzbl -0x6(%rbp), %ecx
movl $0x4a, %edi
leaq 0x3189(%rip), %rsi      # 0x7470
movb $0x0, %al
callq 0x2140
leaq -0xe(%rbp), %rdi
callq 0x5370
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x431f
movzbl -0x5(%rbp), %edx
movzbl -0x6(%rbp), %ecx
movl -0x14(%rbp), %r8d
movl $0x4a, %edi
leaq 0x3173(%rip), %rsi      # 0x748b
movb $0x0, %al
callq 0x2070
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/truenas[P]binaries/src/ixnvdimm.c
// Function: calldsm
static ssize_t
calldsm(int fd, int func, void *in_buf, size_t in_size, void *out_buf,
    size_t out_size)
{
	struct nd_cmd_pkg *pkg;
	uint32_t fw_size;

	pkg = calloc(1, sizeof(*pkg) + in_size + out_size);
	pkg->nd_family = NVDIMM_FAMILY_MSFT;
	pkg->nd_command = func;
	pkg->nd_size_in = in_size;
	pkg->nd_size_out = out_size;
	pkg->nd_fw_size = 0;
	if (in_size)
		memcpy(&pkg->nd_payload[0], in_buf, in_size);
	if (ioctl(fd, ND_IOCTL_CALL, pkg) != 0)
		return (-1);
	fw_size = pkg->nd_fw_size;
	if (out_size)
		memcpy(out_buf, &pkg->nd_payload[in_size], out_size);
	free(pkg);
	return (fw_size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x20(%rbp), %rsi
addq $0x40, %rsi
addq -0x30(%rbp), %rsi
movl $0x1, %edi
callq 0x2100
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq $0x3, (%rax)
movslq -0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x30(%rbp), %rax
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x38(%rbp), %rax
movl $0x0, 0x3c(%rax)
cmpq $0x0, -0x20(%rbp)
je 0x5300
movq -0x38(%rbp), %rdi
addq $0x40, %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2130
movl -0xc(%rbp), %edi
movq -0x38(%rbp), %rdx
movl $0xc0404e0a, %esi       # imm = 0xC0404E0A
movb $0x0, %al
callq 0x20d0
cmpl $0x0, %eax
je 0x5322
movq $-0x1, -0x8(%rbp)
jmp 0x535c
movq -0x38(%rbp), %rax
movl 0x3c(%rax), %eax
movl %eax, -0x3c(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x534c
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rsi
addq $0x40, %rsi
addq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x2130
movq -0x38(%rbp), %rdi
callq 0x2030
movl -0x3c(%rbp), %eax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/truenas[P]binaries/src/ixnvdimm.c
// Function: Crc16
static int
Crc16(char *ptr, int count)
{
	int crc, i;

	crc = 0;
	while (--count >= 0) {
		crc = crc ^ (int)*ptr++ << 8;
		for (i = 0; i < 8; ++i) {
			if (crc & 0x8000) {
				crc = crc << 1 ^ 0x1021;
			} else {
				crc = crc << 1;
			}
		}
	}
	return (crc & 0xFFFF);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
jl 0x54fd
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movsbl (%rcx), %ecx
shll $0x8, %ecx
xorl %ecx, %eax
movl %eax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x8, -0x14(%rbp)
jge 0x54fb
movl -0x10(%rbp), %eax
andl $0x8000, %eax           # imm = 0x8000
cmpl $0x0, %eax
je 0x54e6
movl -0x10(%rbp), %eax
shll %eax
xorl $0x1021, %eax           # imm = 0x1021
movl %eax, -0x10(%rbp)
jmp 0x54ee
movl -0x10(%rbp), %eax
shll %eax
movl %eax, -0x10(%rbp)
jmp 0x54f0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x54c4
jmp 0x5492
movl -0x10(%rbp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/truenas[P]binaries/src/ixnvdimm.c
// Function: le32enc
static __inline void
le32enc(void *pp, uint32_t u)
{
        uint8_t *p = (uint8_t *)pp;

        p[0] = u & 0xff;
        p[1] = (u >> 8) & 0xff;
        p[2] = (u >> 16) & 0xff;
        p[3] = (u >> 24) & 0xff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movl -0xc(%rbp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0xc(%rbp), %eax
shrl $0x10, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x2(%rax)
movl -0xc(%rbp), %eax
shrl $0x18, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x3(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/perftests/serverpool/main.c
// Function: main
int
main(int argc, char * argv[])
{
	struct serverpool * SP;

	WARNP_INIT;

	/* Sanity-check. */
	if (argc != 2) {
		fprintf(stderr, "usage: test_serverpool %s\n", "<target>");
		exit(1);
	}

	/* Fork off a process to perform DNS lookups. */
	if ((SP = serverpool_create(argv[1], 5, 30)) == NULL) {
		warnp("Error launching DNS lookups");
		exit(1);
	}

	/* Call back every second for 2 minutes. */
	ticksleft = 120;
	done = 0;
	if (events_timer_register_double(callback_tick, SP, 1) == NULL) {
		warnp("events_timer_register_double");
		exit(1);
	}

	/* Wait until we're done. */
	if (events_spin(&done)) {
		warnp("Error in event loop");
		exit(1);
	}

	/* Shut down the DNS lookups. */
	serverpool_free(SP);

	/* Success! */
	exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x24bc
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x6500
jmp 0x24be
cmpl $0x2, -0x8(%rbp)
je 0x24ed
movq 0xbb2d(%rip), %rax      # 0xdff8
movq (%rax), %rdi
leaq 0x7b3b(%rip), %rsi      # 0xa010
leaq 0x7b4f(%rip), %rdx      # 0xa02b
movb $0x0, %al
callq 0x21f0
movl $0x1, %edi
callq 0x22f0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x5, %esi
movl $0x1e, %edx
callq 0x6a50
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x254f
jmp 0x2510
callq 0x20a0
cmpl $0x0, (%rax)
je 0x2535
leaq 0x7b13(%rip), %rdi      # 0xa034
movb $0x0, %al
callq 0x65c0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x2543
leaq 0x7af8(%rip), %rdi      # 0xa034
movb $0x0, %al
callq 0x6810
jmp 0x2545
movl $0x1, %edi
callq 0x22f0
movl $0x78, 0xbf5b(%rip)     # 0xe4b4
movl $0x0, 0xbf55(%rip)      # 0xe4b8
movq -0x18(%rbp), %rsi
leaq 0xc2(%rip), %rdi        # 0x2630
movsd 0x7a92(%rip), %xmm0     # 0xa008
callq 0x4340
cmpq $0x0, %rax
jne 0x25c2
jmp 0x2583
callq 0x20a0
cmpl $0x0, (%rax)
je 0x25a8
leaq 0x7abc(%rip), %rdi      # 0xa050
movb $0x0, %al
callq 0x65c0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x25b6
leaq 0x7aa1(%rip), %rdi      # 0xa050
movb $0x0, %al
callq 0x6810
jmp 0x25b8
movl $0x1, %edi
callq 0x22f0
leaq 0xbeef(%rip), %rdi      # 0xe4b8
callq 0x2a50
cmpl $0x0, %eax
je 0x2614
jmp 0x25d5
callq 0x20a0
cmpl $0x0, (%rax)
je 0x25fa
leaq 0x7a87(%rip), %rdi      # 0xa06d
movb $0x0, %al
callq 0x65c0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x2608
leaq 0x7a6c(%rip), %rdi      # 0xa06d
movb $0x0, %al
callq 0x6810
jmp 0x260a
movl $0x1, %edi
callq 0x22f0
movq -0x18(%rbp), %rdi
callq 0x74f0
xorl %edi, %edi
callq 0x22f0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/perftests/serverpool/main.c
// Function: callback_tick
static int
callback_tick(void * cookie)
{
	struct serverpool * SP = cookie;
	struct sock_addr * sa;
	char * s;

	/* Get an address from the pool. */
	if ((sa = serverpool_pick(SP)) == NULL) {
		warnp("serverpool_pick");
		goto err0;
	}

	/* Pretty-print it. */
	if ((s = sock_addr_prettyprint(sa)) == NULL) {
		warnp("sock_addr_prettyprint");
		goto err1;
	}
	printf("%s\n", s);

	/* Free string and address. */
	free(s);
	sock_addr_free(sa);

	/* Are we done yet? */
	if (--ticksleft > 0) {
		/* Schedule another callback. */
		if (events_timer_register_double(callback_tick, SP, 1)
		    == NULL) {
			warnp("events_timer_register_double");
			goto err0;
		}
	} else {
		/* We're done. */
		done = 1;
	}

	/* Success! */
	return (0);

err1:
	sock_addr_free(sa);
err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x72e0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x2693
jmp 0x2659
callq 0x20a0
cmpl $0x0, (%rax)
je 0x267e
leaq 0x7a17(%rip), %rdi      # 0xa081
movb $0x0, %al
callq 0x65c0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x268c
leaq 0x79fc(%rip), %rdi      # 0xa081
movb $0x0, %al
callq 0x6810
jmp 0x268e
jmp 0x278f
movq -0x20(%rbp), %rdi
callq 0x60f0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x26e2
jmp 0x26a8
callq 0x20a0
cmpl $0x0, (%rax)
je 0x26cd
leaq 0x79d8(%rip), %rdi      # 0xa091
movb $0x0, %al
callq 0x65c0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x26db
leaq 0x79bd(%rip), %rdi      # 0xa091
movb $0x0, %al
callq 0x6810
jmp 0x26dd
jmp 0x2786
movq -0x28(%rbp), %rsi
leaq 0x815c(%rip), %rdi      # 0xa849
movb $0x0, %al
callq 0x2150
movq -0x28(%rbp), %rdi
callq 0x2040
movq -0x20(%rbp), %rdi
callq 0x5540
movl 0xbda8(%rip), %eax      # 0xe4b4
addl $-0x1, %eax
movl %eax, 0xbd9f(%rip)      # 0xe4b4
cmpl $0x0, %eax
jle 0x2773
movq -0x18(%rbp), %rsi
leaq -0xf5(%rip), %rdi       # 0x2630
movsd 0x78db(%rip), %xmm0     # 0xa008
callq 0x4340
cmpq $0x0, %rax
jne 0x2771
jmp 0x273a
callq 0x20a0
cmpl $0x0, (%rax)
je 0x275f
leaq 0x7905(%rip), %rdi      # 0xa050
movb $0x0, %al
callq 0x65c0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x276d
leaq 0x78ea(%rip), %rdi      # 0xa050
movb $0x0, %al
callq 0x6810
jmp 0x276f
jmp 0x278f
jmp 0x277d
movl $0x1, 0xbd3b(%rip)      # 0xe4b8
movl $0x0, -0x4(%rbp)
jmp 0x2796
movq -0x20(%rbp), %rdi
callq 0x5540
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/events/events.c
// Function: events_mkrec
struct eventrec *
events_mkrec(int (* func)(void *), void * cookie)
{
	struct eventrec * r;

	/* Allocate structure. */
	if ((r = mpool_eventrec_malloc()) == NULL)
		goto err0;

	/* Initialize. */
	r->func = func;
	r->cookie = cookie;

	/* Success! */
	return (r);

err0:
	/* Failure! */
	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
callq 0x2800
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x27c1
jmp 0x27e2
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x27ea
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/events/events.c
// Function: events_spin
int
events_spin(const int * done)
{
	int rc = 0;

	/* Loop until we're done or have a non-zero status. */
	while ((done[0] == 0) && (rc == 0) && (interrupt_requested == 0)) {
		/* Run events. */
		rc = events_run_internal();
	}

	/* Reset interrupt_requested after quitting the loop. */
	interrupt_requested = 0;

	/* Return status code. */
	return (rc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpl $0x0, (%rcx)
movb %al, -0xd(%rbp)
jne 0x2a8b
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0xd(%rbp)
jne 0x2a8b
movl 0xba3e(%rip), %eax      # 0xe4c0
cmpl $0x0, %eax
sete %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
testb $0x1, %al
jne 0x2a94
jmp 0x2a9e
callq 0x28a0
movl %eax, -0xc(%rbp)
jmp 0x2a63
movl $0x0, 0xba18(%rip)      # 0xe4c0
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/datastruct/mpool.h
// Function: mpool_malloc
static inline void *
mpool_malloc(struct mpool * M, size_t len)
{

	/* Count the total number of allocation requests. */
	M->nallocs++;

	/* If we have an object on the stack, use that. */
	if (M->stacklen)
		return (M->allocs[--(M->stacklen)]);

	/* Count allocation requests where the pool was already empty. */
	M->nempties++;

	/* Initialize the atexit function (the first time we reach here). */
	if (M->state == 0) {
		atexit(M->atexitfunc);
		M->state = 1;
	}

	/* Allocate a new object. */
	return (malloc(len));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2b2e
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rdx
movq (%rdx), %rcx
movq %rcx, %rsi
addq $-0x1, %rsi
movq %rsi, (%rdx)
movq -0x8(%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x2b6d
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x28(%rax)
jne 0x2b60
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x9380
movq -0x10(%rbp), %rax
movl $0x1, 0x28(%rax)
movq -0x18(%rbp), %rdi
callq 0x2240
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/datastruct/mpool.h
// Function: mpool_atexit
static inline void
mpool_atexit(struct mpool * M)
{

	/* Free all items on the stack. */
	while (M->stacklen)
		free(M->allocs[--M->stacklen]);

	/* If we allocated a stack, free it. */
	if (M->allocs != M->allocs_static)
		free(M->allocs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2bdb
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rdx
movq (%rdx), %rcx
movq %rcx, %rsi
addq $-0x1, %rsi
movq %rsi, (%rdx)
movq -0x8(%rax,%rcx,8), %rdi
callq 0x2040
jmp 0x2bac
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x30(%rcx), %rax
je 0x2bfa
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/datastruct/mpool.h
// Function: mpool_free
static inline void
mpool_free(struct mpool * M, void * p)
{
	void ** allocs_new;

	/* Behave consistently with free(NULL). */
	if (p == NULL)
		return;

	/* If we have space in the stack, cache the object. */
	if (M->stacklen < M->allocsize) {
		M->allocs[M->stacklen++] = p;
		return;
	}

	/*
	 * Autotuning: If more than 1/256 of mpool_malloc() calls resulted in
	 * a malloc(), double the stack.
	 */
	if (M->nempties > (M->nallocs >> 8)) {
		/* Sanity check. */
		assert(M->allocsize > 0);

		/* Allocate new stack and copy pointers into it. */
		allocs_new = (void **)malloc(M->allocsize * 2 * sizeof(void *));
		if (allocs_new) {
			memcpy(allocs_new, M->allocs,
			    M->allocsize * sizeof(void *));
			if (M->allocs != M->allocs_static)
				free(M->allocs);
			M->allocs = allocs_new;
			M->allocsize = M->allocsize * 2;
			M->allocs[M->stacklen++] = p;
		} else
			free(p);
	} else
		free(p);

	/* Reset statistics. */
	M->nempties = 0;
	M->nallocs = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2c1c
jmp 0x2d65
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x2c53
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rsi
movq (%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, (%rsi)
movq %rdx, (%rax,%rcx,8)
jmp 0x2d65
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
shrq $0x8, %rcx
cmpq %rcx, %rax
jbe 0x2d44
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jbe 0x2c7d
jmp 0x2c9c
leaq 0x7423(%rip), %rdi      # 0xa0a7
leaq 0x742d(%rip), %rsi      # 0xa0b8
movl $0x5a, %edx
leaq 0x7443(%rip), %rcx      # 0xa0da
callq 0x2180
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
shlq %rdi
shlq $0x3, %rdi
callq 0x2240
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2d39
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
shlq $0x3, %rdx
callq 0x2200
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x30(%rcx), %rax
je 0x2cf7
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2040
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
shlq %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rsi
movq (%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, (%rsi)
movq %rdx, (%rax,%rcx,8)
jmp 0x2d42
movq -0x10(%rbp), %rdi
callq 0x2040
jmp 0x2d4d
movq -0x10(%rbp), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/events/events_immediate.c
// Function: events_immediate_register
void *
events_immediate_register(int (* func)(void *), void * cookie, int prio)
{
	struct eventrec * r;
	struct eventq * q;

	/* Sanity check. */
	assert((prio >= 0) && (prio < 32));

	/* Bundle into an eventrec record. */
	if ((r = events_mkrec(func, cookie)) == NULL)
		goto err0;

	/* Create a linked list node. */
	if ((q = mpool_eventq_malloc()) == NULL)
		goto err1;
	q->r = r;
	q->prio = prio;

	/* Add to the queue. */
	TAILQ_INSERT_TAIL(&heads[prio], q, entries);

	/* Update minq if necessary. */
	if (prio < minq)
		minq = prio;

	/* Success! */
	return (q);

err1:
	events_freerec(r);
err0:
	/* Failure! */
	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x2dd1
cmpl $0x20, -0x1c(%rbp)
jge 0x2dd1
jmp 0x2df0
leaq 0x7340(%rip), %rdi      # 0xa118
leaq 0x7354(%rip), %rsi      # 0xa133
movl $0x47, %edx
leaq 0x7371(%rip), %rcx      # 0xa15c
callq 0x2180
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x27a0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x2e0c
jmp 0x2ec1
callq 0x2ee0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x2e20
jmp 0x2eb8
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movl -0x1c(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x8(%rax)
movslq -0x1c(%rbp), %rcx
leaq 0xb3d4(%rip), %rax      # 0xe220
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
leaq 0xb3b2(%rip), %rax      # 0xe220
shlq $0x4, %rdx
addq %rdx, %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
addq $0x8, %rcx
movslq -0x1c(%rbp), %rdx
leaq 0xb391(%rip), %rax      # 0xe220
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movl -0x1c(%rbp), %eax
cmpl 0xb57d(%rip), %eax      # 0xe420
jge 0x2eae
movl -0x1c(%rbp), %eax
movl %eax, 0xb572(%rip)      # 0xe420
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2ec9
movq -0x28(%rbp), %rdi
callq 0x2820
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/events/events_immediate.c
// Function: events_immediate_cancel
void
events_immediate_cancel(void * cookie)
{
	struct eventq * q = cookie;
	int prio = q->prio;

	/* Remove it from the list. */
	TAILQ_REMOVE(&heads[prio], q, entries);

	/* Free the eventrec. */
	events_freerec(q->r);

	/* Return the node to the malloc pool. */
	mpool_eventq_free(q);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2f3f
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
jmp 0x2f5d
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movslq -0x14(%rbp), %rdx
leaq 0xb2ce(%rip), %rax      # 0xe220
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2820
movq -0x10(%rbp), %rdi
callq 0x2f90
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/events/events_immediate.c
// Function: events_immediate_get
struct eventrec *
events_immediate_get(void)
{
	struct eventq * q;
	struct eventrec * r;

	/* Advance past priorities which have no events. */
	while ((minq < 32) && (TAILQ_EMPTY(&heads[minq])))
		minq++;

	/* Are there any events? */
	if (minq == 32)
		return (NULL);

	/*
	 * Remove the first node from the highest priority non-empty linked
	 * list.
	 */
	q = TAILQ_FIRST(&heads[minq]);
	TAILQ_REMOVE(&heads[minq], q, entries);

	/* Extract the eventrec. */
	r = q->r;

	/* Return the node to the malloc pool. */
	mpool_eventq_free(q);

	/* Return the eventrec. */
	return (r);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
xorl %eax, %eax
cmpl $0x20, 0xb44f(%rip)     # 0xe420
movb %al, -0x19(%rbp)
jge 0x2ff5
movslq 0xb443(%rip), %rcx      # 0xe420
leaq 0xb23c(%rip), %rax      # 0xe220
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x2ffe
jmp 0x300f
movl 0xb41c(%rip), %eax      # 0xe420
addl $0x1, %eax
movl %eax, 0xb413(%rip)      # 0xe420
jmp 0x2fc8
cmpl $0x20, 0xb40a(%rip)     # 0xe420
jne 0x3025
movq $0x0, -0x8(%rbp)
jmp 0x30b2
movslq 0xb3f4(%rip), %rcx      # 0xe420
leaq 0xb1ed(%rip), %rax      # 0xe220
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3062
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
jmp 0x3083
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movslq 0xb3af(%rip), %rdx      # 0xe420
leaq 0xb1a8(%rip), %rax      # 0xe220
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2f90
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/events/events_network.c
// Function: init
static int
init(void)
{

	/* If we're already initialized, do nothing. */
	if (S != NULL)
		goto done;

	/* Initialize the socket list. */
	if ((S = socketlist_init(0)) == NULL)
		goto err0;

	/* We have no poll structures allocated or initialized. */
	fds = NULL;
	fds_alloc = nfds = fdscanpos = 0;

	/* Clean up the socket list at exit. */
	if (atexit(events_network_shutdown))
		goto err0;

done:
	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x1af70(%rip)     # 0x1e4d0
je 0x3564
jmp 0x35bd
xorl %eax, %eax
movl %eax, %edi
callq 0x3e70
movq %rax, 0x1af5c(%rip)     # 0x1e4d0
cmpq $0x0, %rax
jne 0x357c
jmp 0x35c6
movq $0x0, 0x1af59(%rip) # 0x1e4e0
movq $0x0, 0x1af56(%rip) # 0x1e4e8
movq $0x0, 0x1af3b(%rip) # 0x1e4d8
movq $0x0, 0x1af48(%rip) # 0x1e4f0
leaq 0x8f1(%rip), %rdi       # 0x3ea0
callq 0x9380
cmpl $0x0, %eax
je 0x35bb
jmp 0x35c6
jmp 0x35bd
movl $0x0, -0x4(%rbp)
jmp 0x35cd
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/events/events_network.c
// Function: growsocketlist
static int
growsocketlist(size_t nrec)
{
	size_t i;

	/* Get the old size. */
	i = socketlist_getsize(S);

	/* Grow the list. */
	if (socketlist_resize(S, nrec))
		goto err0;

	/* Initialize new members. */
	for (; i < nrec; i++) {
		socketlist_get(S, i)->reader = NULL;
		socketlist_get(S, i)->writer = NULL;
		socketlist_get(S, i)->pollpos = (size_t)(-1);
	}

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0x1aebd(%rip), %rdi     # 0x1e4d0
callq 0x35e0
movq %rax, -0x18(%rbp)
movq 0x1aead(%rip), %rdi     # 0x1e4d0
movq -0x10(%rbp), %rsi
callq 0x3f20
cmpl $0x0, %eax
je 0x3633
jmp 0x369d
jmp 0x3635
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x3694
movq 0x1ae8a(%rip), %rdi     # 0x1e4d0
movq -0x18(%rbp), %rsi
callq 0x36b0
movq $0x0, (%rax)
movq 0x1ae73(%rip), %rdi     # 0x1e4d0
movq -0x18(%rbp), %rsi
callq 0x36b0
movq $0x0, 0x8(%rax)
movq 0x1ae5b(%rip), %rdi     # 0x1e4d0
movq -0x18(%rbp), %rsi
callq 0x36b0
movq $-0x1, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x3635
movl $0x0, -0x4(%rbp)
jmp 0x36a4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../libcperciva/events/events_network.c
// Function: events_network_cancel
int
events_network_cancel(int s, int op)
{
	struct eventrec ** r;

	/* Initialize if necessary. */
	if (init())
		goto err0;

	/* Sanity-check socket number. */
	if (s < 0) {
		warn0("Invalid file descriptor for network event: %d", s);
		goto err0;
	}

	/* Sanity-check operation. */
	if ((op != EVENTS_NETWORK_OP_READ) &&
	    (op != EVENTS_NETWORK_OP_WRITE)) {
		warn0("Invalid operation for network event: %d", op);
		goto err0;
	}

	/* We have no events registered beyond the end of the array. */
	if ((size_t)(s) >= socketlist_getsize(S)) {
		errno = ENOENT;
		goto err0;
	}

	/* Look up the relevant event pointer. */
	if (op == EVENTS_NETWORK_OP_READ)
		r = &socketlist_get(S, (size_t)s)->reader;
	else
		r = &socketlist_get(S, (size_t)s)->writer;

	/* Check if we have an event. */
	if (*r == NULL) {
		errno = ENOENT;
		goto err0;
	}

	/* Free the event. */
	events_freerec(*r);
	*r = NULL;

	/* Clear the appropriate pollfd bit(s). */
	if (op == EVENTS_NETWORK_OP_READ)
		clearbit(socketlist_get(S, (size_t)s)->pollpos, POLLIN);
	else
		clearbit(socketlist_get(S, (size_t)s)->pollpos, POLLOUT);

	/* If that was the last remaining event, stop the clock. */
	if (nfds == 0)
		events_network_selectstats_stopclock();

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
callq 0x3550
cmpl $0x0, %eax
je 0x38cd
jmp 0x3a13
cmpl $0x0, -0x8(%rbp)
jge 0x38f6
jmp 0x38d5
movl -0x8(%rbp), %esi
leaq 0x68bb(%rip), %rdi      # 0xa19a
movb $0x0, %al
callq 0x6810
callq 0x20a0
movl $0x0, (%rax)
jmp 0x3a13
cmpl $0x0, -0xc(%rbp)
je 0x3925
cmpl $0x1, -0xc(%rbp)
je 0x3925
jmp 0x3904
movl -0xc(%rbp), %esi
leaq 0x68ba(%rip), %rdi      # 0xa1c8
movb $0x0, %al
callq 0x6810
callq 0x20a0
movl $0x0, (%rax)
jmp 0x3a13
movslq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x1ab9c(%rip), %rdi     # 0x1e4d0
callq 0x35e0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jb 0x3955
callq 0x20a0
movl $0x2, (%rax)
jmp 0x3a13
cmpl $0x0, -0xc(%rbp)
jne 0x3971
movq 0x1ab6e(%rip), %rdi     # 0x1e4d0
movslq -0x8(%rbp), %rsi
callq 0x36b0
movq %rax, -0x18(%rbp)
jmp 0x3989
movq 0x1ab58(%rip), %rdi     # 0x1e4d0
movslq -0x8(%rbp), %rsi
callq 0x36b0
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x39a0
callq 0x20a0
movl $0x2, (%rax)
jmp 0x3a13
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x2820
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
cmpl $0x0, -0xc(%rbp)
jne 0x39dd
movq 0x1ab0c(%rip), %rdi     # 0x1e4d0
movslq -0x8(%rbp), %rsi
callq 0x36b0
movq 0x10(%rax), %rdi
movl $0x1, %esi
callq 0x3a30
jmp 0x39fb
movq 0x1aaec(%rip), %rdi     # 0x1e4d0
movslq -0x8(%rbp), %rsi
callq 0x36b0
movq 0x10(%rax), %rdi
movl $0x4, %esi
callq 0x3a30
cmpq $0x0, 0x1aad5(%rip)     # 0x1e4d8
jne 0x3a0a
callq 0x3f80
movl $0x0, -0x4(%rbp)
jmp 0x3a1a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)