LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ikbenlike[P]nngutils/src/base64.c
// Function: encode_buffer
void encode_buffer(ssize_t size, char *buf, struct base64_args *args){
    //assert(buf[2] == '\n');
    size_t last_triplet = size - size % 3;
    size_t i = 0;
    char *quad = calloc(4, sizeof(char));
    for(; i < last_triplet; i += 3){
        tripletoquad(&buf[i], quad);
        wrap_quad(quad, args);
        memset(quad, 0, 4);
    }
    if(i < size){
        char *triplet = calloc(3, sizeof(char));
        size_t diff = size - i;
        triplet[0] = buf[i];
        if(diff == 2){
            triplet[1] = buf[i+1];
            tripletoquad(triplet, quad);
            quad[3] = '=';
        }
        else if(diff == 3 || diff == 1){
            tripletoquad(triplet, quad);
            quad[2] = '=';
            quad[3] = '=';
        }
        wrap_quad(quad, args);
        if(args->wrap != 0){
            putchar('\n');
        }
    }
    free(quad);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movl $0x3, %ecx
cqto
idivq %rcx
movq -0x48(%rbp), %rax
subq %rdx, %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x4, %edi
movl $0x1, %esi
callq 0x10c0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x1786
movq -0x10(%rbp), %rdi
addq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x15b0
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1670
movq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x1090
movq -0x28(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x28(%rbp)
jmp 0x1740
movq -0x28(%rbp), %rax
cmpq -0x8(%rbp), %rax
jae 0x1846
movl $0x3, %edi
movl $0x1, %esi
callq 0x10c0
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
subq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movb (%rax,%rcx), %cl
movq -0x38(%rbp), %rax
movb %cl, (%rax)
cmpq $0x2, -0x40(%rbp)
jne 0x17f5
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movb 0x1(%rax,%rcx), %cl
movq -0x38(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x15b0
movq -0x30(%rbp), %rax
movb $0x3d, 0x3(%rax)
jmp 0x1822
cmpq $0x3, -0x40(%rbp)
je 0x1803
cmpq $0x1, -0x40(%rbp)
jne 0x1820
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x15b0
movq -0x30(%rbp), %rax
movb $0x3d, 0x2(%rax)
movq -0x30(%rbp), %rax
movb $0x3d, 0x3(%rax)
jmp 0x1822
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1670
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1844
movl $0xa, %edi
callq 0x1040
jmp 0x1846
movq -0x30(%rbp), %rdi
callq 0x1030
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ikbenlike[P]nngutils/src/base64.c
// Function: encode_file
void encode_file(struct base64_args *args){
    char *buf = calloc(4096, sizeof(char));
    int fd = open(args->file, O_RDONLY);
    if(fd == -1){
        handle_error(errno, args);
    }

    ssize_t r = 0;
    for(r = read(fd, buf, 4095); r > 0; r = read(fd, buf, 4095)){
        encode_buffer(r, buf, args);
    }

    free(buf);
    close(fd);

    if(r == -1){
        handle_error(errno, args);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1000, %edi           # imm = 0x1000
movl $0x1, %esi
callq 0x10c0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x1100
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x18a9
callq 0x1050
movl (%rax), %edi
movq -0x8(%rbp), %rsi
callq 0x1240
movq $0x0, -0x20(%rbp)
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rsi
movl $0xfff, %edx            # imm = 0xFFF
callq 0x10b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jle 0x18f5
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
callq 0x16f0
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rsi
movl $0xfff, %edx            # imm = 0xFFF
callq 0x10b0
movq %rax, -0x20(%rbp)
jmp 0x18c6
movq -0x10(%rbp), %rdi
callq 0x1030
movl -0x14(%rbp), %edi
callq 0x10a0
cmpq $-0x1, -0x20(%rbp)
jne 0x191d
callq 0x1050
movl (%rax), %edi
movq -0x8(%rbp), %rsi
callq 0x1240
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ikbenlike[P]nngutils/src/base64.c
// Function: main
int main(int argc, char **argv){
    struct base64_args *args = calloc(1, sizeof(struct base64_args));
    parse_args(args, argc, argv);

    /*printf("decode: %d\n", args->decode);
    printf("ignore garbage: %d\n", args->ignore_garbage);
    printf("wrap: %d\n", args->wrap);
    printf("help: %d\n", args->help);
    printf("version: %d\n", args->version);
    printf("file: %s\n", args->file);*/

    if(args->file != NULL && strcmp(args->file, "-") && args->decode == false){
        encode_file(args);
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, %edi
movl $0x20, %esi
callq 0x10c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x12a0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x19a6
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
leaq 0x79b(%rip), %rsi       # 0x211e
callq 0x10d0
cmpl $0x0, %eax
je 0x19a6
movq -0x18(%rbp), %rax
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x19a6
movq -0x18(%rbp), %rdi
callq 0x1860
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]gpss/datran.c
// Function: main
int main(int argc, char *argv[])
{
	int npt = 100;
	int nln = 100;
	int cnt = 3;
	int seed = 0;
	int i;
	for (i = 1; i < argc && argv[i][0] == '-'; i++) {
		if (argv[i][1] == 's')
			seed = atoi(argv[i][2] ? argv[i] + 2 : argv[++i]);
	}
	if (i < argc)
		npt = atoi(argv[i]);
	if (i + 1 < argc)
		nln = atoi(argv[i + 1]);
	if (i + 2 < argc)
		cnt = atoi(argv[i + 2]);
	srand(seed);
	pt_init(nln, npt);
	testrand(cnt);
	pt_print();
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x64, -0x14(%rbp)
movl $0x64, -0x18(%rbp)
movl $0x3, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %ecx
xorl %eax, %eax
cmpl -0x8(%rbp), %ecx
movb %al, -0x25(%rbp)
jge 0x11ce
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
sete %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0x11d7
jmp 0x124b
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl 0x1(%rax), %eax
cmpl $0x73, %eax
jne 0x123b
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl 0x2(%rax), %eax
cmpl $0x0, %eax
je 0x1217
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x2, %rax
movq %rax, -0x30(%rbp)
jmp 0x122f
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x24(%rbp)
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1050
movl %eax, -0x20(%rbp)
jmp 0x123d
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x11a9
movl -0x24(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x1267
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1050
movl %eax, -0x14(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
cmpl -0x8(%rbp), %eax
jge 0x128b
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1050
movl %eax, -0x18(%rbp)
movl -0x24(%rbp), %eax
addl $0x2, %eax
cmpl -0x8(%rbp), %eax
jge 0x12af
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1050
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %edi
callq 0x1040
movl -0x18(%rbp), %edi
movl -0x14(%rbp), %esi
callq 0x12e0
movl -0x1c(%rbp), %edi
callq 0x1300
callq 0x1370
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]gpss/datran.c
// Function: testrand
static void testrand(int cnt)
{
	int i;
	for (i = 0; i < cnt * pt_n; i++) {
		int p = rand() % pt_n;
		int l = rand() % ln_n;
		if (!pt_collides(p, l))
			pt_put(p, l);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl -0x4(%rbp), %ecx
imull 0x2d45(%rip), %ecx      # 0x4064
cmpl %ecx, %eax
jge 0x1369
callq 0x1060
cltd
idivl 0x2d35(%rip)            # 0x4064
movl %edx, -0xc(%rbp)
callq 0x1060
cltd
idivl 0x2d22(%rip)            # 0x4060
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0x1480
cmpl $0x0, %eax
jne 0x135c
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0x1530
jmp 0x135e
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1312
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]gpss/datran.c
// Function: pt_print
static void pt_print(void)
{
	int i, j;
	int n = 0;
	for (i = 0; i < ln_n; i++)
		if (ln_cnt[i] > 2)
			n++;
	printf("%d\n", n);
	for (i = 0; i < ln_n; i++) {
		if (ln_cnt[i] > 2) {
			printf("%d", ln_cnt[i]);
			for (j = 0; j < ln_cnt[i]; j++)
				printf(" %d", ln_point[i][j]);
			printf("\n");
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0xc(%rbp)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x2cd1(%rip), %eax      # 0x4060
jge 0x13b8
movslq -0x4(%rbp), %rcx
leaq 0x8587774(%rip), %rax   # 0x8588b10
cmpl $0x2, (%rax,%rcx,4)
jle 0x13ab
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x13ad
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x1386
movl -0xc(%rbp), %esi
leaq 0xc42(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x2c87(%rip), %eax      # 0x4060
jge 0x147a
movslq -0x4(%rbp), %rcx
leaq 0x8587726(%rip), %rax   # 0x8588b10
cmpl $0x2, (%rax,%rcx,4)
jle 0x146a
movslq -0x4(%rbp), %rcx
leaq 0x8587715(%rip), %rax   # 0x8588b10
movl (%rax,%rcx,4), %esi
leaq 0xc04(%rip), %rdi       # 0x2009
movb $0x0, %al
callq 0x1030
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
movslq -0x4(%rbp), %rdx
leaq 0x85876ef(%rip), %rcx   # 0x8588b10
cmpl (%rcx,%rdx,4), %eax
jge 0x145c
movslq -0x4(%rbp), %rcx
leaq 0x72749df(%rip), %rax   # 0x7275e10
imulq $0x7d0, %rcx, %rcx      # imm = 0x7D0
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
movswl (%rax,%rcx,2), %esi
leaq 0xbbe(%rip), %rdi       # 0x2008
movb $0x0, %al
callq 0x1030
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1413
leaq 0xba3(%rip), %rdi       # 0x2006
movb $0x0, %al
callq 0x1030
jmp 0x146c
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x13d0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]gpss/datran.c
// Function: pt_collides
static int pt_collides(int pt, int ln)
{
	int i;
	for (i = 0; i < pt_cnt[pt]; i++)
		if (pt_line[pt][i] == ln || ln_mark[ln][pt_line[pt][i]])
			return 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movslq -0x8(%rbp), %rdx
leaq 0x2bd1(%rip), %rcx      # 0x4070
cmpl (%rcx,%rdx,4), %eax
jge 0x151b
movslq -0x8(%rbp), %rcx
leaq 0x3b61(%rip), %rax      # 0x5010
imulq $0x4e20, %rcx, %rcx     # imm = 0x4E20
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movswl (%rax,%rcx,2), %eax
cmpl -0xc(%rbp), %eax
je 0x1502
movslq -0xc(%rbp), %rcx
leaq 0x131683f(%rip), %rax   # 0x1317d10
imulq $0x2710, %rcx, %rcx     # imm = 0x2710
addq %rcx, %rax
movslq -0x8(%rbp), %rdx
leaq 0x3b2a(%rip), %rcx      # 0x5010
imulq $0x4e20, %rdx, %rdx     # imm = 0x4E20
addq %rdx, %rcx
movslq -0x10(%rbp), %rdx
movswq (%rcx,%rdx,2), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x150b
movl $0x1, -0x4(%rbp)
jmp 0x1522
jmp 0x150d
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1491
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]gpss/datran.c
// Function: pt_put
static void pt_put(int pt, int ln)
{
	int i;
	for (i = 0; i < pt_cnt[pt]; i++) {
		ln_mark[pt_line[pt][i]][ln] = 1;
		ln_mark[ln][pt_line[pt][i]] = 1;
	}
	pt_line[pt][pt_cnt[pt]++] = ln;
	ln_point[ln][ln_cnt[ln]++] = pt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movslq -0x4(%rbp), %rdx
leaq 0x2b21(%rip), %rcx      # 0x4070
cmpl (%rcx,%rdx,4), %eax
jge 0x15d0
movslq -0x4(%rbp), %rcx
leaq 0x3ab1(%rip), %rax      # 0x5010
imulq $0x4e20, %rcx, %rcx     # imm = 0x4E20
addq %rcx, %rax
movslq -0xc(%rbp), %rcx
movswq (%rax,%rcx,2), %rcx
leaq 0x1316797(%rip), %rax   # 0x1317d10
imulq $0x2710, %rcx, %rcx     # imm = 0x2710
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
movb $0x1, (%rax,%rcx)
movslq -0x8(%rbp), %rcx
leaq 0x131677a(%rip), %rax   # 0x1317d10
imulq $0x2710, %rcx, %rcx     # imm = 0x2710
addq %rcx, %rax
movslq -0x4(%rbp), %rdx
leaq 0x3a65(%rip), %rcx      # 0x5010
imulq $0x4e20, %rdx, %rdx     # imm = 0x4E20
addq %rdx, %rcx
movslq -0xc(%rbp), %rdx
movswq (%rcx,%rdx,2), %rcx
movb $0x1, (%rax,%rcx)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1541
movl -0x8(%rbp), %eax
movw %ax, %dx
movslq -0x4(%rbp), %rcx
leaq 0x3a2f(%rip), %rax      # 0x5010
imulq $0x4e20, %rcx, %rcx     # imm = 0x4E20
addq %rcx, %rax
movslq -0x4(%rbp), %rdi
leaq 0x2a7a(%rip), %rcx      # 0x4070
movl (%rcx,%rdi,4), %ecx
movl %ecx, %r8d
addl $0x1, %r8d
leaq 0x2a69(%rip), %rsi      # 0x4070
movl %r8d, (%rsi,%rdi,4)
movslq %ecx, %rcx
movw %dx, (%rax,%rcx,2)
movl -0x4(%rbp), %eax
movw %ax, %dx
movslq -0x8(%rbp), %rcx
leaq 0x72747ed(%rip), %rax   # 0x7275e10
imulq $0x7d0, %rcx, %rcx      # imm = 0x7D0
addq %rcx, %rax
movslq -0x8(%rbp), %rdi
leaq 0x85874d8(%rip), %rcx   # 0x8588b10
movl (%rcx,%rdi,4), %ecx
movl %ecx, %r8d
addl $0x1, %r8d
leaq 0x85874c7(%rip), %rsi   # 0x8588b10
movl %r8d, (%rsi,%rdi,4)
movslq %ecx, %rcx
movw %dx, (%rax,%rcx,2)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_4/exercise_4_03/calculator.c
// Function: main
int main(void)
{
  int type;
  double op2;
  char s[MAXOP];

  while ((type = getop(s)) != EOF)
  {
    switch (type)
    {
    case NUMBER:
      push(atof(s));
      break;

    case '+':
      push(pop() + pop());
      break;

    case '-':
      op2 = pop();
      push(pop() - op2);
      break;

    case '*':
      push(pop() * pop());
      break;

    case '/':
      op2 = pop();

      if (op2 != 0.0)
      {
        push(pop() / op2);
      }
      else
      {
        printf("Error: zero divisor.\n");
      }

      break;

    case '%':
      op2 = pop();

      if (op2 != 0.0)
      {
        push((int)pop() % (int)op2);
      }
      else
      {
        printf("Error: zero divisor.\n");
      }
      break;

    case '\n':
      printf("result: %.8g\n", pop());
      break;

    default:
      printf("Error: unknown command %s.\n", s);
      break;
    }
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x1310
movl %eax, -0x8(%rbp)
cmpl $-0x1, %eax
je 0x12fe
movl -0x8(%rbp), %eax
addl $-0xa, %eax
movl %eax, %ecx
movq %rcx, -0x88(%rbp)
subl $0x26, %eax
ja 0x12e7
movq -0x88(%rbp), %rax
leaq 0xe47(%rip), %rcx       # 0x2004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq -0x80(%rbp), %rdi
callq 0x1030
callq 0x14e0
jmp 0x12f9
callq 0x1540
movsd %xmm0, -0x90(%rbp)
callq 0x1540
movaps %xmm0, %xmm1
movsd -0x90(%rbp), %xmm0
addsd %xmm1, %xmm0
callq 0x14e0
jmp 0x12f9
callq 0x1540
movsd %xmm0, -0x10(%rbp)
callq 0x1540
subsd -0x10(%rbp), %xmm0
callq 0x14e0
jmp 0x12f9
callq 0x1540
movsd %xmm0, -0x98(%rbp)
callq 0x1540
movaps %xmm0, %xmm1
movsd -0x98(%rbp), %xmm0
mulsd %xmm1, %xmm0
callq 0x14e0
jmp 0x12f9
callq 0x1540
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x1269
jp 0x1269
jmp 0x127a
callq 0x1540
divsd -0x10(%rbp), %xmm0
callq 0x14e0
jmp 0x1288
leaq 0xe1f(%rip), %rdi       # 0x20a0
movb $0x0, %al
callq 0x1040
jmp 0x12f9
callq 0x1540
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x12a6
jp 0x12a6
jmp 0x12c2
callq 0x1540
cvttsd2si %xmm0, %eax
cvttsd2si -0x10(%rbp), %ecx
cltd
idivl %ecx
cvtsi2sd %edx, %xmm0
callq 0x14e0
jmp 0x12d0
leaq 0xdd7(%rip), %rdi       # 0x20a0
movb $0x0, %al
callq 0x1040
jmp 0x12f9
callq 0x1540
leaq 0xdd8(%rip), %rdi       # 0x20b6
movb $0x1, %al
callq 0x1040
jmp 0x12f9
leaq -0x80(%rbp), %rsi
leaq 0xdd2(%rip), %rdi       # 0x20c4
movb $0x0, %al
callq 0x1040
jmp 0x1182
xorl %eax, %eax
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_4/exercise_4_03/calculator.c
// Function: pop
double pop(void)
{
  if (sp > 0)
  {
    return val[--sp];
  }
  else
  {
    printf("Error: stack empty.\n");
    return 0.0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0x0, 0x2b11(%rip)      # 0x4060
jle 0x1576
movl 0x2b09(%rip), %eax      # 0x4060
addl $-0x1, %eax
movl %eax, 0x2b00(%rip)      # 0x4060
movslq %eax, %rcx
leaq 0x2b06(%rip), %rax      # 0x4070
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x158c
leaq 0xb86(%rip), %rdi       # 0x2103
movb $0x0, %al
callq 0x1040
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phoboslab[P]pl_mpeg/pl_mpeg_extract_frames.c
// Function: write_bmp
int write_bmp(const char *path, int width, int height, uint8_t *pixels) {
	FILE *fh = fopen(path, "wb");
	if (!fh) {
		return 0;
	}

	int padded_width = (width * 3 + 3) & (~3);
	int padding = padded_width - (width * 3);
	int data_size = padded_width * height;
	int file_size = 54 + data_size;

	fwrite("BM", 1, 2, fh);
	fwrite(&file_size, 1, 4, fh);
	fwrite("\x00\x00\x00\x00\x36\x00\x00\x00\x28\x00\x00\x00", 1, 12, fh);
	fwrite(&width, 1, 4, fh);
	fwrite(&height, 1, 4, fh);
	fwrite("\x01\x00\x18\x00\x00\x00\x00\x00", 1, 8, fh); // planes, bpp, compression
	fwrite(&data_size, 1, 4, fh);
	fwrite("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 1, 16, fh);

	for (int y = height - 1; y >= 0; y--) {
		fwrite(pixels + y * width * 3, 3, width, fh);
		fwrite("\x00\x00\x00\x00", 1, padding, fh);
	}
	fclose(fh);
	return file_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x2692(%rip), %rsi      # 0xd583
callq 0x10e0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xaf0d
movl $0x0, -0x4(%rbp)
jmp 0xb064
imull $0x3, -0x14(%rbp), %eax
addl $0x3, %eax
andl $-0x4, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
imull $0x3, -0x14(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %eax
imull -0x18(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
addl $0x36, %eax
movl %eax, -0x38(%rbp)
movq -0x28(%rbp), %rcx
leaq 0x2642(%rip), %rdi      # 0xd586
movl $0x1, %esi
movl $0x2, %edx
callq 0x1100
movq -0x28(%rbp), %rcx
leaq -0x38(%rbp), %rdi
movl $0x1, %esi
movl $0x4, %edx
callq 0x1100
movq -0x28(%rbp), %rcx
leaq 0x234b(%rip), %rdi      # 0xd2c0
movl $0x1, %esi
movl $0xc, %edx
callq 0x1100
movq -0x28(%rbp), %rcx
leaq -0x14(%rbp), %rdi
movl $0x1, %esi
movl $0x4, %edx
callq 0x1100
movq -0x28(%rbp), %rcx
leaq -0x18(%rbp), %rdi
movl $0x1, %esi
movl $0x4, %edx
callq 0x1100
movq -0x28(%rbp), %rcx
leaq 0x2310(%rip), %rdi      # 0xd2cd
movl $0x1, %esi
movl $0x8, %edx
callq 0x1100
movq -0x28(%rbp), %rcx
leaq -0x34(%rbp), %rdi
movl $0x1, %esi
movl $0x4, %edx
callq 0x1100
movq -0x28(%rbp), %rcx
leaq 0x22e8(%rip), %rdi      # 0xd2d6
movl $0x1, %esi
movl $0x10, %edx
callq 0x1100
movl -0x18(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jl 0xb055
movq -0x20(%rbp), %rdi
movl -0x3c(%rbp), %eax
imull -0x14(%rbp), %eax
imull $0x3, %eax, %eax
cltq
addq %rax, %rdi
movslq -0x14(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl $0x3, %esi
callq 0x1100
movslq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq 0x22a7(%rip), %rdi      # 0xd2e7
movl $0x1, %esi
callq 0x1100
movl -0x3c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0xb006
movq -0x28(%rbp), %rdi
callq 0x1050
movl -0x38(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/phoboslab[P]pl_mpeg/pl_mpeg_extract_frames.c
// Function: main
int main(int argc, char *argv[]) {
	if (argc < 2) {
		printf("Usage: pl_mpeg_extract_frames <file.mpg>\n");
		return 1;
	}

	plm_t *plm = plm_create_with_filename(argv[1]);
	if (!plm) {
		printf("Couldn't open file %s\n", argv[1]);
		return 1;
	}

	plm_set_audio_enabled(plm, FALSE);
	
	int w = plm_get_width(plm);
	int h = plm_get_height(plm);
	uint8_t *pixels = (uint8_t *)malloc(w * h * 3);
	
	char bmp_name[16];
	plm_frame_t *frame = NULL;

	for (int i = 1; frame = plm_decode_video(plm); i++) {
		plm_frame_to_bgr(frame, pixels, w * 3); // BMP expects BGR ordering

		sprintf(bmp_name, "%06d.bmp", i);
		printf("Writing %s\n", bmp_name);
		write_bmp(bmp_name, w, h, pixels);
	}
	
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0xb0a6
leaq 0x24f6(%rip), %rdi      # 0xd589
movb $0x0, %al
callq 0x1060
movl $0x1, -0x4(%rbp)
jmp 0xb198
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1210
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xb0e0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x24e6(%rip), %rdi      # 0xd5b3
movb $0x0, %al
callq 0x1060
movl $0x1, -0x4(%rbp)
jmp 0xb198
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x2080
movq -0x18(%rbp), %rdi
callq 0x21e0
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2270
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
imull -0x20(%rbp), %eax
imull $0x3, %eax, %eax
movslq %eax, %rdi
callq 0x10a0
movq %rax, -0x28(%rbp)
movq $0x0, -0x48(%rbp)
movl $0x1, -0x4c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2ef0
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0xb191
movq -0x48(%rbp), %rdi
movq -0x28(%rbp), %rsi
imull $0x3, -0x1c(%rbp), %edx
callq 0x7250
leaq -0x40(%rbp), %rdi
movl -0x4c(%rbp), %edx
leaq 0x2470(%rip), %rsi      # 0xd5ca
movb $0x0, %al
callq 0x10f0
leaq -0x40(%rbp), %rsi
leaq 0x2467(%rip), %rdi      # 0xd5d3
movb $0x0, %al
callq 0x1060
leaq -0x40(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
movq -0x28(%rbp), %rcx
callq 0xaed0
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0xb128
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/nemequ[P]safe-math/test.c
// Function: test_safe_generic
static MunitResult
test_safe_generic(const MunitParameter params[], void* user_data) {
  (void) params;
  (void) user_data;
  unsigned long long a = 1, b = 1, res;

  do {
    if (!safe_add(&res, a, b)) {
      munit_logf(MUNIT_LOG_DEBUG, "%llu + %llu overflows", a, b);
      break;
    }

    munit_logf(MUNIT_LOG_DEBUG, "%llu + %llu = %llu", a, b, res);
    a = b;
    b = res;
  } while (1);

  return MUNIT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x1, -0x18(%rbp)
movq $0x1, -0x20(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x28(%rbp), %rdi
callq 0xf780
testb $0x1, %al
jne 0xe6db
movq -0x18(%rbp), %r8
movq -0x20(%rbp), %r9
xorl %edi, %edi
leaq 0x5e92(%rip), %rsi      # 0x14558
movl $0xd, %edx
leaq 0xba82(%rip), %rcx      # 0x1a154
movb $0x0, %al
callq 0x10830
jmp 0xe71f
movq -0x18(%rbp), %r8
movq -0x20(%rbp), %r9
movq -0x28(%rbp), %rax
xorl %edi, %edi
leaq 0x5e68(%rip), %rsi      # 0x14558
movl $0x11, %edx
leaq 0xba6e(%rip), %rcx      # 0x1a16a
movq %rax, (%rsp)
movb $0x0, %al
callq 0x10830
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movb $0x1, %al
testb $0x1, %al
jne 0xe6a0
jmp 0xe71f
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nemequ[P]safe-math/munit/munit.c
// Function: munit_logf_ex
void
munit_logf_ex(MunitLogLevel level, const char* filename, int line, const char* format, ...) {
  va_list ap;

  va_start(ap, format);
  munit_logf_exv(level, stderr, filename, line, format, ap);
  va_end(ap);

  if (level >= munit_log_level_fatal) {
#if defined(MUNIT_THREAD_LOCAL)
    if (munit_error_jmp_buf_valid)
      longjmp(munit_error_jmp_buf, 1);
#endif
    abort();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x1086b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x40(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x20, (%rax)
movl -0x4(%rbp), %edi
movq 0xe73b(%rip), %rax      # 0x1eff0
movq (%rax), %rsi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %r8
leaq -0x40(%rbp), %r9
callq 0x10920
leaq -0x40(%rbp), %rax
movl -0x4(%rbp), %eax
cmpl 0xfe27(%rip), %eax      # 0x20700
jb 0x1090f
movq %fs:0x0, %rax
leaq -0xe0(%rax), %rax
testb $0x1, (%rax)
je 0x1090a
movq %fs:0x0, %rax
leaq -0xd0(%rax), %rdi
movl $0x1, %esi
callq 0x3260
callq 0x3040
addq $0xf0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nemequ[P]safe-math/munit/munit.c
// Function: munit_logf_exv
static void
munit_logf_exv(MunitLogLevel level, FILE* fp, const char* filename, int line, const char* format, va_list ap) {
  if (level < munit_log_level_visible)
    return;

  switch (level) {
    case MUNIT_LOG_DEBUG:
      fputs("Debug", fp);
      break;
    case MUNIT_LOG_INFO:
      fputs("Info", fp);
      break;
    case MUNIT_LOG_WARNING:
      fputs("Warning", fp);
      break;
    case MUNIT_LOG_ERROR:
      fputs("Error", fp);
      break;
    default:
      munit_logf_ex(MUNIT_LOG_ERROR, filename, line, "Invalid log level (%d)", level);
      return;
  }

  fputs(": ", fp);
  if (filename != NULL)
    fprintf(fp, "%s:%d: ", filename, line);
  vfprintf(fp, format, ap);
  fputc('\n', fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl -0x4(%rbp), %eax
cmpl 0xfdc1(%rip), %eax      # 0x20708
jae 0x1094e
jmp 0x10a26
movl -0x4(%rbp), %eax
movq %rax, -0x38(%rbp)
subq $0x3, %rax
ja 0x109b7
movq -0x38(%rbp), %rax
leaq 0x981a(%rip), %rcx      # 0x1a180
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rsi
leaq 0x9a26(%rip), %rdi      # 0x1a3a0
callq 0x3120
jmp 0x109d7
movq -0x10(%rbp), %rsi
leaq 0x9a1a(%rip), %rdi      # 0x1a3a6
callq 0x3120
jmp 0x109d7
movq -0x10(%rbp), %rsi
leaq 0x9a0d(%rip), %rdi      # 0x1a3ab
callq 0x3120
jmp 0x109d7
movq -0x10(%rbp), %rsi
leaq 0x9a03(%rip), %rdi      # 0x1a3b3
callq 0x3120
jmp 0x109d7
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x4(%rbp), %r8d
movl $0x3, %edi
leaq 0x99eb(%rip), %rcx      # 0x1a3b9
movb $0x0, %al
callq 0x10830
jmp 0x10a26
movq -0x10(%rbp), %rsi
leaq 0x99f3(%rip), %rdi      # 0x1a3d5
callq 0x3120
cmpq $0x0, -0x18(%rbp)
je 0x10a07
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
leaq 0x99d0(%rip), %rsi      # 0x1a3d0
movb $0x0, %al
callq 0x31e0
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x3280
movq -0x10(%rbp), %rsi
movl $0xa, %edi
callq 0x3160
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nemequ[P]safe-math/munit/munit.c
// Function: munit_malloc_ex
void*
munit_malloc_ex(const char* filename, int line, size_t size) {
  if (size == 0)
    return NULL;

  void* ptr = calloc(1, size);
  if (MUNIT_UNLIKELY(ptr == NULL)) {
    munit_logf_ex (MUNIT_LOG_ERROR, filename, line, "Failed to allocate %" MUNIT_SIZE_MODIFIER "u bytes.", size);
  }

  return ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x10a54
movq $0x0, -0x8(%rbp)
jmp 0x10aa1
movq -0x20(%rbp), %rsi
movl $0x1, %edi
callq 0x31a0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x10a99
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %r8
movl $0x3, %edi
leaq 0x973e(%rip), %rcx      # 0x1a1d0
movb $0x0, %al
callq 0x10830
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nemequ[P]safe-math/munit/munit.c
// Function: munit_rand_uint32
uint32_t
munit_rand_uint32(void) {
  uint32_t old, state;

  do {
    old = munit_atomic_load(&munit_rand_state);
    state = munit_rand_next_state(old);
  } while (!munit_atomic_cas(&munit_rand_state, &old, state));

  return munit_rand_from_state(old);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl 0xfbe6(%rip), %eax      # 0x20704
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %edi
callq 0x10af0
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x4(%rbp), %eax
movl -0x10(%rbp), %ecx
lock
cmpxchgl %ecx, 0xfbbe(%rip)      # 0x20704
movl %eax, %ecx
sete %al
movb %al, -0x19(%rbp)
movl %ecx, -0x18(%rbp)
testb $0x1, %al
jne 0x10b5b
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x10b18
movl -0x4(%rbp), %edi
callq 0x10b80
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nemequ[P]safe-math/munit/munit.c
// Function: munit_rand_memory
void
munit_rand_memory(size_t size, uint8_t data[MUNIT_ARRAY_PARAM(size)]) {
  uint32_t old, state;

  do {
    state = old = munit_atomic_load(&munit_rand_state);
    munit_rand_state_memory(&state, size, data);
  } while (!munit_atomic_cas(&munit_rand_state, &old, state));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl 0xfb2e(%rip), %eax      # 0x20704
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x14(%rbp)
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x18(%rbp), %rdi
callq 0x10c40
movl -0x18(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl -0x20(%rbp), %ecx
lock
cmpxchgl %ecx, 0xfafd(%rip)      # 0x20704
movl %eax, %ecx
sete %al
movb %al, -0x29(%rbp)
movl %ecx, -0x28(%rbp)
testb $0x1, %al
jne 0x10c1c
movl -0x28(%rbp), %eax
movl %eax, -0x14(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x10bd0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nemequ[P]safe-math/munit/munit.c
// Function: munit_rand_state_memory
static void
munit_rand_state_memory(uint32_t* state, size_t size, uint8_t data[MUNIT_ARRAY_PARAM(size)]) {
  size_t members_remaining = size / sizeof(uint32_t);
  size_t bytes_remaining = size % sizeof(uint32_t);
  uint8_t* b = data;
  uint32_t rv;
  while (members_remaining-- > 0) {
    rv = munit_rand_state_uint32(state);
    memcpy(b, &rv, sizeof(uint32_t));
    b += sizeof(uint32_t);
  }
  if (bytes_remaining != 0) {
    rv = munit_rand_state_uint32(state);
    memcpy(b, &rv, bytes_remaining);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
shrq $0x2, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
andq $0x3, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x20(%rbp)
cmpq $0x0, %rax
jbe 0x10cac
movq -0x8(%rbp), %rdi
callq 0x10ec0
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rax
movl -0x34(%rbp), %ecx
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
jmp 0x10c74
cmpq $0x0, -0x28(%rbp)
je 0x10cd0
movq -0x8(%rbp), %rdi
callq 0x10ec0
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq -0x34(%rbp), %rsi
callq 0x31f0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nemequ[P]safe-math/munit/munit.c
// Function: munit_rand_int_range
int
munit_rand_int_range(int min, int max) {
  if (min > max)
    return munit_rand_int_range(max, min);

  uint64_t range = (((int64_t) max) - ((int64_t) min));
  if (range > INT32_MAX)
    range = INT32_MAX;

  return min + munit_rand_at_most(0, (int32_t) range);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
jle 0x10d06
movl -0xc(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x10ce0
movl %eax, -0x4(%rbp)
jmp 0x10d44
movslq -0xc(%rbp), %rax
movslq -0x8(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x18(%rbp)
cmpq $0x7fffffff, -0x18(%rbp) # imm = 0x7FFFFFFF
jbe 0x10d27
movq $0x7fffffff, -0x18(%rbp) # imm = 0x7FFFFFFF
movl -0x8(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl %eax, %esi
xorl %edi, %edi
callq 0x10d50
movl %eax, %ecx
movl -0x1c(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nemequ[P]safe-math/munit/munit.c
// Function: munit_rand_at_most
static int32_t
munit_rand_at_most(uint32_t salt, int32_t max) {
  uint32_t old, state;
  int32_t retval;

  do {
    state = old = munit_atomic_load(&munit_rand_state);
    retval = munit_rand_state_at_most(&state, salt, max);
  } while (!munit_atomic_cas(&munit_rand_state, &old, state));

  return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl 0xf9a0(%rip), %eax      # 0x20704
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0xc(%rbp)
movl %eax, -0x10(%rbp)
movl -0x4(%rbp), %esi
movl -0x8(%rbp), %edx
leaq -0x10(%rbp), %rdi
callq 0x11fa0
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %eax
movl -0x1c(%rbp), %ecx
lock
cmpxchgl %ecx, 0xf96e(%rip)      # 0x20704
movl %eax, %ecx
sete %al
movb %al, -0x25(%rbp)
movl %ecx, -0x24(%rbp)
testb $0x1, %al
jne 0x10dab
movl -0x24(%rbp), %eax
movl %eax, -0xc(%rbp)
movb -0x25(%rbp), %al
andb $0x1, %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x10d5e
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nemequ[P]safe-math/munit/munit.c
// Function: munit_rand_double
double
munit_rand_double(void) {
  uint32_t old, state;
  double retval = 0.0;

  do {
    state = old = munit_atomic_load(&munit_rand_state);

    /* See http://mumble.net/~campbell/tmp/random_real.c for how to do
     * this right.  Patches welcome if you feel that this is too
     * biased. */
    do {
      retval = munit_rand_state_uint32(&state) / ((double) UINT32_MAX);
    } while (MUNIT_UNLIKELY(MUNIT_UNLIKELY(retval >= 1.0) || MUNIT_UNLIKELY(retval <= 0.0)));
  } while (!munit_atomic_cas(&munit_rand_state, &old, state));

  return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movl 0xf91e(%rip), %eax      # 0x20704
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl %eax, -0x8(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x10ec0
movl %eax, %eax
cvtsi2sd %rax, %xmm0
movsd 0x939e(%rip), %xmm1     # 0x1a1a8
divsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
movsd 0x9390(%rip), %xmm1     # 0x1a1b0
ucomisd %xmm1, %xmm0
setae %al
andb $0x1, %al
movzbl %al, %eax
movslq %eax, %rcx
movb $0x1, %al
cmpq $0x0, %rcx
movb %al, -0x1a(%rbp)
jne 0x10e56
xorps %xmm0, %xmm0
ucomisd -0x10(%rbp), %xmm0
setae %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
setne %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
jne 0x10df2
jmp 0x10e68
movl -0x8(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x4(%rbp), %eax
movl -0x18(%rbp), %ecx
lock
cmpxchgl %ecx, 0xf888(%rip)      # 0x20704
movl %eax, %ecx
sete %al
movb %al, -0x21(%rbp)
movl %ecx, -0x20(%rbp)
testb $0x1, %al
jne 0x10e91
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x10de0
movsd -0x10(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nemequ[P]safe-math/munit/munit.c
// Function: munit_parameters_get
const char*
munit_parameters_get(const MunitParameter params[], const char* key) {
  for (const MunitParameter* param = params ; param != NULL && param->name != NULL ; param++)
    if (strcmp(param->name, key) == 0)
      return param->value;
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x21(%rbp)
je 0x10f32
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x10f3b
jmp 0x10f6e
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x31c0
cmpl $0x0, %eax
jne 0x10f5e
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x10f76
jmp 0x10f60
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
jmp 0x10f18
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/nemequ[P]safe-math/munit/munit.c
// Function: munit_print_help
static void
munit_print_help(int argc, const char* argv[MUNIT_ARRAY_PARAM(argc + 1)], void* user_data, const MunitArgument arguments[]) {
  (void) argc;

  printf("USAGE: %s [OPTIONS...] [TEST...]\n\n", argv[0]);
  puts(" --seed SEED\n"
       "           Value used to seed the PRNG.  Must be a 32-bit integer in decimal\n"
       "           notation with no separators (commas, decimals, spaces, etc.), or\n"
       "           hexidecimal prefixed by \"0x\".\n"
       " --iterations N\n"
       "           Run each test N times.  0 means the default number.\n"
       " --param name value\n"
       "           A parameter key/value pair which will be passed to any test with\n"
       "           takes a parameter of that name.  If not provided, the test will be\n"
       "           run once for each possible parameter value.\n"
       " --list    Write a list of all available tests.\n"
       " --list-params\n"
       "           Write a list of all available tests and their possible parameters.\n"
       " --single  Run each parameterized test in a single configuration instead of\n"
       "           every possible combination\n"
       " --log-visible debug|info|warning|error\n"
       " --log-fatal debug|info|warning|error\n"
       "           Set the level at which messages of different severities are visible,\n"
       "           or cause the test to terminate.\n"
#if !defined(_WIN32)
       " --no-fork Do not execute tests in a child process.  If this option is supplied\n"
       "           and a test crashes (including by failing an assertion), no further\n"
       "           tests will be performed.\n"
#endif
       " --fatal-failures\n"
       "           Stop executing tests as soon as a failure is found.\n"
       " --show-stderr\n"
       "           Show data written to stderr by the tests, even if the test succeeds.\n"
       " --color auto|always|never\n"
       "           Colorize (or don't) the output.\n"
     /* 12345678901234567890123456789012345678901234567890123456789012345678901234567890 */
       " --help    Print this help message and exit.");
  for (const MunitArgument* arg = arguments ; arg != NULL && arg->name != NULL ; arg++)
    arg->write_help(arg, user_data);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0x87d5(%rip), %rdi      # 0x1a40a
movb $0x0, %al
callq 0x30f0
leaq 0x87ea(%rip), %rdi      # 0x1a42d
callq 0x3070
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x29(%rbp)
je 0x11c6a
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x11c73
jmp 0x11c93
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movq -0x28(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x28(%rbp)
jmp 0x11c50
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nemequ[P]safe-math/munit/munit.c
// Function: munit_arguments_find
static const MunitArgument*
munit_arguments_find(const MunitArgument arguments[], const char* name) {
  for (const MunitArgument* arg = arguments ; arg != NULL && arg->name != NULL ; arg++)
    if (strcmp(arg->name, name) == 0)
      return arg;

  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x21(%rbp)
je 0x11ee2
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x11eeb
jmp 0x11f1a
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x31c0
cmpl $0x0, %eax
jne 0x11f0a
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x11f22
jmp 0x11f0c
movq -0x20(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
jmp 0x11ec8
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nemequ[P]safe-math/munit/munit.c
// Function: munit_rand_state_at_most
static int32_t
munit_rand_state_at_most(uint32_t* state, uint32_t salt, int32_t max) {
  /* https://stackoverflow.com/questions/2509679/how-to-generate-a-random-number-from-within-a-range#6852396 */
  munit_assert_cmp_int32(max, >, 0);
  const uint64_t
    num_bins = ((uint64_t) max) + 1,
    num_rand = ((uint64_t) INT32_MAX) + 1,
    bin_size = num_rand / num_bins,
    defect   = num_rand % num_bins;

  int64_t x;
  do {
    x = (int64_t) (munit_rand_state_uint32(state) ^ salt);
  } while (num_rand - defect <= (uint64_t) x);

  return (int32_t) (x / bin_size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jg 0x11fee
movl -0x14(%rbp), %r8d
movl -0x18(%rbp), %r9d
movl $0x3, %edi
leaq 0x83fd(%rip), %rsi      # 0x1a3d8
movl $0x180, %edx            # imm = 0x180
leaq 0x83ff(%rip), %rcx      # 0x1a3e6
movb $0x0, %al
callq 0x10830
jmp 0x11ff0
movslq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movl $0x80000000, %eax       # imm = 0x80000000
movq %rax, -0x28(%rbp)
movl $0x80000000, %eax       # imm = 0x80000000
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x20(%rbp)
movq %rax, -0x30(%rbp)
movl $0x80000000, %eax       # imm = 0x80000000
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x20(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10ec0
xorl -0xc(%rbp), %eax
movl %eax, %eax
movq %rax, -0x40(%rbp)
movl $0x80000000, %eax       # imm = 0x80000000
subq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
jbe 0x12027
movq -0x40(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x30(%rbp)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nemequ[P]safe-math/munit/munit.c
// Function: munit_maybe_concat
static char*
munit_maybe_concat(size_t* len, char* prefix, char* suffix) {
  char* res;
  size_t res_l;
  const size_t prefix_l = prefix != NULL ? strlen(prefix) : 0;
  const size_t suffix_l = suffix != NULL ? strlen(suffix) : 0;
  if (prefix_l == 0 && suffix_l == 0) {
    res = NULL;
    res_l = 0;
  } else if (prefix_l == 0 && suffix_l != 0) {
    res = suffix;
    res_l = suffix_l;
  } else if (prefix_l != 0 && suffix_l == 0) {
    res = prefix;
    res_l = prefix_l;
  } else {
    res_l = prefix_l + suffix_l;
    res = malloc(res_l + 1);
    memcpy(res, prefix, prefix_l);
    memcpy(res + prefix_l, suffix, suffix_l);
    res[res_l] = 0;
  }

  if (len != NULL)
    *len = res_l;

  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1208a
movq -0x10(%rbp), %rdi
callq 0x30d0
movq %rax, -0x40(%rbp)
jmp 0x12092
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0x12092
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x120b0
movq -0x18(%rbp), %rdi
callq 0x30d0
movq %rax, -0x48(%rbp)
jmp 0x120b8
xorl %eax, %eax
movq %rax, -0x48(%rbp)
jmp 0x120b8
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x120e3
cmpq $0x0, -0x38(%rbp)
jne 0x120e3
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
jmp 0x12176
cmpq $0x0, -0x30(%rbp)
jne 0x12103
cmpq $0x0, -0x38(%rbp)
je 0x12103
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x12174
cmpq $0x0, -0x30(%rbp)
je 0x12123
cmpq $0x0, -0x38(%rbp)
jne 0x12123
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x12172
movq -0x30(%rbp), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
addq $0x1, %rdi
callq 0x3220
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x31f0
movq -0x20(%rbp), %rdi
addq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x31f0
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x12174
jmp 0x12176
cmpq $0x0, -0x8(%rbp)
je 0x12188
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nemequ[P]safe-math/munit/munit.c
// Function: munit_parameters_add
static MunitResult
munit_parameters_add(size_t* params_size, MunitParameter* params[MUNIT_ARRAY_PARAM(*params_size)], char* name, char* value) {
  *params = realloc(*params, sizeof(MunitParameter) * (*params_size + 2));
  if (*params == NULL)
    return MUNIT_ERROR;

  (*params)[*params_size].name = name;
  (*params)[*params_size].value = value;
  (*params_size)++;
  (*params)[*params_size].name = NULL;
  (*params)[*params_size].value = NULL;

  return MUNIT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
addq $0x2, %rsi
shlq $0x4, %rsi
callq 0x3250
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x13023
movl $0x3, -0x4(%rbp)
jmp 0x130aa
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rdx
movq (%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rdx
movq (%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq $0x0, 0x8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)