LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/stefpant[P]TCPserver/webcrawler/functions.c
// Function: getDir
char* getDir(char* page,char* d){
	int i=1;
	while(1){
		if(page[i++] == '/'){
			page[i-1]='\0';
			break;
		}
	}
	char* dir=malloc((strlen(page)+strlen(d)+1)*sizeof(char));
	strcpy(dir,d);
	strcat(dir,page);
	return dir;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x14(%rbp)
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
jne 0x2c65
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
jmp 0x2c67
jmp 0x2c37
movq -0x8(%rbp), %rdi
callq 0x20e0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20e0
movq -0x28(%rbp), %rdi
addq %rax, %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x2220
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2070
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x2310
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stefpant[P]TCPserver/webcrawler/functions.c
// Function: save_page
int save_page(char* page,char* dir,char* content){

	if(content[9]!='2' || content[10]!='0' || content[11]!='0') return -1;//wrong file

	char *fname=malloc((strlen(page)+strlen(dir)+2)*sizeof(char));
	strcpy(fname,dir);
	strcat(fname,"/");
	strcat(fname,page);
	char* pagedir = getDir(page,dir);
	DIR* d = opendir(pagedir);
	if(d){//dir exists
		closedir(d);
	}
	else if(errno == ENOENT){//dir doesn't exists
		mkdir(pagedir,0700);
	}
	free(pagedir);
	FILE* fp=fopen(fname,"w");
	if(!fp) {free(fname);free(pagedir);return -1;}//couldn't create file
	int start=skip_header(content);//return a pointer after a header to copy the file

	fprintf(fp,"%s",content+start);

	free(fname);
	fclose(fp);
	return start;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl 0x9(%rax), %eax
cmpl $0x32, %eax
jne 0x2d5b
movq -0x20(%rbp), %rax
movsbl 0xa(%rax), %eax
cmpl $0x30, %eax
jne 0x2d5b
movq -0x20(%rbp), %rax
movsbl 0xb(%rax), %eax
cmpl $0x30, %eax
je 0x2d67
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2e89
movq -0x10(%rbp), %rdi
callq 0x20e0
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20e0
movq -0x50(%rbp), %rdi
addq %rax, %rdi
addq $0x2, %rdi
shlq $0x0, %rdi
callq 0x2220
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2070
movq -0x28(%rbp), %rdi
leaq 0x2422(%rip), %rsi      # 0x51cf
callq 0x2310
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2310
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2c20
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x20d0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x2def
movq -0x38(%rbp), %rdi
callq 0x2140
jmp 0x2e09
callq 0x2040
cmpl $0x2, (%rax)
jne 0x2e07
movq -0x30(%rbp), %rdi
movl $0x1c0, %esi            # imm = 0x1C0
callq 0x2080
jmp 0x2e09
movq -0x30(%rbp), %rdi
callq 0x2030
movq -0x28(%rbp), %rdi
leaq 0x256c(%rip), %rsi      # 0x5389
callq 0x22d0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x2e48
movq -0x28(%rbp), %rdi
callq 0x2030
movq -0x30(%rbp), %rdi
callq 0x2030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2e89
movq -0x20(%rbp), %rdi
callq 0x2cc0
movl %eax, -0x44(%rbp)
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rdx
movslq -0x44(%rbp), %rax
addq %rax, %rdx
leaq 0x21e6(%rip), %rsi      # 0x5050
movb $0x0, %al
callq 0x21a0
movq -0x28(%rbp), %rdi
callq 0x2030
movq -0x40(%rbp), %rdi
callq 0x20c0
movl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stefpant[P]TCPserver/webcrawler/functions.c
// Function: getURL
char* getURL(char* x){
	if(strlen(x)<5) return NULL;
	x[4]='\0';//should be '=' in x[4]
	if(strcmp(x,"href")) return NULL;
	int c=5;
	while(1){
		if('>' == x[c]){x[c]='\0';break;}
		else if('\0' == x[c++]) return NULL;
	}
	char* ret=malloc((strlen(x+5)+1)*sizeof(char));
	strcpy(ret,x+5);
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20e0
cmpq $0x5, %rax
jae 0x2ec8
movq $0x0, -0x8(%rbp)
jmp 0x2f80
movq -0x10(%rbp), %rax
movb $0x0, 0x4(%rax)
movq -0x10(%rbp), %rdi
leaq 0x2178(%rip), %rsi      # 0x5053
callq 0x2180
cmpl $0x0, %eax
je 0x2ef2
movq $0x0, -0x8(%rbp)
jmp 0x2f80
movl $0x5, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movl $0x3e, %eax
cmpl %ecx, %eax
jne 0x2f1c
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x2f46
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x14(%rbp)
movslq %ecx, %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x2f42
movq $0x0, -0x8(%rbp)
jmp 0x2f80
jmp 0x2f44
jmp 0x2ef9
movq -0x10(%rbp), %rdi
addq $0x5, %rdi
callq 0x20e0
movq %rax, %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x2220
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x5, %rsi
callq 0x2070
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/stefpant[P]TCPserver/webcrawler/functions.c
// Function: search_new_pages
char** search_new_pages(char* text,int start,int* finalcounter){
	char **res=malloc(sizeof(char*));
	int counter=0;
	char* word;
	char* suburl=NULL;
	while(start!=-1){
		word = NULL;
		start = nextWord(text,&word,start);//save word
		if(start<-1) break;
		if(!strcmp(word,"<a")){//maybe a first step to find new url
			free(word);
			word=NULL;
			start = nextWord(text,&word,start);
			if(start<-1) break;
			suburl=getURL(word);
			if(suburl == NULL){free(word);continue;}//not url here :-(
			if(counter++)
				res=realloc(res,(counter+1)*sizeof(char*));
			res[counter-1]=suburl;
			suburl=NULL;
		}
		free(word);
	}
	*finalcounter=counter;
	return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x8, %edi
callq 0x2220
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq $0x0, -0x38(%rbp)
cmpl $-0x1, -0xc(%rbp)
je 0x30ac
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq -0x30(%rbp), %rsi
callq 0x29b0
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
jge 0x2ff0
jmp 0x30ac
movq -0x30(%rbp), %rdi
leaq 0x205d(%rip), %rsi      # 0x5058
callq 0x2180
cmpl $0x0, %eax
jne 0x309e
movq -0x30(%rbp), %rdi
callq 0x2030
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq -0x30(%rbp), %rsi
callq 0x29b0
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
jge 0x3035
jmp 0x30ac
movq -0x30(%rbp), %rdi
callq 0x2ea0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x3057
movq -0x30(%rbp), %rdi
callq 0x2030
jmp 0x2fc0
movl -0x24(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x24(%rbp)
cmpl $0x0, %eax
je 0x3081
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
shlq $0x3, %rsi
callq 0x2240
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rdx
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movq $0x0, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x2030
jmp 0x2fc0
movl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stefpant[P]TCPserver/webcrawler/functions.c
// Function: createDocfile
void createDocfile(char* root,char* name){
	FILE* fp=fopen(name,"w");
	struct dirent *d;
	DIR *dir = opendir(root);
	char* founddir=NULL;
	if(dir == NULL)//gdir not a directory
		return;
	while((d = readdir(dir)) != NULL){
		if(d->d_type != DT_DIR) continue;//d not a directory
		if(!strcmp(d->d_name,".") || !strcmp(d->d_name,"..")) continue;//ignore '.','..'
		founddir = malloc((strlen(root)+strlen(d->d_name)+2)*sizeof(char));
		strcpy(founddir,root);
		strcat(founddir,"/");
		strcat(founddir,d->d_name);
		fprintf(fp,"%s\n",founddir);
		free(founddir);
		founddir=NULL;
	}
	closedir(dir);
	fclose(fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x22ae(%rip), %rsi      # 0x5389
callq 0x22d0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20d0
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x3105
jmp 0x31ff
jmp 0x3107
movq -0x28(%rbp), %rdi
callq 0x2200
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x31ed
movq -0x20(%rbp), %rax
movzbl 0x12(%rax), %eax
cmpl $0x4, %eax
je 0x312d
jmp 0x3107
movq -0x20(%rbp), %rdi
addq $0x13, %rdi
leaq 0x1f20(%rip), %rsi      # 0x505c
callq 0x2180
cmpl $0x0, %eax
je 0x315f
movq -0x20(%rbp), %rdi
addq $0x13, %rdi
leaq 0x1f06(%rip), %rsi      # 0x505b
callq 0x2180
cmpl $0x0, %eax
jne 0x3161
jmp 0x3107
movq -0x8(%rbp), %rdi
callq 0x20e0
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
addq $0x13, %rdi
callq 0x20e0
movq -0x38(%rbp), %rdi
addq %rax, %rdi
addq $0x2, %rdi
shlq $0x0, %rdi
callq 0x2220
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x2070
movq -0x30(%rbp), %rdi
leaq 0x2024(%rip), %rsi      # 0x51cf
callq 0x2310
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x13, %rsi
callq 0x2310
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq 0x2060(%rip), %rsi      # 0x5230
movb $0x0, %al
callq 0x21a0
movq -0x30(%rbp), %rdi
callq 0x2030
movq $0x0, -0x30(%rbp)
jmp 0x3107
movq -0x28(%rbp), %rdi
callq 0x2140
movq -0x18(%rbp), %rdi
callq 0x20c0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stefpant[P]TCPserver/webcrawler/functions.c
// Function: isIP
int isIP(char *name){//ip4: xxx.xxx.xxx.xxx(maxlen=15)
	if(name==NULL) return 0;
	char c;
	int i=0;
	int dots=0,digs=0;
	while( (c=name[i++]) != '\0' ){
		if(c == '.') dots++;
		else if( (c>='0') && (c<='9')) digs++;
		else return 0;//not ip

		if((dots > 3) || (digs > 12)) return 0;
	}
	if( (dots != 3) || (digs<4) ) return 0;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x322b
movl $0x0, -0x4(%rbp)
jmp 0x32cf
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x18(%rbp)
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
movsbl %al, %eax
cmpl $0x0, %eax
je 0x32b3
movsbl -0x11(%rbp), %eax
cmpl $0x2e, %eax
jne 0x3274
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x329c
movsbl -0x11(%rbp), %eax
cmpl $0x30, %eax
jl 0x3291
movsbl -0x11(%rbp), %eax
cmpl $0x39, %eax
jg 0x3291
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x329a
movl $0x0, -0x4(%rbp)
jmp 0x32cf
jmp 0x329c
cmpl $0x3, -0x1c(%rbp)
jg 0x32a8
cmpl $0xc, -0x20(%rbp)
jle 0x32b1
movl $0x0, -0x4(%rbp)
jmp 0x32cf
jmp 0x3240
cmpl $0x3, -0x1c(%rbp)
jne 0x32bf
cmpl $0x4, -0x20(%rbp)
jge 0x32c8
movl $0x0, -0x4(%rbp)
jmp 0x32cf
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/stefpant[P]TCPserver/webcrawler/input_parse.c
// Function: isDirEmpty
int isDirEmpty(char* gdir){
	int n=0;
	struct dirent *d;
	DIR *dir = opendir(gdir);
	if(dir == NULL)//gdir not a directory
		return -1;
	while((d = readdir(dir)) != NULL){
		if(++n > 2) {closedir(dir);return -2;}//not empty gdir
	}
	closedir(dir);
	return 0;//empty dir
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20d0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x3310
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3357
jmp 0x3312
movq -0x28(%rbp), %rdi
callq 0x2200
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x3347
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x2, %eax
jle 0x3345
movq -0x28(%rbp), %rdi
callq 0x2140
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x3357
jmp 0x3312
movq -0x28(%rbp), %rdi
callq 0x2140
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/stefpant[P]TCPserver/webcrawler/webcrawler.c
// Function: checkinPU
int checkinPU(char** url){
	int counter=0;
	int flag=0;
	while(1){
		pthread_mutex_lock(&pumtx);
		if(counter==pucounter) break;//url not found
		if(!strcmp(placedurls[counter++],*url)) flag=1;
		pthread_mutex_unlock(&pumtx);
		if(flag) return 1;//found
	}
	//still mutex locked
	pucounter++;
	placedurls = realloc(placedurls,pucounter*sizeof(char*));
	placedurls[pucounter-1]=*url;
	pthread_mutex_unlock(&pumtx);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
leaq 0x39bf(%rip), %rdi      # 0x7210
callq 0x2390
movl -0x14(%rbp), %eax
cmpl 0x39a9(%rip), %eax      # 0x7208
jne 0x3863
jmp 0x38b1
movq 0x3996(%rip), %rax      # 0x7200
movl -0x14(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x14(%rbp)
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x2180
cmpl $0x0, %eax
jne 0x3894
movl $0x1, -0x18(%rbp)
leaq 0x3975(%rip), %rdi      # 0x7210
callq 0x2210
cmpl $0x0, -0x18(%rbp)
je 0x38af
movl $0x1, -0x4(%rbp)
jmp 0x390f
jmp 0x384a
movl 0x3951(%rip), %eax      # 0x7208
addl $0x1, %eax
movl %eax, 0x3948(%rip)      # 0x7208
movq 0x3939(%rip), %rdi      # 0x7200
movslq 0x393a(%rip), %rsi      # 0x7208
shlq $0x3, %rsi
callq 0x2240
movq %rax, 0x3922(%rip)      # 0x7200
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movq 0x3914(%rip), %rax      # 0x7200
movl 0x3916(%rip), %ecx      # 0x7208
subl $0x1, %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
leaq 0x390d(%rip), %rdi      # 0x7210
callq 0x2210
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stefpant[P]TCPserver/webcrawler/webcrawler.c
// Function: destroyPU
void destroyPU(void){
	//no need to lock just free memory
	for(int i=0;i<pucounter;i++)
		free(placedurls[i]);
	free(placedurls);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x38d0(%rip), %eax      # 0x7208
jge 0x3959
movq 0x38bf(%rip), %rax      # 0x7200
movslq -0x4(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2030
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x392f
movq 0x38a0(%rip), %rdi      # 0x7200
callq 0x2030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stefpant[P]TCPserver/webcrawler/webcrawler.c
// Function: urlpool_init
void urlpool_init(urlpool** up){
	(*up) = malloc(sizeof(urlpool));
	(*up)->urls = malloc(MAXR*sizeof(char*));
	(*up)->size = MAXR;
	//(*up)->start = 0;2
	(*up)->end = -1;
	(*up)->count = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x18, %edi
callq 0x2220
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl $0x50, %edi
callq 0x2220
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl $0xa, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl $0x0, 0xc(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stefpant[P]TCPserver/webcrawler/webcrawler.c
// Function: urlpool_clear
void urlpool_clear(urlpool** up){//clearing pool
	while(1){
		pthread_mutex_lock(&mtx);
		if( (*up)->count == 0 ){
			pthread_mutex_unlock(&mtx);
			return;
		}
		free( (*up)->urls[(*up)->end] );
		(*up)->end--;
		(*up)->count--;
		pthread_mutex_unlock(&mtx);
	}
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x3845(%rip), %rdi      # 0x7238
callq 0x2390
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0xc(%rax)
jne 0x3a17
leaq 0x382c(%rip), %rdi      # 0x7238
callq 0x2210
addq $0x10, %rsp
popq %rbp
retq
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movslq 0x10(%rcx), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0xc(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0xc(%rax)
leaq 0x37dc(%rip), %rdi      # 0x7238
callq 0x2210
jmp 0x39ec
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stefpant[P]TCPserver/webcrawler/webcrawler.c
// Function: place
void place(urlpool** up,char* url){// place url in buffer
	pthread_mutex_lock(&mtx);
	//while((*up)->count>=MAXR){3
	if((*up)->count>=(*up)->size){//full pool->realloc
		(*up)->size*=2;
		(*up)->urls=realloc((*up)->urls,(*up)->size*sizeof(char*));
		//printf("Pool found full\n");
		//pthread_cond_wait(&cv_notfull,&mtx);4
	}
	(*up)->end = ((*up)->end+1);//%MAXR;
	(*up)->urls[(*up)->end] = malloc((strlen(url)+1)*sizeof(char));
	strcpy((*up)->urls[(*up)->end],url);
	//printf("placed: %d\n",(*ra)->fds[(*ra)->end]);
	(*up)->count++;
	pthread_mutex_unlock(&mtx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x3781(%rip), %rdi      # 0x7238
callq 0x2390
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0xc(%rax), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpl 0x8(%rcx), %eax
jl 0x3b0c
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x8(%rax), %ecx
shll %ecx
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq 0x8(%rax), %rsi
shlq $0x3, %rsi
callq 0x2240
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0x20e0
movq %rax, %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x2220
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movslq 0x10(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movslq 0x10(%rcx), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
callq 0x2070
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
leaq 0x36a7(%rip), %rdi      # 0x7238
callq 0x2210
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stefpant[P]TCPserver/webcrawler/webcrawler.c
// Function: obtain
char* obtain(urlpool** up){//get request from buffer
	char* data;
	pthread_mutex_lock(&mtx);
	while( (*up)->count <= 0 ){
		//printf("Pool found empty\n");
		pthread_cond_wait(&cv_notempty,&mtx);
	}
	//data = malloc((strlen((*up)->urls[(*up)->start]) + 1)*sizeof(char));
	data = malloc((strlen((*up)->urls[(*up)->end]) + 1)*sizeof(char));
	//strcpy(data,(*up)->urls[(*up)->start]);
	strcpy(data,(*up)->urls[(*up)->end]);
	//free( (*up)->urls[(*up)->start] );
	free( (*up)->urls[(*up)->end] );
	//(*up)->start = ( (*up)->start + 1 ) % MAXR;
	(*up)->end--;
	(*up)->count--;
	pthread_mutex_unlock(&mtx);
	return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x3685(%rip), %rdi      # 0x7238
callq 0x2390
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0xc(%rax)
jg 0x3bda
leaq 0x3694(%rip), %rdi      # 0x7260
leaq 0x3665(%rip), %rsi      # 0x7238
callq 0x20b0
jmp 0x3bb8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movslq 0x10(%rcx), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x20e0
movq %rax, %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x2220
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movslq 0x10(%rcx), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x2070
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movslq 0x10(%rcx), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0xc(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0xc(%rax)
leaq 0x35c5(%rip), %rdi      # 0x7238
callq 0x2210
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/generot[P]VM-0/src/disasm.c
// Function: display_instr
void display_instr(instr *prog, size_t prog_sz, size_t entry) {
    for(size_t i = 0; i < prog_sz; i++) {
        const char *instr_to_display = prog[i].op == OPC_SYSCALL
            ? syscalls[prog[i].scall]
            : opcodes[prog[i].op - 0x10];

        if(i == entry)
            puts("----ENTRY POINT----");

        printf("0x%.2X: [ %s", (unsigned)i, instr_to_display);

        switch(prog[i].content_type) {
        case INST_ADDR:
            printf(" <0x%.2X>", (unsigned)prog[i].addr);
            break;
        case INST_VAL:
            printf(" %.3lf", prog[i].val);
            break;
        case INST_NOARGS:
            break;
        }
        
        puts(" ]");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x1314
movq -0x8(%rbp), %rax
imulq $0x18, -0x20(%rbp), %rcx
addq %rcx, %rax
cmpl $0x25, 0x4(%rax)
jne 0x122e
movq -0x8(%rbp), %rax
imulq $0x18, -0x20(%rbp), %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, %ecx
leaq 0x2f1c(%rip), %rax      # 0x4140
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
jmp 0x1253
movq -0x8(%rbp), %rax
imulq $0x18, -0x20(%rbp), %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
subl $0x10, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x2e35(%rip), %rax      # 0x4080
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x1271
leaq 0xe2d(%rip), %rdi       # 0x2099
callq 0x1030
movl -0x20(%rbp), %esi
movq -0x28(%rbp), %rdx
leaq 0xe2e(%rip), %rdi       # 0x20ad
xorl %eax, %eax
callq 0x1060
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
leaq (%rcx,%rcx,2), %rcx
movl (%rax,%rcx,8), %eax
movl %eax, -0x34(%rbp)
testl %eax, %eax
je 0x12d4
jmp 0x129e
movl -0x34(%rbp), %eax
subl $0x1, %eax
je 0x12b2
jmp 0x12a8
movl -0x34(%rbp), %eax
subl $0x2, %eax
je 0x12f5
jmp 0x12f7
movq -0x8(%rbp), %rax
imulq $0x18, -0x20(%rbp), %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movl %eax, %esi
leaq 0xdef(%rip), %rdi       # 0x20ba
movb $0x0, %al
callq 0x1060
jmp 0x12f7
movq -0x8(%rbp), %rax
imulq $0x18, -0x20(%rbp), %rcx
addq %rcx, %rax
movsd 0x10(%rax), %xmm0
leaq 0xdd8(%rip), %rdi       # 0x20c4
movb $0x1, %al
callq 0x1060
jmp 0x12f7
jmp 0x12f7
leaq 0xdcd(%rip), %rdi       # 0x20cb
callq 0x1030
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x11ec
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/generot[P]VM-0/src/disasm.c
// Function: main
int main(int argc, char **argv) {
    if(argc < 2)
        ISSUE_ERROR("Usage: ./dasm <bytecode_src>");

    bcode_file fl = read_bytecode(argv[1]);

    bool stack_size_provided = fl.metadata.stack_size_spec == STACK_SIZE_SPECIFIED;

    size_t code_seg_sz = !stack_size_provided ? CODE_SEG_SZ : fl.metadata.code_seg_sz;
    size_t data_seg_sz = !stack_size_provided ? DATA_SEG_SZ : fl.metadata.data_seg_sz;

    printf(
        "Program size: %I64u instructions\n"
        "Stack size%s: [Code segment: %I64u, Data segment: %I64u]\n"
        "Entry point address: 0x%.2X\n\n",
        fl.metadata.program_size,
        !stack_size_provided ? "(default)" : "",
        code_seg_sz, data_seg_sz,
        (unsigned)fl.metadata.entry_point_addr
    );

    display_instr(fl.prog, fl.metadata.program_size, 
        fl.metadata.entry_point_addr);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0x135e
movq 0x2cb5(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xd81(%rip), %rsi       # 0x20ce
movb $0x0, %al
callq 0x1090
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x10b0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x40(%rbp), %rdi
callq 0x14b0
cmpl $0x0, -0x28(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
jne 0x138f
movl $0x200, %eax            # imm = 0x200
movq %rax, -0x60(%rbp)
jmp 0x1397
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpl $0x0, -0x44(%rbp)
jne 0x13b0
movl $0x600, %eax            # imm = 0x600
movq %rax, -0x68(%rbp)
jmp 0x13b8
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x38(%rbp), %rsi
cmpl $0x0, -0x44(%rbp)
setne %cl
xorb $-0x1, %cl
leaq 0xd8e(%rip), %rdx       # 0x2163
leaq 0xd88(%rip), %rax       # 0x2164
testb $0x1, %cl
cmovneq %rax, %rdx
movq -0x50(%rbp), %rcx
movq -0x58(%rbp), %r8
movq -0x30(%rbp), %rax
movl %eax, %r9d
leaq 0xcf3(%rip), %rdi       # 0x20ec
movb $0x0, %al
callq 0x1060
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x11d0
xorl %eax, %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/generot[P]VM-0/src/vm/bytecode.c
// Function: dump_bytecode
void dump_bytecode(const char *filename, instr *program, size_t prog_sz, size_t entry_addr) {
    FILE *f = fopen(filename, "wb");

    bcode_header prog_metadata = {
        .program_size = prog_sz,
        .entry_point_addr = entry_addr,
        .stack_size_spec = STACK_SIZE_DEFAULT
    };

    fwrite(&prog_metadata, sizeof(bcode_header), 1, f);
    fwrite(program, sizeof(instr), prog_metadata.program_size, f);

    fclose(f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xd2b(%rip), %rsi       # 0x216e
callq 0x10a0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x1, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x28(%rbp), %rcx
leaq -0x50(%rbp), %rdi
movl $0x28, %esi
movl $0x1, %edx
callq 0x10c0
movq -0x10(%rbp), %rdi
movq -0x50(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl $0x18, %esi
callq 0x10c0
movq -0x28(%rbp), %rdi
callq 0x1050
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/generot[P]VM-0/src/vm/bytecode.c
// Function: read_bytecode
bcode_file read_bytecode(const char *filename) {
    FILE *f = fopen(filename, "rb");

    bcode_file new_file = {0};
    fread(&new_file.metadata, sizeof(bcode_header), 1, f);

    new_file.prog = calloc(new_file.metadata.program_size, sizeof(instr));
    fread(new_file.prog, sizeof(instr), new_file.metadata.program_size, f);

    fclose(f);

    return new_file;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xca2(%rip), %rsi       # 0x2171
callq 0x10a0
movq -0x20(%rbp), %rdi
movq %rax, -0x10(%rbp)
xorl %esi, %esi
movl $0x30, %edx
callq 0x1070
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rcx
movl $0x28, %esi
movl $0x1, %edx
callq 0x1040
movq -0x20(%rbp), %rdi
movq 0x8(%rdi), %rdi
movl $0x18, %esi
callq 0x1080
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq (%rax), %rdi
movq 0x8(%rax), %rdx
movq -0x10(%rbp), %rcx
movl $0x18, %esi
callq 0x1040
movq -0x10(%rbp), %rdi
callq 0x1050
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/evilwombat[P]gopro-fw-tools/fwunpacker.c
// Function: find_magic
static int find_magic(void)
{
	int c;
	int state = 0;
	
	while (!feof(fd)) {
		c = fgetc(fd);
		if (c < 0)
			return -1;

		switch (state) {
			case 0:
				if (c == 0x90)
					state = 1;
				else
					state = 0;

				break;
			case 1:
				if (c == 0xEB)
					state = 2;
				else
					state = 0;

				break;

			case 2:
				if (c == 0x24)
					state = 3;
				else
					state = 0;
				break;

			case 3:
				if (c == 0xA3) {
					return 0;

				} else
					state = 0;
				break;

			default:
				fprintf(stderr, "Unexpected state %u in find_magic", state);
				return -1;
		}

		if (c == 0x90)
			state = 1;
	}

	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0xc(%rbp)
movq 0x2c12(%rip), %rdi      # 0x4088
callq 0x10a0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x148c
jmp 0x1570
movq 0x2bf5(%rip), %rdi      # 0x4088
callq 0x1070
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x14ad
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1577
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x3, %rax
ja 0x1537
movq -0x18(%rbp), %rax
leaq 0xb3f(%rip), %rcx       # 0x2004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpl $0x90, -0x8(%rbp)
jne 0x14e0
movl $0x1, -0xc(%rbp)
jmp 0x14e7
movl $0x0, -0xc(%rbp)
jmp 0x155b
cmpl $0xeb, -0x8(%rbp)
jne 0x14fb
movl $0x2, -0xc(%rbp)
jmp 0x1502
movl $0x0, -0xc(%rbp)
jmp 0x155b
cmpl $0x24, -0x8(%rbp)
jne 0x1513
movl $0x3, -0xc(%rbp)
jmp 0x151a
movl $0x0, -0xc(%rbp)
jmp 0x155b
cmpl $0xa3, -0x8(%rbp)
jne 0x152e
movl $0x0, -0x4(%rbp)
jmp 0x1577
movl $0x0, -0xc(%rbp)
jmp 0x155b
movq 0x2aba(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movl -0xc(%rbp), %edx
leaq 0xbbd(%rip), %rsi       # 0x2108
movb $0x0, %al
callq 0x1080
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1577
cmpl $0x90, -0x8(%rbp)
jne 0x156b
movl $0x1, -0xc(%rbp)
jmp 0x146f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/evilwombat[P]gopro-fw-tools/fwunpacker.c
// Function: read_word
static unsigned int read_word(void)
{
	unsigned int r = 0;
	r |= fgetc(fd) <<  0;
	r |= fgetc(fd) <<  8;
	r |= fgetc(fd) << 16;
	r |= fgetc(fd) << 24;
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movq 0x2af2(%rip), %rdi      # 0x4088
callq 0x1070
shll $0x0, %eax
orl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movq 0x2add(%rip), %rdi      # 0x4088
callq 0x1070
shll $0x8, %eax
orl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movq 0x2ac8(%rip), %rdi      # 0x4088
callq 0x1070
shll $0x10, %eax
orl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movq 0x2ab3(%rip), %rdi      # 0x4088
callq 0x1070
shll $0x18, %eax
orl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/evilwombat[P]gopro-fw-tools/fwunpacker.c
// Function: save_section
static int save_section(const char *output_name, int length)
{
	FILE *ofd;
	int i;
	char t;
	ofd = fopen(output_name, "wb+");

	if (!ofd) {
		printf("Could not write to %s\n", output_name);
		return -1;
	}

	for (i = 0; i < length; i++) {
		fread(&t, 1, 1, fd);
		fwrite(&t, 1, 1, ofd);
	}
	fclose(ofd);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xb20(%rip), %rsi       # 0x212a
callq 0x10c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1635
movq -0x10(%rbp), %rsi
leaq 0xb09(%rip), %rdi       # 0x212e
movb $0x0, %al
callq 0x1050
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x168c
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x167c
movq 0x2a3d(%rip), %rcx      # 0x4088
leaq -0x25(%rbp), %rdi
movl $0x1, %edx
movq %rdx, %rsi
callq 0x1030
movq -0x20(%rbp), %rcx
leaq -0x25(%rbp), %rdi
movl $0x1, %edx
movq %rdx, %rsi
callq 0x10d0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x163c
movq -0x20(%rbp), %rdi
callq 0x1040
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test_index.c
// Function: usage
void HTS_NORETURN usage(FILE *fp) {
    fprintf(fp, "Usage: test_index [opts] in.{sam.gz,bam,cram}|in.{vcf.gz,bcf}\n\n");
    fprintf(fp, "  -b       Use BAI index (BAM, SAM)\n");
    fprintf(fp, "  -c       Use CSI index (BAM, SAM, VCF, BCF)\n");
    fprintf(fp, "  -t       Use TBI index (VCF) \n");
    fprintf(fp, "  -m bits  Adjust min_shift; implies CSI\n");
    fprintf(fp, "\nThe default index format is CSI for sam/bam/vcf/bcf and CRAI for crams\n");
    exit(fp == stderr ? 1 : 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xfd559(%rip), %rsi     # 0x103050
movb $0x0, %al
callq 0x4700
movq -0x8(%rbp), %rdi
leaq 0xfd587(%rip), %rsi     # 0x103090
movb $0x0, %al
callq 0x4700
movq -0x8(%rbp), %rdi
leaq 0xfd59a(%rip), %rsi     # 0x1030b5
movb $0x0, %al
callq 0x4700
movq -0x8(%rbp), %rdi
leaq 0xfd5b7(%rip), %rsi     # 0x1030e4
movb $0x0, %al
callq 0x4700
movq -0x8(%rbp), %rdi
leaq 0xfd5c6(%rip), %rsi     # 0x103105
movb $0x0, %al
callq 0x4700
movq -0x8(%rbp), %rdi
leaq 0xfd5de(%rip), %rsi     # 0x10312f
movb $0x0, %al
callq 0x4700
movq -0x8(%rbp), %rcx
movq 0x11f46d(%rip), %rax    # 0x124fd0
movq (%rax), %rdx
xorl %edi, %edi
movl $0x1, %eax
cmpq %rdx, %rcx
cmovel %eax, %edi
callq 0x45e0
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gadget114514[P]fatfs-example/cf2.c
// Function: main
void main()
{
  FIL f;
  int w;
  FATFS fs;
  FCHK(f_mount(&fs, "", 1)); 
  if (f_open(&f, "0:a.txt", FA_CREATE_ALWAYS|FA_READ|FA_WRITE) == FR_OK) {
    FCHK(f_write(&f, "abc\ndef\n", 9, &w));
    printf("open & write %d\n", w);
    FCHK(f_sync(&f));
    FCHK(f_close(&f));
  } else {
    printf("open error\n");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4d0, %rsp            # imm = 0x4D0
leaq -0x4b0(%rbp), %rdi
leaq 0x6324(%rip), %rsi      # 0x74bd
movl $0x1, %edx
callq 0x1680
movl %eax, -0x4b4(%rbp)
movl -0x4b4(%rbp), %eax
movl %eax, -0x4c4(%rbp)
movl -0x4b4(%rbp), %edi
callq 0x1320
movl -0x4c4(%rbp), %edx
movq %rax, %rcx
leaq 0x5e84(%rip), %rdi      # 0x7054
leaq 0x5e90(%rip), %rsi      # 0x7067
movb $0x0, %al
callq 0x1040
leaq -0x250(%rbp), %rdi
leaq 0x5e8f(%rip), %rsi      # 0x707b
movl $0xb, %edx
callq 0x2050
cmpl $0x0, %eax
jne 0x12fd
leaq -0x250(%rbp), %rdi
leaq 0x5e76(%rip), %rsi      # 0x7083
movl $0x9, %edx
leaq -0x254(%rbp), %rcx
callq 0x3190
movl %eax, -0x4b8(%rbp)
movl -0x4b8(%rbp), %eax
movl %eax, -0x4d0(%rbp)
movl -0x4b8(%rbp), %edi
callq 0x1320
movl -0x4d0(%rbp), %edx
movq %rax, %rcx
leaq 0x5e09(%rip), %rdi      # 0x7054
leaq 0x5e3a(%rip), %rsi      # 0x708c
movb $0x0, %al
callq 0x1040
movl -0x254(%rbp), %esi
leaq 0x5e47(%rip), %rdi      # 0x70ad
movb $0x0, %al
callq 0x1040
leaq -0x250(%rbp), %rdi
callq 0x38a0
movl %eax, -0x4bc(%rbp)
movl -0x4bc(%rbp), %eax
movl %eax, -0x4cc(%rbp)
movl -0x4bc(%rbp), %edi
callq 0x1320
movl -0x4cc(%rbp), %edx
movq %rax, %rcx
leaq 0x5dae(%rip), %rdi      # 0x7054
leaq 0x5e11(%rip), %rsi      # 0x70be
movb $0x0, %al
callq 0x1040
leaq -0x250(%rbp), %rdi
callq 0x3b90
movl %eax, -0x4c0(%rbp)
movl -0x4c0(%rbp), %eax
movl %eax, -0x4c8(%rbp)
movl -0x4c0(%rbp), %edi
callq 0x1320
movl -0x4c8(%rbp), %edx
movq %rax, %rcx
leaq 0x5d67(%rip), %rdi      # 0x7054
leaq 0x5dd5(%rip), %rsi      # 0x70c9
movb $0x0, %al
callq 0x1040
jmp 0x130b
leaq 0x5dd1(%rip), %rdi      # 0x70d5
movb $0x0, %al
callq 0x1040
addq $0x4d0, %rsp            # imm = 0x4D0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aezv3/ref/aez_ref.c
// Function: Decrypt
int Decrypt(byte *K, unsigned kbytes,
            byte *N, unsigned nbytes,
            byte *AD[], unsigned adbytes[],
            unsigned veclen, unsigned abytes,
            byte *C, unsigned cbytes, byte *M) {
    byte delta[16], *X, sum=0;
    unsigned i;
    if (cbytes < abytes) return -1;
    AEZhash(K, kbytes, N, nbytes, AD, adbytes, veclen, abytes*8, delta);
    X = (byte *)malloc(cbytes);
    if (cbytes==abytes) {
        AEZprf(K, kbytes, delta, abytes, X);
        for (i=0; i<abytes; i++) sum |= (X[i] ^ C[i]);
    } else {
        Decipher(K, kbytes, delta, C, cbytes, X);
        for (i=0; i<abytes; i++) sum |= X[cbytes-abytes+i];
        if (sum==0) memcpy(M,X,cbytes-abytes);
    }
    free(X);
    return (sum == 0 ? 0 : -1);  /* return 0 if valid, -1 if invalid */
}

// Assembly:
subq $0x78, %rsp
movq 0xa0(%rsp), %rax
movl 0x98(%rsp), %eax
movq 0x90(%rsp), %rax
movl 0x88(%rsp), %eax
movl 0x80(%rsp), %eax
movq %rdi, 0x68(%rsp)
movl %esi, 0x64(%rsp)
movq %rdx, 0x58(%rsp)
movl %ecx, 0x54(%rsp)
movq %r8, 0x48(%rsp)
movq %r9, 0x40(%rsp)
movb $0x0, 0x27(%rsp)
movl 0x98(%rsp), %eax
cmpl 0x88(%rsp), %eax
jae 0x1227
movl $0xffffffff, 0x74(%rsp) # imm = 0xFFFFFFFF
jmp 0x13c4
movq 0x68(%rsp), %rdi
movl 0x64(%rsp), %esi
movq 0x58(%rsp), %rdx
movl 0x54(%rsp), %ecx
movq 0x48(%rsp), %r8
movq 0x40(%rsp), %r9
movl 0x80(%rsp), %r11d
movl 0x88(%rsp), %r10d
shll $0x3, %r10d
leaq 0x30(%rsp), %rax
movl %r11d, (%rsp)
movl %r10d, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x13d0
movl 0x98(%rsp), %eax
movl %eax, %edi
callq 0x1050
movq %rax, 0x28(%rsp)
movl 0x98(%rsp), %eax
cmpl 0x88(%rsp), %eax
jne 0x1302
movq 0x68(%rsp), %rdi
movl 0x64(%rsp), %esi
leaq 0x30(%rsp), %rdx
movl 0x88(%rsp), %ecx
movq 0x28(%rsp), %r8
callq 0x16b0
movl $0x0, 0x20(%rsp)
movl 0x20(%rsp), %eax
cmpl 0x88(%rsp), %eax
jae 0x12fd
movq 0x28(%rsp), %rax
movl 0x20(%rsp), %ecx
movzbl (%rax,%rcx), %ecx
movq 0x90(%rsp), %rax
movl 0x20(%rsp), %edx
movzbl (%rax,%rdx), %eax
xorl %eax, %ecx
movzbl 0x27(%rsp), %eax
orl %ecx, %eax
movb %al, 0x27(%rsp)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x12b9
jmp 0x13a4
movq 0x68(%rsp), %rdi
movl 0x64(%rsp), %esi
leaq 0x30(%rsp), %rdx
movq 0x90(%rsp), %rcx
movl 0x98(%rsp), %r8d
movq 0x28(%rsp), %r9
callq 0x17e0
movl $0x0, 0x20(%rsp)
movl 0x20(%rsp), %eax
cmpl 0x88(%rsp), %eax
jae 0x1374
movq 0x28(%rsp), %rax
movl 0x98(%rsp), %ecx
subl 0x88(%rsp), %ecx
addl 0x20(%rsp), %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %ecx
movzbl 0x27(%rsp), %eax
orl %ecx, %eax
movb %al, 0x27(%rsp)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x1332
movzbl 0x27(%rsp), %eax
cmpl $0x0, %eax
jne 0x13a2
movq 0xa0(%rsp), %rdi
movq 0x28(%rsp), %rsi
movl 0x98(%rsp), %eax
subl 0x88(%rsp), %eax
movl %eax, %eax
movl %eax, %edx
callq 0x10d0
jmp 0x13a4
movq 0x28(%rsp), %rdi
callq 0x1070
movzbl 0x27(%rsp), %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movl %eax, 0x74(%rsp)
movl 0x74(%rsp), %eax
addq $0x78, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aezv3/ref/aez_ref.c
// Function: AEZprf
static void AEZprf(byte *K, unsigned kbytes, byte delta[16], unsigned bytes, byte *result) {

    byte buf[16], ctr[16];
    memset(ctr,0,16);
    for ( ; bytes >= 16; bytes-=16, result+=16) {
        unsigned i=15;
        xor_bytes(delta, ctr, 16, buf);
        E(K,kbytes,-1,3,buf,result);
        do { ctr[i]++; i--; } while (ctr[i+1]==0);   /* ctr+=1 */
    }
    if (bytes) {
        xor_bytes(delta, ctr, 16, buf);
        E(K,kbytes,-1,3,buf,buf);
        memcpy(result, buf, bytes);
    }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movq %rdx, 0x40(%rsp)
movl %ecx, 0x3c(%rsp)
movq %r8, 0x30(%rsp)
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1040
cmpl $0x10, 0x3c(%rsp)
jb 0x1777
movl $0xf, 0xc(%rsp)
movq 0x40(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x20(%rsp), %rcx
movl $0x10, %edx
callq 0x2170
movq 0x50(%rsp), %rdi
movl 0x4c(%rsp), %esi
leaq 0x20(%rsp), %r8
movq 0x30(%rsp), %r9
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x3, %ecx
callq 0x1c40
movl 0xc(%rsp), %eax
movb 0x10(%rsp,%rax), %cl
addb $0x1, %cl
movb %cl, 0x10(%rsp,%rax)
movl 0xc(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
movzbl 0x10(%rsp,%rax), %eax
cmpl $0x0, %eax
je 0x172a
jmp 0x1759
movl 0x3c(%rsp), %eax
subl $0x10, %eax
movl %eax, 0x3c(%rsp)
movq 0x30(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x30(%rsp)
jmp 0x16dc
cmpl $0x0, 0x3c(%rsp)
je 0x17ce
movq 0x40(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x20(%rsp), %rcx
movl $0x10, %edx
callq 0x2170
movq 0x50(%rsp), %rdi
movl 0x4c(%rsp), %esi
leaq 0x20(%rsp), %r8
leaq 0x20(%rsp), %r9
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x3, %ecx
callq 0x1c40
movq 0x30(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movl 0x3c(%rsp), %eax
movl %eax, %edx
callq 0x10d0
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aezv3/ref/aez_ref.c
// Function: Encrypt
void Encrypt(byte *K, unsigned kbytes,
             byte *N, unsigned nbytes,
             byte *AD[], unsigned adbytes[],
             unsigned veclen, unsigned abytes,
             byte *M, unsigned mbytes, byte *C) {
    byte delta[16], *X;
    AEZhash(K, kbytes, N, nbytes, AD, adbytes, veclen, abytes*8, delta);
    if (mbytes==0) {
        AEZprf(K, kbytes, delta, abytes, C);
    } else {
        X = (byte *)malloc(mbytes+abytes);
        memcpy(X, M, mbytes); memset(X+mbytes,0,abytes);
        Encipher(K, kbytes, delta, X, mbytes+abytes, X);
        memcpy(C, X, mbytes+abytes);
        free(X);
    }
}

// Assembly:
subq $0x68, %rsp
movq 0x90(%rsp), %rax
movl 0x88(%rsp), %eax
movq 0x80(%rsp), %rax
movl 0x78(%rsp), %eax
movl 0x70(%rsp), %eax
movq %rdi, 0x60(%rsp)
movl %esi, 0x5c(%rsp)
movq %rdx, 0x50(%rsp)
movl %ecx, 0x4c(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x38(%rsp)
movq 0x60(%rsp), %rdi
movl 0x5c(%rsp), %esi
movq 0x50(%rsp), %rdx
movl 0x4c(%rsp), %ecx
movq 0x40(%rsp), %r8
movq 0x38(%rsp), %r9
movl 0x70(%rsp), %r11d
movl 0x78(%rsp), %r10d
shll $0x3, %r10d
leaq 0x20(%rsp), %rax
movl %r11d, (%rsp)
movl %r10d, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x13d0
cmpl $0x0, 0x88(%rsp)
jne 0x191f
movq 0x60(%rsp), %rdi
movl 0x5c(%rsp), %esi
leaq 0x20(%rsp), %rdx
movl 0x78(%rsp), %ecx
movq 0x90(%rsp), %r8
callq 0x16b0
jmp 0x19c4
movl 0x88(%rsp), %eax
addl 0x78(%rsp), %eax
movl %eax, %eax
movl %eax, %edi
callq 0x1050
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x80(%rsp), %rsi
movl 0x88(%rsp), %eax
movl %eax, %edx
callq 0x10d0
movq 0x18(%rsp), %rdi
movl 0x88(%rsp), %eax
addq %rax, %rdi
movl 0x78(%rsp), %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x1040
movq 0x60(%rsp), %rdi
movl 0x5c(%rsp), %esi
leaq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
movl 0x88(%rsp), %r8d
addl 0x78(%rsp), %r8d
movq 0x18(%rsp), %r9
callq 0x19d0
movq 0x90(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x88(%rsp), %eax
addl 0x78(%rsp), %eax
movl %eax, %eax
movl %eax, %edx
callq 0x10d0
movq 0x18(%rsp), %rdi
callq 0x1070
addq $0x68, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aezv3/ref/aez_ref.c
// Function: crypto_aead_encrypt
int crypto_aead_encrypt(
    unsigned char *c,unsigned long long *clen,
    const unsigned char *m,unsigned long long mlen,
    const unsigned char *ad,unsigned long long adlen,
    const unsigned char *nsec,
    const unsigned char *npub,
    const unsigned char *k
)
{
    byte *AD[] = {(byte*)ad};
    unsigned adbytes[] = {(unsigned)adlen};
    (void)nsec;
    if (clen) *clen = mlen+16;
    Encrypt((byte*)k, CRYPTO_KEYBYTES, (byte*)npub, CRYPTO_NPUBBYTES,
            AD, adbytes, 1, CRYPTO_ABYTES, (byte*)m, mlen, (byte*)c);
    return 0;
}

// Assembly:
subq $0x68, %rsp
movq 0x80(%rsp), %rax
movq 0x78(%rsp), %rax
movq 0x70(%rsp), %rax
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rax
movl %eax, 0x2c(%rsp)
cmpq $0x0, 0x58(%rsp)
je 0x1ac0
movq 0x48(%rsp), %rcx
addq $0x10, %rcx
movq 0x58(%rsp), %rax
movq %rcx, (%rax)
movq 0x80(%rsp), %rdi
movq 0x78(%rsp), %rdx
leaq 0x30(%rsp), %r8
leaq 0x2c(%rsp), %r9
movq 0x50(%rsp), %r11
movq 0x48(%rsp), %rax
movl %eax, %r10d
movq 0x60(%rsp), %rax
movl $0x10, %esi
movl $0xc, %ecx
movl $0x1, (%rsp)
movl $0x10, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movl %r10d, 0x18(%rsp)
movq %rax, 0x20(%rsp)
callq 0x10a0
xorl %eax, %eax
addq $0x68, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aezv3/ref/aez_ref.c
// Function: crypto_aead_decrypt
int crypto_aead_decrypt(
    unsigned char *m,unsigned long long *mlen,
    unsigned char *nsec,
    const unsigned char *c,unsigned long long clen,
    const unsigned char *ad,unsigned long long adlen,
    const unsigned char *npub,
    const unsigned char *k
)
{
    byte *AD[] = {(byte*)ad};
    unsigned adbytes[] = {(unsigned)adlen};
    (void)nsec;
    if (mlen) *mlen = clen-16;
    return Decrypt((byte*)k, CRYPTO_KEYBYTES, (byte*)npub, CRYPTO_NPUBBYTES,
                    AD, adbytes, 1, CRYPTO_ABYTES, (byte*)c, clen, (byte*)m);
}

// Assembly:
subq $0x68, %rsp
movq 0x80(%rsp), %rax
movq 0x78(%rsp), %rax
movq 0x70(%rsp), %rax
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x70(%rsp), %rax
movl %eax, 0x2c(%rsp)
cmpq $0x0, 0x58(%rsp)
je 0x1b80
movq 0x40(%rsp), %rcx
subq $0x10, %rcx
movq 0x58(%rsp), %rax
movq %rcx, (%rax)
movq 0x80(%rsp), %rdi
movq 0x78(%rsp), %rdx
leaq 0x30(%rsp), %r8
leaq 0x2c(%rsp), %r9
movq 0x48(%rsp), %r11
movq 0x40(%rsp), %rax
movl %eax, %r10d
movq 0x60(%rsp), %rax
movl $0x10, %esi
movl $0xc, %ecx
movl $0x1, (%rsp)
movl $0x10, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movl %r10d, 0x18(%rsp)
movq %rax, 0x20(%rsp)
callq 0x1030
addq $0x68, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aezv3/ref/aez_ref.c
// Function: mult_block
static void mult_block(unsigned x, byte *src, byte *dst) {
    byte t[16], r[16];
    memcpy(t,src,16); memset(r,0,16);
    for ( ; x; x>>=1) {
        if (x&1) xor_bytes(r,t,16,r);
        double_block(t);
    }
    memcpy(dst,r,16);
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq %rsp, %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1040
cmpl $0x0, 0x34(%rsp)
je 0x2695
movl 0x34(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x267f
movq %rsp, %rdi
leaq 0x10(%rsp), %rsi
movq %rsp, %rcx
movl $0x10, %edx
callq 0x2170
leaq 0x10(%rsp), %rdi
callq 0x26b0
movl 0x34(%rsp), %eax
shrl %eax
movl %eax, 0x34(%rsp)
jmp 0x2657
movq 0x20(%rsp), %rax
movq (%rsp), %rcx
movq %rcx, (%rax)
movq 0x8(%rsp), %rcx
movq %rcx, 0x8(%rax)
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aezv3/ref/aez_ref.c
// Function: double_block
static void double_block(byte *p) {
    byte i, tmp = p[0];
    for (i=0; i<15; i++)
        p[i] = (p[i] << 1) | (p[i+1] >> 7);
    p[15] = (p[15] << 1) ^ ((tmp >> 7) * 135);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movb (%rax), %al
movb %al, -0xa(%rsp)
movb $0x0, -0x9(%rsp)
movzbl -0x9(%rsp), %eax
cmpl $0xf, %eax
jge 0x2713
movq -0x8(%rsp), %rax
movzbl -0x9(%rsp), %ecx
movzbl (%rax,%rcx), %eax
shll %eax
movq -0x8(%rsp), %rcx
movzbl -0x9(%rsp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
sarl $0x7, %ecx
orl %ecx, %eax
movb %al, %dl
movq -0x8(%rsp), %rax
movzbl -0x9(%rsp), %ecx
movb %dl, (%rax,%rcx)
movb -0x9(%rsp), %al
addb $0x1, %al
movb %al, -0x9(%rsp)
jmp 0x26c5
movq -0x8(%rsp), %rax
movzbl 0xf(%rax), %eax
shll %eax
movzbl -0xa(%rsp), %ecx
sarl $0x7, %ecx
imull $0x87, %ecx, %ecx
xorl %ecx, %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0xf(%rax)
retq
nopl (%rax)