LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/usgs[P]nshmp-haz-catalogs/src/agrid/adaptive/ck_args_wt_results.c
// Function: write_results_to_file
void write_results_to_file(struct smoothp* smp, struct rates* seisr, struct catalog * cat, struct boundaries *boundR, char *outf)
/*--------------------------------------------------------------------------*/
{
  int cnt;
  float magv;
  float tmpsum=0.0;

// quick check of earthquake numbers
  for (cnt=0; cnt<seisr->nv; cnt++) {
    tmpsum=tmpsum+seisr->asum[cnt]*7;
  }
  fprintf(stderr,"tmpsum (no. M0+ eqs in 7 years) = %.4f\n", tmpsum);

// if a smoothed seismicity model is generated, output results at M0(10^a), M4, M5 and unsmoothed model
  if ( smp->apply_sm ) {
// M0, 10^a values
    magv=0.0;
    write_asum_to_file(seisr, outf, cat, magv);
    fprintf(stderr,"Writing to csv file...\n");
    write_asum_to_csvfile(seisr, outf, cat, boundR, magv);
// M0, 10^a, un-smoothed 
//    write_unsmoothed_asum_to_file(seisr, outf);

// M3.0, 10^(a-3.0b) values
/*
*    magv=3.0;
*    write_asum_to_file(seisr, outf, cat, magv);
// M3.5, 10^(a-3.5b) values
*    magv=3.5;
*    write_asum_to_file(seisr, outf, cat, magv);
// M4, 10^(a-4b) values
*    magv=4.0;
*    write_asum_to_file(seisr, outf, cat, magv);
// M4.5, 10^(a-4.5b) values
*    magv=4.5;
*    write_asum_to_file(seisr, outf, cat, magv);
*
// M5, 10^(a-5b) values
*    magv=5.0;
*    write_asum_to_file(seisr, outf, cat, magv);
*/    
  }
  else {
    magv=0.0;
    write_asum_to_file(seisr, outf, cat, magv);
    magv=cat->minMag;
    write_asum_to_file(seisr, outf, cat, magv);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r13
movl 0x298100(%rsi), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
xorps %xmm0, %xmm0
movss 0x2606(%rip), %xmm1     # 0x763c
cmpq %rcx, %rax
je 0x5052
movss 0x14c080(%r12,%rcx,4), %xmm2
mulss %xmm1, %xmm2
addss %xmm2, %xmm0
incq %rcx
jmp 0x5036
movq 0x4f9f(%rip), %rbp      # 0x9ff8
movq (%rbp), %rdi
cvtss2sd %xmm0, %xmm0
leaq 0x2806(%rip), %rsi      # 0x786e
movb $0x1, %al
callq 0x10f0
movl 0x8(%r13), %r13d
xorps %xmm0, %xmm0
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x44d4
testl %r13d, %r13d
jne 0x50aa
movss 0x4(%rbx), %xmm0
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x44d4
movq (%rbp), %rcx
leaq 0x27e1(%rip), %rdi      # 0x7896
pushq $0x17
popq %rsi
pushq $0x1
popq %rdx
callq 0x1190
xorps %xmm0, %xmm0
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r15, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4bc5
nop
// File: /workspace/github_c_makefile_star2_O2/Mikejmoffitt[P]romtools/binvert/binvert.c
// Function: main
int main(int argc, char **argv)
{
	FILE *fi, *fo;
	size_t fsize;
	char *buf;

	if (argc < 3)
	{
		printf("Usage: %s in_fname out_fname\n", argv[0]);
		return 0;
	}

	fi = fopen(argv[1], "rb");
	if (!fi)
	{
		fprintf(stderr, "Couldn't open %s for reading.\n",
		        argv[1]);
		return 1;
	}

	fseek(fi, 0L, SEEK_END);
	fsize = ftell(fi);
	fseek(fi, 0L, SEEK_SET);

	buf = (char *)malloc(sizeof(char) * fsize);
	if (!buf)
	{
		fprintf(stderr, "Couldn't allocate %zu for buffer.\n", fsize);
		fclose(fi);
		return 1;
	}

	fo = fopen(argv[2], "wb");
	if (!fo)
	{
		fclose(fi);
		free(buf);
		fprintf(stderr, "Couldn't open %s for writing.\n", argv[2]);
		return 1;
	}

	for (size_t i = 0; i < fsize; i++)
	{
		buf[fsize - i - 1] = fgetc(fi);
	}

	fwrite((void *)buf, fsize, 1, fo);

	printf("Wrote %zu ($%X) bytes to %s.\n", fsize, (int)fsize, argv[2]);

	fclose(fi);
	fclose(fo);
	free(buf);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
cmpl $0x2, %edi
jg 0x11f7
movq (%r15), %rsi
leaq 0xe1b(%rip), %rdi       # 0x2004
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x1050
jmp 0x12d0
movq 0x8(%r15), %rdi
leaq 0xe20(%rip), %rsi       # 0x2022
callq 0x10b0
testq %rax, %rax
je 0x12e1
movq %rax, %rbx
pushq $0x2
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x10a0
movq %rbx, %rdi
callq 0x1080
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x10a0
movq %r14, %rdi
callq 0x1090
testq %rax, %rax
je 0x12f8
movq %rax, %r12
movq 0x10(%r15), %rdi
leaq 0xe11(%rip), %rsi       # 0x2067
callq 0x10b0
testq %rax, %rax
je 0x131d
movq %rax, %r13
movq %r15, (%rsp)
movq %r14, %r15
movq %r14, %rbp
subq $0x1, %rbp
jb 0x1289
movq %rbx, %rdi
callq 0x1060
movb %al, -0x1(%r12,%r15)
movq %rbp, %r15
jmp 0x1271
pushq $0x1
popq %rdx
movq %r12, %rdi
movq %r14, %rsi
movq %r13, %rcx
callq 0x10c0
movq (%rsp), %rax
movq 0x10(%rax), %rcx
leaq 0xde0(%rip), %rdi       # 0x2089
xorl %ebp, %ebp
movq %r14, %rsi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1050
movq %rbx, %rdi
callq 0x1040
movq %r13, %rdi
callq 0x1040
movq %r12, %rdi
callq 0x1030
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2d10(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq 0x8(%r15), %rdx
leaq 0xd2f(%rip), %rsi       # 0x2025
jmp 0x1342
movq 0x2cf9(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xd3b(%rip), %rsi       # 0x2044
movq %r14, %rdx
xorl %eax, %eax
callq 0x1070
movq %rbx, %rdi
callq 0x1040
jmp 0x1349
movq %rbx, %rdi
callq 0x1040
movq %r12, %rdi
callq 0x1030
movq 0x2cc4(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq 0x10(%r15), %rdx
leaq 0xd28(%rip), %rsi       # 0x206a
xorl %eax, %eax
callq 0x1070
pushq $0x1
popq %rbp
jmp 0x12d0
// File: /workspace/github_c_makefile_star2_O2/felipelouza[P]egap/tools/main_gsacak.c
// Function: usage
void usage(char *name){
  printf("\n\tUsage: %s [options] FILE N\n\n",name);
  puts("Computes SA (and optionally LCP array) for the first N sequences of a");
  puts("collection using algorithm gSACA-K from Louza et al. DCC 16 paper. ");
  puts("Sequences from FILE are extracted according to FILE's");
  puts("extension; currently supported extensions are: .txt .fasta .fastq\n");
  puts("Available options:");
  puts("\t-h      this help message");
  puts("\t-m RAM  available memory in MB (def: no limit)");
  puts("\t-o OUT  base name for output files (def: FILE)");
  puts("\t-L      compute LCP array as well (use only with option -s)");
  puts("\t-c      check SA and LCP");
  puts("\t-s      output SA (ext: .sa) and possibly LCP (ext: .sa_lcp)");
  puts("\t-l      output suffix lengths (ext: .sl)");
  puts("\t-q      output QS sequences permuted according to the BWT (ext: .qs)");
  puts("\t-b      output BWT (ext: .bwt)");
  puts("\t-r      output RLE(BWT) (ext: .rle.bwt)");
  puts("\t-g D    output LCP in gap format D bytes per entry (ext: .D.lcp)");
  puts("\t-x      extract individual input files and stop");
  puts("\t-X      convert input to raw+len format (ext: .cat .len) and stop");
  // puts("\t-L    lengths of the input sequences in FILE.len (no separator)");
  puts("\t-R      compute data structures for the reversed string\n");
  puts("\t-v      verbose output (more v's for more verbose)\n");
  printf("sizeof(int): %zu bytes\n", sizeof(int_t));
  printf("Max text size: %zu\n", WORD);
  exit(EXIT_FAILURE);
}

// Assembly:
pushq %rax
movq %rdi, %rsi
leaq 0x7d25(%rip), %rdi      # 0xa0cc
xorl %eax, %eax
callq 0x20f0
leaq 0x7d36(%rip), %rdi      # 0xa0eb
callq 0x2080
leaq 0x7d70(%rip), %rdi      # 0xa131
callq 0x2080
leaq 0x7da8(%rip), %rdi      # 0xa175
callq 0x2080
leaq 0x7dd2(%rip), %rdi      # 0xa1ab
callq 0x2080
leaq 0x7e09(%rip), %rdi      # 0xa1ee
callq 0x2080
leaq 0x7e10(%rip), %rdi      # 0xa201
callq 0x2080
leaq 0x7e1f(%rip), %rdi      # 0xa21c
callq 0x2080
leaq 0x7e43(%rip), %rdi      # 0xa24c
callq 0x2080
leaq 0x7e67(%rip), %rdi      # 0xa27c
callq 0x2080
leaq 0x7e98(%rip), %rdi      # 0xa2b9
callq 0x2080
leaq 0x7ea6(%rip), %rdi      # 0xa2d3
callq 0x2080
leaq 0x7ed8(%rip), %rdi      # 0xa311
callq 0x2080
leaq 0x7ef6(%rip), %rdi      # 0xa33b
callq 0x2080
leaq 0x7f30(%rip), %rdi      # 0xa381
callq 0x2080
leaq 0x7f44(%rip), %rdi      # 0xa3a1
callq 0x2080
leaq 0x7f61(%rip), %rdi      # 0xa3ca
callq 0x2080
leaq 0x7f97(%rip), %rdi      # 0xa40c
callq 0x2080
leaq 0x7fbc(%rip), %rdi      # 0xa43d
callq 0x2080
leaq 0x7ff3(%rip), %rdi      # 0xa480
callq 0x2080
leaq 0x8021(%rip), %rdi      # 0xa4ba
callq 0x2080
leaq 0x804a(%rip), %rdi      # 0xa4ef
pushq $0x8
popq %rsi
xorl %eax, %eax
callq 0x20f0
leaq 0x8051(%rip), %rdi      # 0xa507
movabsq $-0x8000000000000000, %rsi # imm = 0x8000000000000000
xorl %eax, %eax
callq 0x20f0
pushq $0x1
popq %rdi
callq 0x2270
// File: /workspace/github_c_makefile_star2_O2/felipelouza[P]egap/tools/lib/utils.c
// Function: time_stop
double time_stop(time_t t_time, clock_t c_clock){

	double aux1 = (clock() - c_clock) / (double)(CLOCKS_PER_SEC);
	double aux2 = difftime (time(NULL),t_time);
	
	printf("CLOCK = %lf TIME = %lf\n", aux1, aux2);
	
	return aux1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x20b0
subq %rbx, %rax
cvtsi2sd %rax, %xmm0
divsd 0x7131(%rip), %xmm0     # 0xa820
movsd %xmm0, (%rsp)
xorl %edi, %edi
callq 0x21c0
movq %rax, %rdi
movq %r14, %rsi
callq 0x2100
movapd %xmm0, %xmm1
leaq 0x7117(%rip), %rdi      # 0xa828
movsd (%rsp), %xmm0
movb $0x2, %al
callq 0x20f0
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/felipelouza[P]egap/tools/lib/utils.c
// Function: dies
void dies(const char* where, char* format, ...) {

	int_t err = errno;
	va_list val;

	printf("Error at %s: %s.\n",where,errno ? strerror(errno) : "errno not set");
	va_start(val,format);
	vprintf(format,val);
	va_end(val);
	printf("\n");

	exit(err ? err : 1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x37cf
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
callq 0x2050
movl (%rax), %ebx
testl %ebx, %ebx
jne 0x37e3
leaq 0x7071(%rip), %rdx      # 0xa852
jmp 0x37ed
movl %ebx, %edi
callq 0x2290
movq %rax, %rdx
leaq 0x704c(%rip), %rdi      # 0xa840
movq %r15, %rsi
xorl %eax, %eax
callq 0x20f0
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rsp, %rsi
movq %rax, (%rsi)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rsi)
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsi)
movq %r14, %rdi
callq 0x21d0
pushq $0xa
popq %rdi
callq 0x2040
cmpl $0x1, %ebx
adcl $0x0, %ebx
movl %ebx, %edi
callq 0x2270
// File: /workspace/github_c_makefile_star2_O2/felipelouza[P]egap/tools/lib/utils.c
// Function: print_char
int_t print_char(char* A, int_t n){

	int_t i;
	for(i=0; i<n; i++)	
		printf("%" PRIdN ") %c\n", i, A[i]);

	printf("\n");

return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %eax, %eax
testq %rsi, %rsi
cmovleq %rax, %rbx
leaq 0x7002(%rip), %r15      # 0xa860
xorl %r12d, %r12d
cmpq %r12, %rbx
je 0x387d
movsbl (%r14,%r12), %edx
movq %r15, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x20f0
incq %r12
jmp 0x3861
pushq $0xa
popq %rdi
callq 0x2040
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/felipelouza[P]egap/tools/lib/utils.c
// Function: print_int
int_t print_int(int_t* A, int_t n){

	int_t i;
	for(i=0; i<n; i++)	
		printf("%" PRIdN ") %" PRIdN "\n", i, A[i]);

	printf("\n");

return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %eax, %eax
testq %rsi, %rsi
cmovleq %rax, %rbx
leaq 0x6fb8(%rip), %r15      # 0xa869
xorl %r12d, %r12d
cmpq %r12, %rbx
je 0x38cf
movq (%r14,%r12,8), %rdx
movq %r15, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x20f0
incq %r12
jmp 0x38b4
pushq $0xa
popq %rdi
callq 0x2040
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/felipelouza[P]egap/tools/lib/utils.c
// Function: min_range
int_t min_range(int_t* A, int_t l, int_t r){


	if(r>l)return 0;

	printf("[l, r] = [%" PRIdN ", %" PRIdN "]\n", l, r);

	int_t min = INT_MAX;
	int_t i;
	for(i=l; i<=l; i++)
		min = (A[i]<min?A[i]:min);

	printf("min = %" PRIdN "\n", min);

return min;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpq %rsi, %rdx
jle 0x38f3
xorl %ebx, %ebx
jmp 0x3935
movq %rsi, %r14
movq %rdi, %r15
leaq 0x6f73(%rip), %rdi      # 0xa873
xorl %eax, %eax
callq 0x20f0
movl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
movq %r14, %rax
cmpq %r14, %rax
jg 0x3924
movq (%r15,%rax,8), %rcx
cmpq %rbx, %rcx
cmovlq %rcx, %rbx
incq %rax
jmp 0x390f
leaq 0x6f5d(%rip), %rdi      # 0xa888
movq %rbx, %rsi
xorl %eax, %eax
callq 0x20f0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/felipelouza[P]egap/tools/lib/utils.c
// Function: cat_int
int_t* cat_int(unsigned char** R, int k, int_t *n){

	(*n)++; //add 0 at the end

	int_t i, j;
	int_t l=0;
	int_t *str_int = (int_t*) malloc((*n)*sizeof(int_t));

	for(i=0; i<k; i++){
		int_t m = strlen((char*)R[i]);
		for(j=0; j<m; j++){
			//removes symbols > 255
			if(R[i][j]+1<256) str_int[l++] = R[i][j]+(k+1);
			else (*n)--;
		}
//		for(j=0; j<m; j++)
//			str_int[l++] = R[i][j]+(k+1);
		str_int[l++] = i+1; //add $_i as separator
	}
	
	str_int[l++]=0;
        if(*n>l){
		str_int = (int_t*) realloc(str_int, (l)*sizeof(int_t));
		printf("N = %" PRIdN "\n", l);
	}
	*n = l;

return str_int;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, (%rsp)
movq (%rdx), %rax
leaq 0x1(%rax), %r13
movq %r13, (%rdx)
leaq 0x8(,%rax,8), %rdi
callq 0x92c8
movq %rax, %r14
leal 0x1(%r15), %r12d
xorl %eax, %eax
testl %r15d, %r15d
cmovlel %eax, %r15d
movq %r15, 0x8(%rsp)
xorl %r15d, %r15d
xorl %ecx, %ecx
cmpq 0x8(%rsp), %rcx
je 0x39ee
movq (%rsp), %rax
movq %rcx, 0x10(%rsp)
movq (%rax,%rcx,8), %rbp
movq %rbp, %rdi
callq 0x20d0
testq %rax, %rax
movl $0x0, %ecx
cmovleq %rcx, %rax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x39dd
movzbl (%rbp,%rcx), %edx
cmpl $0xff, %edx
je 0x39d2
addl %r12d, %edx
movslq %edx, %rdx
movq %rdx, (%r14,%r15,8)
incq %r15
jmp 0x39d8
decq %r13
movq %r13, (%rbx)
incq %rcx
jmp 0x39b1
movq 0x10(%rsp), %rcx
incq %rcx
movq %rcx, (%r14,%r15,8)
incq %r15
jmp 0x3987
andq $0x0, (%r14,%r15,8)
incq %r15
cmpq %r15, %r13
jle 0x3a1f
leaq (,%r15,8), %rsi
movq %r14, %rdi
callq 0x9470
movq %rax, %r14
leaq 0x6e7e(%rip), %rdi      # 0xa893
movq %r15, %rsi
xorl %eax, %eax
callq 0x20f0
movq %r15, (%rbx)
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/felipelouza[P]egap/tools/lib/utils.c
// Function: cat_char
unsigned char* cat_char(unsigned char** R, int k, size_t *n){

	(*n)++; //add 0 at the end

	int_t i, j;
	int_t l=0;
	unsigned char *str = (unsigned char*) malloc((*n)*sizeof(unsigned char));

	for(i=0; i<k; i++){
		int_t m = strlen((char*)R[i]);
		//removes empty strings
		if(m==0){
			(*n)--;
			continue;
		}
		for(j=0; j<m; j++){
			//removes symbols > 255
			if(R[i][j]+1<256) str[l++] = R[i][j]+1;
			else (*n)--;
		}
		str[l++] = 1; //add 1 as separator
	}

	str[l++]=0;
  if(*n>l){
		str = (unsigned char*) realloc(str, (l)*sizeof(unsigned char));
		printf("N = %" PRIdN "\n", l);
	}
	*n = l;

return str;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, 0x8(%rsp)
movq (%rdx), %r12
incq %r12
movq %r12, (%rdx)
movq %r12, %rdi
callq 0x92c8
movq %rax, %r14
xorl %eax, %eax
testl %r15d, %r15d
cmovlel %eax, %r15d
movq %r15, 0x10(%rsp)
xorl %r15d, %r15d
xorl %r13d, %r13d
cmpq 0x10(%rsp), %r13
je 0x3ba3
movq 0x8(%rsp), %rax
movq (%rax,%r13,8), %rbp
movq %rbp, %rdi
callq 0x20d0
testq %rax, %rax
je 0x3b98
movl $0x0, %ecx
cmovleq %rcx, %rax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x3b8e
movb (%rbp,%rcx), %dl
cmpb $-0x1, %dl
je 0x3b83
incb %dl
movb %dl, (%r14,%r15)
incq %r15
jmp 0x3b89
decq %r12
movq %r12, (%rbx)
incq %rcx
jmp 0x3b6a
movb $0x1, (%r14,%r15)
incq %r15
jmp 0x3b9e
decq %r12
movq %r12, (%rbx)
incq %r13
jmp 0x3b42
movb $0x0, (%r14,%r15)
incq %r15
cmpq %r15, %r12
jbe 0x3bcf
movq %r14, %rdi
movq %r15, %rsi
callq 0x9470
movq %rax, %r14
leaq 0x6cce(%rip), %rdi      # 0xa893
movq %r15, %rsi
xorl %eax, %eax
callq 0x20f0
movq %r15, (%rbx)
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/felipelouza[P]egap/tools/lib/utils.c
// Function: sort
static void sort(char *array, size_t size, int (*cmp)(void*,void*), int begin, int end) {
   if (end > begin) {
      void *pivot = array + begin;
      int l = begin + size;
      int r = end;
      while(l < r) {
         if (cmp(array+l,pivot) <= 0) {
            l += size;
         } else if ( cmp(array+r, pivot) > 0 )  {
            r -= size;
         } else if ( l < r ) {
            swap2(array+l, array+r, size);
         }
      }
      l -= size;
      swap2(array+begin, array+l, size);
      sort(array, size, cmp, begin, l);
      sort(array, size, cmp, r, end);
   }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %r12d
movq %rdx, %r14
movq %rsi, 0x8(%rsp)
movq %rdi, %rbp
movl %r8d, 0x18(%rsp)
movq %rdi, 0x10(%rsp)
cmpl %r8d, %r12d
jge 0x3cd6
movslq %r12d, %r13
addq %rbp, %r13
movl %r12d, 0x1c(%rsp)
movl %r12d, %ecx
movl %r8d, %r12d
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rsp)
leal (%rcx,%rax), %r15d
movslq %r15d, %rbx
addq %rbp, %rbx
movq %rbp, %rax
movslq %r12d, %rbp
addq %rax, %rbp
cmpl %r12d, %r15d
jge 0x3c99
movq %rbx, %rdi
movq %r13, %rsi
callq *%r14
testl %eax, %eax
jle 0x3c8f
movq %rbp, %rdi
movq %r13, %rsi
callq *%r14
testl %eax, %eax
jg 0x3c83
movq %rbx, %rdi
movq %rbp, %rsi
movq 0x8(%rsp), %rdx
callq 0x3d5b
jmp 0x3c52
subl 0x8(%rsp), %r12d
movq 0x10(%rsp), %rax
jmp 0x3c4c
movl %r15d, %ecx
movq 0x10(%rsp), %rbp
jmp 0x3c35
movslq 0x20(%rsp), %rbx
movq 0x10(%rsp), %rbp
leaq (%rbx,%rbp), %rsi
movq %r13, %rdi
movq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x3d5b
movq %rbp, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl 0x1c(%rsp), %ecx
movl %ebx, %r8d
callq 0x3bf5
movl 0x18(%rsp), %r8d
jmp 0x3c1b
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/felipelouza[P]egap/tools/lib/utils.c
// Function: swap2
static void swap2(void *x, void *y, size_t l) {
   char *a = x, *b = y, c;
   while(l--) {
      c = *a;
      *a++ = *b;
      *b++ = c;
   }
}

// Assembly:
xorl %eax, %eax
cmpq %rax, %rdx
je 0x3d75
movb (%rdi,%rax), %cl
movb (%rsi,%rax), %r8b
movb %r8b, (%rdi,%rax)
movb %cl, (%rsi,%rax)
incq %rax
jmp 0x3d5d
retq
nop
// File: /workspace/github_c_makefile_star2_O2/felipelouza[P]egap/tools/lib/file.c
// Function: file_chdir
int file_chdir(char* dir){
  
  char* oldwd = getcwd(NULL,0);
  if (!oldwd) die(__func__);
  if (chdir(dir) == -1) die(__func__);

  free(oldwd);
return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %edi, %edi
xorl %esi, %esi
callq 0x2160
movq %rax, %rbx
testq %rax, %rax
jne 0x3dc6
leaq 0x6adb(%rip), %rdi      # 0xa89c
callq 0x372a
movq %r14, %rdi
callq 0x20e0
cmpl $-0x1, %eax
jne 0x3ddf
leaq 0x6ac2(%rip), %rdi      # 0xa89c
callq 0x372a
movq %rbx, %rdi
callq 0x939e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/felipelouza[P]egap/tools/lib/file.c
// Function: file_open
FILE* file_open(char *c_file, const char * c_mode){
  
  FILE* f_in;
  
  f_in = fopen(c_file, c_mode);
  if (!f_in) {perror(__func__); exit(EXIT_FAILURE);}
  fseek(f_in, 0, SEEK_SET);
  
return f_in;
}

// Assembly:
pushq %rbx
callq 0x2200
testq %rax, %rax
je 0x3e10
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x21e0
movq %rbx, %rax
popq %rbx
retq
leaq 0x6a90(%rip), %rdi      # 0xa8a7
callq 0x2210
pushq $0x1
popq %rdi
callq 0x2270
// File: /workspace/github_c_makefile_star2_O2/felipelouza[P]egap/tools/lib/file.c
// Function: file_size
size_t file_size(FILE* f_in){

    fseek(f_in, 0, SEEK_END);
    size_t length = ftell(f_in);
    rewind(f_in);
  
return length;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x2
popq %rdx
xorl %esi, %esi
callq 0x21e0
movq %rbx, %rdi
callq 0x21a0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2110
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/felipelouza[P]egap/tools/lib/file.c
// Function: file_read
uint_t file_read(FILE* f_in){

  uint_t value;

  int e = fread(&value, sizeof(uint_t), 1, f_in);
  if(e!=1) {perror("read error"); exit(1);}

return value;
}

// Assembly:
pushq %rax
movq %rdi, %rcx
movq %rsp, %rdi
pushq $0x8
popq %rsi
pushq $0x1
popq %rdx
callq 0x20a0
cmpl $0x1, %eax
jne 0x3e96
movq (%rsp), %rax
popq %rcx
retq
leaq 0x6a1f(%rip), %rdi      # 0xa8bc
callq 0x2210
pushq $0x1
popq %rdi
callq 0x2270
// File: /workspace/github_c_makefile_star2_O2/felipelouza[P]egap/tools/lib/file.c
// Function: file_load
char* file_load(FILE* f_in) {
  
  size_t len = 0;
  ssize_t size = 0;
  char *c_aux = NULL;
  
  /*Read one line*/
  size = getline(&c_aux, &len, f_in);
  if (size == -1) {perror(__func__); exit(EXIT_FAILURE);}

  /*Copy line to c_buffer*/
  char *c_buffer = (char*) malloc((size+1)*sizeof(char));
  strncpy(c_buffer, c_aux, size);

  c_buffer[size-1] = END_MARKER;
  c_buffer[size] = '\0';

  free(c_aux);

return c_buffer;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rdx
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
movq %rsp, %rdi
andq $0x0, (%rdi)
callq 0x2250
cmpq $-0x1, %rax
je 0x3f74
movq %rax, %rbx
movq %rax, %rdi
incq %rdi
callq 0x92c8
movq %rax, %r14
movq (%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x2060
movw $0x24, -0x1(%r14,%rbx)
movq %r15, %rdi
callq 0x939e
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x694c(%rip), %rdi      # 0xa8c7
callq 0x2210
pushq $0x1
popq %rdi
callq 0x2270
// File: /workspace/github_c_makefile_star2_O2/felipelouza[P]egap/tools/lib/file.c
// Function: load_multiple_txt
char** load_multiple_txt(FILE* f_in, int_t k, size_t *n) {

  char **c_buffer = (char**) malloc(k*sizeof(char*));

  int_t i;
  for(i=0; i<k; i++){
    size_t len = 0;
    c_buffer[i] = NULL;
      
    ssize_t size = getline(&c_buffer[i], &len, f_in);
    if (size == -1){
      printf("K = %" PRIdN" \n", i);
      return 0;
    }
    c_buffer[i][size-1] = 0;

    (*n) += (size_t)size;
  }


return c_buffer;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r13
leaq (,%rsi,8), %rdi
callq 0x92c8
xorl %r12d, %r12d
testq %r15, %r15
cmovleq %r12, %r15
movq %rax, %r14
negq %r15
leaq 0x10(%rsp), %rbp
movq %rax, 0x8(%rsp)
cmpq %r12, %r15
je 0x45fc
andq $0x0, 0x10(%rsp)
andq $0x0, (%r14)
movq %r14, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x2250
cmpq $-0x1, %rax
je 0x4603
movq (%r14), %rcx
movb $0x0, -0x1(%rcx,%rax)
addq %rax, (%rbx)
decq %r12
addq $0x8, %r14
jmp 0x45c5
movq 0x8(%rsp), %rbx
jmp 0x4619
negq %r12
leaq 0x62c4(%rip), %rdi      # 0xa8d1
xorl %ebx, %ebx
movq %r12, %rsi
xorl %eax, %eax
callq 0x20f0
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/felipelouza[P]egap/tools/lib/file.c
// Function: load_multiple_fastq
char** load_multiple_fastq(FILE* f_in, int_t k, size_t *n){

  char **c_buffer = (char**) malloc(k*sizeof(char*));

  int_t i;
  for(i=0; i<k; i++){
    size_t len = 0;
    char *buf = NULL;

    ssize_t size = getline(&buf, &len, f_in); // @'s line
    //printf("Line of size: %d\n", strlen(buf));
    free(buf);buf = NULL;
    if (size <= 1) return 0;

    c_buffer[i] = NULL; len=0;
    size = getline(&c_buffer[i], &len, f_in); // read line
    //printf("Line of size: %d\n", strlen(c_buffer[i]));
    c_buffer[i][size-1] = 0;
    (*n) += (size_t)size;

    buf = NULL; len = 0;  
    size = getline(&buf, &len, f_in); // +'s line
    // printf("Line of size: %d\n", strlen(buf));
    free(buf);
    buf = NULL; len = 0;  
    size = getline(&buf, &len, f_in); // @'s line
    //printf("Line of size: %d\n", strlen(buf));
    free(buf);buf = NULL;
    //printf("Line %d OK\n", i);
    // free(buf);
  }
  return c_buffer;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, 0x20(%rsp)
movq %rsi, %r15
movq %rdi, %r14
leaq (,%rsi,8), %rdi
callq 0x92c8
xorl %ebx, %ebx
testq %r15, %r15
cmovgq %r15, %rbx
movq %rax, %rbp
leaq 0x8(%rsp), %r12
leaq 0x10(%rsp), %r13
movq %rax, 0x18(%rsp)
subq $0x1, %rbx
jb 0x4728
andq $0x0, 0x10(%rsp)
andq $0x0, 0x8(%rsp)
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x2250
movq %rax, %r15
movq 0x8(%rsp), %rdi
callq 0x939e
andq $0x0, 0x8(%rsp)
cmpq $0x2, %r15
jl 0x472f
andq $0x0, (%rbp)
andq $0x0, 0x10(%rsp)
movq %rbp, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x2250
movq (%rbp), %rcx
movb $0x0, -0x1(%rcx,%rax)
movq 0x20(%rsp), %rcx
addq %rax, (%rcx)
andq $0x0, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x2250
movq 0x8(%rsp), %rdi
callq 0x939e
andq $0x0, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x2250
movq 0x8(%rsp), %rdi
callq 0x939e
addq $0x8, %rbp
jmp 0x466c
movq 0x18(%rsp), %rax
jmp 0x4731
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/felipelouza[P]egap/tools/lib/file.c
// Function: load_multiple_qs
char** load_multiple_qs(FILE* f_in, int_t k){

  char **c_buffer = (char**) malloc(k*sizeof(char*));

  int_t i;
  for(i=0; i<k; i++){
    size_t len = 0;
    char *buf = NULL;

    ssize_t size = getline(&buf, &len, f_in); // @'s line
    //printf("Line of size: %d\n", strlen(buf));
    free(buf);buf = NULL;
    if (size <= 1) return 0;

    buf = NULL; len = 0;  
    size = getline(&buf, &len, f_in); // read line
    // printf("Line of size: %d\n", strlen(buf));
    free(buf);
    buf = NULL; len = 0;  
    size = getline(&buf, &len, f_in); // +'s line
    //printf("Line of size: %d\n", strlen(buf));
    free(buf);buf = NULL;
    //printf("Line %d OK\n", i);
    // free(buf);

    c_buffer[i] = NULL; len=0;
    size = getline(&c_buffer[i], &len, f_in); // read line
    //printf("Line of size: %d\n", strlen(c_buffer[i]));
    c_buffer[i][size-1] = 0;
  }
  return c_buffer;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq (,%rsi,8), %rdi
callq 0x92c8
xorl %r14d, %r14d
testq %r15, %r15
cmovgq %r15, %r14
movq %rax, %r13
movq %rsp, %r15
leaq 0x8(%rsp), %r12
movq %rax, 0x10(%rsp)
subq $0x1, %r14
jb 0x4824
andq $0x0, 0x8(%rsp)
andq $0x0, (%rsp)
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2250
movq %rax, %rbp
movq (%rsp), %rdi
callq 0x939e
cmpq $0x2, %rbp
jl 0x482b
andq $0x0, (%rsp)
andq $0x0, 0x8(%rsp)
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2250
movq (%rsp), %rdi
callq 0x939e
andq $0x0, (%rsp)
andq $0x0, 0x8(%rsp)
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2250
movq (%rsp), %rdi
callq 0x939e
andq $0x0, (%rsp)
andq $0x0, (%r13)
andq $0x0, 0x8(%rsp)
movq %r13, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2250
movq (%r13), %rcx
movb $0x0, -0x1(%rcx,%rax)
addq $0x8, %r13
jmp 0x477b
movq 0x10(%rsp), %rax
jmp 0x482d
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/felipelouza[P]egap/tools/lib/file.c
// Function: file_load_multiple_qs_chunks
char** file_load_multiple_qs_chunks(char* c_file, int_t k, FILE *f_in) {

/* .ext
 * .fastq - strings separated by four lines
 */

  const char *type = get_filename_ext(c_file);
  char **c_buffer = NULL; // = (char**) malloc(k*sizeof(char*));

  if(strcmp(type,"fastq") == 0 || strcmp(type,"fq") == 0)
    c_buffer = load_multiple_qs(f_in, k);
  else{
    printf("Error: file not recognized (.fastq or .fq)\n");
    exit (EXIT_FAILURE);
  }

return c_buffer;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
callq 0x3d78
movq %rax, %r15
leaq 0x6085(%rip), %rsi      # 0xa8db
movq %rax, %rdi
callq 0x2180
testl %eax, %eax
je 0x4876
cmpb $0x66, (%r15)
jne 0x4886
cmpb $0x71, 0x1(%r15)
jne 0x4886
cmpb $0x0, 0x2(%r15)
jne 0x4886
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x4740
leaq 0x60bf(%rip), %rdi      # 0xa94c
callq 0x2080
pushq $0x1
popq %rdi
callq 0x2270
// File: /workspace/github_c_makefile_star2_O2/felipelouza[P]egap/tools/lib/file.c
// Function: load_multiple_fasta
char** load_multiple_fasta(FILE* f_in, int_t k, size_t *n){

  char **c_buffer = (char**) malloc(k*sizeof(char*));

  char *buf = NULL;
  size_t len = 0;
  ssize_t size=0;

  size = getline(&buf, &len, f_in);// first sequence
  free(buf);

  size_t tell=0;

  int count=0;
  int_t i;
  for(i=0; i<k; i++){


    if(i!=count) return 0;

    len = 0;
    size_t nalloc = N_ALLOC;
    c_buffer[i] = malloc(nalloc*sizeof(char));

    size_t p=0;
    buf = NULL; len = 0;  
    while((size = getline(&buf, &len, f_in))!=-1){

      if(buf[0] == '>'){
        count++;
        break;
      }

      if(p+len>nalloc){
        nalloc += len+N_ALLOC;
        c_buffer[i] = realloc(c_buffer[i], sizeof(char) * nalloc);
      }

      strcpy(&c_buffer[i][p], buf);
      p+=strlen(buf)-1;
      
      tell = ftell(f_in);
      free(buf); len=0; buf=NULL;
    }
/*
    if (size == -1){//EOF
      printf("K = %" PRIdN "\n", i);
      free(buf);
      return 0;
    }
*/

    free(buf);
    c_buffer[i][p] = 0;
    (*n) += p+1;
  }

fseek(f_in , tell, SEEK_SET);
return c_buffer;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, 0x28(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
leaq (,%rsi,8), %rdi
callq 0x92c8
movq %rax, %rbp
leaq 0x8(%rsp), %r15
andq $0x0, (%r15)
leaq 0x18(%rsp), %rsi
andq $0x0, (%rsi)
movq %r15, %rdi
movq %r14, %rdx
callq 0x2250
movq (%r15), %rdi
callq 0x939e
xorl %r15d, %r15d
testq %rbx, %rbx
cmovleq %r15, %rbx
movq %rbx, 0x30(%rsp)
xorl %ebx, %ebx
xorl %r13d, %r13d
movq %rbp, 0x20(%rsp)
cmpq 0x30(%rsp), %r13
je 0x4a0d
movslq %ebx, %rax
cmpq %rax, %r13
jne 0x4a1c
movl %ebx, 0x14(%rsp)
movl $0x800, %ebx            # imm = 0x800
movl $0x800, %edi            # imm = 0x800
callq 0x92c8
movq %rax, %r12
movq %rax, (%rbp,%r13,8)
andq $0x0, 0x8(%rsp)
andq $0x0, 0x18(%rsp)
xorl %ebp, %ebp
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
movq %r14, %rdx
callq 0x2250
movq 0x8(%rsp), %rsi
cmpq $-0x1, %rax
je 0x49d6
cmpb $0x3e, (%rsi)
je 0x49dc
movq 0x18(%rsp), %rax
leaq (%rax,%rbp), %rcx
cmpq %rbx, %rcx
jbe 0x4997
addq %rax, %rbx
addq $0x800, %rbx            # imm = 0x800
movq %r12, %rdi
movq %rbx, %rsi
callq 0x9470
movq %rax, %r12
movq 0x20(%rsp), %rax
movq %r12, (%rax,%r13,8)
movq 0x8(%rsp), %rsi
leaq (%r12,%rbp), %rdi
callq 0x2070
movq 0x8(%rsp), %rdi
callq 0x20d0
addq %rax, %rbp
decq %rbp
movq %r14, %rdi
callq 0x21a0
movq %rax, %r15
movq 0x8(%rsp), %rdi
callq 0x939e
andq $0x0, 0x18(%rsp)
andq $0x0, 0x8(%rsp)
jmp 0x4941
movl 0x14(%rsp), %ebx
jmp 0x49e2
movl 0x14(%rsp), %ebx
incl %ebx
movq %rsi, %rdi
callq 0x939e
movb $0x0, (%r12,%rbp)
movq 0x28(%rsp), %rcx
movq (%rcx), %rax
addq %rbp, %rax
incq %rax
movq %rax, (%rcx)
incq %r13
movq 0x20(%rsp), %rbp
jmp 0x4901
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x21e0
jmp 0x4a1e
xorl %ebp, %ebp
movq %rbp, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/felipelouza[P]egap/tools/lib/file.c
// Function: file_count_multiple
int_t* file_count_multiple(char* c_file, int_t *k, uint_t chunk_size, int_t *chunks, size_t *n, FILE *f_in, ssize_t **pos) {

/* .ext
 * .txt   - strings per line
 * .fa .fasta - strings separated by '>' line
 * .fastq - strings separated by four lines
 */

  const char *type = get_filename_ext(c_file);
  int_t *K = NULL; 
  *pos = NULL; 

  if(strcmp(type,"txt") == 0)
    K = count_multiple_txt(f_in, k, chunk_size, n, chunks, pos);

  else if(strcmp(type,"fasta") == 0 || strcmp(type,"fa")==0 )
    K = count_multiple_fasta(f_in, k, chunk_size, n, chunks, pos);

  else if(strcmp(type,"fastq") == 0 || strcmp(type,"fq")==0 )
    K = count_multiple_fastq(f_in, k, chunk_size, n, chunks, pos);

  else{
    printf("Error: file not recognized (.txt, .fa, .fasta, .fastq, .fq)\n");
    exit(EXIT_FAILURE);
  }

  //sets the pointer to the beginning of the file
  rewind(f_in);

return K;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r12
movq %rcx, (%rsp)
movq %rdx, %r13
movq %rsi, %rbp
movq 0x40(%rsp), %r14
callq 0x3d78
movq %rax, %r15
andq $0x0, (%r14)
leaq 0x5e7e(%rip), %rsi      # 0xa8e1
movq %rax, %rdi
callq 0x2180
testl %eax, %eax
je 0x4adc
leaq 0x5e6f(%rip), %rsi      # 0xa8e5
movq %r15, %rdi
callq 0x2180
testl %eax, %eax
je 0x4af8
movb (%r15), %r14b
cmpb $0x66, %r14b
jne 0x4a99
cmpb $0x61, 0x1(%r15)
jne 0x4a99
cmpb $0x0, 0x2(%r15)
je 0x4af8
leaq 0x5e3b(%rip), %rsi      # 0xa8db
movq %r15, %rdi
callq 0x2180
testl %eax, %eax
je 0x4ac0
cmpb $0x66, %r14b
jne 0x4b2f
cmpb $0x71, 0x1(%r15)
jne 0x4b2f
cmpb $0x0, 0x2(%r15)
jne 0x4b2f
movq %rbx, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq (%rsp), %r8
movq 0x40(%rsp), %r9
callq 0x412d
jmp 0x4b12
movq %rbx, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq (%rsp), %r8
movq 0x40(%rsp), %r9
callq 0x3f88
jmp 0x4b12
movq %rbx, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq (%rsp), %r8
movq 0x40(%rsp), %r9
callq 0x4361
movq %rax, %r14
movq %rbx, %rdi
callq 0x2110
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5e41(%rip), %rdi      # 0xa977
callq 0x2080
pushq $0x1
popq %rdi
callq 0x2270
// File: /workspace/github_c_makefile_star2_O2/felipelouza[P]egap/tools/lib/file.c
// Function: file_load_multiple_chunks
char** file_load_multiple_chunks(char* c_file, int_t k, size_t *n, FILE *f_in) {

/* .ext
 * .txt   - strings per line
 * .fa .fasta - strings separated by '>' line
 * .fastq - strings separated by four lines
 */

  const char *type = get_filename_ext(c_file);
  char **c_buffer = NULL; // = (char**) malloc(k*sizeof(char*));

  if(strcmp(type,"txt") == 0)
    c_buffer = load_multiple_txt(f_in, k, n);

  else if(strcmp(type,"fasta") == 0 || strcmp(type,"fa")==0 )
    c_buffer = load_multiple_fasta(f_in, k, n);

  else if(strcmp(type,"fastq") == 0 || strcmp(type,"fq")==0 )
    c_buffer = load_multiple_fastq(f_in, k, n);

  else{
    printf("Error: file not recognized (.txt, .fa, .fasta, .fastq, .fq)\n");
    exit(EXIT_FAILURE);
  }

return c_buffer;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r14
callq 0x3d78
movq %rax, %r12
leaq 0x5d7e(%rip), %rsi      # 0xa8e1
movq %rax, %rdi
callq 0x2180
testl %eax, %eax
je 0x4bdb
leaq 0x5d6f(%rip), %rsi      # 0xa8e5
movq %r12, %rdi
callq 0x2180
testl %eax, %eax
je 0x4bf1
movb (%r12), %bpl
cmpb $0x66, %bpl
jne 0x4b9c
cmpb $0x61, 0x1(%r12)
jne 0x4b9c
cmpb $0x0, 0x2(%r12)
je 0x4bf1
leaq 0x5d38(%rip), %rsi      # 0xa8db
movq %r12, %rdi
callq 0x2180
testl %eax, %eax
je 0x4bc5
cmpb $0x66, %bpl
jne 0x4c07
cmpb $0x71, 0x1(%r12)
jne 0x4c07
cmpb $0x0, 0x2(%r12)
jne 0x4c07
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x462b
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4587
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x489a
leaq 0x5d69(%rip), %rdi      # 0xa977
callq 0x2080
pushq $0x1
popq %rdi
callq 0x2270
// File: /workspace/github_c_makefile_star2_O2/felipelouza[P]egap/tools/lib/file.c
// Function: file_load_multiple
char** file_load_multiple(char* c_file, int k, size_t *n) {

/* .ext
 * .txt   - strings per line
 * .fa .fasta - strings separated by '>' line
 * .fastq - strings separated by four lines
 */

  FILE* f_in = file_open(c_file, "rb");
  if(!f_in) return 0;

  const char *type = get_filename_ext(c_file);
  char **c_buffer = NULL; // = (char**) malloc(k*sizeof(char*));

  if(strcmp(type,"txt") == 0)
    c_buffer = load_multiple_txt(f_in, k, n);

  else if(strcmp(type,"fasta") == 0 || strcmp(type,"fa")==0 )
    c_buffer = load_multiple_fasta(f_in, k, n);

  else if(strcmp(type,"fastq") == 0 || strcmp(type,"fq")==0 )
    c_buffer = load_multiple_fastq(f_in, k, n);
  else{
    printf("Error: file not recognized (.txt, .fa, .fasta, .fastq, .fq)\n");
    exit(EXIT_FAILURE);
  }

  fclose(f_in);

return c_buffer;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
leaq 0x59c0(%rip), %rsi      # 0xa5f2
callq 0x3df1
movq %rax, %rbx
movq %r15, %rdi
callq 0x3d78
movq %rax, %r15
leaq 0x5c95(%rip), %rsi      # 0xa8e1
movq %rax, %rdi
callq 0x2180
testl %eax, %eax
je 0x4cb9
leaq 0x5c86(%rip), %rsi      # 0xa8e5
movq %r15, %rdi
callq 0x2180
testl %eax, %eax
je 0x4cc9
movb (%r15), %r12b
cmpb $0x66, %r12b
jne 0x4c82
cmpb $0x61, 0x1(%r15)
jne 0x4c82
cmpb $0x0, 0x2(%r15)
je 0x4cc9
leaq 0x5c52(%rip), %rsi      # 0xa8db
movq %r15, %rdi
callq 0x2180
testl %eax, %eax
je 0x4ca9
cmpb $0x66, %r12b
jne 0x4cee
cmpb $0x71, 0x1(%r15)
jne 0x4cee
cmpb $0x0, 0x2(%r15)
jne 0x4cee
movslq %ebp, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x462b
jmp 0x4cd7
movslq %ebp, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x4587
jmp 0x4cd7
movslq %ebp, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x489a
movq %rax, %r14
movq %rbx, %rdi
callq 0x20c0
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5c82(%rip), %rdi      # 0xa977
callq 0x2080
pushq $0x1
popq %rdi
callq 0x2270
// File: /workspace/github_c_makefile_star2_O2/felipelouza[P]egap/tools/lib/file.c
// Function: file_load_concat
unsigned char** file_load_concat(char* c_file, char *len_file, int k, int_t *n) {

  unsigned char **c_buffer = (unsigned char**) malloc(k*sizeof(unsigned char*));
  if(c_buffer==NULL) die("out of mem");

  FILE *f = fopen(c_file,"rb");
  if(f==NULL) {perror("sequence file missing"); fprintf(stderr, "<%s> ", c_file); die("file_load_concat");}
  FILE *fl = fopen(len_file,"rb");
  if(fl==NULL) {perror("sequence file missing"); fprintf(stderr, "<%s> ", len_file); die("file_load_concat");}
  
  int i;
  for(i=0;i<k;i++) {
    uint32_t size;
    size_t r = fread(&size, 4, 1, fl);// assume big endian!
    if(r!=1) die("len file too short");
    c_buffer[i] = malloc((size+1)*sizeof(char));
    if(!c_buffer[i]) die("out of mem");
    r = fread(c_buffer[i], 1, size, f);
    if(r!=size) die("concat file too short");
    c_buffer[i][size] = 0;
    *n += size+1;
  }
  fclose(fl);
  fclose(f);
  return c_buffer;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, 0x20(%rsp)
movq %rsi, %rbp
movq %rdi, %rbx
movq %rdx, %r13
movslq %edx, %rdi
shlq $0x3, %rdi
callq 0x92c8
movq %rax, 0x18(%rsp)
testq %rax, %rax
jne 0x4d40
leaq 0x5bb0(%rip), %rdi      # 0xa8eb
callq 0x372a
leaq 0x58ab(%rip), %rsi      # 0xa5f2
movq %rbx, %rdi
callq 0x2200
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x4e45
leaq 0x588e(%rip), %rsi      # 0xa5f2
movq %rbp, %rdi
callq 0x2200
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x4e7d
xorl %r12d, %r12d
testl %r13d, %r13d
cmovlel %r12d, %r13d
pushq $0x1
popq %rbx
cmpq %r12, %r13
je 0x4e1d
leaq 0x4(%rsp), %rdi
pushq $0x4
popq %rsi
movq %rbx, %rdx
movq 0x8(%rsp), %rcx
callq 0x20a0
cmpq $0x1, %rax
je 0x4db7
leaq 0x5b71(%rip), %rdi      # 0xa923
callq 0x372a
movl 0x4(%rsp), %ebp
leal 0x1(%rbp), %r15d
movq %r15, %rdi
callq 0x92c8
movq %rax, %r14
movq 0x18(%rsp), %rax
movq %r14, (%rax,%r12,8)
testq %r14, %r14
jne 0x4de4
leaq 0x5b0c(%rip), %rdi      # 0xa8eb
callq 0x372a
movq %r14, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
movq 0x10(%rsp), %rcx
callq 0x20a0
cmpq %rbp, %rax
je 0x4e08
leaq 0x5b33(%rip), %rdi      # 0xa936
callq 0x372a
movb $0x0, (%r14,%rbp)
movq 0x20(%rsp), %rax
addq %r15, (%rax)
incq %r12
jmp 0x4d87
movq 0x8(%rsp), %rdi
callq 0x20c0
movq 0x10(%rsp), %rdi
callq 0x20c0
movq 0x18(%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5aaa(%rip), %rdi      # 0xa8f6
callq 0x2210
movq 0x91a0(%rip), %rax      # 0xdff8
movq (%rax), %rdi
leaq 0x5aaa(%rip), %rsi      # 0xa90c
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2190
leaq 0x5a9f(%rip), %rdi      # 0xa912
callq 0x372a
jmp 0x4d5d
leaq 0x5a72(%rip), %rdi      # 0xa8f6
callq 0x2210
movq 0x9168(%rip), %rax      # 0xdff8
movq (%rax), %rdi
leaq 0x5a72(%rip), %rsi      # 0xa90c
movq %rbp, %rdx
xorl %eax, %eax
callq 0x2190
leaq 0x5a67(%rip), %rdi      # 0xa912
callq 0x372a
jmp 0x4d7a
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/felipelouza[P]egap/tools/lib/suffix_array.c
// Function: suffix_array_write
int suffix_array_write(int_t *SA, int_t n, char* c_file, const char* ext){

  FILE *f_out;
  char *c_out = malloc((strlen(c_file)+strlen(ext))*sizeof(char));
  
  sprintf(c_out, "%s.%s", c_file, ext);
  f_out = file_open(c_out, "wb");
  
  fwrite(SA, sizeof(int_t), n, f_out);
  
  file_close(f_out);
  free(c_out);

return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rdi
callq 0x20d0
movq %rax, %r15
movq %r12, %rdi
callq 0x20d0
addq %rax, %r15
movq %r15, %rdi
callq 0x92c8
movq %rax, %r15
leaq 0x5abe(%rip), %rsi      # 0xa9b3
movq %rax, %rdi
movq %r13, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x2260
leaq 0x572f(%rip), %rsi      # 0xa63b
movq %r15, %rdi
callq 0x3df1
movq %rax, %r12
pushq $0x8
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x2280
movq %r12, %rdi
callq 0x3e24
movq %r15, %rdi
callq 0x939e
pushq $0x1
popq %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/felipelouza[P]egap/tools/lib/suffix_array.c
// Function: suffix_array_read
int_t* suffix_array_read(int_t n, char* c_file, const char* ext){

  FILE *f_in;
  char *c_in = malloc((strlen(c_file)+strlen(ext))*sizeof(char));
  
  sprintf(c_in, "%s.%s", c_file, ext);
  f_in = file_open(c_in, "rb");
  
  int_t *SA = (int_t*) malloc(n*sizeof(int_t));
  size_t e = fread(SA, sizeof(int_t), n, f_in);
  if(e!=n) {perror(__func__); exit(1);}
  
  file_close(f_in);
  free(c_in);

return SA;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x20d0
movq %rax, %r14
movq %r15, %rdi
callq 0x20d0
addq %rax, %r14
movq %r14, %rdi
callq 0x92c8
movq %rax, %r14
leaq 0x5a35(%rip), %rsi      # 0xa9b3
movq %rax, %rdi
movq %r12, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x2260
leaq 0x565d(%rip), %rsi      # 0xa5f2
movq %r14, %rdi
callq 0x3df1
movq %rax, %r12
leaq (,%rbx,8), %rdi
callq 0x92c8
movq %rax, %r15
pushq $0x8
popq %rsi
movq %rax, %rdi
movq %rbx, %rdx
movq %r12, %rcx
callq 0x20a0
cmpq %rbx, %rax
jne 0x4fe5
movq %r12, %rdi
callq 0x3e24
movq %r14, %rdi
callq 0x939e
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x59cd(%rip), %rdi      # 0xa9b9
callq 0x2210
pushq $0x1
popq %rdi
callq 0x2270
// File: /workspace/github_c_makefile_star2_O2/felipelouza[P]egap/tools/lib/suffix_array.c
// Function: suffix_array_print
int_t suffix_array_print(unsigned char *T, int_t *SA, size_t n, int cs){

int_t i;
  for(i=0; i<n; i++){

    printf("%" PRIdN ") %" PRIdN "\t", i, SA[i]);
  
    int_t j=SA[i];
    for(j=SA[i]; (j<SA[i]+5); j++)
      printf("%" PRIdN " ", chr(j));
    printf("\n");
  }

return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, (%rsp)
movq %rsi, %r15
movq %rdi, %r12
leaq 0x59be(%rip), %rbp      # 0xa9d5
xorl %r13d, %r13d
cmpq (%rsp), %r13
je 0x5075
movq (%r15,%r13,8), %rdx
leaq 0x59a0(%rip), %rdi      # 0xa9cb
movq %r13, %rsi
xorl %eax, %eax
callq 0x20f0
movq (%r15,%r13,8), %rax
movq %rax, %r14
addq $0x5, %rax
cmpq %rax, %r14
jge 0x5068
cmpl $0x8, %ebx
jne 0x5050
movq (%r12,%r14,8), %rsi
jmp 0x5055
movzbl (%r12,%r14), %esi
movq %rbp, %rdi
xorl %eax, %eax
callq 0x20f0
incq %r14
movq (%r15,%r13,8), %rax
jmp 0x503c
pushq $0xa
popq %rdi
callq 0x2040
incq %r13
jmp 0x501a
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/felipelouza[P]egap/tools/lib/suffix_array.c
// Function: sleq
int_t sleq(unsigned char *T, int_t a, int_t b, size_t n, int cs, unsigned char sentinel) {

  size_t i;

  for(i=0; i<n; i++){

          if (chr(a) < chr(b))
      return 1;
          else if (chr(a) > chr(b))
                  return 0;
    else if(chr(a)==sentinel && chr(b)==sentinel){// $_i < $_j iff i < j
      if(a < b) 
        return 1;
      else  
        return 0;
    }
    a++;
    b++;
        }

return 1;
}

// Assembly:
pushq %rbx
movl %r9d, %r10d
movabsq $0x1, %rax
subq $0x1, %rcx
jb 0x50e7
cmpl $0x8, %r8d
jne 0x50b7
movq (%rdi,%rsi,8), %rbx
movq (%rdi,%rdx,8), %r11
cmpq %r11, %rbx
jl 0x50e7
jg 0x50db
cmpq %r10, %rbx
je 0x50ce
jmp 0x50d3
movb (%rdi,%rsi), %bl
movzbl (%rdi,%rdx), %r11d
cmpb %r11b, %bl
jb 0x50e7
cmpb %r11b, %bl
ja 0x50db
cmpb %r9b, %bl
jne 0x50d3
cmpq %r10, %r11
je 0x50df
incq %rsi
incq %rdx
jmp 0x5095
xorl %eax, %eax
jmp 0x50e7
xorl %eax, %eax
cmpq %rdx, %rsi
setl %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/felipelouza[P]egap/tools/lib/suffix_array.c
// Function: suffix_array_check
int_t suffix_array_check(unsigned char *T, int_t *SA,  size_t n, int cs, unsigned char sentinel){

  int_t i,j,k;
  
  for (i = 0; i < n-1;  i++) {
    size_t min = SA[i+1]<SA[i]?(n-SA[i]):(n-SA[i+1]);
    if (!sleq(T, SA[i], SA[i+1], min, cs, sentinel)){

      printf("#%" PRIdN ") %" PRIdN ", %" PRIdN "&\n", i, SA[i], SA[i+1]);

      for(j=SA[i], k=SA[i+1]; (j<SA[i]+5); j++, k++)
        printf("%" PRIdN " | %" PRIdN "\n", chr(j), chr(k));
      printf("\n");

      return 0;
    }
  }

  unsigned char *tmp = (unsigned char*) malloc(n*sizeof(unsigned char));

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

  for (i = 0; i < n;  i++) 
    tmp[SA[i]] = 1;
  
  for (i = 0; i < n;  i++){ 
    if(!tmp[i]){
      free(tmp);
      fprintf(stderr, "Error: is not a permutation\n");
      return 0;
    }
  }

  free(tmp);
  
return 1;  
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, 0x8(%rsp)
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r15
pushq $0x1
popq %rax
subq %rdx, %rax
movq %rax, 0x10(%rsp)
pushq $-0x1
popq %r12
movzbl %r8b, %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
addq %r12, %rax
cmpq $-0x1, %rax
je 0x51cf
movq 0x8(%rbx,%r12,8), %r14
movq 0x10(%rbx,%r12,8), %rbp
cmpq %r14, %rbp
movq %r14, %rax
cmovgq %rbp, %rax
movq %r13, %rcx
subq %rax, %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %rbp, %rdx
movl 0x8(%rsp), %r8d
movl 0xc(%rsp), %r9d
callq 0x5087
incq %r12
testq %rax, %rax
jne 0x511b
leaq 0x586c(%rip), %rdi      # 0xa9da
movq %r12, %rsi
movq %r14, %rdx
movq %rbp, %rcx
xorl %eax, %eax
callq 0x20f0
movq (%rbx,%r12,8), %rax
movq 0x8(%rbx,%r12,8), %r13
leaq 0x585d(%rip), %r14      # 0xa9eb
movq %rax, %rbp
addq $0x5, %rax
cmpq %rax, %rbp
jge 0x5232
cmpl $0x8, 0x8(%rsp)
jne 0x51af
movq (%r15,%rbp,8), %rsi
movq (%r15,%r13,8), %rdx
jmp 0x51b9
movzbl (%r15,%rbp), %esi
movzbl (%r15,%r13), %edx
movq %r14, %rdi
xorl %eax, %eax
callq 0x20f0
incq %rbp
incq %r13
movq (%rbx,%r12,8), %rax
jmp 0x5191
movq %r13, %rdi
callq 0x92c8
xorl %ecx, %ecx
cmpq %rcx, %r13
je 0x51e7
movb $0x0, (%rax,%rcx)
incq %rcx
jmp 0x51d9
xorl %ecx, %ecx
cmpq %rcx, %r13
je 0x51fb
movq (%rbx,%rcx,8), %rdx
movb $0x1, (%rax,%rdx)
incq %rcx
jmp 0x51e9
xorl %ecx, %ecx
cmpq %rcx, %r13
je 0x523e
cmpb $0x0, (%rax,%rcx)
leaq 0x1(%rcx), %rcx
jne 0x51fd
movq %rax, %rdi
callq 0x939e
movq 0x8ddd(%rip), %rax      # 0xdff8
movq (%rax), %rcx
leaq 0x57d1(%rip), %rdi      # 0xa9f6
pushq $0x1c
popq %rsi
pushq $0x1
popq %rdx
callq 0x2280
jmp 0x523a
pushq $0xa
popq %rdi
callq 0x2040
xorl %eax, %eax
jmp 0x5249
movq %rax, %rdi
callq 0x939e
pushq $0x1
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq