LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: pawan231[P]MiniDataBase/include/BPtree.h
// Function: BPtree::get_record(int)
int
BPtree::get_record(int primary_key)
{
	clock_t start=clock();
    Btreenode n = search_leaf(primary_key);
    int pos = n.get_next_key(primary_key) + 1;
    clock_t stop=clock();
    double elapsed=(double)(stop-start)*1000.0/CLOCKS_PER_SEC;
    printf("\nTime elapsed for search is %f ms",elapsed);
    if (pos <= n.num_keys() && n.get_key(pos) == primary_key)
    {
        return n.get_pointer(pos);
    }
    else
    {
        return BPTREE_SEARCH_NOT_FOUND;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
callq 0x2120
movq -0xa0(%rbp), %rsi
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %edx
leaq -0x60(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x24f0
movq -0x98(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x5500
movl %eax, -0x90(%rbp)
jmp 0x26c7
movl -0x90(%rbp), %eax
incl %eax
movl %eax, -0x64(%rbp)
callq 0x2120
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movq -0x20(%rbp), %rcx
subq %rcx, %rax
cvtsi2sd %rax, %xmm0
movsd 0x8915(%rip), %xmm1     # 0xb008
mulsd %xmm1, %xmm0
movsd 0x8911(%rip), %xmm1     # 0xb010
divsd %xmm1, %xmm0
movsd %xmm0, -0x88(%rbp)
movsd -0x88(%rbp), %xmm0
leaq 0x891e(%rip), %rdi      # 0xb038
movb $0x1, %al
callq 0x2030
jmp 0x2723
movl -0x64(%rbp), %eax
movl %eax, -0xa8(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x55c0
movl %eax, -0xa4(%rbp)
jmp 0x273d
movl -0xa8(%rbp), %eax
movl -0xa4(%rbp), %ecx
cmpl %ecx, %eax
jg 0x27ac
movl -0x64(%rbp), %esi
leaq -0x60(%rbp), %rdi
callq 0x54a0
movl %eax, -0xac(%rbp)
jmp 0x2761
movl -0xac(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x27ac
movl -0x64(%rbp), %esi
leaq -0x60(%rbp), %rdi
callq 0x54d0
movl %eax, -0xb0(%rbp)
jmp 0x2780
movl -0xb0(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0x8c(%rbp)
jmp 0x27bd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x5570
jmp 0x27d2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x8c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x5570
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x2340
nopl (%rax,%rax)
// File: pawan231[P]MiniDataBase/include/file_handler.h
// Function: open_file(char*, char*)
FILE *open_file(char t_name[] ,char perm[]){

    FILE *fp;
    struct stat st = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
    char *name = (char *)malloc(sizeof(char) * (2 * MAX_NAME + 15));
       strcpy(name, "./table/");

    if (stat(name, &st) == -1)
        mkdir(name, 0775);

    strcat(name, t_name);
    strcat(name, "/");

    if (stat(name, &st) == -1)
        mkdir(name, 0775);
    strcat(name, "met");
    fp = fopen(name, perm);
    if (!fp){
        printf("\nError in opening file\n");
    }
    free(name);
    return fp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0xa8(%rbp), %rdi
xorl %esi, %esi
movl $0x90, %edx
callq 0x20e0
movl $0x73, %edi
callq 0x2260
movq %rax, -0xb0(%rbp)
movq -0xb0(%rbp), %rdi
leaq 0x7f35(%rip), %rsi      # 0xb05a
callq 0x2180
movq -0xb0(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x2170
cmpl $-0x1, %eax
jne 0x3153
movq -0xb0(%rbp), %rdi
movl $0x1fd, %esi            # imm = 0x1FD
callq 0x20c0
movq -0xb0(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x2350
movq -0xb0(%rbp), %rdi
leaq 0x7ef0(%rip), %rsi      # 0xb061
callq 0x2350
movq -0xb0(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x2170
cmpl $-0x1, %eax
jne 0x319f
movq -0xb0(%rbp), %rdi
movl $0x1fd, %esi            # imm = 0x1FD
callq 0x20c0
movq -0xb0(%rbp), %rdi
leaq 0x81ef(%rip), %rsi      # 0xb39c
callq 0x2350
movq -0xb0(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2210
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x31db
leaq 0x7e8f(%rip), %rdi      # 0xb063
movb $0x0, %al
callq 0x2030
movq -0xb0(%rbp), %rdi
callq 0x2220
movq -0x18(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: pawan231[P]MiniDataBase/include/file_handler.h
// Function: store_meta_data(table*)
int store_meta_data(struct table *t_ptr)
{
    FILE *fp = open_file(t_ptr->name, const_cast<char*>("w"));
    fwrite(t_ptr, sizeof(struct table), 1, fp);
    fclose(fp);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x3e4, %rdi            # imm = 0x3E4
leaq 0x7e5d(%rip), %rsi      # 0xb07b
callq 0x30e0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x420, %esi            # imm = 0x420
movl $0x1, %edx
callq 0x2390
movq -0x10(%rbp), %rdi
callq 0x21a0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: pawan231[P]MiniDataBase/include/create.h
// Function: record_size(table*)
int record_size(table *temp){
	int size=0;
	temp->prefix[0]=0;
	for(int i=0;i<temp->count;i++){
		switch(temp->col[i].type){
		case INT:
			temp->prefix[i+1]=sizeof(int)+temp->prefix[i];
			size+=sizeof(int);
			break;
		case VARCHAR:
			temp->prefix[i+1]=sizeof(char)*(MAX_VARCHAR +1) +temp->prefix[i];
			size+=sizeof(char)*(MAX_VARCHAR +1);
			break;
		}
	}
	return size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x3e0(%rcx), %eax
jge 0x331d
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rdx
leaq (%rdx,%rdx,8), %rcx
leaq (%rcx,%rcx,2), %rcx
addq %rdx, %rcx
movl 0x90(%rax,%rcx), %eax
movl %eax, -0x14(%rbp)
subl $0x1, %eax
je 0x32b1
jmp 0x32a7
movl -0x14(%rbp), %eax
subl $0x2, %eax
je 0x32e0
jmp 0x330d
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movslq (%rax,%rcx,4), %rax
addq $0x4, %rax
movl %eax, %edx
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movslq -0xc(%rbp), %rax
addq $0x4, %rax
movl %eax, -0xc(%rbp)
jmp 0x330d
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movslq (%rax,%rcx,4), %rax
addq $0x33, %rax
movl %eax, %edx
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movslq -0xc(%rbp), %rax
addq $0x33, %rax
movl %eax, -0xc(%rbp)
jmp 0x330f
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3270
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: pawan231[P]MiniDataBase/include/insert.h
// Function: search_table(char*)
int search_table(char tab_name[]){
	
	//check if new table already exists in table list or not 
		//use grep to search table_name string inside table_list
		// -F -> --fixed-strings ;intepret pattern as a list of fixed strings
		// -x -> --line-regexp ;select only those matches that exactly match the whole line
		// -q -> quite, --silent ;write anything to standard output, exit immediately with zero status if any match is found
		char str[MAX_NAME+1];
		strcpy(str,"grep -Fxq");
		strcat(str,tab_name);
		strcat(str," ./table/table_list");
		int x = system(str);
		if(x==0)return 1;
		else return 0;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x50(%rbp), %rdi
leaq 0x77cc(%rip), %rsi      # 0xb323
callq 0x2180
leaq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2350
leaq -0x50(%rbp), %rdi
leaq 0x7b7f(%rip), %rsi      # 0xb6f3
callq 0x2350
leaq -0x50(%rbp), %rdi
callq 0x2140
movl %eax, -0x54(%rbp)
cmpl $0x0, -0x54(%rbp)
jne 0x3b94
movl $0x1, -0x4(%rbp)
jmp 0x3b9b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: pawan231[P]MiniDataBase/include/display.h
// Function: show_tables()
void show_tables(){
	char *name;
	printf("\n\nLIST OF TABLES\n\n");
	printf("---------------------------\n");
	int tabcount=0;
	name=(char*)malloc(sizeof(char)*MAX_NAME);
	FILE *fp=fopen("./table/table_list","r+");
	while(fscanf(fp,"%s",name)!=EOF){
		tabcount++;
		cout<<name<<"\n";
	}
	if(tabcount==0) printf("Database empty!!!\n");
	printf("---------------------------\n");
	free(name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x6c8a(%rip), %rdi      # 0xb4d9
movb $0x0, %al
callq 0x2030
leaq 0x6b6f(%rip), %rdi      # 0xb3cc
movb $0x0, %al
callq 0x2030
movl $0x0, -0xc(%rbp)
movl $0x32, %edi
callq 0x2260
movq %rax, -0x8(%rbp)
leaq 0x6e74(%rip), %rdi      # 0xb6f4
leaq 0x6a14(%rip), %rsi      # 0xb29b
callq 0x2210
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq 0x6e11(%rip), %rsi      # 0xb6b0
movb $0x0, %al
callq 0x2380
cmpl $-0x1, %eax
je 0x48d5
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rsi
movq 0xb711(%rip), %rdi      # 0xffd0
callq 0x2190
movq %rax, %rdi
leaq 0x73d7(%rip), %rsi      # 0xbca5
callq 0x2190
jmp 0x4890
cmpl $0x0, -0xc(%rbp)
jne 0x48e9
leaq 0x6c0a(%rip), %rdi      # 0xb4ec
movb $0x0, %al
callq 0x2030
leaq 0x6adc(%rip), %rdi      # 0xb3cc
movb $0x0, %al
callq 0x2030
movq -0x8(%rbp), %rdi
callq 0x2220
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: pawan231[P]MiniDataBase/include/drop.h
// Function: drop()
void drop(){
	char *tab;
	char *temp;
	char *temp1;
	temp1=(char*)malloc(sizeof(char)*MAX_NAME);
	temp=(char*)malloc(sizeof(char)*MAX_NAME);
	tab=(char*)malloc(sizeof(char)*MAX_NAME);
	cout<<"\nenter table name to delete: ";
	cin>>tab;
	strcpy(temp1,tab);
	int check=search_table(tab);
	if(check==0) printf("\n%s doesn't exist\n\n",tab);
	else if(check==1){
		sprintf(temp, "rm -R ./table/%s", tab);
		system(temp);
		//copy all the table names to new temp excluding given table to delete;
		sprintf(temp, "grep -v \"%s\" ./table/table_list > ./table/temp ; mv ./table/temp ./table/table_list", tab);
        system(temp);
        printf("\n%s deleted\n\n",temp1);
		printf("-------------------------------");
	}
	else{
		printf("\nerror\nexiting...\n\n");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x32, %edi
callq 0x2260
movq %rax, -0x18(%rbp)
movl $0x32, %edi
callq 0x2260
movq %rax, -0x10(%rbp)
movl $0x32, %edi
callq 0x2260
movq %rax, -0x8(%rbp)
movq 0xb017(%rip), %rdi      # 0xffd0
leaq 0x66b0(%rip), %rsi      # 0xb670
callq 0x2190
movq -0x8(%rbp), %rsi
movq 0xb010(%rip), %rdi      # 0xffe0
callq 0x5f30
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x2180
movq -0x8(%rbp), %rdi
callq 0x3b40
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x5008
movq -0x8(%rbp), %rsi
leaq 0x668f(%rip), %rdi      # 0xb68e
movb $0x0, %al
callq 0x2030
jmp 0x507e
cmpl $0x1, -0x1c(%rbp)
jne 0x506e
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq 0x6685(%rip), %rsi      # 0xb6a2
movb $0x0, %al
callq 0x2040
movq -0x10(%rbp), %rdi
callq 0x2140
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq 0x6677(%rip), %rsi      # 0xb6b3
movb $0x0, %al
callq 0x2040
movq -0x10(%rbp), %rdi
callq 0x2140
movq -0x18(%rbp), %rsi
leaq 0x66b0(%rip), %rdi      # 0xb707
movb $0x0, %al
callq 0x2030
leaq 0x6ae5(%rip), %rdi      # 0xbb4a
movb $0x0, %al
callq 0x2030
jmp 0x507c
leaq 0x66a0(%rip), %rdi      # 0xb715
movb $0x0, %al
callq 0x2030
jmp 0x507e
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: pawan231[P]MiniDataBase/src/main.cpp
// Function: take_input_option()
int take_input_option(){
	string option;
	fflush(stdout);
	fflush(stdin);
	printf("\n select the query to implement\n");
	printf("\n1.show all tables in database\n2.create table\n3.insert into table\n4.drop table\n5.display table contents\n6.search table or search inside table\n7.help\n8.quit\n\n");
	cin>>option;
	if(option.length() >1){
		printf("\nwrong input\nexiting...\n\n");
		exit(0);
	}else{
		if(option[0] > 48 && option[0]<58){
			return option[0]-48;
		}
		else{
			printf("\nwrong input\nexiting...\n\n");
			exit(0);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq -0x20(%rbp), %rdi
callq 0x2270
movq 0xaee8(%rip), %rax      # 0xffb0
movq (%rax), %rdi
callq 0x2200
jmp 0x50d2
movq 0xaeef(%rip), %rax      # 0xffc8
movq (%rax), %rdi
callq 0x2200
jmp 0x50e3
leaq 0x6a80(%rip), %rdi      # 0xbb6a
xorl %eax, %eax
callq 0x2030
jmp 0x50f3
leaq 0x6a91(%rip), %rdi      # 0xbb8b
xorl %eax, %eax
callq 0x2030
jmp 0x5103
movq 0xaed6(%rip), %rdi      # 0xffe0
leaq -0x20(%rbp), %rsi
callq 0x2240
jmp 0x5115
leaq -0x20(%rbp), %rdi
callq 0x22e0
cmpq $0x1, %rax
jbe 0x5155
leaq 0x6afe(%rip), %rdi      # 0xbc29
xorl %eax, %eax
callq 0x2030
jmp 0x5134
xorl %edi, %edi
callq 0x2230
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x2110
jmp 0x51dc
xorl %eax, %eax
movl %eax, %esi
leaq -0x20(%rbp), %rdi
callq 0x23a0
movq %rax, -0x38(%rbp)
jmp 0x5168
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jle 0x51c5
xorl %eax, %eax
movl %eax, %esi
leaq -0x20(%rbp), %rdi
callq 0x23a0
movq %rax, -0x40(%rbp)
jmp 0x5187
movq -0x40(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3a, %eax
jge 0x51c5
xorl %eax, %eax
movl %eax, %esi
leaq -0x20(%rbp), %rdi
callq 0x23a0
movq %rax, -0x48(%rbp)
jmp 0x51a6
movq -0x48(%rbp), %rax
movsbl (%rax), %eax
subl $0x30, %eax
movl %eax, -0x4c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x2110
movl -0x4c(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
leaq 0x6a5d(%rip), %rdi      # 0xbc29
xorl %eax, %eax
callq 0x2030
jmp 0x51d5
xorl %edi, %edi
callq 0x2230
movq -0x28(%rbp), %rdi
callq 0x2340
nopw %cs:(%rax,%rax)
// File: pawan231[P]MiniDataBase/src/main.cpp
// Function: input()
void input(){
	int c = take_input_option();
	while(c<9 && c>0){
		switch(c){
			case 1:
				show_tables();
				break;
			case 2:
				create();
				break;
			case 3:
				insert();
				break;
			case 4:
				drop();
				break;
			case 5:
				display();
				break;
			case 6:
				search();
				break;
			case 8:
				printf("\nexiting...\n");
				printf("\n\t\t good bye!!!\n\n");
				exit(0);
				break;
			case 7:
				help();
				break;
			default:
				printf("\nplease choose a correct option\n");
				break;
		}
		c = take_input_option();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x50b0
movl %eax, -0x4(%rbp)
xorl %eax, %eax
cmpl $0x9, -0x4(%rbp)
movb %al, -0x5(%rbp)
jge 0x5215
cmpl $0x0, -0x4(%rbp)
setg %al
movb %al, -0x5(%rbp)
movb -0x5(%rbp), %al
testb $0x1, %al
jne 0x5221
jmp 0x52b4
movl -0x4(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x7, %eax
ja 0x5299
movq -0x10(%rbp), %rax
leaq 0x5ddc(%rip), %rcx      # 0xb018
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
callq 0x4840
jmp 0x52a7
callq 0x3950
jmp 0x52a7
callq 0x3e30
jmp 0x52a7
callq 0x4f80
jmp 0x52a7
callq 0x4400
jmp 0x52a7
callq 0x4910
jmp 0x52a7
leaq 0x5f63(%rip), %rdi      # 0xb1d9
movb $0x0, %al
callq 0x2030
leaq 0x69bf(%rip), %rdi      # 0xbc43
movb $0x0, %al
callq 0x2030
xorl %edi, %edi
callq 0x2230
callq 0x5090
jmp 0x52a7
leaq 0x69b5(%rip), %rdi      # 0xbc55
movb $0x0, %al
callq 0x2030
callq 0x50b0
movl %eax, -0x4(%rbp)
jmp 0x5200
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: pawan231[P]MiniDataBase/src/main.cpp
// Function: start_system()
void start_system(){
	system("clear");
	printf("\n\t\t\tWELCOME\n\n");
	printf("\t\tWelcome to myDB monitor \n\n");
	//cout<<"\t\tType h for help and q for quit\n\n";
	input();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x69ab(%rip), %rdi      # 0xbc76
callq 0x2140
leaq 0x69a5(%rip), %rdi      # 0xbc7c
movb $0x0, %al
callq 0x2030
leaq 0x69a5(%rip), %rdi      # 0xbc8a
movb $0x0, %al
callq 0x2030
callq 0x51f0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: pawan231[P]MiniDataBase/include/BPtree.h
// Function: BPtree::read_node(int, Btreenode&)
void read_node(int filenum, Btreenode & n)
    {
        char *str;
        str = (char *) malloc(sizeof(char) * BPTREE_MAX_FILE_PATH_SIZE);
        sprintf(str, "table/%s/tree/tree%d.dat", tablename, filenum);
        std::ifstream in_file(str, std::ifstream::in | std::ifstream::binary);
        free(str);
        in_file >> n;
        in_file.close();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp            # imm = 0x250
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x250(%rbp)
movl $0x3e8, %edi            # imm = 0x3E8
callq 0x2260
movq -0x250(%rbp), %rdx
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0x8, %rdx
movl -0xc(%rbp), %ecx
leaq 0x68ef(%rip), %rsi      # 0xbca7
xorl %eax, %eax
callq 0x2040
movq -0x20(%rbp), %rax
movq %rax, -0x248(%rbp)
movl $0x8, %edi
movl $0x4, %esi
callq 0x63b0
movq -0x248(%rbp), %rsi
movl %eax, %edx
leaq -0x228(%rbp), %rdi
movq %rdi, -0x240(%rbp)
callq 0x2370
movq -0x20(%rbp), %rdi
callq 0x2220
movq -0x240(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x63d0
jmp 0x5410
leaq -0x228(%rbp), %rdi
callq 0x2050
jmp 0x541e
leaq -0x228(%rbp), %rdi
callq 0x2060
addq $0x250, %rsp            # imm = 0x250
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x230(%rbp)
movl %eax, -0x234(%rbp)
leaq -0x228(%rbp), %rdi
callq 0x2060
movq -0x230(%rbp), %rdi
callq 0x2340
nopl (%rax)
// File: pawan231[P]MiniDataBase/include/BPtree.h
// Function: Btreenode::full()
bool full()
    {
        if (leaf)
        {
            if (pointers.size() < BPTREE_MAX_KEYS_PER_NODE - 1)
                return false;
            else
                return true;
        }
        if (pointers.size() < BPTREE_MAX_KEYS_PER_NODE)
            return false;
        else
            return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, (%rax)
je 0x56d8
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x6580
cmpq $0x31, %rax
jae 0x56d2
movb $0x0, -0x1(%rbp)
jmp 0x56f5
movb $0x1, -0x1(%rbp)
jmp 0x56f5
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x6580
cmpq $0x32, %rax
jae 0x56f1
movb $0x0, -0x1(%rbp)
jmp 0x56f5
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
// File: pawan231[P]MiniDataBase/include/BPtree.h
// Function: Btreenode::insert_key(int, int)
void insert_key(int key, int point)
    {
        int pos = get_next_key(key);
        keys.insert(keys.begin() + pos, key);
        if (leaf)
            pointers.insert(pointers.begin() + pos, point);
        else
            pointers.insert(pointers.begin() + pos + 1, point);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x88(%rbp)
movl -0xc(%rbp), %esi
callq 0x5500
movq -0x88(%rbp), %rdi
movl %eax, -0x14(%rbp)
movq %rdi, %rax
addq $0x20, %rax
movq %rax, -0x90(%rbp)
addq $0x20, %rdi
callq 0x70c0
movq %rax, -0x30(%rbp)
movslq -0x14(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x7770
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x77b0
movq -0x90(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0xc(%rbp), %rdx
callq 0x7570
movq %rax, %rcx
movq -0x88(%rbp), %rax
movq %rcx, -0x38(%rbp)
testb $0x1, (%rax)
je 0x57ec
movq -0x88(%rbp), %rdi
movq %rdi, %rax
addq $0x8, %rax
movq %rax, -0x98(%rbp)
addq $0x8, %rdi
callq 0x70c0
movq %rax, -0x50(%rbp)
movslq -0x14(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x7770
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x77b0
movq -0x98(%rbp), %rdi
movq -0x40(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0x7570
movq %rax, -0x58(%rbp)
jmp 0x5856
movq -0x88(%rbp), %rdi
movq %rdi, %rax
addq $0x8, %rax
movq %rax, -0xa0(%rbp)
addq $0x8, %rdi
callq 0x70c0
movq %rax, -0x78(%rbp)
movslq -0x14(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x7770
movq %rax, -0x70(%rbp)
leaq -0x70(%rbp), %rdi
movl $0x1, %esi
callq 0x7770
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x77b0
movq -0xa0(%rbp), %rdi
movq -0x60(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0x7570
movq %rax, -0x80(%rbp)
addq $0xa0, %rsp
popq %rbp
retq
nop
// File: pawan231[P]MiniDataBase/include/BPtree.h
// Function: BPtree::write_node(int, Btreenode)
void write_node(int filenum, Btreenode n)
    {
        char *str;
          str = (char *) malloc(sizeof(char) * BPTREE_MAX_FILE_PATH_SIZE);
          sprintf(str, "table/%s/tree/tree%d.dat", tablename,filenum);
          std::ofstream out_file(str, std::ofstream::binary |  std::ofstream::out | std::ofstream::trunc);
          free(str);
          out_file << n;
          out_file.close();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp            # imm = 0x250
movq %rdx, -0x238(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x250(%rbp)
movl $0x3e8, %edi            # imm = 0x3E8
callq 0x2260
movq -0x250(%rbp), %rdx
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0x8, %rdx
movl -0xc(%rbp), %ecx
leaq 0x63f8(%rip), %rsi      # 0xbca7
xorl %eax, %eax
callq 0x2040
movq -0x20(%rbp), %rax
movq %rax, -0x248(%rbp)
movl $0x4, %edi
movl $0x10, %esi
callq 0x63b0
movl %eax, %edi
movl $0x20, %esi
callq 0x63b0
movq -0x248(%rbp), %rsi
movl %eax, %edx
leaq -0x220(%rbp), %rdi
movq %rdi, -0x240(%rbp)
callq 0x21d0
movq -0x20(%rbp), %rdi
callq 0x2220
movq -0x240(%rbp), %rdi
movq -0x238(%rbp), %rsi
callq 0x7e60
jmp 0x5916
leaq -0x220(%rbp), %rdi
callq 0x2290
jmp 0x5924
leaq -0x220(%rbp), %rdi
callq 0x22c0
addq $0x250, %rsp            # imm = 0x250
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x22c0
movq -0x228(%rbp), %rdi
callq 0x2340
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: pawan231[P]MiniDataBase/include/BPtree.h
// Function: BPtree::update_meta_data()
void update_meta_data()
    {
        char *str;
        str = (char *) malloc(sizeof(char) * BPTREE_MAX_FILE_PATH_SIZE);
        sprintf(str, "table/%s/tree/meta_tree.dat", tablename);
        std::ofstream out_file(str, std::ofstream::out | std::ofstream::trunc
                                        | std::ofstream::binary );
        out_file << files_till_now << " " << root_num;
        out_file.close();
        free(str);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp            # imm = 0x250
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x238(%rbp)
movl $0x3e8, %edi            # imm = 0x3E8
callq 0x2260
movq -0x238(%rbp), %rdx
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdx
leaq 0x62c6(%rip), %rsi      # 0xbcf4
xorl %eax, %eax
callq 0x2040
movq -0x10(%rbp), %rax
movq %rax, -0x240(%rbp)
movl $0x10, %edi
movl $0x20, %esi
callq 0x63b0
movl %eax, %edi
movl $0x4, %esi
callq 0x63b0
movq -0x240(%rbp), %rsi
movl %eax, %edx
leaq -0x210(%rbp), %rdi
movq %rdi, -0x230(%rbp)
callq 0x21d0
movq -0x238(%rbp), %rax
movq -0x230(%rbp), %rdi
movl (%rax), %esi
callq 0x2330
movq %rax, -0x228(%rbp)
jmp 0x5a95
movq -0x228(%rbp), %rdi
leaq 0x57f6(%rip), %rsi      # 0xb299
callq 0x2190
movq %rax, -0x248(%rbp)
jmp 0x5ab1
movq -0x248(%rbp), %rdi
movq -0x238(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x2330
jmp 0x5ac9
leaq -0x210(%rbp), %rdi
callq 0x2290
jmp 0x5ad7
movq -0x10(%rbp), %rdi
callq 0x2220
leaq -0x210(%rbp), %rdi
callq 0x22c0
addq $0x250, %rsp            # imm = 0x250
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x22c0
movq -0x218(%rbp), %rdi
callq 0x2340
nop
// File: pawan231[P]MiniDataBase/include/BPtree.h
// Function: Btreenode::operator=(Btreenode const&)
Btreenode & operator=(const Btreenode & n)
    {
        if (this != &n)
        {
            leaf = n.leaf;
            keys.assign(n.keys.begin(), n.keys.end());
            pointers.assign(n.pointers.begin(), n.pointers.end());
        }
        return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq -0x10(%rbp), %rax
je 0x5bcb
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
movb (%rcx), %cl
andb $0x1, %cl
movb %cl, (%rax)
addq $0x20, %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x81e0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x8210
movq -0x48(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x8580
movq -0x38(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x81e0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x8210
movq -0x40(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x8580
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: pawan231[P]MiniDataBase/include/BPtree.h
// Function: Btreenode::copy_first(Btreenode&, int)
void copy_first(Btreenode & node, int n)
    {
        keys.clear();
        pointers.clear();
        for (int i = 1; i < n; i++)
        {
            keys.push_back(node.get_key(i));
            pointers.push_back(node.get_pointer(i));
        }
        pointers.push_back(node.get_pointer(n));
        if (leaf)
        {
            keys.push_back(node.get_key(n));
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x20, %rdi
callq 0x8b20
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x8b20
movl $0x1, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x5c7b
movq -0x30(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x54a0
movq -0x40(%rbp), %rdi
movl %eax, -0x1c(%rbp)
leaq -0x1c(%rbp), %rsi
callq 0x8b40
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x54d0
movq -0x38(%rbp), %rdi
movl %eax, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x8b40
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5c18
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x54d0
movq -0x48(%rbp), %rdi
movl %eax, -0x24(%rbp)
leaq -0x24(%rbp), %rsi
callq 0x8b40
movq -0x30(%rbp), %rax
testb $0x1, (%rax)
je 0x5cd4
movq -0x30(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x54a0
movq -0x50(%rbp), %rdi
movl %eax, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x8b40
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: pawan231[P]MiniDataBase/include/BPtree.h
// Function: Btreenode::copy_last(Btreenode&, int)
void copy_last(Btreenode & node, int n)
    {
        keys.clear();
        pointers.clear();
        int lim = node.num_pointers();
        for (int i = n + 1; i <= lim; i++)
        {
            pointers.push_back(node.get_pointer(i));
        }
        lim = node.num_keys();
        for (int i = n + 1; i <= lim; i++)
        {
            keys.push_back(node.get_key(i));
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x20, %rdi
callq 0x8b20
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x8b20
movq -0x10(%rbp), %rdi
callq 0x5480
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jg 0x5da1
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x54d0
movq -0x38(%rbp), %rdi
movl %eax, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x8b40
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5d66
movq -0x10(%rbp), %rdi
callq 0x55c0
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x18(%rbp), %eax
jg 0x5df1
movq -0x30(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x54a0
movq -0x40(%rbp), %rdi
movl %eax, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x8b40
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5db6
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: pawan231[P]MiniDataBase/include/BPtree.h
// Function: operator>>(std::basic_ifstream<char, std::char_traits<char>>&, Btreenode&)
std::ifstream & operator>>(std::ifstream & is, Btreenode & en)
    {
        int ts;
        is >> en.leaf;
        is >> ts;
        en.keys.resize(ts);
        for (int i = 0; i < ts; i++)
        {
            is >> en.keys[i];
        }
        is >> ts;
        en.pointers.resize(ts);
        for (int i = 0; i < ts; i++)
        {
            is >> en.pointers[i];
        }
        is >> en.next_node;
        return is;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2150
movq -0x8(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x2100
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
movslq -0x14(%rbp), %rsi
callq 0x64d0
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x644a
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
movslq -0x18(%rbp), %rsi
callq 0x6560
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x2100
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x6412
movq -0x8(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x2100
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movslq -0x14(%rbp), %rsi
callq 0x64d0
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x64a7
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x6560
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x2100
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x646f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x38, %rsi
callq 0x2100
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: pawan231[P]MiniDataBase/include/BPtree.h
// Function: operator<<(std::basic_ofstream<char, std::char_traits<char>>&, Btreenode const&)
std::ofstream & operator<<(std::ofstream & os, const Btreenode & en)
    {
        os << en.leaf << " ";
        os << (int) en.keys.size() << " ";
        for (unsigned int i = 0; i < en.keys.size(); i++)
        {
            os << en.keys[i] << " ";
        }
        os << (int) en.pointers.size() << " ";
        for (unsigned int i = 0; i < en.pointers.size(); i++)
        {
            os << en.pointers[i] << " ";
        }
        os << en.next_node;
        return os;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movb (%rax), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x2360
movq %rax, %rdi
leaq 0x340b(%rip), %rsi      # 0xb299
callq 0x2190
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x6580
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0x2330
movq %rax, %rdi
leaq 0x33dc(%rip), %rsi      # 0xb299
callq 0x2190
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x6580
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x7f28
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x7fe0
movq -0x30(%rbp), %rdi
movl (%rax), %esi
callq 0x2330
movq %rax, %rdi
leaq 0x3381(%rip), %rsi      # 0xb299
callq 0x2190
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7ec9
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x6580
movq -0x38(%rbp), %rdi
movl %eax, %esi
callq 0x2330
movq %rax, %rdi
leaq 0x3347(%rip), %rsi      # 0xb299
callq 0x2190
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x6580
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x7fbd
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x7fe0
movq -0x48(%rbp), %rdi
movl (%rax), %esi
callq 0x2330
movq %rax, %rdi
leaq 0x32ec(%rip), %rsi      # 0xb299
callq 0x2190
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x7f5e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x38(%rax), %esi
callq 0x2330
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ocornoc[P]crolol/tests/basic_arith.cpp
// Function: main
int main()
{
	bool success = true;
	
	success &= add_test();
	success &= sub_test();
	success &= mul_test();
	success &= div_test();
	success &= pow_test();
	success &= mod_test();
	
	return success ? EXIT_SUCCESS : EXIT_FAILURE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movb $0x1, -0x5(%rbp)
callq 0x7d30
andb $0x1, %al
movzbl %al, %ecx
movb -0x5(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x5(%rbp)
callq 0x8020
andb $0x1, %al
movzbl %al, %ecx
movb -0x5(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x5(%rbp)
callq 0x8310
andb $0x1, %al
movzbl %al, %ecx
movb -0x5(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x5(%rbp)
callq 0x8600
andb $0x1, %al
movzbl %al, %ecx
movb -0x5(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x5(%rbp)
callq 0x88f0
andb $0x1, %al
movzbl %al, %ecx
movb -0x5(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x5(%rbp)
callq 0x8be0
andb $0x1, %al
movzbl %al, %ecx
movb -0x5(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x5(%rbp)
movb -0x5(%rbp), %dl
movl $0x1, %eax
xorl %ecx, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ocornoc[P]crolol/src/num.cpp
// Function: crolol::num::operator+=(crolol::num)
num& num::operator+=(num rhs)
{
	// If the sign of lhs and rhs aren't the same, we can always add.
	// Same if either args are 0.
	if ((bi < 0) != (rhs.bi < 0) || bi == 0 || rhs.bi == 0)
		bi += rhs.bi;
	else if (bi < 0) {
		if (num_min - bi > rhs.bi)
			bi = num_min;
		else bi += rhs.bi;
	} else {
		if (num_max - bi < rhs.bi)
			bi = num_max;
		else bi += rhs.bi;
	}
	
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, (%rax)
setl %al
andb $0x1, %al
movzbl %al, %eax
cmpq $0x0, -0x8(%rbp)
setl %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x9e33
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x9e33
cmpq $0x0, -0x8(%rbp)
jne 0x9e46
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
addq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x9ec6
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jge 0x9e8a
movq -0x18(%rbp), %rcx
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
subq (%rcx), %rax
cmpq -0x8(%rbp), %rax
jle 0x9e7a
movq -0x18(%rbp), %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
movq %rcx, (%rax)
jmp 0x9e88
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
addq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x9ec4
movq -0x18(%rbp), %rcx
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
subq (%rcx), %rax
cmpq -0x8(%rbp), %rax
jge 0x9eb4
movq -0x18(%rbp), %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
movq %rcx, (%rax)
jmp 0x9ec2
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
addq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x9ec4
jmp 0x9ec6
movq -0x18(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: ocornoc[P]crolol/src/num.cpp
// Function: crolol::num::operator-=(crolol::num)
num& num::operator-=(num rhs)
{
	// If sgn(lhs) == sgn(rhs) or rhs or lhs == 0, we can subtract.
	// EXCEPT if rhs == num_min, as that would allow 0-(-2^63)=2^63.
	if (((bi < 0) == (rhs.bi < 0)) ||
		((rhs.bi == 0 || bi == 0) && rhs.bi != num_min))
		bi -= rhs.bi;
	else if (rhs.bi == num_min) *this += num::max();
	else *this += -rhs.bi;
	
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, (%rax)
setl %al
andb $0x1, %al
movzbl %al, %eax
cmpq $0x0, -0x8(%rbp)
setl %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x9f27
cmpq $0x0, -0x8(%rbp)
je 0x9f17
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x9f3a
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
cmpq %rax, -0x8(%rbp)
je 0x9f3a
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rdx
movq (%rax), %rcx
subq %rdx, %rcx
movq %rcx, (%rax)
jmp 0x9f82
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
cmpq %rax, -0x8(%rbp)
jne 0x9f62
callq 0x9b30
movq -0x28(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
callq 0x9df0
jmp 0x9f80
xorl %eax, %eax
movl %eax, %esi
subq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x9250
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x9df0
jmp 0x9f82
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: ocornoc[P]crolol/src/num.cpp
// Function: crolol::num::operator*=(crolol::num)
num& num::operator*=(num rhs)
{
	const backend::saferet result = backend::multiply(bi, rhs.bi);
	
	switch (result.flow) {
		case backend::badarg: throw std::invalid_argument("Bad mult");
		case backend::underflow: *this = num::min(); return *this;
		case backend::overflow: *this = num::max(); return *this;
		default: *this = result.val; return *this;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xadf0
movl %edx, -0x30(%rbp)
movq %rax, -0x38(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x64(%rbp)
subl $0x1, %eax
je 0xa041
jmp 0x9fd9
movl -0x64(%rbp), %eax
subl $0x2, %eax
je 0xa05e
jmp 0x9fe3
movl -0x64(%rbp), %eax
subl $0x3, %eax
jne 0xa07b
jmp 0x9ff1
movl $0x10, %edi
callq 0x5190
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x78(%rbp)
leaq 0x22158(%rip), %rsi     # 0x2c164
callq 0x56f0
jmp 0xa013
movq -0x78(%rbp), %rdi
movq 0x35fba(%rip), %rsi     # 0x3ffd8
movq 0x35fa3(%rip), %rdx     # 0x3ffc8
callq 0x5680
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x52f0
jmp 0xa0a4
callq 0x9b00
movq %rax, %rcx
movq -0x70(%rbp), %rax
movq %rcx, -0x50(%rbp)
movq -0x50(%rbp), %rcx
movq %rcx, (%rax)
movq %rax, -0x8(%rbp)
jmp 0xa097
callq 0x9b30
movq %rax, %rcx
movq -0x70(%rbp), %rax
movq %rcx, -0x58(%rbp)
movq -0x58(%rbp), %rcx
movq %rcx, (%rax)
movq %rax, -0x8(%rbp)
jmp 0xa097
movq -0x28(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x9250
movq -0x70(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, (%rax)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x56b0
nopl (%rax)
// File: ocornoc[P]crolol/src/num.cpp
// Function: crolol::num::operator/=(crolol::num)
num& num::operator/=(num rhs)
{
	const backend::saferet result = backend::divide(bi, rhs.bi);
	
	switch (result.flow) {
		case backend::badarg: throw std::invalid_argument("Bad div");
		case backend::underflow: *this = num::min(); return *this;
		case backend::overflow: *this = num::max(); return *this;
		default: *this = result.val; return *this;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xaf80
movl %edx, -0x30(%rbp)
movq %rax, -0x38(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x64(%rbp)
subl $0x1, %eax
je 0xa161
jmp 0xa0f9
movl -0x64(%rbp), %eax
subl $0x2, %eax
je 0xa17e
jmp 0xa103
movl -0x64(%rbp), %eax
subl $0x3, %eax
jne 0xa19b
jmp 0xa111
movl $0x10, %edi
callq 0x5190
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x78(%rbp)
leaq 0x22041(%rip), %rsi     # 0x2c16d
callq 0x56f0
jmp 0xa133
movq -0x78(%rbp), %rdi
movq 0x35e9a(%rip), %rsi     # 0x3ffd8
movq 0x35e83(%rip), %rdx     # 0x3ffc8
callq 0x5680
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x52f0
jmp 0xa1c4
callq 0x9b00
movq %rax, %rcx
movq -0x70(%rbp), %rax
movq %rcx, -0x50(%rbp)
movq -0x50(%rbp), %rcx
movq %rcx, (%rax)
movq %rax, -0x8(%rbp)
jmp 0xa1b7
callq 0x9b30
movq %rax, %rcx
movq -0x70(%rbp), %rax
movq %rcx, -0x58(%rbp)
movq -0x58(%rbp), %rcx
movq %rcx, (%rax)
movq %rax, -0x8(%rbp)
jmp 0xa1b7
movq -0x28(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x9250
movq -0x70(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, (%rax)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x56b0
nopl (%rax)
// File: ocornoc[P]crolol/src/num.cpp
// Function: crolol::num::operator%=(crolol::num)
num& num::operator%=(num rhs)
{
	const bool sign = rhs.bi < 0;
	
	bi = abs(*this).bi % abs(rhs).bi;
	
	if (sign) *this = -*this;
	
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x8(%rbp)
setl %cl
andb $0x1, %cl
movb %cl, -0x11(%rbp)
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xa280
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0xa280
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, -0x30(%rbp)
cqto
idivq -0x30(%rbp)
movq -0x50(%rbp), %rax
movq %rdx, (%rax)
testb $0x1, -0x11(%rbp)
je 0xa267
movq -0x50(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0xa2d0
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, -0x40(%rbp)
movq -0x40(%rbp), %rcx
movq %rcx, (%rax)
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ocornoc[P]crolol/src/num.cpp
// Function: operator^(crolol::num, crolol::num)
num operator^(num lhs, num rhs)
{
	const backend::saferet result = backend::pow(lhs.bi, rhs.bi);
	int64_t newv;
	
	switch (result.flow) {
		case backend::badarg: throw std::invalid_argument("Bad pow");
		case backend::underflow: newv = num_min; return newv;
		case backend::overflow: newv = num_max; return newv;
		default: newv = result.val; return newv;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xb0c0
movl %edx, -0x30(%rbp)
movq %rax, -0x38(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x50(%rbp)
subl $0x1, %eax
je 0xa4f7
jmp 0xa48f
movl -0x50(%rbp), %eax
subl $0x2, %eax
je 0xa514
jmp 0xa499
movl -0x50(%rbp), %eax
subl $0x3, %eax
jne 0xa531
jmp 0xa4a7
movl $0x10, %edi
callq 0x5190
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
leaq 0x21cb3(%rip), %rsi     # 0x2c175
callq 0x56f0
jmp 0xa4c9
movq -0x58(%rbp), %rdi
movq 0x35b04(%rip), %rsi     # 0x3ffd8
movq 0x35aed(%rip), %rdx     # 0x3ffc8
callq 0x5680
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x52f0
jmp 0xa550
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x9250
jmp 0xa546
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x9250
jmp 0xa546
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x9250
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x56b0
nopl (%rax)
// File: ocornoc[P]crolol/src/losslessops.cpp
// Function: clamp(boost::multiprecision::number<boost::multiprecision::backends::cpp_int_backend<128u, 128u, (boost::multiprecision::cpp_integer_type)1, (boost::multiprecision::cpp_int_check_type)0, void>, (boost::multiprecision::expression_template_option)0> const&)
static saferet clamp(const int128& n)
{
	saferet out;
	out.val = static_cast<int64_t>(n);
	
	if (n > static_cast<int128>(slmax))
		out.flow = overflow;
	else if (n < static_cast<int128>(slmin))
		out.flow = underflow;

	return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x22530
movq -0x18(%rbp), %rdi
callq 0x22550
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x40(%rbp), %rdi
leaq 0x212f3(%rip), %rsi     # 0x2c208
xorl %eax, %eax
movl %eax, %edx
callq 0xbc50
movq -0x68(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x22570
testb $0x1, %al
jne 0xaf31
jmp 0xaf3a
movl $0x2, -0x8(%rbp)
jmp 0xaf72
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x60(%rbp), %rdi
leaq 0x212cb(%rip), %rsi     # 0x2c218
xorl %eax, %eax
movl %eax, %edx
callq 0xbc50
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x225d0
testb $0x1, %al
jne 0xaf69
jmp 0xaf70
movl $0x1, -0x8(%rbp)
jmp 0xaf72
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %edx
addq $0x70, %rsp
popq %rbp
retq
nop
// File: ocornoc[P]crolol/src/losslessops.cpp
// Function: crolol::backend::factorial(long)
saferet backend::factorial(int64_t n)
{
	if (n < 0 or n % scale != 0) return make_badarg(n);
	
	saferet acc = clamp(scale);
	
	for (int64_t i = 0; i < n && acc.flow == noflow; i += scale)
		acc = multiply(acc.val, i);
	
	return acc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jl 0xb4ca
movq -0x18(%rbp), %rax
movl $0x3e8, %ecx            # imm = 0x3E8
cqto
idivq %rcx
cmpq $0x0, %rdx
je 0xb4ed
movq -0x18(%rbp), %rdi
callq 0xb080
movl %edx, -0x20(%rbp)
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0xb5a4
leaq 0x20d1c(%rip), %rsi     # 0x2c210
xorl %eax, %eax
movl %eax, %edx
leaq -0x50(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0xbc50
movq -0x90(%rbp), %rdi
callq 0xaee0
movl %edx, -0x58(%rbp)
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x58(%rbp), %eax
movl %eax, -0x8(%rbp)
movq $0x0, -0x68(%rbp)
movq -0x68(%rbp), %rcx
xorl %eax, %eax
cmpq -0x18(%rbp), %rcx
movb %al, -0x91(%rbp)
jge 0xb550
cmpl $0x0, -0x8(%rbp)
sete %al
movb %al, -0x91(%rbp)
movb -0x91(%rbp), %al
testb $0x1, %al
jne 0xb55c
jmp 0xb5a2
movq -0x10(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0xadf0
movl %edx, -0x80(%rbp)
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0x78(%rbp)
movl -0x80(%rbp), %eax
movl %eax, -0x70(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x70(%rbp), %eax
movl %eax, -0x8(%rbp)
movq -0x68(%rbp), %rax
addq $0x3e8, %rax            # imm = 0x3E8
movq %rax, -0x68(%rbp)
jmp 0xb531
jmp 0xb5a4
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %edx
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ocornoc[P]crolol/src/losslessops.cpp
// Function: crolol::backend::asin(long)
saferet backend::asin(int64_t n)
{
	if (n > scale or n < -scale) return make_badarg(n);
	else return clamp(static_cast<int128>(
		std::truncl(std::asin(
			static_cast<long double>(n) / scale
		)) * scale * radtodeg
	));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x18(%rbp)
cmpq $0x3e8, -0x18(%rbp)     # imm = 0x3E8
jg 0xb7a3
cmpq $-0x3e8, -0x18(%rbp)    # imm = 0xFC18
jge 0xb7c3
movq -0x18(%rbp), %rdi
callq 0xb080
movl %edx, -0x20(%rbp)
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0xb838
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
fildll -0x78(%rbp)
flds 0x2098c(%rip)           # 0x2c160
fld %st(0)
fstpt -0x8c(%rbp)
fdivrp %st, %st(1)
movq %rsp, %rax
fstpt (%rax)
callq 0xc0e0
movq %rsp, %rax
fstpt (%rax)
callq 0x5040
fldt -0x8c(%rbp)
fmulp %st, %st(1)
fldt 0x209e0(%rip)           # 0x2c1e0
fmulp %st, %st(1)
fstpt -0x60(%rbp)
xorl %eax, %eax
movl %eax, %edx
leaq -0x50(%rbp), %rdi
movq %rdi, -0x80(%rbp)
leaq -0x60(%rbp), %rsi
callq 0xc040
movq -0x80(%rbp), %rdi
callq 0xaee0
movl %edx, -0x68(%rbp)
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x68(%rbp), %eax
movl %eax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %edx
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax,%rax)