LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/zhoudian64[P]OS2-exp/io.c
// Function: main
int main() {
// 申请20字节内存
	char* helloString = malloc(20*sizeof(char));
// 字符串常量
	char* src = "hello, glibc.\n";
// 将src指向的内存拷贝至helloString
	strcpy(helloString, src);

// 打开文件hello.txt, 没有责创建｜可读可写｜有则从零开始, rw_rw_r
	int fd_hello = open("hello.txt", O_CREAT | O_RDWR | O_TRUNC, 0664);
// 向文件fd_hello 写入helloString
	write(fd_hello, helloString, 20*sizeof(char));
// 关闭文件
	close(fd_hello);
// 清理申请的内存
	free(helloString);
	
	char* byeString = malloc(20*sizeof(char));
// 只读
	int fd_bye = open("bye.txt", O_RDONLY);
	read(fd_bye, byeString, 20*sizeof(char));
	printf("bye.txt: %s", byeString);
	close(fd_bye);
	free(byeString);

	char glibc2clang[5] = "clang";
	fd_bye = open("bye.txt", O_WRONLY);
// 在fd_bye原有的位置+5offset
	lseek(fd_bye, 5, SEEK_SET);
	write(fd_bye, glibc2clang, 5*sizeof(char));	
	close(fd_bye);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq $0x14
popq %rbx
movq %rbx, %rdi
callq 0x1090
movq %rax, %r14
movabsq $0x67202c6f6c6c6568, %rax # imm = 0x67202C6F6C6C6568
movq %rax, (%r14)
movabsq $0xa2e6362696c67, %rax  # imm = 0xA2E6362696C67
movq %rax, 0x7(%r14)
leaq 0xe2c(%rip), %rdi       # 0x2013
movl $0x242, %esi            # imm = 0x242
movl $0x1b4, %edx            # imm = 0x1B4
xorl %eax, %eax
callq 0x10a0
movl %eax, %r15d
movl %eax, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1040
movl %r15d, %edi
callq 0x1070
movq %r14, %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x1090
movq %rax, %r15
leaq 0xdf3(%rip), %r14       # 0x201d
movq %r14, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x10a0
movl %eax, %r12d
movl %eax, %edi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1080
leaq 0xdd8(%rip), %rdi       # 0x2025
movq %r15, %rsi
xorl %eax, %eax
callq 0x1050
movl %r12d, %edi
callq 0x1070
movq %r15, %rdi
callq 0x1030
pushq $0x1
popq %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x10a0
movl %eax, %ebx
pushq $0x5
popq %r14
movl %eax, %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0x1060
leaq 0xda4(%rip), %rsi       # 0x2031
movl %ebx, %edi
movq %r14, %rdx
callq 0x1040
movl %ebx, %edi
callq 0x1070
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/CSerxzm[P]WindowstoLinuxInterface/src/../include/line.h
// Function: predealLine
int predealLine(int argc, char* argv[], char (*lines)[255]){
    int real_len=0;
    for(int j=0;j<strlen(argv[0]);j++){
        if(isalpha(argv[0][j])||isdigit(argv[0][j]))
            lines[0][real_len++]=tolower(argv[0][j]);
    }
    lines[0][real_len]='\0';
    for(int i=1;i<argc;i++){
        //printf("%s ", argv[i]);
        real_len=0;
        for(int j=0;j<strlen(argv[i]);j++){
            lines[i][real_len++]=argv[i][j];
        }
        lines[i][real_len]='\0';
        //printf("%s ", lines[i]);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, -0x38(%rbp)
movq %rsi, %r14
movl %edi, -0x30(%rbp)
xorl %ebx, %ebx
xorl %r13d, %r13d
movq (%r14), %r12
movq %r12, %rdi
callq 0x1040
movslq %r13d, %r15
cmpq %rbx, %rax
jbe 0x1221
callq 0x10b0
movq (%rax), %rax
movsbq (%r12,%rbx), %r12
testb $0xc, 0x1(%rax,%r12,2)
je 0x121c
callq 0x10a0
movq (%rax), %rax
movb (%rax,%r12,4), %al
leal 0x1(%r15), %r13d
movq -0x38(%rbp), %rcx
movb %al, (%rcx,%r15)
incq %rbx
jmp 0x11dc
movq -0x38(%rbp), %rax
movb $0x0, (%rax,%r15)
movslq -0x30(%rbp), %rcx
movq %rcx, -0x30(%rbp)
leaq 0xff(%rax), %r13
pushq $0x1
popq %rbx
cmpq -0x30(%rbp), %rbx
jge 0x1283
xorl %r12d, %r12d
movq (%r14,%rbx,8), %r15
movq %r15, %rdi
callq 0x1040
cmpq %r12, %rax
jbe 0x1264
movb (%r15,%r12), %al
movb %al, (%r13,%r12)
incq %r12
jmp 0x1245
movl %r12d, %eax
imulq $0xff, %rbx, %rcx
addq -0x38(%rbp), %rcx
movb $0x0, (%rax,%rcx)
incq %rbx
movl $0xff, %eax
addq %rax, %r13
jmp 0x123c
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/CSerxzm[P]WindowstoLinuxInterface/src/MORE.c
// Function: main
int main(int ac, char *av[])  { 
    FILE *fp;  
    if(ac==1)  
      do_more(stdin);  
    else  {  
        while(--ac)  
          if( (fp = fopen(* ++av, "r")) != NULL)  {  
              do_more(fp);  
              fclose(fp);  
          }  
          else  
            exit(1);  
    }  
    return 0;  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x1, %edi
jne 0x12c7
movq 0x2d32(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x130e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %rbx
movl %edi, %r12d
pushq $0x1
popq %r13
leaq 0xd2c(%rip), %r14       # 0x2004
cmpl %r13d, %r12d
je 0x12b6
movq (%rbx,%r13,8), %rdi
movq %r14, %rsi
callq 0x1070
testq %rax, %rax
je 0x1306
movq %rax, %r15
movq %rax, %rdi
callq 0x130e
movq %r15, %rdi
callq 0x1030
incq %r13
jmp 0x12d8
pushq $0x1
popq %rdi
callq 0x1080
// File: /workspace/github_c_makefile_star2_O2/CSerxzm[P]WindowstoLinuxInterface/src/MORE.c
// Function: do_more
void do_more(FILE *fp)  {  
    char line[LINELEN];  
    int reply;  
    int number_line = 0;  
    FILE *fp_tty;  
    fp_tty = fopen("/dev/tty", "r");
    if(fp_tty == NULL)  
      exit(1);  
    while(fgets(line, LINELEN, fp) != NULL)  {  
        if(number_line == PAGELEN)  {  
            reply = see_more(fp_tty);  
            if(reply == 0)   
              break;  
            number_line -= reply;  
        }  
        if( fputs(line, stdout) == EOF)  
          exit(1);  
        number_line ++;  
    }  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
leaq 0xcda(%rip), %rdi       # 0x2006
leaq 0xcd1(%rip), %rsi       # 0x2004
callq 0x1070
testq %rax, %rax
je 0x1393
movq %rax, %r14
xorl %r12d, %r12d
leaq -0x230(%rbp), %r15
movq 0x2c87(%rip), %r13      # 0x3fd8
movq %r15, %rdi
movl $0x202, %esi            # imm = 0x202
movq %rbx, %rdx
callq 0x1060
testq %rax, %rax
je 0x139b
cmpl $0x18, %r12d
jne 0x137f
movq %r14, %rdi
callq 0x13ad
testl %eax, %eax
je 0x139b
pushq $0x18
popq %r12
subl %eax, %r12d
movq (%r13), %rsi
movq %r15, %rdi
callq 0x1050
incl %r12d
cmpl $-0x1, %eax
jne 0x1351
pushq $0x1
popq %rdi
callq 0x1080
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mulle-nat[P]long-long-double-trouble/int.c
// Function: fits_int
int   fits_int( double value)
{
   int  i_val;
   int  fits;

   if( value < (double) INT_MIN || value > (double) INT_MAX)
      return( 0);

   i_val = (int) value;
   fits  = (double) i_val == value;
   if( ! fits)
      fprintf( stderr, "Mismatch %f with %d\n", value, i_val);

   return( fits);
}

// Assembly:
pushq %rbx
xorl %ebx, %ebx
movsd 0xea1(%rip), %xmm1      # 0x2008
ucomisd %xmm0, %xmm1
ja 0x118a
ucomisd 0xe9b(%rip), %xmm0      # 0x2010
ja 0x118a
cvttpd2dq %xmm0, %xmm1
cvtdq2pd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jne 0x118e
jp 0x118e
pushq $0x1
popq %rbx
movl %ebx, %eax
popq %rbx
retq
cvttsd2si %xmm0, %edx
movq 0x2e5f(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xe85(%rip), %rsi       # 0x2028
movb $0x1, %al
callq 0x1040
jmp 0x118a
// File: /workspace/github_c_makefile_star2_O2/mulle-nat[P]long-long-double-trouble/int.c
// Function: main
int   main( int argc, char *argv[])
{
   double  value;

   fprintf( stderr, "int (%d bytes): %d - %d\n", (int) sizeof( int), INT_MIN, INT_MAX);
   fprintf( stderr, "double (%d bytes): %g - %g\n", (int) sizeof( double), DBL_MIN, DBL_MAX);

   assert( (double) INT_MAX <= DBL_MAX);

   // keep my code optimiza
   if( argc == 1)
      value = (double) INT_MAX;
   else
      value = (double) (INT_MAX - atoi( argv[ 1]));

   if( fits_int( value))
      printf( "FITS\n");
   else
      printf( "NOPE\n");
   return( 0);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
movq 0x2e3c(%rip), %r14      # 0x3ff8
movq (%r14), %rdi
leaq 0xe77(%rip), %rsi       # 0x203d
pushq $0x4
popq %rdx
movl $0x80000000, %ecx       # imm = 0x80000000
movl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
xorl %eax, %eax
callq 0x1040
movq (%r14), %rdi
leaq 0xe71(%rip), %rsi       # 0x2056
pushq $0x8
popq %rdx
movsd 0xe28(%rip), %xmm0      # 0x2018
movsd 0xe28(%rip), %xmm1      # 0x2020
movb $0x2, %al
callq 0x1040
cmpl $0x1, %ebp
jne 0x120e
movsd 0xe04(%rip), %xmm0      # 0x2010
jmp 0x1220
movq 0x8(%rbx), %rdi
callq 0x1050
xorl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
cvtsi2sd %eax, %xmm0
callq 0x115c
testl %eax, %eax
leaq 0xe44(%rip), %rax       # 0x2072
leaq 0xe42(%rip), %rdi       # 0x2077
cmoveq %rax, %rdi
callq 0x1030
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/radforddc[P]icpc_siggen/icpc_fieldgen_opt.c
// Function: dist_from_contact
float dist_from_contact(cyl_pt pt, cyl_pt delta, MJD_Siggen_Setup *setup) {
  float  factor = 1, d = 0.5;
  cyl_pt test;
  int    n;

  for (n=0; n<7; n++) {  // 7 steps => 1/128 precision
    test.r = pt.r + factor * delta.r;
    test.z = pt.z + factor * delta.z;
    if (outside_detector_cyl(test, setup)) {
      factor -= d;
    } else {
      if (n == 0) return -1.0;
      factor += d;
    } 
    d /= 2.0;
  }
  return factor;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movss %xmm3, 0xc(%rsp)
movaps %xmm2, 0x20(%rsp)
movss %xmm1, 0x8(%rsp)
movaps %xmm0, 0x10(%rsp)
movss 0x3268(%rip), %xmm0     # 0x8144
movss 0x3264(%rip), %xmm1     # 0x8148
pushq $0x7
popq %r14
movl %r14d, %ebp
subl $0x1, %ebp
jb 0x4f78
movss %xmm1, 0x4(%rsp)
movaps %xmm0, %xmm1
mulss 0x20(%rsp), %xmm1
addss 0x10(%rsp), %xmm1
movss %xmm1, %xmm2            # xmm2 = xmm1[0],xmm2[1,2,3]
movaps %xmm0, %xmm1
movss %xmm0, (%rsp)
mulss 0xc(%rsp), %xmm1
addss 0x8(%rsp), %xmm1
movaps %xmm2, 0x30(%rsp)
movaps %xmm2, %xmm0
movq %rbx, %rdi
callq 0x7368
testl %eax, %eax
je 0x4f46
movss 0x4(%rsp), %xmm1
movss (%rsp), %xmm0
subss %xmm1, %xmm0
jmp 0x4f5b
movss (%rsp), %xmm0
cmpl $0x7, %r14d
movss 0x4(%rsp), %xmm1
je 0x4f70
addss %xmm1, %xmm0
mulss 0x31e5(%rip), %xmm1     # 0x8148
movl %ebp, %r14d
movaps 0x30(%rsp), %xmm2
jmp 0x4eeb
movss 0x31c8(%rip), %xmm0     # 0x8140
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/radforddc[P]icpc_siggen/icpc_fieldgen_opt.c
// Function: report_config
int report_config(FILE *fp_out, char *config_file_name) {
  char  *c, line[256];
  FILE  *file;

  fprintf(fp_out, "# Config file: %s\n", config_file_name);
  if (!(file = fopen(config_file_name, "r"))) return 1;

  while (fgets(line, sizeof(line), file)) {
    if (strlen(line) < 3 || *line == ' ' || *line == '\t' || *line == '#') continue;
    if ((c = strchr(line, '#')) || (c = strchr(line, '\n'))) *c = '\0';
    fprintf(fp_out, "# %s\n", line);
  }
  fclose(file);
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x2c22(%rip), %rsi      # 0x8e50
movq %r14, %rdx
xorl %eax, %eax
callq 0x1150
leaq 0x246e(%rip), %rsi      # 0x86ad
movq %r14, %rdi
callq 0x11b0
testq %rax, %rax
je 0x62d2
movq %rax, %r14
movq %rsp, %r15
pushq $0x23
popq %rbp
pushq $0xa
popq %r12
leaq 0x2bff(%rip), %r13      # 0x8e63
movq %r15, %rdi
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdx
callq 0x1130
testq %rax, %rax
je 0x62ca
movq %r15, %rdi
callq 0x10d0
cmpq $0x3, %rax
jb 0x6264
movb (%rsp), %al
cmpb $0x23, %al
je 0x6264
cmpb $0x20, %al
je 0x6264
cmpb $0x9, %al
je 0x6264
movq %r15, %rdi
movl %ebp, %esi
callq 0x10e0
testq %rax, %rax
jne 0x62b5
movq %r15, %rdi
movl %r12d, %esi
callq 0x10e0
testq %rax, %rax
je 0x62b8
movb $0x0, (%rax)
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x1150
jmp 0x6264
movq %r14, %rdi
callq 0x10c0
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/eric-lo[P]3150/3-ProcessUser/envp.c
// Function: main
int main(int argc, char **argv, char **envp) {
	int i;
	for(i = 0; envp[i]; i++)
		printf("%s\n", envp[i]);
	return 0;
}

// Assembly:
pushq %rbx
movq %rdx, %rbx
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1153
callq 0x1030
addq $0x8, %rbx
jmp 0x1140
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/diaxen[P]fft-garden/./ct_bf.h
// Function: ct_dit_bf2_pi2
static inline void
ct_dit_bf2_pi2(unsigned s,
           complex double * restrict out)
{
  complex double a = out[0];
  complex double b = out[s];
  complex double t = CMPLX(cimag(b), -creal(b));
  out[0] = a + t;
  out[s] = a - t;
}

// Assembly:
movsd (%rsi), %xmm0
movsd 0x8(%rsi), %xmm1
movl %edi, %eax
shlq $0x4, %rax
movsd (%rsi,%rax), %xmm2
movsd 0x8(%rsi,%rax), %xmm3
movapd %xmm0, %xmm4
addsd %xmm3, %xmm4
movapd %xmm1, %xmm5
subsd %xmm2, %xmm5
movsd %xmm4, (%rsi)
movsd %xmm5, 0x8(%rsi)
subsd %xmm3, %xmm0
addsd %xmm2, %xmm1
movsd %xmm0, (%rsi,%rax)
movsd %xmm1, 0x8(%rsi,%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/diaxen[P]fft-garden/./ct_bf.h
// Function: ct_dit_bf2
static inline void
ct_dit_bf2(unsigned s,
       complex double * restrict out,
       complex double w)
{
  complex double a = out[0];
  complex double b = out[s] * w;
  out[0] = a + b;
  out[s] = a - b;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movapd %xmm1, %xmm3
movapd %xmm0, %xmm2
movq %rsi, %rbx
movsd (%rsi), %xmm7
movsd 0x8(%rsi), %xmm8
movl %edi, %eax
shlq $0x4, %rax
leaq (%rsi,%rax), %r14
movsd (%rsi,%rax), %xmm4
movsd 0x8(%rsi,%rax), %xmm5
movapd %xmm4, %xmm0
mulsd %xmm2, %xmm0
movapd %xmm5, %xmm1
mulsd %xmm3, %xmm1
subsd %xmm1, %xmm0
movapd %xmm4, %xmm6
mulsd %xmm3, %xmm6
movapd %xmm5, %xmm1
mulsd %xmm2, %xmm1
addsd %xmm6, %xmm1
ucomisd %xmm0, %xmm0
jp 0x1db5
movapd %xmm7, %xmm2
addsd %xmm0, %xmm2
movapd %xmm8, %xmm3
addsd %xmm1, %xmm3
movsd %xmm2, (%rbx)
movsd %xmm3, 0x8(%rbx)
subsd %xmm0, %xmm7
subsd %xmm1, %xmm8
movsd %xmm7, (%r14)
movsd %xmm8, 0x8(%r14)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
ucomisd %xmm1, %xmm1
jnp 0x1d7f
movapd %xmm4, %xmm0
movapd %xmm5, %xmm1
movsd %xmm7, 0x10(%rsp)
movsd %xmm8, 0x8(%rsp)
callq 0x1df0
movsd 0x8(%rsp), %xmm8
movsd 0x10(%rsp), %xmm7
jmp 0x1d7f
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O2/tkln[P]mcwm/hidden.c
// Function: init
void init(void)
{
    int scrno;
    xcb_screen_iterator_t iter;
    
    conn = xcb_connect(NULL, &scrno);
    if (!conn)
    {
        fprintf(stderr, "can't connect to an X server\n");
        exit(1);
    }

    iter = xcb_setup_roots_iterator(xcb_get_setup(conn));

    for (int i = 0; i < scrno; ++i)
    {
        xcb_screen_next(&iter);
    }

    screen = iter.data;

    if (!screen)
    {
        fprintf(stderr, "can't get the current screen\n");
        xcb_disconnect(conn);
        exit(1);
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
xorl %r14d, %r14d
leaq 0x4(%rsp), %rsi
xorl %edi, %edi
callq 0x1070
movq %rax, 0x2dad(%rip)      # 0x4108
testq %rax, %rax
je 0x13a9
movq %rax, %rdi
callq 0x11a0
movq %rax, %rdi
callq 0x1110
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
movq %rdx, 0x8(%rbx)
cmpl 0x4(%rsp), %r14d
jge 0x1390
movq %rbx, %rdi
callq 0x10f0
incl %r14d
jmp 0x137c
movq 0x8(%rsp), %rax
movq %rax, 0x2d74(%rip)      # 0x4110
testq %rax, %rax
je 0x13c7
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq 0x2c48(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xc55(%rip), %rdi       # 0x200f
pushq $0x1d
popq %rsi
pushq $0x1
popq %rdx
callq 0x11c0
jmp 0x13ef
movq 0x2c2a(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xc55(%rip), %rdi       # 0x202d
pushq $0x1d
popq %rsi
pushq $0x1
popq %rdx
callq 0x11c0
movq 0x2d1e(%rip), %rdi      # 0x4108
callq 0x1180
pushq $0x1
popq %rdi
callq 0x11b0
// File: /workspace/github_c_makefile_star2_O2/tkln[P]mcwm/hidden.c
// Function: getatom
xcb_atom_t getatom(char *atom_name)
{
    xcb_intern_atom_cookie_t atom_cookie;
    xcb_atom_t atom;
    xcb_intern_atom_reply_t *rep;
    
    atom_cookie = xcb_intern_atom(conn, 0, strlen(atom_name), atom_name);
    rep = xcb_intern_atom_reply(conn, atom_cookie, NULL);
    if (NULL != rep)
    {
        atom = rep->atom;
        free(rep);
        return atom;
    }

    /*
     * XXX Note that we return 0 as an atom if anything goes wrong.
     * Might become interesting.
     */
    return 0;
}

// Assembly:
pushq %rbx
movq 0x2d09(%rip), %rdi      # 0x4108
leaq 0xc00(%rip), %rcx       # 0x2006
xorl %ebx, %ebx
pushq $0x8
popq %rdx
xorl %esi, %esi
callq 0x10d0
movq 0x2cef(%rip), %rdi      # 0x4108
movl %eax, %esi
xorl %edx, %edx
callq 0x1160
testq %rax, %rax
je 0x1432
movl 0x8(%rax), %ebx
movq %rax, %rdi
callq 0x1030
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/diaxen[P]fft-garden/./mr_bf.h
// Function: mr_dit_bf4_0
static inline void
mr_dit_bf4_0(unsigned so, unsigned si,
         complex double * out,
         const complex double * in)
{
  complex double a = in[0     ];
  complex double b = in[si    ];
  complex double c = in[si * 2];
  complex double d = in[si * 3];
  complex double e = a + c;
  complex double f = a - c;
  complex double g = b + d;
  complex double j = (b - d) * I;
  out[0     ] = e + g;
  out[so    ] = f - j;
  out[so * 2] = e - g;
  out[so * 3] = f + j;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movl %edi, %r14d
movl %esi, %eax
shlq $0x4, %rax
leal (%rsi,%rsi), %edx
shlq $0x4, %rdx
leal (%rsi,%rsi,2), %esi
shlq $0x4, %rsi
movupd (%rcx), %xmm3
movupd (%rcx,%rax), %xmm5
movupd (%rcx,%rdx), %xmm6
movupd (%rcx,%rsi), %xmm7
movapd %xmm5, %xmm4
subpd %xmm7, %xmm4
xorpd %xmm0, %xmm0
mulpd %xmm4, %xmm0
movapd %xmm4, %xmm1
shufpd $0x1, %xmm4, %xmm1      # xmm1 = xmm1[1],xmm4[0]
movapd %xmm0, %xmm2
subpd %xmm1, %xmm2
addpd %xmm0, %xmm1
movapd %xmm1, %xmm0
movsd %xmm2, %xmm0            # xmm0 = xmm2[0],xmm0[1]
ucomisd %xmm2, %xmm2
jp 0x1f30
movapd %xmm3, %xmm1
subpd %xmm6, %xmm1
movl %r14d, %eax
shlq $0x4, %rax
leal (%r14,%r14), %ecx
shlq $0x4, %rcx
addpd %xmm7, %xmm5
addpd %xmm6, %xmm3
movapd %xmm3, %xmm2
addpd %xmm5, %xmm2
movupd %xmm2, (%rbx)
movapd %xmm1, %xmm2
subpd %xmm0, %xmm2
movupd %xmm2, (%rbx,%rax)
subpd %xmm5, %xmm3
movupd %xmm3, (%rbx,%rcx)
leal (%r14,%r14,2), %eax
shlq $0x4, %rax
addpd %xmm0, %xmm1
movupd %xmm1, (%rbx,%rax)
addq $0x48, %rsp
popq %rbx
popq %r14
retq
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
ucomisd %xmm1, %xmm1
jnp 0x1ed6
movapd %xmm4, %xmm1
unpckhpd %xmm4, %xmm1            # xmm1 = xmm1[1],xmm4[1]
movapd %xmm3, 0x30(%rsp)
movsd 0x12d8(%rip), %xmm3     # 0x3228
xorpd %xmm2, %xmm2
movapd %xmm4, %xmm0
movapd %xmm5, 0x20(%rsp)
movapd %xmm6, 0x10(%rsp)
movapd %xmm7, (%rsp)
callq 0x23c0
movapd (%rsp), %xmm7
movapd 0x10(%rsp), %xmm6
movapd 0x20(%rsp), %xmm5
movapd 0x30(%rsp), %xmm3
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
jmp 0x1ed6
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/ksw2/kalloc.c
// Function: km_destroy
void km_destroy(void *_km)
{
	kmem_t *km = (kmem_t*)_km;
	allocated_t *p, *q;
	if (km == 0) return;
	p = &km->list_head;
	do {
		q = p->next;
		free(p->ptr);
		if (p != &km->list_head) free(p);
		p = q;
	} while (p && p->next);
	if (p != &km->list_head) free(p);
	free(km);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x19e362
movq %rdi, %rbx
leaq 0x18(%rdi), %r12
movq 0x18(%rdi), %rax
movq %r12, %r15
movq %rax, %r14
movq 0x8(%r15), %rdi
callq 0x19e120
cmpq %r12, %r15
je 0x19e34b
movq %r15, %rdi
callq 0x19e120
testq %r14, %r14
je 0x19e36e
movq (%r14), %rax
movq %r14, %r15
testq %rax, %rax
jne 0x19e332
cmpq %r12, %r14
jne 0x19e371
jmp 0x19e379
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %r14d, %r14d
movq %r14, %rdi
callq 0x19e120
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x19e120
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/ksw2/kalloc.c
// Function: krealloc
void *krealloc(void *_km, void *ap, size_t n_bytes)
{
	kmem_t *km = (kmem_t*)_km;
	size_t n_units, *p, *q;

	if (n_bytes == 0) {
		kfree(km, ap); return 0;
	}
	if (km == 0) return realloc(ap, n_bytes);
	if (!ap) return kmalloc(km, n_bytes);
	n_units = 1 + (n_bytes + sizeof(size_t) - 1) / sizeof(size_t);
	p = (size_t*)ap - 1;
	if (*p >= n_units) return ap; /* TODO: this prevents shrinking */
	q = (size_t*)kmalloc(km, n_bytes);
	memcpy(q, ap, (*p - 1) * sizeof(size_t));
	kfree(km, ap);
	return q;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x19e4dc
testq %r14, %r14
je 0x19e4f2
testq %rbx, %rbx
je 0x19e502
leaq 0x7(%rdx), %rax
shrq $0x3, %rax
cmpq %rax, -0x8(%rbx)
ja 0x19e4e9
movq %r14, %rdi
movq %rdx, %rsi
callq 0x19e512
movq %rax, %r15
movq -0x8(%rbx), %rax
leaq -0x8(,%rax,8), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x19e0c0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x19e38c
movq %r15, %rbx
jmp 0x19e4e9
movq %r14, %rdi
movq %rbx, %rsi
callq 0x19e38c
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
movq %rdx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x19e1e0
movq %r14, %rdi
movq %rdx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x19e512
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/ksw2/kalloc.c
// Function: kcalloc
void *kcalloc(void *_km, size_t count, size_t size)
{
	kmem_t *km = (kmem_t*)_km;
	void *p;
	if (size == 0 || count == 0) return 0;
	if (km == 0) return calloc(count, size);
	p = kmalloc(km, count * size);
	memset(p, 0, count * size);
	return p;
}

// Assembly:
pushq %rbx
testq %rdx, %rdx
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0x19e683
xorl %eax, %eax
popq %rbx
retq
movq %rdx, %rbx
testq %rdi, %rdi
je 0x19e6a5
imulq %rsi, %rbx
movq %rbx, %rsi
callq 0x19e512
movq %rax, %rdi
xorl %esi, %esi
movq %rbx, %rdx
popq %rbx
jmp 0x19e090
movq %rsi, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x19e0b0
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/ksw2/kalloc.c
// Function: km_stat
void km_stat(const void *_km)
{
	kmem_t *km = (kmem_t*)_km;
	unsigned n_blocks, n_units;
	size_t max_block = 0, *p, *q;
	float frag;

	if (km == 0 || !(p = km->loop_head)) return;
	n_blocks = n_units = 0;
	do {
		q = PTR(p);
		if (*p > max_block) max_block = *p;
		n_units += *p;
		if (p + (*p) > q && q > p)
			kerror("[kr_stat] The end of a free block enters another free block.");
		p = q;
		++n_blocks;
	} while (p != km->loop_head);
	
	--n_blocks;
	frag = 1.0/1024.0 * n_units * sizeof(size_t) / n_blocks;
	fprintf(stderr, "[kr_stat] tot=%lu, free=%lu, n_block=%u, max_block=%lu, frag_len=%.3fK\n",
			km->total_allocated, n_units * sizeof(size_t), n_blocks, max_block * sizeof(size_t), frag);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x19e6c0
movq 0x10(%rdi), %rax
testq %rax, %rax
jne 0x19e6c2
popq %rax
retq
pushq $-0x1
popq %r8
xorl %r9d, %r9d
movq %rax, %r10
xorl %ecx, %ecx
movq (%r10), %rsi
movq 0x8(%r10), %rdx
leaq (%r10,%rsi,8), %r11
cmpq %rdx, %r11
setbe %r11b
cmpq %rdx, %r10
setae %r10b
orb %r11b, %r10b
je 0x19e755
addq %rsi, %rcx
cmpq %r9, %rsi
cmovaq %rsi, %r9
incl %r8d
movq %rdx, %r10
cmpq %rdx, %rax
jne 0x19e6ce
movl %ecx, %ecx
cvtsi2sd %rcx, %xmm0
mulsd 0x3c98f8(%rip), %xmm0   # 0x568008
mulsd 0x3c98f8(%rip), %xmm0   # 0x568010
movl %r8d, %eax
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq 0x59c8a9(%rip), %rax    # 0x73afd8
movq (%rax), %rax
movq 0x30(%rdi), %rdx
shlq $0x3, %rcx
shlq $0x3, %r9
cvtss2sd %xmm0, %xmm0
leaq 0x3c9984(%rip), %rsi    # 0x5680cd
movq %rax, %rdi
movb $0x1, %al
popq %r11
jmp 0x19e180
leaq 0x3c9934(%rip), %rdi    # 0x568090
callq 0x19e45b
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/ksw2/./ksw2.h
// Function: ksw_push_cigar
static inline uint32_t *ksw_push_cigar(void *km, int *n_cigar, int *m_cigar, uint32_t *cigar, uint32_t op, int len)
{
	if (*n_cigar == 0 || op != (cigar[(*n_cigar) - 1]&0xf)) {
		if (*n_cigar == *m_cigar) {
			*m_cigar = *m_cigar? (*m_cigar)<<1 : 4;
			cigar = (uint32_t*)krealloc(km, cigar, (*m_cigar) << 2);
		}
		cigar[(*n_cigar)++] = len<<4 | op;
	} else cigar[(*n_cigar)-1] += len<<4;
	return cigar;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %r9d, %ebx
movl %r8d, %ebp
movq %rcx, %rax
movq %rsi, %r14
movslq (%rsi), %rcx
testq %rcx, %rcx
je 0x19f26f
movl -0x4(%rax,%rcx,4), %esi
movl %esi, %r8d
andl $0xf, %r8d
cmpl %ebp, %r8d
jne 0x19f26f
shll $0x4, %ebx
addl %ebx, %esi
movl %esi, -0x4(%rax,%rcx,4)
jmp 0x19f2a2
cmpl (%rdx), %ecx
jne 0x19f291
leal (%rcx,%rcx), %esi
testl %ecx, %ecx
pushq $0x4
popq %rcx
cmovnel %esi, %ecx
movl %ecx, (%rdx)
shll $0x2, %ecx
movslq %ecx, %rdx
movq %rax, %rsi
callq 0x19e47f
movl (%r14), %ecx
shll $0x4, %ebx
orl %ebp, %ebx
leal 0x1(%rcx), %edx
movl %edx, (%r14)
movslq %ecx, %rcx
movl %ebx, (%rax,%rcx,4)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/ksw2/./ksw2.h
// Function: ksw_apply_zdrop
static inline int ksw_apply_zdrop(ksw_extz_t *ez, int is_rot, int32_t H, int a, int b, int zdrop, int8_t e)
{
	int r, t;
	if (is_rot) r = a, t = b;
	else r = a + b, t = a;
	if (H > (int32_t)ez->max) {
		ez->max = H, ez->max_t = t, ez->max_q = r - t;
	} else if (t >= ez->max_t && r - t >= ez->max_q) {
		int tl = t - ez->max_t, ql = (r - t) - ez->max_q, l;
		l = tl > ql? tl - ql : ql - tl;
		if (zdrop >= 0 && ez->max - H > zdrop + l * e) {
			ez->zdropped = 1;
			return 1;
		}
	}
	return 0;
}

// Assembly:
movl (%rdi), %r10d
movl %r10d, %r11d
andl $0x7fffffff, %r11d      # imm = 0x7FFFFFFF
subl %esi, %r11d
jge 0x1a0b77
andl $0x80000000, %r10d      # imm = 0x80000000
orl %esi, %r10d
movl %r10d, (%rdi)
movl %ecx, 0x8(%rdi)
subl %ecx, %edx
movl %edx, 0x4(%rdi)
xorl %eax, %eax
retq
movl 0x8(%rdi), %esi
xorl %eax, %eax
cmpl %ecx, %esi
jle 0x1a0b81
retq
pushq %rbp
pushq %r14
pushq %rbx
subl %ecx, %edx
movl 0x4(%rdi), %ebx
cmpl %ebx, %edx
setl %bpl
testl %r8d, %r8d
sets %r14b
orb %bpl, %r14b
jne 0x1a0bc7
addl %esi, %edx
subl %edx, %ecx
addl %ebx, %ecx
movl %ecx, %edx
negl %edx
cmovsl %ecx, %edx
movsbl %r9b, %ecx
imull %edx, %ecx
addl %r8d, %ecx
cmpl %ecx, %r11d
jle 0x1a0bc7
orl $0x80000000, %r10d      # imm = 0x80000000
movl %r10d, (%rdi)
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/main.c
// Function: fill_matrix
void fill_matrix(int8_t *matrix, char *fn) {
	FILE *fp = fopen(fn, "r");
	char buffer[256];
	char *pch;
	int i = 0;

	while (0 < fgets(buffer, 256, fp)) {
		pch = strtok(buffer, ",\t");
		while (pch != NULL) {
			if (25 <= i) {
				fprintf(stderr, "Too many values in %s\n", fn);
				exit(1);
			}
			matrix[i] = atoi(pch);
			i++;
		}
	}
	if (i != 16 || i != 25) {
		fprintf(stderr, "Incorrect # of values (found %d, want 16 or 25) in %s\n", i, fn);
		exit(1);
	}

	fclose(fp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rsi, %rax
movq %rdi, %r14
leaq 0x3c2a3d(%rip), %rsi    # 0x568cdf
movq %rax, 0x8(%rsp)
movq %rax, %rdi
callq 0x19e110
movq %rax, %r15
leaq 0x10(%rsp), %r12
leaq 0x3c21f2(%rip), %r13    # 0x5684b0
movq %r12, %rdi
movl $0x100, %esi            # imm = 0x100
movq %r15, %rdx
callq 0x19e1c0
testq %rax, %rax
je 0x1a6324
movq %r12, %rdi
movq %r13, %rsi
callq 0x19e1b0
movq %rax, %rbp
xorl %ebx, %ebx
testq %rbp, %rbp
je 0x1a62be
cmpq $0x19, %rbx
jae 0x1a62ff
movq %rbp, %rdi
callq 0x19e1a0
movb %al, (%r14,%rbx)
incq %rbx
jmp 0x1a62e3
movq 0x594cd2(%rip), %rax    # 0x73afd8
movq (%rax), %rdi
leaq 0x3c21a3(%rip), %rsi    # 0x5684b3
movq 0x8(%rsp), %rdx
xorl %eax, %eax
callq 0x19e180
pushq $0x1
popq %rdi
callq 0x19e130
movq 0x594cad(%rip), %rax    # 0x73afd8
movq (%rax), %rdi
leaq 0x3c2195(%rip), %rsi    # 0x5684ca
xorl %edx, %edx
movq 0x8(%rsp), %rcx
xorl %eax, %eax
callq 0x19e180
jmp 0x1a631c
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/main.c
// Function: ksw2_data_init
ksw2_data_t *ksw2_data_init(main_opt_t *opt, const int8_t *matrix)
{
	ksw2_data_t *data = calloc(1, sizeof(ksw2_data_t));

	data->ksw2_flags = (opt->right_align_gaps == 1) ? KSW_EZ_RIGHT : 0;
	if (opt->add_cigar != 1) data->ksw2_flags |= KSW_EZ_SCORE_ONLY;
	memset(&data->ez, 0, sizeof(ksw_extz_t));
	
	//data->km = km_init(); FIXME

	data->matrix = calloc(1, sizeof(int8_t)*25);
	memcpy(data->matrix, matrix, sizeof(int8_t)*25);
	
	return data;

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
pushq $0x1
popq %rdi
pushq $0x48
popq %rsi
callq 0x19e0b0
movq %rax, %r14
xorl %eax, %eax
cmpl $0x1, 0x30(%r15)
sete %al
addl %eax, %eax
movl %eax, 0x8(%r14)
cmpl $0x1, 0x24(%r15)
je 0x1a63b5
orl $0x1, %eax
movl %eax, 0x8(%r14)
pushq $0x1
popq %rdi
pushq $0x19
popq %rsi
callq 0x19e0b0
movq %rax, (%r14)
movups (%rbx), %xmm0
movups 0x9(%rbx), %xmm1
movups %xmm0, (%rax)
movups %xmm1, 0x9(%rax)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/main.c
// Function: parasail_to_func_name
void parasail_to_func_name(char *parasail_func_name, int alignment_mode, int add_cigar, int vec_strategy)
{
	parasail_func_name[0] = '\0';
	strcat(parasail_func_name, "parasail");


	// Vectorized
	switch (alignment_mode) {
		case Local: strcat(parasail_func_name, "_sw"); break; // local
		case Glocal: strcat(parasail_func_name, "_sg_dx"); break; // glocal
		case Extension: fprintf(stderr, "Parasail does not support extension\n"); exit(1);
		case Global: strcat(parasail_func_name, "_nw"); break; // global
		default: fprintf(stderr, "Unknown alignment mode: %d\n", alignment_mode); exit(1);
	}
	if (add_cigar == 1) strcat(parasail_func_name, "_trace");
	switch (vec_strategy) {
		case 0: strcat(parasail_func_name, "_striped"); break;
		case 1: strcat(parasail_func_name, "_scan"); break;
		case 2: strcat(parasail_func_name, "_diag"); break;
		default: fprintf(stderr, "Unknown parasail vectorization strategy: %d\n", vec_strategy); exit(1);
	}
	strcat(parasail_func_name, "_32"); // TODO: add this as a command line option?
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
xorl %r12d, %r12d
movb %r12b, (%rdi)
callq 0x19e070
movabsq $0x6c69617361726170, %rcx # imm = 0x6C69617361726170
movq %rcx, (%rbx,%rax)
movb %r12b, 0x8(%rbx,%rax)
cmpl $0x3, %r15d
ja 0x1a6540
movl %r15d, %eax
leaq 0x3c1fc3(%rip), %rcx    # 0x568400
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
callq 0x19e070
movl $0x77735f, (%rbx,%rax)  # imm = 0x77735F
jmp 0x1a647f
movq %rbx, %rdi
callq 0x19e070
movl $0x5f67735f, (%rbx,%rax) # imm = 0x5F67735F
movl $0x78645f, 0x3(%rbx,%rax) # imm = 0x78645F
jmp 0x1a647f
movq %rbx, %rdi
callq 0x19e070
movl $0x776e5f, (%rbx,%rax)  # imm = 0x776E5F
cmpl $0x1, %r14d
jne 0x1a649c
movq %rbx, %rdi
callq 0x19e070
movl $0x6172745f, (%rbx,%rax) # imm = 0x6172745F
movl $0x656361, 0x3(%rbx,%rax) # imm = 0x656361
cmpl $0x2, %ebp
je 0x1a64df
cmpl $0x1, %ebp
je 0x1a64c7
testl %ebp, %ebp
jne 0x1a650d
movq %rbx, %rdi
callq 0x19e070
movabsq $0x646570697274735f, %rcx # imm = 0x646570697274735F
movq %rcx, (%rbx,%rax)
movb $0x0, 0x8(%rbx,%rax)
jmp 0x1a64f5
movq %rbx, %rdi
callq 0x19e070
movl $0x6163735f, (%rbx,%rax) # imm = 0x6163735F
movw $0x6e, 0x4(%rbx,%rax)
jmp 0x1a64f5
movq %rbx, %rdi
callq 0x19e070
movl $0x6169645f, (%rbx,%rax) # imm = 0x6169645F
movw $0x67, 0x4(%rbx,%rax)
movq %rbx, %rdi
callq 0x19e070
movl $0x32335f, (%rbx,%rax)  # imm = 0x32335F
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x594ac4(%rip), %rax    # 0x73afd8
movq (%rax), %rdi
leaq 0x3c204f(%rip), %rsi    # 0x56856d
movl %ebp, %edx
jmp 0x1a6554
movq 0x594aaf(%rip), %rax    # 0x73afd8
movq (%rax), %rcx
leaq 0x3c1ff9(%rip), %rdi    # 0x56852c
pushq $0x24
popq %rsi
pushq $0x1
popq %rdx
callq 0x19e200
jmp 0x1a655b
movq 0x594a91(%rip), %rax    # 0x73afd8
movq (%rax), %rdi
leaq 0x3c2000(%rip), %rsi    # 0x568551
movl %r15d, %edx
xorl %eax, %eax
callq 0x19e180
pushq $0x1
popq %rdi
callq 0x19e130
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/main.c
// Function: parasail_data_init
parasail_data_t *parasail_data_init(main_opt_t *opt, const int8_t *matrix)
{
	int i, j, l;
	parasail_data_t *data = calloc(1, sizeof(parasail_data_t));
	char parasail_func_name[128];
	
	// create a matrix, don't care about the valukes
	data->matrix = parasail_matrix_create("ACGTN", matrix[0], matrix[1]); 
	// update the matrix with the correct values
	for (i = l = 0; i < 5; ++i) {
		for (j = 0; j < 5; ++j, ++l) {
			parasail_matrix_set_value(data->matrix, i, j, matrix[l]);
		}
	}

	parasail_to_func_name(parasail_func_name, opt->alignment_mode, opt->add_cigar, opt->parasail_vec_strat);
	data->func = parasail_lookup_function(parasail_func_name);

	// the global alignment function is needed for glocal when we don't align the full query
	if (opt->alignment_mode == Glocal) {
		data->func_global = data->func;
	}
	else {
		parasail_to_func_name(parasail_func_name, Global, opt->add_cigar, opt->parasail_vec_strat);
		data->func_global = parasail_lookup_function(parasail_func_name);
	}

	return data;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r15
movq %rdi, %r14
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
callq 0x19e0b0
movq %rax, %rbx
movsbl (%r15), %esi
movsbl 0x1(%r15), %edx
leaq 0x3c2002(%rip), %rdi    # 0x56859a
callq 0x1abf86
movq %rax, %r12
movq %rbx, 0x8(%rsp)
movq %rax, (%rbx)
xorl %ebx, %ebx
xorl %ebp, %ebp
cmpl $0x5, %ebp
je 0x1a65db
movslq %ebx, %rbx
xorl %r13d, %r13d
cmpl $0x5, %r13d
je 0x1a65d7
movsbl (%r15,%rbx), %ecx
movq %r12, %rdi
movl %ebp, %esi
movl %r13d, %edx
callq 0x1aca06
incq %rbx
incq %r13
jmp 0x1a65b7
incl %ebp
jmp 0x1a65ac
movl 0x20(%r14), %esi
movl 0x24(%r14), %edx
movl 0x3c(%r14), %ecx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x1a63f8
movq %r15, %rdi
callq 0x1ab564
movq 0x8(%rsp), %rbx
movq %rax, 0x8(%rbx)
cmpl $0x1, 0x20(%r14)
je 0x1a662c
movl 0x24(%r14), %edx
movl 0x3c(%r14), %ecx
leaq 0x10(%rsp), %r14
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x1a63f8
movq %r14, %rdi
callq 0x1ab564
movq %rax, 0x10(%rbx)
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/main.c
// Function: main_opt_init_library
void main_opt_init_library(main_opt_t *opt)
{
	int i, j, k;
	int8_t matrix[25];

	// initialize scoring matrix
	for (i = k = 0; i < 4; ++i) {
		for (j = 0; j < 4; ++j) {
			matrix[k++] = i == j? opt->match_score: -opt->mismatch_score;
		}
		matrix[k++] = 0; // ambiguous base
	}
	for (j = 0; j < 5; ++j) matrix[k++] = 0;
	// overwrite if a matrix file was given
	if (opt->matrix_fn != NULL) fill_matrix(matrix, opt->matrix_fn);

	// adjust the library mode if it is set on auto
	if (opt->library == AutoLibrary) {
		switch (opt->alignment_mode) {
			case Local: 
			case Glocal: 
			case Global: opt->library = Parasail; break;
			case Extension: opt->library = Ksw2; break;
			default:
				fprintf(stderr, "Unknown alignment mode in %s: %d\n", __func__, opt->alignment_mode); 
				exit(1);
		}
	}

	switch (opt->library) {
		case Ksw2: 
			opt->_library_func = align_with_ksw2;
			opt->_library_data = (void*)ksw2_data_init(opt, matrix); 
			break;
		case Parasail: 
			opt->_library_func = align_with_parasail;
			opt->_library_data = (void*)parasail_data_init(opt, matrix); 
			break;
		default:
			fprintf(stderr, "Unknown library in %s: %d", __func__, opt->library);
			exit(1);
	}
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
xorl %eax, %eax
movabsq $0x100000000, %rcx      # imm = 0x100000000
xorl %edx, %edx
cmpl $0x4, %eax
je 0x1a66d1
movslq %edx, %rsi
leaq 0x1(%rsi), %rdx
shlq $0x20, %rsi
xorl %edi, %edi
cmpl $0x4, %edi
je 0x1a66c5
cmpl %edi, %eax
jne 0x1a66af
movl (%rbx), %r8d
jmp 0x1a66b6
xorl %r8d, %r8d
subl 0x4(%rbx), %r8d
movb %r8b, -0x1(%rsp,%rdx)
incl %edi
incq %rdx
addq %rcx, %rsi
jmp 0x1a66a1
sarq $0x20, %rsi
movb $0x0, (%rsp,%rsi)
incl %eax
jmp 0x1a668f
movslq %edx, %rax
addq %rsp, %rax
xorl %ecx, %ecx
cmpl $0x5, %ecx
je 0x1a66e7
movb $0x0, (%rax,%rcx)
incq %rcx
jmp 0x1a66d9
movq 0x18(%rbx), %rsi
testq %rsi, %rsi
jne 0x1a6756
movl 0x38(%rbx), %ecx
cmpl $0x2, %ecx
je 0x1a6717
cmpl $0x1, %ecx
je 0x1a6736
testl %ecx, %ecx
jne 0x1a675e
movl 0x20(%rbx), %ecx
cmpl $0x2, %ecx
jb 0x1a6710
je 0x1a672f
cmpl $0x3, %ecx
jne 0x1a6785
movl $0x2, 0x38(%rbx)
leaq 0x30e(%rip), %rax       # 0x1a6a2c
movq %rax, 0x40(%rbx)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1a6563
jmp 0x1a674c
movl $0x1, 0x38(%rbx)
leaq 0x5b(%rip), %rax        # 0x1a6798
movq %rax, 0x40(%rbx)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1a637e
movq %rax, 0x48(%rbx)
addq $0x20, %rsp
popq %rbx
retq
movq %rsp, %rdi
callq 0x1a6284
movq 0x594873(%rip), %rax    # 0x73afd8
movq (%rax), %rdi
leaq 0x3c1e69(%rip), %rsi    # 0x5685d8
leaq 0x3c1e4c(%rip), %rdx    # 0x5685c2
xorl %eax, %eax
callq 0x19e180
pushq $0x1
popq %rdi
callq 0x19e130
movq 0x59484c(%rip), %rax    # 0x73afd8
movq (%rax), %rdi
leaq 0x3c1e0a(%rip), %rsi    # 0x5685a0
jmp 0x1a676f
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/main.c
// Function: main_opt_destroy
void main_opt_destroy(main_opt_t *opt)
{
	switch (opt->library) {
		case Ksw2: ksw2_data_destroy((ksw2_data_t*)opt->_library_data); break;
		case Parasail: parasail_data_destroy((parasail_data_t*)opt->_library_data); break;
		default:
			fprintf(stderr, "Unknown library in %s: %d", __func__, opt->library);
			exit(1);
	}
	free(opt);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x38(%rdi), %ecx
cmpl $0x2, %ecx
je 0x1a6c1b
cmpl $0x1, %ecx
jne 0x1a6c2d
movq 0x48(%rbx), %rdi
callq 0x1a63da
jmp 0x1a6c24
movq 0x48(%rbx), %rdi
callq 0x1a6645
movq %rbx, %rdi
popq %rbx
jmp 0x19e120
movq 0x5943a4(%rip), %rax    # 0x73afd8
movq (%rax), %rdi
leaq 0x3c199a(%rip), %rsi    # 0x5685d8
leaq 0x3c19ad(%rip), %rdx    # 0x5685f2
xorl %eax, %eax
callq 0x19e180
pushq $0x1
popq %rdi
callq 0x19e130
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/main.c
// Function: assert_or_exit
void assert_or_exit(int condition, const char *fmt, ...)
{
	if (condition == 0) {
		fprintf(stderr, "Error: ");
		va_list args;
		va_start(args, fmt);
		vfprintf(stderr, fmt, args);
		va_end(args);
		fprintf(stderr, "\n");
		exit(1);
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x1a6cad
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)
testl %edi, %edi
je 0x1a6cbc
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
movq %rsi, %rbx
movq 0x594312(%rip), %r14    # 0x73afd8
movq (%r14), %rcx
leaq 0x3c1933(%rip), %rdi    # 0x568603
pushq $0x7
popq %rsi
pushq $0x1
popq %rdx
callq 0x19e200
leaq 0x20(%rsp), %rax
movq %rsp, %rdx
movq %rax, 0x10(%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x19e160
movq (%r14), %rsi
pushq $0xa
popq %rdi
callq 0x19e140
pushq $0x1
popq %rdi
callq 0x19e130
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/main.c
// Function: alignment_print
void alignment_print(FILE *fp, const char *query, const char *target, const main_opt_t *opt, const alignment_t *a) 
{
	int i;
	// output the score and start/end or start/length
	if (opt->offset_and_length == 1) {
		int qll = a->qle - a->qlb + 1;
		int tll = a->tle - a->tlb + 1;
		fprintf(fp, "%d\t%d\t%d\t%d\t%d", a->score, a->qlb, qll, a->tlb, tll);
	}
	else {
		fprintf(fp, "%d\t%d\t%d\t%d\t%d", a->score, a->qlb, a->qle, a->tlb, a->tle);
	}
	// output the cigar
	if (opt->add_cigar == 1) {
		fputc('\t', fp);
		if (a->n_cigar == 0) fputc('*', fp);
		for (i = 0; i < a->n_cigar; ++i) {
			fprintf(fp, "%d%c", a->cigar[i]>>4, "MID"[a->cigar[i]&0xf]);
		}
	}
	// output the query and target
	if (opt->add_seq) fprintf(fp, "\t%s\t%s", query, target);
	// flush the output so no one is waiting on buffering.
	fputc('\n', fp);
	fflush(fp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r13
movq %rcx, %r12
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, %rbx
cmpl $0x1, 0x34(%rcx)
jne 0x1a6ed0
movl 0xc(%r13), %r8d
movl (%r13), %edx
movl 0x4(%r13), %ecx
subl %ecx, %r8d
incl %r8d
movl 0x10(%r13), %eax
movl 0x8(%r13), %r9d
subl %r9d, %eax
incl %eax
jmp 0x1a6ee4
movl (%r13), %edx
movl 0x4(%r13), %ecx
movl 0xc(%r13), %r8d
movl 0x8(%r13), %r9d
movl 0x10(%r13), %eax
movl %eax, (%rsp)
leaq 0x3c1927(%rip), %rsi    # 0x568815
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19e180
cmpl $0x1, 0x24(%r12)
jne 0x1a6f5e
pushq $0x9
popq %rdi
movq %rbx, %rsi
callq 0x19e140
cmpl $0x0, 0x20(%r13)
jne 0x1a6f1d
pushq $0x2a
popq %rdi
movq %rbx, %rsi
callq 0x19e140
leaq 0x3c1905(%rip), %r14    # 0x568829
leaq 0x3c18f9(%rip), %rbp    # 0x568824
xorl %r15d, %r15d
movslq 0x20(%r13), %rax
cmpq %rax, %r15
jge 0x1a6f5e
movq 0x18(%r13), %rax
movl (%rax,%r15,4), %eax
movl %eax, %edx
shrl $0x4, %edx
andl $0xf, %eax
movsbl (%rax,%r14), %ecx
movq %rbx, %rdi
movq %rbp, %rsi
xorl %eax, %eax
callq 0x19e180
incq %r15
jmp 0x1a6f2e
cmpl $0x0, 0x28(%r12)
je 0x1a6f81
leaq 0x3c18c0(%rip), %rsi    # 0x56882d
movq %rbx, %rdi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
xorl %eax, %eax
callq 0x19e180
pushq $0xa
popq %rdi
movq %rbx, %rsi
callq 0x19e140
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x19e100
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/cigar.c
// Function: parasail_cigar_encode_string
parasail_cigar_t* parasail_cigar_encode_string(const char *cigar)
{
    int sscanf_retcode = 0;
    size_t offset = 0;
    int chars_read = 0;
    unsigned int len = 0;
    char op = 'M';
    int done = 0;
    size_t string_length = 0;
    size_t size = 0;
    parasail_cigar_t *ret = NULL;

    string_length = strlen(cigar);
    size = sizeof(uint32_t)*string_length;
    ret = malloc(sizeof(parasail_cigar_t));
    ret->seq = malloc(size);
    ret->len = 0;

    while (!done) {
        sscanf_retcode = sscanf(
                &cigar[offset], "%u%c%n", &len, &op, &chars_read);
        if (2 != sscanf_retcode) {
            fprintf(stderr, "invalid CIGAR string\n");
            parasail_cigar_free(ret);
            return NULL;
        }
        offset += chars_read;
        ret->len += 1;
        if ((size_t)ret->len >= size) {
            size *= 2;
            ret->seq = realloc(ret->seq, size);
        }
        ret->seq[ret->len-1] = parasail_cigar_encode(len, op);
        if (offset >= string_length) {
            done = 1;
        }
    }

    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq 0x14(%rsp), %rax
andl $0x0, (%rax)
leaq 0x10(%rsp), %rax
andl $0x0, (%rax)
leaq 0xf(%rsp), %rax
movb $0x4d, (%rax)
movq %rdi, 0x20(%rsp)
callq 0x19e070
movq %rax, 0x18(%rsp)
leaq (,%rax,4), %r14
pushq $0x18
popq %rdi
callq 0x19e150
movq %rax, %rbx
movq %r14, %rdi
callq 0x19e150
movq %rax, %r15
movq %rax, (%rbx)
andl $0x0, 0x8(%rbx)
movb $0x1, %al
pushq $0x1
popq %r13
xorl %r12d, %r12d
testb $0x1, %al
je 0x1a792c
movq 0x20(%rsp), %rax
leaq (%rax,%r12), %rdi
leaq 0x3c14e9(%rip), %rsi    # 0x568d80
leaq 0x10(%rsp), %rdx
leaq 0xf(%rsp), %rcx
leaq 0x14(%rsp), %r8
xorl %eax, %eax
callq 0x19e0d0
cmpl $0x2, %eax
jne 0x1a7906
movslq 0x14(%rsp), %rbp
movl %r13d, 0x8(%rbx)
cmpq %r13, %r14
ja 0x1a78d4
addq %r14, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x19e1e0
movq %rax, %r15
movq %rax, (%rbx)
addq %rbp, %r12
movl 0x10(%rsp), %eax
movsbq 0xf(%rsp), %rcx
shll $0x4, %eax
leaq 0x3c1415(%rip), %rdx    # 0x568d00
movzbl (%rcx,%rdx), %ecx
orl %eax, %ecx
movl %ecx, -0x4(%r15,%r13,4)
cmpq 0x18(%rsp), %r12
setb %al
incq %r13
jmp 0x1a787f
movq 0x5936cb(%rip), %rax    # 0x73afd8
movq (%rax), %rcx
leaq 0x3c1470(%rip), %rdi    # 0x568d87
pushq $0x15
popq %rsi
pushq $0x1
popq %rdx
callq 0x19e200
movq %rbx, %rdi
callq 0x1a793e
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/cigar.c
// Function: parasail_cigar_decode
char* parasail_cigar_decode(parasail_cigar_t *cigar)
{
#define SIZE 40
    char *ret = NULL;
    size_t retlen = 0;
    size_t size = 0;
    int i = 0;

    /* initial allocation for 1 op and 3 number characters per cigar int */
    size = sizeof(char)*cigar->len*4;
    ret = malloc(size+1);
    ret[0] = '\0';

    for (i=0; i<cigar->len; ++i) {
        char tmp[SIZE];
        char op = parasail_cigar_decode_op(cigar->seq[i]);
        uint32_t len = parasail_cigar_decode_len(cigar->seq[i]);
        int snprintf_retcode = snprintf(tmp, SIZE, "%u%c", len, op);
        if (snprintf_retcode >= SIZE) {
            fprintf(stderr, "invalid CIGAR\n");
            free(ret);
            return NULL;
        }
        retlen += snprintf_retcode;
        if (retlen >= size) {
            size *= 2;
            ret = realloc(ret, size+1);
        }
        strcat(ret, tmp);
    }

    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movslq 0x8(%rdi), %rbp
leaq 0x1(,%rbp,4), %rdi
movq %rbp, %r12
shlq $0x2, %r12
callq 0x19e150
movq %rax, %rbx
movb $0x0, (%rax)
xorl %r15d, %r15d
xorl %r13d, %r13d
movslq %ebp, %rax
cmpq %rax, %r15
jge 0x1a7a46
movq (%r14), %rax
movl (%rax,%r15,4), %ecx
movl %ecx, %eax
andl $0xf, %eax
pushq $0x4d
popq %r8
cmpl $0x9, %eax
ja 0x1a79d0
leaq 0x3c13d2(%rip), %rdx    # 0x568d9d
movsbl (%rax,%rdx), %r8d
shrl $0x4, %ecx
movq %rsp, %rdi
pushq $0x28
popq %rsi
leaq 0x3c13c8(%rip), %rdx    # 0x568da8
xorl %eax, %eax
callq 0x19e1d0
cmpl $0x27, %eax
jg 0x1a7a20
cltq
addq %rax, %r13
cmpq %r12, %r13
jb 0x1a7a0c
leaq 0x1(,%r12,2), %rsi
addq %r12, %r12
movq %rbx, %rdi
callq 0x19e1e0
movq %rax, %rbx
movq %rbx, %rdi
movq %rsp, %rsi
callq 0x19e1f0
incq %r15
movl 0x8(%r14), %ebp
jmp 0x1a79a3
movq 0x5935b1(%rip), %rax    # 0x73afd8
movq (%rax), %rcx
leaq 0x3c137c(%rip), %rdi    # 0x568dad
pushq $0xe
popq %rsi
pushq $0x1
popq %rdx
callq 0x19e200
movq %rbx, %rdi
callq 0x19e120
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/function_lookup.c
// Function: parasail_lookup_function_info
const parasail_function_info_t * parasail_lookup_function_info(const char *funcname)
{
    const parasail_function_info_t * f = NULL;

    if (funcname) {
        int index = 0;
        f = &functions[index++];
        while (f->pointer) {
            if (0 == strcmp(funcname, f->name)) {
                break;
            }
            f = &functions[index++];
        }
        if (!f->pointer) {
            /* perhaps caller forgot "parasail_" prefix? */
            const char *prefix = "parasail_";
            char *newname = (char*)malloc(strlen(prefix)+strlen(funcname)+1);
            strcpy(newname, prefix);
            strcat(newname, funcname);
            index = 0;
            f = &functions[index++];
            while (f->pointer) {
                if (0 == strcmp(newname, f->name)) {
                    break;
                }
                f = &functions[index++];
            }
            free(newname);
        }
    }

    if (!f->pointer) {
        f = NULL;
    }

    return f;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x4e5186(%rip), %rbx    # 0x690710
cmpq $0x0, (%rbx)
je 0x1ab5a6
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x19e170
testl %eax, %eax
je 0x1ab60d
addq $0x48, %rbx
jmp 0x1ab58a
movq %r14, %rdi
callq 0x19e070
leaq 0xa(%rax), %rdi
callq 0x19e150
movq %rax, %r15
movabsq $0x6c69617361726170, %rax # imm = 0x6C69617361726170
movq %rax, (%r15)
movw $0x5f, 0x8(%r15)
movq %r15, %rdi
movq %r14, %rsi
callq 0x19e1f0
leaq 0x4e5130(%rip), %rbx    # 0x690710
movq (%rbx), %r14
testq %r14, %r14
je 0x1ab5fe
movq 0x8(%rbx), %rsi
movq %r15, %rdi
callq 0x19e170
testl %eax, %eax
je 0x1ab5fe
addq $0x48, %rbx
jmp 0x1ab5e0
movq %r15, %rdi
callq 0x19e120
testq %r14, %r14
cmoveq %r14, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq