LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Zarh[P]regps3iso/main.c
// Function: main
int main (int argc, char **argv)
{	
	if(argc==1) print_help();
	
	u8 task = do_fixps3iso_region;
	verbose=0;
	
	int args = 1;
	if(strcmp(argv[args], "verbose") == 0){
		verbose=1;
		args++;
	}
	
	if(strcmp(argv[args], "do_read_region_info") == 0){
		task=do_read_region_info;
		args++;
	} else
	if(strcmp(argv[args], "do_get_plain_files") == 0){
		task=do_get_plain_files;
		args++;
	} else
	if(strcmp(argv[args], "do_get_enc_files") == 0){
		task=do_get_enc_files;
		args++;
	} else
	if(strcmp(argv[args], "do_fixps3iso_region") == 0){
		task=do_fixps3iso_region;
		args++;
	}
	
	u32 i;
	for(i=args;i<argc;i++) {
		do_task(argv[i], task);
	}
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jne 0x4044f1
callq 0x401ad0
movb $0x3, -0x11(%rbp)
movb $0x0, 0xf3ed4(%rip)     # 0x4f83d0
movl $0x1, -0x18(%rbp)
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0xbfd04(%rip), %rsi     # 0x4c421a
callq 0x4010c0
cmpl $0x0, %eax
jne 0x404530
movb $0x1, 0xf3ea9(%rip)     # 0x4f83d0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0xbfcdf(%rip), %rsi     # 0x4c4222
callq 0x4010c0
cmpl $0x0, %eax
jne 0x40455f
movb $0x0, -0x11(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4045e7
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0xbfcc4(%rip), %rsi     # 0x4c4236
callq 0x4010c0
cmpl $0x0, %eax
jne 0x40458b
movb $0x1, -0x11(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4045e5
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0xbfcab(%rip), %rsi     # 0x4c4249
callq 0x4010c0
cmpl $0x0, %eax
jne 0x4045b7
movb $0x2, -0x11(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4045e3
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0xbfc90(%rip), %rsi     # 0x4c425a
callq 0x4010c0
cmpl $0x0, %eax
jne 0x4045e1
movb $0x3, -0x11(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4045e3
jmp 0x4045e5
jmp 0x4045e7
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x8(%rbp), %eax
jae 0x404614
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
movzbl -0x11(%rbp), %esi
callq 0x404300
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4045ed
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Zarh[P]regps3iso/iso.c
// Function: strcpy_malloc
char *strcpy_malloc(char *STR_DEFAULT)
{
	if(STR_DEFAULT==NULL) return NULL;
	u32 size = strlen(STR_DEFAULT)+1;
	char *STR = malloc(size+1);
	if(STR==NULL) return NULL;
	memset(STR, 0, size+1);
	memcpy(STR, STR_DEFAULT, size);
	return STR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x40463d
movq $0x0, -0x8(%rbp)
jmp 0x4046a0
movq -0x10(%rbp), %rdi
callq 0x4010f0
addq $0x1, %rax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x42c910
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x404671
movq $0x0, -0x8(%rbp)
jmp 0x4046a0
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x4010b0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
callq 0x401040
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Zarh[P]regps3iso/iso.c
// Function: fixpath
static void fixpath(char *p)
{
    u8 * pp = (u8 *) p;

    if(*p == '"') {
        p[strlen(p) -1] = 0;
        memcpy(p, p + 1, strlen(p));
    }

    while(*pp) {
        if(*pp == '"') {*pp = 0; break;}
        else
        if(*pp == '\\') *pp = '/';
        else
        if(*pp > 0 && *pp < 32) {*pp = 0; break;}
        pp++;
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0x4058ed
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4010f0
movq %rax, %rcx
movq -0x28(%rbp), %rax
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4010f0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq %rax, %rdx
callq 0x401040
jmp 0x4058ef
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x405955
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x22, %eax
jne 0x40590d
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
jmp 0x405955
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x5c, %eax
jne 0x405922
movq -0x10(%rbp), %rax
movb $0x2f, (%rax)
jmp 0x405945
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
jle 0x405943
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x20, %eax
jge 0x405943
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
jmp 0x405955
jmp 0x405945
jmp 0x405947
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x4058ef
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Zarh[P]regps3iso/iso.c
// Function: isonum_731
static int isonum_731 (unsigned char * p)
{
	return ((p[0] & 0xff)
		| ((p[1] & 0xff) << 8)
		| ((p[2] & 0xff) << 16)
		| ((p[3] & 0xff) << 24));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
andl $0xff, %eax
movq -0x8(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
andl $0xff, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x8(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
andl $0xff, %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x8(%rbp), %rcx
movzbl 0x3(%rcx), %ecx
andl $0xff, %ecx
shll $0x18, %ecx
orl %ecx, %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Zarh[P]regps3iso/iso.c
// Function: get_iso_path
static void get_iso_path(char *path, int indx) 
{
    char aux[0x420];

    path[0] = 0;

    if(!indx) {path[0] = '/'; path[1] = 0; return;}

    while(1) {
        strcpy(aux, directory_iso2[indx].name);
        strcat(aux, path);
        strcpy(path, aux);
       
        indx = directory_iso2[indx].parent - 1;
        if(indx == 0) break;     
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
cmpl $0x0, -0xc(%rbp)
jne 0x4060a0
movq -0x8(%rbp), %rax
movb $0x2f, (%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x1(%rax)
jmp 0x406108
jmp 0x4060a2
leaq -0x430(%rbp), %rdi
movq 0xf3370(%rip), %rax     # 0x4f9420
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rsi
callq 0x401020
leaq -0x430(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x401058
movq -0x8(%rbp), %rdi
leaq -0x430(%rbp), %rsi
callq 0x401020
movq 0xf3335(%rip), %rax     # 0x4f9420
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
subl $0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x406106
jmp 0x406108
jmp 0x4060a2
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/eiselekd[P]MinimalLisp/l.c
// Function: main
int
main(int argc, char **argv) 
{
    ctx cctx; 
    FILE *f; char *m = 0, *lft; long l, val; int c, ad = 1, i; 
    v *cl = mkCons(0,0), *v, *n, *r;
    memset(&cctx, 0, sizeof(cctx));
    
    if (argv[1] && (f = fopen(argv[1],"r"))) {
        fseek(f, 0, SEEK_END); 
        l = ftell(f);
        fseek(f, 0, SEEK_SET); 
        m = (char *)malloc(l+1);
        fread(m, 1, l, f);
        m[l] = 0;
        fclose(f);
        printf("%s", m);
    }
    v = scan(&cctx, m);
    
    print(&cctx, stderr, v ); printf("\n");

    l_init(&cctx) ;
    
    evlist(&cctx, v, cctx.env);
    
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x30(%rbp)
movl $0x1, -0x50(%rbp)
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x1330
movq %rax, -0x60(%rbp)
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1080
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x37e1
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xa88(%rip), %rsi       # 0x41de
callq 0x1120
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x37e1
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x1110
movq -0x28(%rbp), %rdi
callq 0x10a0
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x1110
movq -0x40(%rbp), %rdi
addq $0x1, %rdi
callq 0x10d0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl $0x1, %esi
callq 0x1030
movq -0x30(%rbp), %rax
movq -0x40(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x28(%rbp), %rdi
callq 0x1040
movq -0x30(%rbp), %rsi
leaq 0x949(%rip), %rdi       # 0x4123
movb $0x0, %al
callq 0x1070
movq -0x30(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x3240
movq %rax, -0x68(%rbp)
movq 0x27ff(%rip), %rax      # 0x5ff8
movq (%rax), %rsi
movq -0x68(%rbp), %rdx
leaq -0x20(%rbp), %rdi
callq 0x1b80
leaq 0x96d(%rip), %rdi       # 0x417d
movb $0x0, %al
callq 0x1070
leaq -0x20(%rbp), %rdi
callq 0x35f0
movq -0x68(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rdi
callq 0x27d0
xorl %eax, %eax
addq $0x80, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/keithnoguchi[P]pearls-in-action/0x9/main_test.c
// Function: main
int main(void)
{
	int fail = 0;
	int i = 0;

	printf("===============================\n");
	printf("Programming Pearls: Chapter 0x9\n");
	printf("===============================\n");

	if (test_find_first_10(&i))
		fail++;
	if (test_find_first_1000(&i))
		fail++;
	if (test_find_first1000(&i))
		fail++;
	if (test_find_first1023_512(&i))
		fail++;
	if (test_find_first1023_1000(&i))
		fail++;
	if (test_find_first_flat_1023(&i))
		fail++;

	return fail;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
leaq 0x1e70(%rip), %rdi      # 0x3004
movb $0x0, %al
callq 0x1040
leaq 0x1e83(%rip), %rdi      # 0x3025
movb $0x0, %al
callq 0x1040
leaq 0x1e54(%rip), %rdi      # 0x3004
movb $0x0, %al
callq 0x1040
leaq -0xc(%rbp), %rdi
callq 0x12e0
cmpl $0x0, %eax
je 0x11ce
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
leaq -0xc(%rbp), %rdi
callq 0x1530
cmpl $0x0, %eax
je 0x11e5
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
leaq -0xc(%rbp), %rdi
callq 0x1720
cmpl $0x0, %eax
je 0x11fc
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
leaq -0xc(%rbp), %rdi
callq 0x1a30
cmpl $0x0, %eax
je 0x1213
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
leaq -0xc(%rbp), %rdi
callq 0x1c60
cmpl $0x0, %eax
je 0x122a
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
leaq -0xc(%rbp), %rdi
callq 0x1f40
cmpl $0x0, %eax
je 0x1241
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/keithnoguchi[P]pearls-in-action/0x9/find_first.c
// Function: find_first
int find_first(int v, const int x[], int n)
{
	int l, u;

	l = -1, u = n;
	while (l+1 != u) {
		int m = (l+u)/2;

		if (x[m] < v)
			l = m;
		else
			u = m;
	}

	if (u >= n || x[u] != v)
		return -1;
	return u;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
cmpl -0x1c(%rbp), %eax
je 0x12a7
movl -0x18(%rbp), %eax
addl -0x1c(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x8(%rbp), %eax
jge 0x129f
movl -0x20(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x12a5
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x126b
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x12bf
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x8(%rbp), %eax
je 0x12c8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x12ce
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/keithnoguchi[P]pearls-in-action/0x9/find_first_test.c
// Function: generate_array
static void generate_array(int x[], int n, enum dup_pos p, int count)
{
	int i, value, start;

	for (i = 0; i < n; i++)
		x[i] = i;
	if (count == 1)
		goto out;

	/* create duplicate */
	switch (p) {
	case DUPLICATE_FRONT:
		value = x[0];
		start = 0;
		break;
	case DUPLICATE_MIDDLE:
		value = x[(n-1)/2];
		start = (n-count)/2;
		break;
	case DUPLICATE_BACK:
		value = x[n-1];
		start = n-count;
		break;
	}
	for (i = 0; i < count; i++)
		x[start+i] = value;
out:
	dump_array(x, n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x145d
movl -0x18(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x143c
cmpl $0x1, -0x14(%rbp)
jne 0x1468
jmp 0x151d
movl -0x10(%rbp), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0x1488
jmp 0x1474
movl -0x24(%rbp), %eax
subl $0x1, %eax
je 0x149a
jmp 0x147e
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0x14d2
jmp 0x14ee
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
jmp 0x14ee
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %eax
subl -0x14(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x20(%rbp)
jmp 0x14ee
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %eax
subl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x151b
movl -0x1c(%rbp), %edx
movq -0x8(%rbp), %rax
movl -0x20(%rbp), %ecx
addl -0x18(%rbp), %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x14f5
jmp 0x151d
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1670
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/keithnoguchi[P]pearls-in-action/0x9/find_first1000.c
// Function: find_first1000
int find_first1000(int t, const int x[])
{
	int l, i, p;

	i = 512;
	l = -1;
	if (x[511] < t)
		l = 1000-512;
	while (i != 1) {
		i /= 2;
		if (x[l+i] < t)
			l += i;
	}
	p = l+1;
	if (p == 1000 || x[p] != t)
		p = -1;

	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x200, -0x18(%rbp)     # imm = 0x200
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movl 0x7fc(%rax), %eax
cmpl -0x4(%rbp), %eax
jge 0x16af
movl $0x1e8, -0x14(%rbp)     # imm = 0x1E8
jmp 0x16b1
cmpl $0x1, -0x18(%rbp)
je 0x16e5
movl -0x18(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl -0x18(%rbp), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x4(%rbp), %eax
jge 0x16e3
movl -0x18(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x16b1
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x3e8, -0x1c(%rbp)     # imm = 0x3E8
je 0x1707
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x4(%rbp), %eax
je 0x170e
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movl -0x1c(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/keithnoguchi[P]pearls-in-action/0x9/find_first1000_test.c
// Function: generate_array1000
static void generate_array1000(int x[], enum dup_pos p, int count)
{
	const int n = 1000;
	int i, value, start;

	for (i = 0; i < n; i++)
		x[i] = i;

	/* create duplicate */
	switch (p) {
	case DUPLICATE_FRONT:
		value = x[0];
		start = 0;
		break;
	case DUPLICATE_MIDDLE:
		value = x[(n-1)/2];
		start = (n-count)/2;
		break;
	case DUPLICATE_BACK:
		value = x[n-1];
		start = n-count;
		break;
	}
	for (i = 0; i < count; i++)
		x[start+i] = value;

	dump_array1000(x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x3e8, -0x14(%rbp)     # imm = 0x3E8
movl $0x0, -0x18(%rbp)
cmpl $0x3e8, -0x18(%rbp)     # imm = 0x3E8
jge 0x1892
movl -0x18(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1870
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0x18b2
jmp 0x189e
movl -0x24(%rbp), %eax
subl $0x1, %eax
je 0x18c4
jmp 0x18a8
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0x18e6
jmp 0x18fe
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
jmp 0x18fe
movq -0x8(%rbp), %rax
movl 0x7cc(%rax), %eax
movl %eax, -0x1c(%rbp)
movl $0x3e8, %eax            # imm = 0x3E8
subl -0x10(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x20(%rbp)
jmp 0x18fe
movq -0x8(%rbp), %rax
movl 0xf9c(%rax), %eax
movl %eax, -0x1c(%rbp)
movl $0x3e8, %eax            # imm = 0x3E8
subl -0x10(%rbp), %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x192b
movl -0x1c(%rbp), %edx
movq -0x8(%rbp), %rax
movl -0x20(%rbp), %ecx
addl -0x18(%rbp), %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1905
movq -0x8(%rbp), %rdi
callq 0x1940
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/keithnoguchi[P]pearls-in-action/0x9/find_first1023.c
// Function: find_first1023
int find_first1023(int t, const int x[], unsigned int nr)
{
	int l, i, p;

	assert(512 <= nr && nr < 1024);

	i = 512;
	l = -1;
	if (x[511] < t)
		l = nr-512;
	while (i != 1) {
		i /= 2;
		if (x[l+i] < t)
			l += i;
	}
	p = l+1;
	if (p >= nr || x[p] != t)
		p = -1;
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x200, %eax            # imm = 0x200
cmpl -0x14(%rbp), %eax
ja 0x1977
cmpl $0x400, -0x14(%rbp)     # imm = 0x400
jae 0x1977
jmp 0x1996
leaq 0x181e(%rip), %rdi      # 0x319c
leaq 0x182e(%rip), %rsi      # 0x31b3
movl $0xb, %edx
leaq 0x1833(%rip), %rcx      # 0x31c4
callq 0x1050
movl $0x200, -0x1c(%rbp)     # imm = 0x200
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movl 0x7fc(%rax), %eax
cmpl -0x4(%rbp), %eax
jge 0x19be
movl -0x14(%rbp), %eax
subl $0x200, %eax            # imm = 0x200
movl %eax, -0x18(%rbp)
jmp 0x19c0
cmpl $0x1, -0x1c(%rbp)
je 0x19f4
movl -0x1c(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
addl -0x1c(%rbp), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x4(%rbp), %eax
jge 0x19f2
movl -0x1c(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x19c0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x1a15
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x4(%rbp), %eax
je 0x1a1c
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movl -0x20(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/keithnoguchi[P]pearls-in-action/0x9/find_first1023_test.c
// Function: generate_array1023
static void generate_array1023(int x[], unsigned int nr, enum dup_pos p, int count)
{
	int i, value, start;

	for (i = 0; i < nr; i++)
		x[i] = i;

	/* create duplicate */
	switch (p) {
	case DUPLICATE_FRONT:
		value = x[0];
		start = 0;
		break;
	case DUPLICATE_MIDDLE:
		value = x[(nr-1)/2];
		start = (nr-count)/2;
		break;
	case DUPLICATE_BACK:
		value = x[nr-1];
		start = nr-count;
		break;
	}
	for (i = 0; i < count; i++)
		x[start+i] = value;

	dump_array1023(x, nr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x1bad
movl -0x18(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1b8c
movl -0x10(%rbp), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0x1bcd
jmp 0x1bb9
movl -0x24(%rbp), %eax
subl $0x1, %eax
je 0x1bdf
jmp 0x1bc3
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0x1c00
jmp 0x1c1b
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
jmp 0x1c1b
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
shrl %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %eax
subl -0x14(%rbp), %eax
shrl %eax
movl %eax, -0x20(%rbp)
jmp 0x1c1b
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %eax
subl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1c48
movl -0x1c(%rbp), %edx
movq -0x8(%rbp), %rax
movl -0x20(%rbp), %ecx
addl -0x18(%rbp), %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1c22
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1da0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/keithnoguchi[P]pearls-in-action/0x9/find_first_flat.c
// Function: find_first_flat
int find_first_flat(int t, const int x[], int nr)
{
	int l = -1;

	if (x[l+512] < t) l  = nr-512;
	if (x[l+256] < t) l += 256;
	if (x[l+128] < t) l += 128;
	if (x[l+64]  < t) l += 64;
	if (x[l+32]  < t) l += 32;
	if (x[l+16]  < t) l += 16;
	if (x[l+8]   < t) l += 8;
	if (x[l+4]   < t) l += 4;
	if (x[l+2]   < t) l += 2;
	if (x[l+1]   < t) l += 1;

	if (l+1 >= nr || x[l+1] != t)
		return -1;
	return l+1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x200, %ecx            # imm = 0x200
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x8(%rbp), %eax
jge 0x1de8
movl -0x14(%rbp), %eax
subl $0x200, %eax            # imm = 0x200
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x100, %ecx            # imm = 0x100
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x8(%rbp), %eax
jge 0x1e0b
movl -0x18(%rbp), %eax
addl $0x100, %eax            # imm = 0x100
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x80, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x8(%rbp), %eax
jge 0x1e2e
movl -0x18(%rbp), %eax
addl $0x80, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x40, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x8(%rbp), %eax
jge 0x1e4c
movl -0x18(%rbp), %eax
addl $0x40, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x20, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x8(%rbp), %eax
jge 0x1e6a
movl -0x18(%rbp), %eax
addl $0x20, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x10, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x8(%rbp), %eax
jge 0x1e88
movl -0x18(%rbp), %eax
addl $0x10, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x8, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x8(%rbp), %eax
jge 0x1ea6
movl -0x18(%rbp), %eax
addl $0x8, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x4, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x8(%rbp), %eax
jge 0x1ec4
movl -0x18(%rbp), %eax
addl $0x4, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x8(%rbp), %eax
jge 0x1ee2
movl -0x18(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x8(%rbp), %eax
jge 0x1f00
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
cmpl -0x14(%rbp), %eax
jge 0x1f20
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x8(%rbp), %eax
je 0x1f29
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1f32
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/keithnoguchi[P]pearls-in-action/0x9/find_first_flat_test.c
// Function: generate_array
static void generate_array(int x[], unsigned int nr, enum dup_pos p, int count)
{
	int i, value, start;

	for (i = 0; i < nr; i++)
		x[i] = i;

	/* create duplicate */
	switch (p) {
	case DUPLICATE_FRONT:
		value = x[0];
		start = 0;
		break;
	case DUPLICATE_MIDDLE:
		value = x[(nr-1)/2];
		start = (nr-count)/2;
		break;
	case DUPLICATE_BACK:
		value = x[nr-1];
		start = nr-count;
		break;
	}
	for (i = 0; i < count; i++)
		x[start+i] = value;

	dump_array(x, nr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x20cd
movl -0x18(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x20ac
movl -0x10(%rbp), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0x20ed
jmp 0x20d9
movl -0x24(%rbp), %eax
subl $0x1, %eax
je 0x20ff
jmp 0x20e3
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0x2120
jmp 0x213b
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
jmp 0x213b
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
shrl %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %eax
subl -0x14(%rbp), %eax
shrl %eax
movl %eax, -0x20(%rbp)
jmp 0x213b
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %eax
subl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x2168
movl -0x1c(%rbp), %edx
movq -0x8(%rbp), %rax
movl -0x20(%rbp), %ecx
addl -0x18(%rbp), %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2142
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x2180
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/califlower[P]Multithreaded_Bank/client.c
// Function: printInstructions
void printInstructions()
{

	printf("Connection to Online Bank Successful\n");
	printf("Welcome to Your Online Bank\n");
	printf("-----------------------------\n");
	printf("Options\n");
	printf("open   <account name> to open a new account\n");
	printf("start  <account name> to start a new account session\n");
	printf("credit <amount> to credit an account that was opened\n");
	printf("debit  <amount> to debit an account that was opened\n");
	printf("balance to print total balance in bank account\n");
	printf("finish to release your current account session\n");
	printf("exit to exit your session completely\n");
	printf("-----------------------------\n");
	printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xd69(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1070
leaq 0xd81(%rip), %rdi       # 0x202a
movb $0x0, %al
callq 0x1070
leaq 0xd90(%rip), %rdi       # 0x2047
movb $0x0, %al
callq 0x1070
leaq 0xda1(%rip), %rdi       # 0x2066
movb $0x0, %al
callq 0x1070
leaq 0xd9c(%rip), %rdi       # 0x206f
movb $0x0, %al
callq 0x1070
leaq 0xdbb(%rip), %rdi       # 0x209c
movb $0x0, %al
callq 0x1070
leaq 0xde3(%rip), %rdi       # 0x20d2
movb $0x0, %al
callq 0x1070
leaq 0xe0b(%rip), %rdi       # 0x2108
movb $0x0, %al
callq 0x1070
leaq 0xe32(%rip), %rdi       # 0x213d
movb $0x0, %al
callq 0x1070
leaq 0xe54(%rip), %rdi       # 0x216d
movb $0x0, %al
callq 0x1070
leaq 0xe76(%rip), %rdi       # 0x219d
movb $0x0, %al
callq 0x1070
leaq 0xd12(%rip), %rdi       # 0x2047
movb $0x0, %al
callq 0x1070
leaq 0xd21(%rip), %rdi       # 0x2064
movb $0x0, %al
callq 0x1070
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/califlower[P]Multithreaded_Bank/client.c
// Function: exitHandler
void exitHandler()
{
	char input[strSize]="exit";
	int len= strlen(input);

	if (sock!=-1)
	{
		write(sock, &len, sizeof(int));
		write(sock, input, len);
	}
	exit(0);	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x400, %rsp            # imm = 0x400
leaq -0x3f0(%rbp), %rdi
xorl %esi, %esi
movl $0x3e8, %edx            # imm = 0x3E8
callq 0x1080
movb $0x65, -0x3f0(%rbp)
movb $0x78, -0x3ef(%rbp)
movb $0x69, -0x3ee(%rbp)
movb $0x74, -0x3ed(%rbp)
leaq -0x3f0(%rbp), %rdi
callq 0x1050
movl %eax, -0x3f4(%rbp)
cmpl $-0x1, 0x2d39(%rip)     # 0x40dc
je 0x13d5
movl 0x2d31(%rip), %edi      # 0x40dc
leaq -0x3f4(%rbp), %rsi
movl $0x4, %edx
callq 0x1040
movl 0x2d1a(%rip), %edi      # 0x40dc
leaq -0x3f0(%rbp), %rsi
movslq -0x3f4(%rbp), %rdx
callq 0x1040
xorl %edi, %edi
callq 0x1150
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/califlower[P]Multithreaded_Bank/client.c
// Function: initConnection
void initConnection(char * inputHost)
{
	struct sockaddr_in address;
	struct hostent * host;
	
	/* create socket */
	sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

	/* connect to server */
	address.sin_family = AF_INET;
	address.sin_port = htons(port);
	host = gethostbyname(inputHost);

	memcpy(&address.sin_addr, host->h_addr_list[0], host->h_length);
	
	while (connect(sock, (struct sockaddr *)&address, sizeof(address))==-1)
	{
		printf("NO SERVER FOUND...Trying again\n");
		signal(SIGALRM,reconnectAlarmHandler);
		alarm(2);
		sem_wait(&recSemaphore);
		
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x2, %edi
movl $0x1, %esi
movl $0x6, %edx
callq 0x1180
movl %eax, 0x2c96(%rip)      # 0x40dc
movw $0x2, -0x18(%rbp)
movl 0x2c86(%rip), %eax      # 0x40d8
movzwl %ax, %edi
callq 0x1060
movw %ax, -0x16(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10f0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
addq $0x4, %rdi
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movslq 0x14(%rax), %rdx
callq 0x1100
movl 0x2c4b(%rip), %edi      # 0x40dc
leaq -0x18(%rbp), %rsi
movl $0x10, %edx
callq 0x1160
cmpl $-0x1, %eax
jne 0x14db
leaq 0xd18(%rip), %rdi       # 0x21c3
movb $0x0, %al
callq 0x1070
movl $0xe, %edi
leaq -0xbe(%rip), %rsi       # 0x1400
callq 0x10e0
movl $0x2, %edi
callq 0x1090
leaq 0x2c34(%rip), %rdi      # 0x4108
callq 0x1030
jmp 0x148b
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/califlower[P]Multithreaded_Bank/client.c
// Function: recieveInput
void *recieveInput(void *emptyPtr)
{
	int len=strSize;
	char input[strSize];
	
	while (1)
	{	
		/* read length of message */
		
		read(sock, &len, sizeof(int));
		input[len] = 0;

		/* read message */
		read(sock, input, len);
		
		if (strcmp(input, "exit")==0)
		{
			printf("Server Exiting\n");
			exitHandler();
			pthread_exit(0);
		}
		signal(SIGALRM, alarmHandler);
		alarm(2);
		sem_wait(&semaphore);
		
		/* print message */
		printf("%s\n", input);
		

		
	}

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x400, %rsp            # imm = 0x400
movq %rdi, -0x8(%rbp)
movl $0x3e8, -0xc(%rbp)      # imm = 0x3E8
movl 0x2bd0(%rip), %edi      # 0x40dc
leaq -0xc(%rbp), %rsi
movl $0x4, %edx
callq 0x10c0
movslq -0xc(%rbp), %rax
movb $0x0, -0x400(%rbp,%rax)
movl 0x2bb0(%rip), %edi      # 0x40dc
leaq -0x400(%rbp), %rsi
movslq -0xc(%rbp), %rdx
callq 0x10c0
leaq -0x400(%rbp), %rdi
leaq 0xc99(%rip), %rsi       # 0x21e3
callq 0x10d0
cmpl $0x0, %eax
jne 0x1570
leaq 0xc8d(%rip), %rdi       # 0x21e8
movb $0x0, %al
callq 0x1070
callq 0x1350
xorl %eax, %eax
movl %eax, %edi
callq 0x1110
movl $0xe, %edi
leaq -0x19c(%rip), %rsi      # 0x13e0
callq 0x10e0
movl $0x2, %edi
callq 0x1090
leaq 0x2b56(%rip), %rdi      # 0x40e8
callq 0x1030
leaq -0x400(%rbp), %rsi
leaq 0xc53(%rip), %rdi       # 0x21f8
movb $0x0, %al
callq 0x1070
jmp 0x1506
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/califlower[P]Multithreaded_Bank/client.c
// Function: sendInput
void *sendInput(void *emptyPtr)
{
	int len;
	char input[strSize];

	while (1)
	{
		scanf("%s", (char *)&input);
		
		len = strlen(input);

		write(sock, &len, sizeof(int));
		write(sock, input, len);

		if (strcmp(input, "exit")==0)
		{
			exitHandler();
		}
	}

	return NULL;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x400, %rsp            # imm = 0x400
movq %rdi, -0x8(%rbp)
leaq 0xc26(%rip), %rdi       # 0x21fc
leaq -0x400(%rbp), %rsi
movb $0x0, %al
callq 0x1140
leaq -0x400(%rbp), %rdi
callq 0x1050
movl %eax, -0xc(%rbp)
movl 0x2ae3(%rip), %edi      # 0x40dc
leaq -0xc(%rbp), %rsi
movl $0x4, %edx
callq 0x1040
movl 0x2acf(%rip), %edi      # 0x40dc
leaq -0x400(%rbp), %rsi
movslq -0xc(%rbp), %rdx
callq 0x1040
leaq -0x400(%rbp), %rdi
leaq 0xbb8(%rip), %rsi       # 0x21e3
callq 0x10d0
cmpl $0x0, %eax
jne 0x163a
callq 0x1350
jmp 0x15cf
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/califlower[P]Multithreaded_Bank/client.c
// Function: main
int main(int argc, char ** argv)
{
	pthread_t rThread;
	pthread_t sThread;

	sem_init(&semaphore, 0, 0);
	sem_init(&recSemaphore, 0, 0);
	
	signal(SIGHUP, exitHandler);
	signal(SIGINT, exitHandler);
	
	(argc==2) ? initConnection(argv[1]): initConnection("localhost");

	printInstructions();

	pthread_create(&sThread, NULL, sendInput, NULL);
	pthread_create(&rThread, NULL, recieveInput, NULL);

	pthread_join(rThread,NULL);
	pthread_join(sThread,NULL);

	/* close socket */
	close(sock);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x2a8b(%rip), %rdi      # 0x40e8
xorl %edx, %edx
movl %edx, %esi
callq 0x1120
leaq 0x2a9b(%rip), %rdi      # 0x4108
xorl %edx, %edx
movl %edx, %esi
callq 0x1120
movl $0x1, %edi
leaq -0x332(%rip), %rsi      # 0x1350
callq 0x10e0
movl $0x2, %edi
leaq -0x343(%rip), %rsi      # 0x1350
callq 0x10e0
cmpl $0x2, -0x8(%rbp)
jne 0x16ad
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1420
jmp 0x16b9
leaq 0xb4b(%rip), %rdi       # 0x21ff
callq 0x1420
callq 0x1290
leaq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq -0x10d(%rip), %rdx      # 0x15c0
movq %rcx, %rsi
callq 0x1130
leaq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq -0x1f4(%rip), %rdx      # 0x14f0
movq %rcx, %rsi
callq 0x1130
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1170
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1170
movl 0x29d0(%rip), %edi      # 0x40dc
callq 0x10a0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/niho[P]elmc/src/elmc.c
// Function: main
int main (int argc, char **argv) {
    if (argc <= 1) {
        print_usage();
    } else if (strcmp(argv[1], "-v") == 0) {
        print_version();
    } else {
        return handle_script(&argv[1]);
    } 
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jg 0x1303
callq 0x1350
jmp 0x1337
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xfcf2(%rip), %rsi      # 0x11004
callq 0x10e0
cmpl $0x0, %eax
jne 0x1323
callq 0x1370
jmp 0x1335
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x13a0
movl %eax, -0x4(%rbp)
jmp 0x133e
jmp 0x1337
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/niho[P]elmc/src/elmc.c
// Function: handle_script
static int handle_script(char **argv) {
    const char *fname = argv[0];

    elm_result_t r;

    if (strcmp(argv[0], "-") == 0) {
        if (elm_parse_pipe("<stdin>", stdin, &r)) {
            elm_ast_print(r.output);
            elm_ast_delete(r.output);
            return 0;
        } else {
            elm_err_print(r.error);
            elm_err_delete(r.error);
            return 1;
        }
    } else {
        if (elm_parse_contents(fname, &r)) {
            elm_ast_print(r.output);
            elm_ast_delete(r.output);
            return 0;
        } else {
            elm_err_print(r.error);
            elm_err_delete(r.error);
            return 1;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x1011e(%rip), %rsi     # 0x114e3
callq 0x10e0
cmpl $0x0, %eax
jne 0x1424
movq 0x15c0a(%rip), %rax     # 0x16fe0
movq (%rax), %rsi
leaq 0xfcf4(%rip), %rdi      # 0x110d4
leaq -0x20(%rbp), %rdx
callq 0x2e50
cmpl $0x0, %eax
je 0x1409
movq -0x20(%rbp), %rdi
callq 0x2420
movq -0x20(%rbp), %rdi
callq 0x1e60
movl $0x0, -0x4(%rbp)
jmp 0x146a
movq -0x20(%rbp), %rdi
callq 0x2f60
movq -0x20(%rbp), %rdi
callq 0x2fb0
movl $0x1, -0x4(%rbp)
jmp 0x146a
movq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2ee0
cmpl $0x0, %eax
je 0x1451
movq -0x20(%rbp), %rdi
callq 0x2420
movq -0x20(%rbp), %rdi
callq 0x1e60
movl $0x0, -0x4(%rbp)
jmp 0x146a
movq -0x20(%rbp), %rdi
callq 0x2f60
movq -0x20(%rbp), %rdi
callq 0x2fb0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/niho[P]elmc/src/east.c
// Function: elm_ast_new
elm_ast_t *elm_ast_new(int tag, elm_ast_val_t *contents) {
    elm_ast_t *node = malloc(sizeof(elm_ast_t));
    node->tag = tag;
    node->contents = contents;
    node->children_num = 0;
    node->children = NULL;
    return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x20, %edi
callq 0x1130
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/niho[P]elmc/src/east.c
// Function: elm_ast_add_child
elm_ast_t *elm_ast_add_child(elm_ast_t *r, elm_ast_t *a) {
    r->children_num++;
    r->children = realloc(r->children, sizeof(elm_ast_t*) * r->children_num);
    r->children[r->children_num-1] = a;
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x10(%rax), %rsi
shlq $0x3, %rsi
callq 0x1160
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x10(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/niho[P]elmc/src/east.c
// Function: elm_ast_expr
elm_ast_val_t *elm_ast_expr(int i, elm_ast_val_t **xs) {
    elm_ast_t *node = elm_ast_new(ELM_AST_EXPR, NULL);
    for (int x = 0; x < i; x++) {
        elm_ast_add_child(node, xs[x]);
    }
    return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x7, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x1480
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x16b0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x14e0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1688
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/niho[P]elmc/src/east.c
// Function: elm_ast_list
elm_ast_val_t *elm_ast_list(int i, elm_ast_val_t **xs) {
    elm_ast_t *node = elm_ast_new(ELM_AST_LIST, NULL);
    for (int x = 0; x < i; x++) {
        elm_ast_add_child(node, xs[x]);
    }
    return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x8, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x1480
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x1730
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x14e0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1708
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/niho[P]elmc/src/east.c
// Function: elm_ast_list_cons
elm_ast_val_t *elm_ast_list_cons(int i, elm_ast_val_t **xs) {
    elm_ast_t *node = elm_ast_new(ELM_AST_LIST, NULL);
    for (int x = 0; x < i; x++) {
        elm_ast_t *nx = (elm_ast_t *)xs[x];
        if (nx->tag == ELM_AST_LIST) {
            for (int y = 0; y < nx->children_num; y++) {
                elm_ast_add_child(node, nx->children[y]);
            }
            elm_ast_delete_no_children(nx);
        } else {
            elm_ast_add_child(node, xs[x]);
        }
    }
    return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x8, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x1480
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x17f4
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x8, (%rax)
jne 0x17cf
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x17c4
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x14e0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1794
movq -0x28(%rbp), %rdi
callq 0x1800
jmp 0x17e4
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x14e0
jmp 0x17e6
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1768
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/niho[P]elmc/src/east.c
// Function: elm_ast_tuple
elm_ast_val_t *elm_ast_tuple(int i, elm_ast_val_t **xs) {
    elm_ast_t *node = elm_ast_new(ELM_AST_TUPLE, NULL);
    for (int x = 0; x < i; x++) {
        elm_ast_add_child(node, xs[x]);
    }
    return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x9, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x1480
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x1890
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x14e0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1868
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/niho[P]elmc/src/east.c
// Function: elm_ast_tuple_cons
elm_ast_val_t *elm_ast_tuple_cons(int i, elm_ast_val_t **xs) {
    elm_ast_t *node = elm_ast_new(ELM_AST_TUPLE, NULL);
    for (int x = 0; x < i; x++) {
        elm_ast_t *nx = (elm_ast_t *)xs[x];
        if (nx->tag == ELM_AST_TUPLE) {
            for (int y = 0; y < nx->children_num; y++) {
                elm_ast_add_child(node, nx->children[y]);
            }
            elm_ast_delete_no_children(nx);
        } else {
            elm_ast_add_child(node, xs[x]);
        }
    }
    return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x9, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x1480
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x1954
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x9, (%rax)
jne 0x192f
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x1924
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x14e0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x18f4
movq -0x28(%rbp), %rdi
callq 0x1800
jmp 0x1944
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x14e0
jmp 0x1946
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x18c8
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/niho[P]elmc/src/east.c
// Function: elm_ast_if
elm_ast_val_t *elm_ast_if(int i, elm_ast_val_t **xs) {
    assert(i == 6);
    elm_ast_t *node = elm_ast_new(ELM_AST_IF, NULL);
    elm_ast_add_child(node, xs[1]);
    elm_ast_add_child(node, xs[3]);
    elm_ast_add_child(node, xs[5]);
    free(xs[0]);
    free(xs[2]);
    free(xs[4]);
    return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x6, -0x4(%rbp)
jne 0x1977
jmp 0x1996
leaq 0xf7a7(%rip), %rdi      # 0x11125
leaq 0xf7a7(%rip), %rsi      # 0x1112c
movl $0x7c, %edx
leaq 0xf7a2(%rip), %rcx      # 0x11133
callq 0x10a0
movl $0xa, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x1480
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x14e0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x14e0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x14e0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x11e0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x11e0
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x11e0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)