LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/Matthias-Wandel[P]imgcomp/src/util.c
// Function: CopyFile
static int CopyFile(char * src, char * dest)
{
    int inputFd, outputFd, openFlags;
    int filePerms;
    struct stat statbuf;
    size_t numRead;
    #define BUF_SIZE 8192
    char buf[BUF_SIZE];

    // Get file modification time from old file.
    stat(src, &statbuf);

    // Open input and output files  
    inputFd = open(src, O_RDONLY, 0);
    if (inputFd == -1){
        fprintf(Log,"CopyFile could not open src %s\n",src);
        exit(-1);
    }
 
    openFlags = O_CREAT | O_WRONLY | O_TRUNC;

    filePerms = 0x1ff;

    outputFd = open(dest, openFlags, filePerms);
    if (outputFd == -1){
        fprintf(Log,"CopyFile could not open dest %s\n",dest);
        exit(-1);
    }

    // Transfer data until we encounter end of input or an error
 
    for(;;){
        numRead = read(inputFd, buf, BUF_SIZE);
        if (numRead <= 0) break;
        if (write(outputFd, buf, numRead) != numRead){
            fprintf(Log,"write error to %s",dest);
            exit(-1);
        }
    }

    if (numRead == -1){
        fprintf(Log,"CopyFile read error from %s\n",src);
        exit(-1);
    }

    close(inputFd);
    close(outputFd);

    {
        struct utimbuf mtime;
        mtime.actime = statbuf.st_ctime;
        mtime.modtime = statbuf.st_mtime;
        utime(dest, &mtime);
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20a0, %rsp           # imm = 0x20A0
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %rsi
callq 0x32c0
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x3420
cmpl $-0x1, %eax
je 0xa015
movl %eax, %ebp
movq %rbx, %rdi
movl $0x241, %esi            # imm = 0x241
movl $0x1ff, %edx            # imm = 0x1FF
xorl %eax, %eax
callq 0x3420
cmpl $-0x1, %eax
je 0xa02b
movl %eax, %r14d
leaq 0xa0(%rsp), %r15
movl $0x2000, %edx           # imm = 0x2000
movl %ebp, %edi
movq %r15, %rsi
callq 0x3210
testq %rax, %rax
je 0x9fda
movq %rax, %r12
movl %r14d, %edi
movq %r15, %rsi
movq %rax, %rdx
callq 0x30f0
cmpq %r12, %rax
je 0x9f8b
leaq 0x8ffc(%rip), %rax      # 0x12fb8
movq (%rax), %rdi
leaq 0x4464(%rip), %rsi      # 0xe42a
movq %rbx, %rdx
xorl %eax, %eax
callq 0x32a0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x3490
movl %ebp, %edi
callq 0x31e0
movl %r14d, %edi
callq 0x31e0
movq 0x68(%rsp), %rax
movq 0x78(%rsp), %rcx
movq %rsp, %rsi
movq %rcx, (%rsi)
movq %rax, 0x8(%rsi)
movq %rbx, %rdi
callq 0x3030
addq $0x20a0, %rsp           # imm = 0x20A0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8f9c(%rip), %rax      # 0x12fb8
movq (%rax), %rdi
leaq 0x43c3(%rip), %rsi      # 0xe3e9
movq %r14, %rdx
jmp 0x9fc9
leaq 0x8f86(%rip), %rax      # 0x12fb8
movq (%rax), %rdi
leaq 0x43cd(%rip), %rsi      # 0xe409
jmp 0x9fc6
// File: /workspace/github_c_makefile_star2_O3/Matthias-Wandel[P]imgcomp/src/send_udp.c
// Function: SendUDP
void SendUDP(int x, int y, int level, int motion)
{
    int wrote;
    int datasize;
    Udp_t Buf;

    if (NumDests == 0){
        fprintf(stderr, "UDP not initialized\n");
        return;
    }

    memset(&Buf, 0, sizeof(Buf));

    Buf.Ident = UDP_MAGIC;
    Buf.Level = level;
    Buf.xpos = x;
    Buf.ypos = y;
    Buf.IsMotion = motion;

    datasize = sizeof(Udp_t);

    for (int n=0;n<NumDests;n++){ // Loop through destinations -- can have targets for motion UDP
        wrote = sendto(sockUDP,(char *)&Buf, datasize, 0,(struct sockaddr*)&dests[n], sizeof(struct sockaddr_in));

        if (wrote == SOCKET_ERROR){
            perror("UDP sendto failed");
        }

        if (wrote < datasize ) {
            fprintf(stdout,"Wrote %d bytes of %d\n",wrote, datasize);
        }

        //printf("Sent UDP packet, x=%d\n",x);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl 0xb7d0(%rip), %eax      # 0x15ab0
testl %eax, %eax
je 0xa38c
movw $0x46c1, 0xe(%rsp)      # imm = 0x46C1
movw %dx, 0x10(%rsp)
movw %di, 0x12(%rsp)
movw %si, 0x14(%rsp)
movw %cx, 0x16(%rsp)
jle 0xa391
leaq 0xb7b0(%rip), %rbx      # 0x15ac0
leaq 0xe(%rsp), %r14
movq 0x7cb4(%rip), %rbp      # 0x11fd0
leaq 0x4194(%rip), %r12      # 0xe4b7
xorl %r15d, %r15d
movl 0xb788(%rip), %edi      # 0x15ab4
movl $0xa, %edx
movq %r14, %rsi
xorl %ecx, %ecx
movq %rbx, %r8
movl $0x10, %r9d
callq 0x31c0
movq %rax, %r13
cmpl $-0x1, %r13d
je 0xa37e
cmpl $0x9, %r13d
jg 0xa369
movq (%rbp), %rdi
movq %r12, %rsi
movl %r13d, %edx
movl $0xa, %ecx
xorl %eax, %eax
callq 0x32a0
incq %r15
movslq 0xb73d(%rip), %rax      # 0x15ab0
addq $0x10, %rbx
cmpq %rax, %r15
jl 0xa326
jmp 0xa391
leaq 0x4120(%rip), %rdi      # 0xe4a5
callq 0x3440
jmp 0xa353
callq 0x38e3
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/kobolt[P]curses-collection/snake/snake.c
// Function: exit_handler
static void exit_handler(void)
{
  direction_queue_t *current, *last = NULL;

  if (queue_tail != NULL) {
    for (current = queue_tail; current != NULL; current = current->next) {
      if (last != NULL)
        free(last);
      last = current->prev;
    }
    if (last != NULL)
      free(last);
  }

  endwin();
  printf("\nScore: %d\n", score);
}

// Assembly:
pushq %rbx
movq 0x2c27(%rip), %rbx      # 0x40f0
testq %rbx, %rbx
je 0x14f4
xorl %edi, %edi
testq %rdi, %rdi
je 0x14da
callq 0x1040
movq 0x10(%rbx), %rdi
movq 0x8(%rbx), %rax
movq %rax, %rbx
testq %rax, %rax
jne 0x14d0
testq %rdi, %rdi
je 0x14f4
callq 0x1040
callq 0x1170
movl 0x2be1(%rip), %esi      # 0x40e0
leaq 0xb1e(%rip), %rdi       # 0x2024
xorl %eax, %eax
popq %rbx
jmp 0x1090
// File: /workspace/github_c_makefile_star2_O3/kobolt[P]curses-collection/snake/snake.c
// Function: queue_insert
static void queue_insert(direction_t direction, int remove_tail)
{
  direction_queue_t *new, *temp;

  new = (direction_queue_t *)malloc(sizeof(direction_queue_t));
  if (new == NULL)
    exit(1);
  new->direction = direction;

  new->next = NULL;
  if (queue_head != NULL)
    queue_head->next = new;
  new->prev = queue_head;
  queue_head = new;
  if (queue_tail == NULL)
    queue_tail = new;

  if (remove_tail && queue_tail != NULL) {
    temp = queue_tail;
    queue_tail = queue_tail->next;
    queue_tail->prev = NULL;
    free(temp);
  }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
movl $0x18, %edi
callq 0x1120
testq %rax, %rax
je 0x1588
movl %ebp, (%rax)
movq $0x0, 0x8(%rax)
movq 0x2bc3(%rip), %rcx      # 0x40f8
testq %rcx, %rcx
je 0x153e
movq %rax, 0x8(%rcx)
movq %rcx, 0x10(%rax)
movq %rax, 0x2baf(%rip)      # 0x40f8
movq 0x2ba0(%rip), %rdi      # 0x40f0
testq %rdi, %rdi
jne 0x155f
movq %rax, 0x2b94(%rip)      # 0x40f0
movq %rax, %rdi
testl %ebx, %ebx
je 0x1581
movq 0x8(%rdi), %rax
movq %rax, 0x2b82(%rip)      # 0x40f0
movq $0x0, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1040
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl $0x1, %edi
callq 0x1160
// File: /workspace/github_c_makefile_star2_O3/kobolt[P]curses-collection/snake/snake.c
// Function: place_apple
static void place_apple(void)
{
  int maxx, maxy;
  getmaxyx(stdscr, maxy, maxx);
  do {
    move((random() % (maxy - 2)) + 1, (random() % (maxx - 2)) + 1); 
  } while (inch() != ' ');
  getyx(stdscr, apple_y, apple_x);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x2a3f(%rip), %r14      # 0x3fe0
movq (%r14), %rax
testq %rax, %rax
je 0x15bb
movswq 0x4(%rax), %r15
decq %r15
movswq 0x6(%rax), %r12
decq %r12
jmp 0x15c9
movq $-0x3, %r15
movq $-0x3, %r12
movq (%r14), %rbx
callq 0x1100
cqto
idivq %r15
leal 0x1(%rdx), %ebp
callq 0x1100
cqto
idivq %r12
incl %edx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1130
movq (%r14), %rdi
callq 0x1110
cmpl $0x20, %eax
jne 0x15c9
movq (%r14), %rcx
testq %rcx, %rcx
je 0x160d
movswl (%rcx), %eax
movswl 0x2(%rcx), %ecx
jmp 0x1617
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl %eax, 0x2ae3(%rip)      # 0x4100
movl %ecx, 0x2ae1(%rip)      # 0x4104
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/kobolt[P]curses-collection/snake/snake.c
// Function: update_screen
static void update_screen(void)
{
  int current_y, current_x;
  direction_queue_t *current;

  erase();

  box(stdscr, '|', '-');

  current_y = pos_y;
  current_x = pos_x;
  for (current = queue_head; current != NULL; current = current->prev) {
    mvaddch(current_y, current_x, '#');
    switch (current->direction) {
    case DIRECTION_UP:
      current_y++;
      break;
    case DIRECTION_DOWN:
      current_y--;
      break;
    case DIRECTION_LEFT:
      current_x++;
      break;
    case DIRECTION_RIGHT:
      current_x--;
      break;
    }
  }

  mvaddch(apple_y, apple_x, '@');

  move(pos_y, pos_x);

  refresh();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x29a5(%rip), %r14      # 0x3fe0
movq (%r14), %rdi
callq 0x1030
movq (%r14), %rdi
subq $0x8, %rsp
xorl %eax, %eax
movl $0x7c, %esi
movl $0x7c, %edx
movl $0x2d, %ecx
movl $0x2d, %r8d
xorl %r9d, %r9d
pushq %rax
pushq %rax
pushq %rax
callq 0x1060
addq $0x20, %rsp
movq 0x2a81(%rip), %r15      # 0x40f8
testq %r15, %r15
je 0x16d6
movl 0x2a66(%rip), %ebx      # 0x40e8
movl 0x2a5c(%rip), %ebp      # 0x40e4
leaq 0x985(%rip), %r12       # 0x2014
movq (%r14), %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x1130
cmpl $-0x1, %eax
je 0x16ad
movq (%r14), %rdi
movl $0x23, %esi
callq 0x1150
movl (%r15), %eax
cmpq $0x3, %rax
ja 0x16cd
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
incl %ebp
jmp 0x16cd
incl %ebx
jmp 0x16cd
decl %ebx
jmp 0x16cd
decl %ebp
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0x168f
movq (%r14), %rdi
movl 0x2a21(%rip), %esi      # 0x4100
movl 0x2a1f(%rip), %edx      # 0x4104
callq 0x1130
cmpl $-0x1, %eax
je 0x16fc
movq (%r14), %rdi
movl $0x40, %esi
callq 0x1150
movq (%r14), %rdi
movl 0x29df(%rip), %esi      # 0x40e4
movl 0x29dd(%rip), %edx      # 0x40e8
callq 0x1130
movq (%r14), %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x10b0
// File: /workspace/github_c_makefile_star2_O3/dwelch67[P]lc3/lc3sim.c
// Function: main
int main ( int argc, char *argv[] )
{
    FILE *fp;

    if(argc<2)
    {
        fprintf(stderr,".hex file not specified\n");
        return(1);
    }

    memset(mem,0xDD,sizeof(mem));
    reset();

    fp=fopen(argv[1],"rt");
    if(fp==NULL)
    {
        fprintf(stderr,"Error opening file [%s]\n",argv[1]);
        return(1);
    }
    if(readhex(fp)) return(1);
    fclose(fp);

    sim();
    return(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpl $0x1, %edi
jle 0x17e1
movq %rsi, %rbx
leaq 0x292a(%rip), %rdi      # 0x40a0
movl $0x20000, %edx          # imm = 0x20000
movl $0xdd, %esi
callq 0x1060
movw $0x3000, 0x22912(%rip)  # imm = 0x3000
movw $0x2, 0x28f9(%rip)      # 0x4090
movaps 0x8b2(%rip), %xmm0      # 0x2050
movaps %xmm0, 0x2290b(%rip)    # 0x240b0
movq 0x8(%rbx), %rdi
leaq 0x8e2(%rip), %rsi       # 0x2092
callq 0x1090
testq %rax, %rax
je 0x17e8
movq %rax, %r14
movq %rax, %rdi
callq 0x1800
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x17f9
movq %r14, %rdi
callq 0x1040
callq 0x12a7
xorl %eax, %eax
jmp 0x17f9
callq 0x1103
jmp 0x17f4
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x10e0
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/htmshell.c
// Function: htmlVaEncodeErrorText
void htmlVaEncodeErrorText(char *format, va_list args)
/* Write an error message encoded against XSS. */
{
va_list argscp;
va_copy(argscp, args);
char warning[1024];

struct dyString *ds = newDyString(1024);
vaHtmlDyStringPrintf(ds, format, args);
int n = ds->stringSize;
int nLimit = sizeof(warning) - 1;
if (ds->stringSize > nLimit)
    n = nLimit;
safencpy(warning, sizeof warning, ds->string, n);
if (ds->stringSize > nLimit)
    strcpy(warning+n-5,"[...]");  // indicated trucation
freeDyString(&ds);

fprintf(stdout, "%s\n", warning);
/* write warning/error message to stderr so they get logged. */
vfprintf(stderr, format, argscp);
fprintf(stderr, "\n");
fflush(stderr);
va_end(argscp);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x430, %rsp            # imm = 0x430
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq %rax, 0x20(%rsp)
movups (%rsi), %xmm0
movaps %xmm0, 0x10(%rsp)
movl $0x400, %edi            # imm = 0x400
callq 0x264e0
movq %rax, %r15
movq %rax, 0x8(%rsp)
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x47e6c
movl 0x14(%r15), %eax
movl $0x3ff, %ecx            # imm = 0x3FF
cmpl %ecx, %eax
cmovll %eax, %ecx
movq 0x8(%r15), %rdx
movslq %ecx, %r14
leaq 0x30(%rsp), %rdi
movl $0x400, %esi            # imm = 0x400
movq %r14, %rcx
callq 0x23fb3
cmpl $0x400, 0x14(%r15)      # imm = 0x400
jl 0x71ab
movw $0x5d, 0x2f(%rsp,%r14)
movl $0x2e2e2e5b, 0x2b(%rsp,%r14) # imm = 0x2E2E2E5B
leaq 0x8(%rsp), %rdi
callq 0x2651d
movq 0xb7df4(%rip), %rax     # 0xbefb0
movq (%rax), %rdi
leaq 0x89d15(%rip), %rsi     # 0x90edb
leaq 0x30(%rsp), %rdx
xorl %eax, %eax
callq 0x6a90
movq 0xb7dff(%rip), %r14     # 0xbefd8
movq (%r14), %rdi
leaq 0x10(%rsp), %rdx
movq %rbx, %rsi
callq 0x69e0
movq (%r14), %rsi
pushq $0xa
popq %rdi
callq 0x6930
movq (%r14), %rdi
callq 0x6870
addq $0x430, %rsp            # imm = 0x430
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/htmshell.c
// Function: earlyWarningHandler
static void earlyWarningHandler(char *format, va_list args)
/* Write an error message so user can see it before page is really started. */
{
static boolean initted = FALSE;
if (!initted && !errorsNoHeader)
    {
    htmlStart("Very Early Error");
    initted = TRUE;
    }
printf("%s", htmlWarnStartPattern());
fputs("<P>", stdout);
htmlVaEncodeErrorText(format,args);
fputs("</P>\n", stdout);
printf("%s", htmlWarnEndPattern());
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x0, 0xcd2fe(%rip)     # 0xd4668
jne 0x7388
testb $0x1, 0xcd1f1(%rip)     # 0xd4564
jne 0x7388
leaq 0x904a2(%rip), %rdi     # 0x9781e
callq 0x49296
movb $0x1, 0xcd2e0(%rip)     # 0xd4668
leaq 0x9052a(%rip), %rdi     # 0x978b9
callq 0x6bb0
movq 0xb7c15(%rip), %r15     # 0xbefb0
movq (%r15), %rsi
leaq 0x8f6f1(%rip), %rdi     # 0x96a96
callq 0x6810
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7126
movq (%r15), %rsi
leaq 0x8f6db(%rip), %rdi     # 0x96a9a
callq 0x6810
leaq 0x90505(%rip), %rdi     # 0x978d0
popq %rbx
popq %r14
popq %r15
jmp 0x6bb0
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/htslib/cram/cram_stats.c
// Function: cram_stats_dump
void cram_stats_dump(cram_stats *st) {
    int i;
    fprintf(stderr, "cram_stats:\n");
    for (i = 0; i < MAX_STAT_VAL; i++) {
	if (!st->freqs[i])
	    continue;
	fprintf(stderr, "\t%d\t%d\n", i, st->freqs[i]);
    }
    if (st->h) {
	khint_t k;
	for (k = kh_begin(st->h); k != kh_end(st->h); k++) {
	    if (!kh_exist(st->h, k))
		continue;

	    fprintf(stderr, "\t%d\t%d\n", kh_key(st->h, k), kh_val(st->h, k));
	}
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0xb75e1(%rip), %r12     # 0xbefd8
movq (%r12), %rcx
leaq 0x91bcc(%rip), %rdi     # 0x995ce
pushq $0xc
popq %rsi
pushq $0x1
popq %rdx
callq 0x6e70
leaq 0x883e2(%rip), %r14     # 0x8fdf6
xorl %r15d, %r15d
movl (%rbx,%r15,4), %ecx
testl %ecx, %ecx
jne 0x7a2d
incq %r15
cmpq $0x400, %r15            # imm = 0x400
jne 0x7a17
jmp 0x7a40
movq (%r12), %rdi
movq %r14, %rsi
movl %r15d, %edx
xorl %eax, %eax
callq 0x6a90
jmp 0x7a1f
movq 0x1000(%rbx), %rax
testq %rax, %rax
je 0x7aaf
movl (%rax), %edx
testl %edx, %edx
je 0x7aaf
leaq 0x8839d(%rip), %r14     # 0x8fdf6
xorl %ebp, %ebp
xorl %r15d, %r15d
movq 0x10(%rax), %rcx
movl %r15d, %esi
shrl $0x4, %esi
movl (%rcx,%rsi,4), %esi
movl %ebp, %ecx
andb $0x1e, %cl
shrl %cl, %esi
testb $0x3, %sil
je 0x7a85
incl %r15d
addl $0x2, %ebp
cmpl %edx, %r15d
jne 0x7a5e
jmp 0x7aaf
movq (%r12), %rdi
movl %r15d, %ecx
movq 0x18(%rax), %rdx
movq 0x20(%rax), %rax
movl (%rdx,%rcx,4), %edx
movl (%rax,%rcx,4), %ecx
movq %r14, %rsi
xorl %eax, %eax
callq 0x6a90
movq 0x1000(%rbx), %rax
movl (%rax), %edx
jmp 0x7a78
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/blatSrc/blat.c
// Function: searchOneStrand
void searchOneStrand(struct dnaSeq *seq, struct genoFind *gf, FILE *psl,
                     boolean isRc, struct hash *maskHash, Bits *qMaskBits, struct gfOutput *gvo)
/* Search for seq in index, align it, and write results to psl. */
{
    if (fastMap && (seq->size > MAXSINGLEPIECESIZE))
        errAbort("Maximum single piece size (%d) exceeded by query %s of size (%d). "
        "Larger pieces will have to be split up until no larger than this limit "
        "when the -fastMap option is used."	
        , MAXSINGLEPIECESIZE, seq->name, seq->size);
    
    gfLongDnaInMem(seq, gf, isRc, minScore, qMaskBits, gvo, fastMap, optionExists("fine"));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movl %ecx, %ebp
movq %rsi, %r15
movq %rdi, %r12
movl 0xb86d4(%rip), %r14d    # 0xc0e84
testl %r14d, %r14d
je 0x87e3
movl 0x18(%r12), %ecx
cmpl $0x1389, %ecx           # imm = 0x1389
jl 0x87e6
movq 0x8(%r12), %rdx
leaq 0x84cc4(%rip), %rdi     # 0x8d492
movl $0x1388, %esi           # imm = 0x1388
xorl %eax, %eax
callq 0x26e94
movl 0xb86a3(%rip), %r14d    # 0xc0e84
jmp 0x87e6
xorl %r14d, %r14d
movl 0xb6f7f(%rip), %r13d    # 0xbf76c
leaq 0x84c80(%rip), %rdi     # 0x8d474
callq 0x3465f
movq %r12, %rdi
movq %r15, %rsi
movl %ebp, %edx
movl %r13d, %ecx
movq %rbx, %r8
movq 0x40(%rsp), %r9
pushq %rax
pushq %r14
callq 0x11eb7
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/blatSrc/blat.c
// Function: searchOneProt
void searchOneProt(aaSeq *seq, struct genoFind *gf, FILE *f, struct gfOutput *gvo)
/* Search for protein seq in index and write results to psl. */
{
    int hitCount;
    struct lm *lm = lmInit(0);
    struct gfClump *clumpList = gfFindClumps(gf, seq, lm, &hitCount);
    gfAlignAaClumps(gf, clumpList, seq, FALSE, minScore, gvo);
    gfClumpFreeList(&clumpList);
    lmCleanup(&lm);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %edi, %edi
callq 0x2c220
leaq 0x18(%rsp), %r12
movq %rax, (%r12)
leaq 0xc(%rsp), %rcx
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xeeb8
leaq 0x10(%rsp), %r13
movq %rax, (%r13)
movl 0xb6f00(%rip), %r8d     # 0xbf76c
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
movq %rbx, %r9
callq 0x105bb
movq %r13, %rdi
callq 0xdbe4
movq %r12, %rdi
callq 0x2c2c7
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/blatSrc/blat.c
// Function: dotOut
void dotOut()
/* Put out a dot every now and then if user want's to. */
{
    static int mod = 1;
    if (dotEvery > 0)
    {
        if (--mod <= 0)
        {
            fputc('.', stdout);
            fflush(stdout);
            mod = dotEvery;
        }
    }
}

// Assembly:
cmpl $0x0, 0xb85c8(%rip)     # 0xc0e6c
jle 0x88e4
movl 0xb70b4(%rip), %eax     # 0xbf960
leal -0x1(%rax), %ecx
movl %ecx, 0xb70ab(%rip)     # 0xbf960
cmpl $0x1, %eax
jg 0x88e4
pushq %rbx
movq 0xb66ee(%rip), %rbx     # 0xbefb0
movq (%rbx), %rsi
movl $0x2e, %edi
callq 0x6930
movq (%rbx), %rdi
callq 0x6870
movl 0xb858f(%rip), %eax     # 0xc0e6c
movl %eax, 0xb707d(%rip)     # 0xbf960
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/blatSrc/blat.c
// Function: searchOne
void searchOne(bioSeq *seq, struct genoFind *gf, FILE *f, boolean isProt,
               struct hash *maskHash, Bits *qMaskBits, struct gfOutput *gvo)
/* Search for seq on either strand in index. */
{
    dotOut();
    if (isProt)
    {
        searchOneProt(seq, gf, f, gvo);
    }
    else
    {
        gvo->maskHash = maskHash;
        searchOneStrand(seq, gf, f, FALSE, maskHash, qMaskBits, gvo);
        reverseComplement(seq->dna, seq->size);
        searchOneStrand(seq, gf, f, TRUE, maskHash, qMaskBits, gvo);
        reverseComplement(seq->dna, seq->size);
    }
    gfOutputQuery(gvo, f);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r12
movq %r8, %rbp
movl %ecx, %ebx
movq %rdx, 0x10(%rsp)
movq %rsi, %r13
movq %rdi, %r15
movq 0x50(%rsp), %r14
callq 0x889d
testl %ebx, %ebx
je 0x8924
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rcx
callq 0x8823
jmp 0x896d
movq %rbp, 0x30(%r14)
movq %r14, (%rsp)
movq %r15, %rdi
movq %r13, %rsi
xorl %ecx, %ecx
movq %r12, %r9
callq 0x8793
movq 0x10(%r15), %rdi
movslq 0x18(%r15), %rsi
callq 0x25423
movq %r14, (%rsp)
movq %r15, %rdi
movq %r13, %rsi
movl $0x1, %ecx
movq %r12, %r9
callq 0x8793
movq 0x10(%r15), %rdi
movslq 0x18(%r15), %rsi
callq 0x25423
movq %r14, %rdi
movq 0x10(%rsp), %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x147bc
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/blatSrc/blat.c
// Function: trimSeq
void trimSeq(struct dnaSeq *seq, struct dnaSeq *trimmed)
/* Copy seq to trimmed (shallow copy) and optionally trim
 * off polyA tail or polyT head. */
{
    DNA *dna = seq->dna;
    int size = seq->size;
    *trimmed = *seq;
    if (trimT)
        maskHeadPolyT(dna, size);
    if (trimA || trimHardA)
    {
        int trimSize = maskTailPolyA(dna, size);
        if (trimHardA)
        {
            trimmed->size -= trimSize;
            dna[size-trimSize] = 0;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq 0x10(%rdi), %rbx
movl 0x18(%rdi), %ebp
movq 0x20(%rdi), %rax
movq %rax, 0x20(%rsi)
movups (%rdi), %xmm0
movups 0x10(%rdi), %xmm1
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
cmpl $0x0, 0xb84cd(%rip)     # 0xc0e80
je 0x89bf
movq %rbx, %rdi
movl %ebp, %esi
callq 0x25db4
movl 0xb84b7(%rip), %eax     # 0xc0e7c
orl 0xb84ad(%rip), %eax     # 0xc0e78
je 0x89ed
movq %rbx, %rdi
movl %ebp, %esi
callq 0x25d05
cmpl $0x0, 0xb849e(%rip)     # 0xc0e7c
je 0x89ed
subl %eax, 0x18(%r14)
subl %eax, %ebp
movslq %ebp, %rax
movb $0x0, (%rbx,%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/blatSrc/blat.c
// Function: maskQuerySeq
Bits *maskQuerySeq(struct dnaSeq *seq, boolean isProt,
                   boolean maskQuery, boolean lcMask)
/* Massage query sequence a bit, converting it to correct
 * case (upper for protein/lower for DNA) and optionally
 * returning upper/lower case info , and trimming poly A. */
{
    Bits *qMaskBits = NULL;
    verbose(2, "%s\n", seq->name);
    if (isProt)
        faToProtein(seq->dna, seq->size);
    else
    {
        if (maskQuery)
        {
            if (lcMask)
                toggleCase(seq->dna, seq->size);
            qMaskBits = maskFromUpperCaseSeq(seq);
        }
        faToDna(seq->dna, seq->size);
    }
    if (seq->size > qWarnSize)
    {
        warn("Query sequence %s has size %d, it might take a while.",
             seq->name, seq->size);
    }
    return qMaskBits;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
movq 0x8(%rdi), %rdx
leaq 0x884cc(%rip), %rsi     # 0x90edb
movl $0x2, %edi
xorl %eax, %eax
callq 0x427e5
testl %r15d, %r15d
je 0x8a31
movq 0x10(%rbx), %rdi
movl 0x18(%rbx), %esi
callq 0x27e77
xorl %r14d, %r14d
jmp 0x8a62
testl %r14d, %r14d
je 0x8a53
testl %ebp, %ebp
je 0x8a46
movq 0x10(%rbx), %rdi
movl 0x18(%rbx), %esi
callq 0x21ffe
movq %rbx, %rdi
callq 0x25071
movq %rax, %r14
jmp 0x8a56
xorl %r14d, %r14d
movq 0x10(%rbx), %rdi
movl 0x18(%rbx), %esi
callq 0x27ebd
movl 0x18(%rbx), %edx
cmpl $0x4c4b41, %edx         # imm = 0x4C4B41
jl 0x8a7f
movq 0x8(%rbx), %rsi
leaq 0x84ac5(%rip), %rdi     # 0x8d53d
xorl %eax, %eax
callq 0x26bea
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/blatSrc/blat.c
// Function: searchOneMaskTrim
void searchOneMaskTrim(struct dnaSeq *seq, boolean isProt,
                       struct genoFind *gf, FILE *outFile,
                       struct hash *maskHash,
                       long long *retTotalSize, int *retCount,
                       struct gfOutput *gvo)
/* Search a single sequence against a single genoFind index. */
{
    boolean maskQuery = (qMask != NULL);
    boolean lcMask = (qMask != NULL && sameWord(qMask, "lower"));
    Bits *qMaskBits = maskQuerySeq(seq, isProt, maskQuery, lcMask);
    struct dnaSeq trimmedSeq;
    ZeroVar(&trimmedSeq);
    trimSeq(seq, &trimmedSeq);
    if (qType == gftRna || qType == gftRnaX)
        memSwapChar(trimmedSeq.dna, trimmedSeq.size, 'u', 't');
    searchOne(&trimmedSeq, gf, outFile, isProt, maskHash, qMaskBits, gvo);
    *retTotalSize += seq->size;
    *retCount += 1;
    bitFree(&qMaskBits);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, 0x10(%rsp)
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movl %esi, %ebp
movq %rdi, %r14
movq 0xb83fb(%rip), %rdi     # 0xc0eb0
xorl %ebx, %ebx
testq %rdi, %rdi
setne %bl
je 0x8ad4
leaq 0x84aad(%rip), %rsi     # 0x8d573
callq 0x209d6
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
jmp 0x8ad6
xorl %ecx, %ecx
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x89f2
movq %rax, %rbx
movq %rax, 0x18(%rsp)
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
movq $0x0, 0x20(%rsi)
movq %r14, %rdi
callq 0x8988
movl 0xb8389(%rip), %eax     # 0xc0e98
cmpl $0x4, %eax
je 0x8b19
cmpl $0x1, %eax
jne 0x8b31
movq 0x30(%rsp), %rdi
movl 0x38(%rsp), %esi
movl $0x75, %edx
movl $0x74, %ecx
callq 0x2233e
movq 0x88(%rsp), %rax
movq %rax, (%rsp)
leaq 0x20(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
movl %ebp, %ecx
movq %r15, %r8
movq %rbx, %r9
callq 0x88e5
movslq 0x18(%r14), %rax
movq 0x10(%rsp), %rcx
addq %rax, (%rcx)
movq 0x80(%rsp), %rax
incl (%rax)
leaq 0x18(%rsp), %rdi
callq 0x1bafc
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/blatSrc/blat.c
// Function: seqListToTrans3List
struct trans3 *seqListToTrans3List(struct dnaSeq *seqList, aaSeq *transLists[3], struct hash **retHash)
/* Convert sequence list to a trans3 list and lists for each of three frames. */
{
    int frame;
    struct dnaSeq *seq;
    struct trans3 *t3List = NULL, *t3;
    struct hash *hash = newHash(0);

    for (seq = seqList; seq != NULL; seq = seq->next)
    {
        t3 = trans3New(seq);
        hashAddUnique(hash, t3->name, t3);
        slAddHead(&t3List, t3);
        for (frame = 0; frame < 3; ++frame)
        {
            slAddHead(&transLists[frame], t3->trans[frame]);
        }
    }
    slReverse(&t3List);
    for (frame = 0; frame < 3; ++frame)
    {
        slReverse(&transLists[frame]);
    }
    *retHash = hash;
    return t3List;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq $0x0, (%rsp)
xorl %edi, %edi
movl $0x1, %esi
callq 0x294ea
movq %rax, %r15
testq %r12, %r12
je 0x9078
xorl %r13d, %r13d
movq %r13, %rbp
movq %r12, %rdi
callq 0x15dc0
movq %rax, %r13
movq 0x8(%rax), %rsi
movq %r15, %rdi
movq %rax, %rdx
callq 0x29254
movq %rbp, (%r13)
movq %r13, (%rsp)
xorl %eax, %eax
movq 0x18(%r13,%rax,8), %rcx
movq (%r14,%rax,8), %rdx
movq %rdx, (%rcx)
movq %rcx, (%r14,%rax,8)
incq %rax
cmpq $0x3, %rax
jne 0x9056
movq (%r12), %r12
testq %r12, %r12
jne 0x902f
movq %rsp, %rdi
callq 0x20173
xorl %r12d, %r12d
leaq (%r14,%r12), %rdi
callq 0x20173
addq $0x8, %r12
cmpq $0x18, %r12
jne 0x9083
movq %r15, (%rbx)
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/blatSrc/blat.c
// Function: transTripleSearch
void transTripleSearch(struct dnaSeq *qSeq, struct genoFind *gfs[3], struct hash *t3Hash,
                       boolean dbIsRc, boolean qIsDna, FILE *f, struct gfOutput *gvo)
/* Translate qSeq three ways and look for each in three frames of index. */
{
    int qIsRc;
    gvo->reportTargetStrand = TRUE;
    for (qIsRc = 0; qIsRc <= qIsDna; qIsRc += 1)
    {
        gfLongTransTransInMem(qSeq, gfs, t3Hash, qIsRc, dbIsRc, !qIsDna, minScore, gvo);
        if (qIsDna)
            reverseComplement(qSeq->dna, qSeq->size);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, 0xc(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x50(%rsp), %rax
movl $0x1, 0x28(%rax)
testl %r8d, %r8d
js 0x914a
movl %r8d, %ebx
movq %rsi, %r15
movq %rdi, %r12
sete %al
movzbl %al, %r13d
leal 0x1(%rbx), %r14d
xorl %ebp, %ebp
movl 0xb665f(%rip), %eax     # 0xbf76c
movq %r12, %rdi
movq %r15, %rsi
movq 0x10(%rsp), %rdx
movl %ebp, %ecx
movl 0xc(%rsp), %r8d
movl %r13d, %r9d
pushq 0x50(%rsp)
pushq %rax
callq 0x1270b
addq $0x10, %rsp
testl %ebx, %ebx
je 0x9143
movq 0x10(%r12), %rdi
movslq 0x18(%r12), %rsi
callq 0x25423
incl %ebp
cmpl %ebp, %r14d
jne 0x9107
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/jkOwnLib/fuzzyFind.c
// Function: expandThroughNRight
boolean expandThroughNRight(struct ffAli *ali, DNA *needleStart, DNA *needleEnd,
    DNA *hayStart, DNA *hayEnd)
/* Expand through up to three N's to the left. */
{
DNA *nEnd = ali->nEnd;
DNA *hEnd = ali->hEnd;
DNA n,h;
boolean expanded = FALSE;
while (nEnd < needleEnd && hEnd < hayEnd)
    {
    n = *nEnd;
    h = *hEnd;
    if ((n == h) || 
        (n == 'n' && 
        (extendThroughN || nEnd + 3 >= needleEnd || nEnd[1] != 'n' || nEnd[2] != 'n' || nEnd[3] != 'n')) ||
    (h == 'n' && 
    (extendThroughN || hEnd + 3 >= hayEnd || hEnd[1] != 'n' || hEnd[2] != 'n' || hEnd[3] != 'n')))
        {
        nEnd += 1;
        hEnd += 1;
        expanded = TRUE;
        }
    else
        break;
    }
ali->nEnd = nEnd;
ali->hEnd = hEnd;
return expanded;
}

// Assembly:
movq 0x18(%rdi), %rcx
movq 0x28(%rdi), %r9
cmpq %rdx, %rcx
setb %al
cmpq %r8, %r9
setb %sil
andb %al, %sil
xorl %eax, %eax
cmpb $0x1, %sil
jne 0xa57d
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
xorl %r10d, %r10d
movl 0xb69f2(%rip), %ebx     # 0xc0ec0
xorl %eax, %eax
movq %rcx, %r11
movq %r9, %rsi
movb (%rcx,%r10), %r14b
movb (%r9,%r10), %bpl
cmpb %bpl, %r14b
je 0xa545
cmpb $0x6e, %r14b
jne 0xa518
testl %ebx, %ebx
jne 0xa545
leaq (%rcx,%r10), %r14
addq $0x3, %r14
cmpq %rdx, %r14
jae 0xa545
cmpb $0x6e, 0x1(%rcx,%r10)
jne 0xa545
cmpb $0x6e, 0x2(%rcx,%r10)
jne 0xa545
cmpb $0x6e, (%r14)
jne 0xa545
cmpb $0x6e, %bpl
je 0xa522
jmp 0xa582
cmpb $0x6e, %bpl
jne 0xa582
testl %ebx, %ebx
jne 0xa545
leaq (%r9,%r10), %r14
addq $0x3, %r14
cmpq %r8, %r14
jae 0xa545
cmpb $0x6e, 0x1(%r9,%r10)
jne 0xa545
cmpb $0x6e, 0x2(%r9,%r10)
jne 0xa545
cmpb $0x6e, (%r14)
je 0xa594
leaq (%r10,%rcx), %rax
incq %rax
incq %rsi
leaq 0x1(%r10), %r14
cmpq %rdx, %rax
jae 0xa573
incq %r11
leaq (%r10,%r9), %r15
incq %r15
movl $0x1, %eax
movq %r14, %r10
cmpq %r8, %r15
jb 0xa4d6
addq %r14, %rcx
movl $0x1, %eax
jmp 0xa585
movq %r9, %rsi
jmp 0xa58b
movq %r11, %rcx
popq %rbx
popq %r14
popq %r15
popq %rbp
movq %rcx, 0x18(%rdi)
movq %rsi, 0x28(%rdi)
retq
addq %r10, %rcx
addq %r10, %r9
movq %r9, %rsi
jmp 0xa585
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/jkOwnLib/fuzzyFind.c
// Function: expandThroughNLeft
boolean expandThroughNLeft(struct ffAli *ali, DNA *needleStart, DNA *needleEnd,
    DNA *hayStart, DNA *hayEnd)
/* Expand through up to three N's to the left. */
{
DNA *nStart = ali->nStart-1;
DNA *hStart = ali->hStart-1;
DNA n,h;
boolean expanded = FALSE;
while (nStart >= needleStart && hStart >= hayStart)
    {
    n = *nStart;
    h = *hStart;
    if ((n == h) ||
    (n == 'n' && (extendThroughN || nStart - 3 < needleStart || nStart[-1] != 'n' || nStart[-2] != 'n' || nStart[-3] != 'n')) ||
    (h == 'n' && (extendThroughN || hStart - 3 < hayStart || hStart[-1] != 'n' || hStart[-2] != 'n' || hStart[-3] != 'n')))
        {
        nStart -= 1;
        hStart -= 1;
        expanded = TRUE;
        }
    else
        break;
    }
ali->nStart = nStart + 1;
ali->hStart = hStart + 1;
return expanded;
}

// Assembly:
movq 0x10(%rdi), %r8
movq 0x20(%rdi), %rdx
leaq -0x1(%r8), %rax
leaq -0x1(%rdx), %r9
cmpq %rsi, %rax
setae %al
cmpq %rcx, %r9
setae %r9b
andb %al, %r9b
xorl %eax, %eax
cmpb $0x1, %r9b
jne 0xa687
pushq %rbx
xorl %r9d, %r9d
movl 0xb68ea(%rip), %r10d    # 0xc0ec0
xorl %eax, %eax
movb -0x1(%r8,%r9), %bl
movb -0x1(%rdx,%r9), %r11b
cmpb %r11b, %bl
je 0xa649
cmpb $0x6e, %bl
jne 0xa61b
testl %r10d, %r10d
jne 0xa649
leaq (%r8,%r9), %rbx
addq $-0x4, %rbx
cmpq %rsi, %rbx
jb 0xa649
cmpb $0x6e, -0x2(%r8,%r9)
jne 0xa649
cmpb $0x6e, -0x3(%r8,%r9)
jne 0xa649
cmpb $0x6e, (%rbx)
jne 0xa649
cmpb $0x6e, %r11b
je 0xa626
jmp 0xa680
cmpb $0x6e, %r11b
jne 0xa680
testl %r10d, %r10d
jne 0xa649
leaq (%rdx,%r9), %r11
addq $-0x4, %r11
cmpq %rcx, %r11
jb 0xa649
cmpb $0x6e, -0x2(%rdx,%r9)
jne 0xa649
cmpb $0x6e, -0x3(%rdx,%r9)
jne 0xa649
cmpb $0x6e, (%r11)
je 0xa680
leaq (%r8,%r9), %rax
addq $-0x2, %rax
leaq -0x1(%r9), %r11
cmpq %rsi, %rax
jb 0xa673
leaq (%rdx,%r9), %rbx
addq $-0x2, %rbx
movl $0x1, %eax
movq %r11, %r9
cmpq %rcx, %rbx
jae 0xa5d8
addq %r11, %rdx
addq %r11, %r8
movl $0x1, %eax
jmp 0xa686
addq %r9, %rdx
addq %r9, %r8
popq %rbx
movq %r8, 0x10(%rdi)
movq %rdx, 0x20(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/jkOwnLib/fuzzyFind.c
// Function: matchInMem
DNA *matchInMem(DNA *ns, DNA *ne, DNA *hs, DNA *he)
{
int nLen = ne - ns;
DNA c = *ns++;
he -= nLen;
nLen -= 1;
while (hs < he)
    {   
    if (*hs++ == c && memcmp(ns, hs, nLen) == 0)
        {
        return hs-1;
        }
    }
return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdi, %r15
subl %r15d, %esi
movslq %esi, %rax
subq %rax, %r14
cmpq %rdx, %r14
jbe 0xa6e0
movq %rdx, %rbx
movb (%r15), %bpl
incq %r15
decl %esi
movslq %esi, %r12
leaq 0x1(%rbx), %r13
cmpb %bpl, (%rbx)
jne 0xa6d8
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x6710
testl %eax, %eax
je 0xa6e2
movq %r13, %rbx
cmpq %r14, %r13
jb 0xa6bd
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/jkOwnLib/fuzzyFind.c
// Function: findAliBetween
struct ffAli *findAliBetween(DNA *tile, int tileSize, DNA *ns, DNA *ne, DNA *hs, DNA *he, struct lm **ffMemPool)
{
    DNA *match;
    DNA *tileEnd = tile + tileSize;
    int tries = 0;

    for (;;)
    {
        if ((match = matchInMem(tile, tileEnd, hs, he)) == NULL)
            return NULL;
        if (matchInMem(tile, tileEnd, match+1, he) == NULL)
        {
            /* Got exactly one match, whoopie! */
            struct ffAli *ali = ffNeedMem(sizeof(*ali), ffMemPool);
            ali->nStart = tile;
            ali->nEnd = tileEnd;
            ali->hStart = match;
            ali->hEnd = match + (tileEnd-tile);
            ffExpandExactLeft(ali, ns, hs);
            ffExpandExactRight(ali, ne, he);
            return ali;
        }

        /* Got more than one match.  Expand tile to make it more specific.
         * In general first add base to start, then base to beginning.  If
         * at beginning or end already are constrained.  If already spanning
         * full needle, can't expand, so you're done. */
        if (tile <= ns)
        {
            if (tileEnd >= ne)
                return NULL;
            ++tileEnd;
        }
        else if (tile >= tileEnd)
        {
            --tile;
        }
        else if (tries & 1)
        {
            ++tileEnd;
        }
        else
        {
            --tile;
        }
        ++tries;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %rbx
movq %r8, %r15
movq %rcx, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %rdi, %r12
movslq %esi, %rbp
addq %rdi, %rbp
movq %rbp, %rsi
movq %r8, %rdx
movq %r9, %rcx
callq 0xa690
xorl %r13d, %r13d
testq %rax, %rax
je 0xa7df
movq %rax, %r14
xorl %r13d, %r13d
leaq 0x1(%r14), %rdx
movq %r12, %rdi
movq %rbp, %rsi
movq %rbx, %rcx
callq 0xa690
testq %rax, %rax
je 0xa794
cmpq 0x10(%rsp), %r12
jbe 0xa769
cmpq %rbp, %r12
jae 0xa764
testb $0x1, %r13b
jne 0xa770
decq %r12
jmp 0xa773
cmpq 0x8(%rsp), %rbp
jae 0xa78f
incq %rbp
incl %r13d
movq %r12, %rdi
movq %rbp, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0xa690
movq %rax, %r14
testq %rax, %rax
jne 0xa73b
xorl %r13d, %r13d
jmp 0xa7df
movq 0x50(%rsp), %rax
movq (%rax), %rdi
movl $0x38, %esi
callq 0x2c325
movq %rax, %r13
movq %r12, 0x10(%rax)
movq %rbp, 0x18(%rax)
movq %r14, 0x20(%rax)
subq %r12, %rbp
addq %r14, %rbp
movq %rbp, 0x28(%rax)
movq %rax, %rdi
movq 0x10(%rsp), %rsi
movq %r15, %rdx
callq 0x160ea
movq %r13, %rdi
movq 0x8(%rsp), %rsi
movq %rbx, %rdx
callq 0x160aa
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/jkOwnLib/fuzzyFind.c
// Function: evalExactAli
double evalExactAli(struct ffAli *ali, DNA *ns, DNA *ne, DNA *hs, DNA *he, int numTiles,
    double freq[4])
{
int haySize = he-hs;
double prob = 1.0;
double allPossibles = haySize*numTiles;

for (;ali != NULL;ali=ali->right)
    {
    double p = oligoProb(ali->nStart, ali->nEnd - ali->nStart, freq) * allPossibles;
    if (p < 1.0)
        prob *= p;
    }
return prob;
}

// Assembly:
testq %rdi, %rdi
je 0xa885
subl %ecx, %r8d
imull %r9d, %r8d
cvtsi2sd %r8d, %xmm1
movq 0x8(%rsp), %rax
movsd 0x83065(%rip), %xmm2    # 0x8d878
leaq 0xb6c46(%rip), %rcx     # 0xc1460
movapd %xmm2, %xmm3
movq 0x10(%rdi), %rdx
movq 0x18(%rdi), %rsi
subq %rdx, %rsi
movapd %xmm2, %xmm0
testl %esi, %esi
jle 0xa85a
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
xorl %r8d, %r8d
movapd %xmm2, %xmm0
movsbq (%rdx,%r8), %r9
movslq (%rcx,%r9,4), %r9
testq %r9, %r9
js 0xa852
mulsd (%rax,%r9,8), %xmm0
incq %r8
cmpq %r8, %rsi
jne 0xa83e
mulsd %xmm1, %xmm0
movapd %xmm3, %xmm4
mulsd %xmm0, %xmm4
cmpltsd %xmm2, %xmm0
andpd %xmm0, %xmm4
andnpd %xmm3, %xmm0
orpd %xmm4, %xmm0
movq 0x8(%rdi), %rdi
movapd %xmm0, %xmm3
testq %rdi, %rdi
jne 0xa81e
retq
movsd 0x82feb(%rip), %xmm0    # 0x8d878
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/jkOwnLib/fuzzyFind.c
// Function: bestMerger
boolean bestMerger(struct protoGene *list, enum ffStringency stringency,
    DNA *ns, DNA *hs, struct protoGene **retA, struct protoGene **retB)
/* Figure out best scoring merger in list. */
{
int bestScore = -0x7fffffff;
int score;
struct protoGene *bestA = NULL, *bestB = NULL;
struct protoGene *a, *b;
boolean isCdna = (stringency == ffCdna);

if (list == NULL)
    return FALSE;

for (a = list; a != NULL; a = a->right)
    {
    for (b = a->right; b != NULL; b = b->right)
        {
        if (canAdd(a,b))
            {
            int hGap = b->hStart - a->hEnd;
            int nGap = b->nStart - a->nEnd;
            if (hGap < 0)
                {
                hGap = -8*hGap;
                if (!isCdna || hGap < 32)
                    hGap = (hGap*hGap);
                }
            if (nGap < 0)
                nGap = -8*nGap;
            score = -hGap - nGap*nGap;
            if (score > bestScore)
                {
                bestA = a;
                bestB = b;
                bestScore = score;
                }
            }
        }
    }
*retA = bestA;
*retB = bestB;
return bestA != NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, 0x4(%rsp)
testq %rdi, %rdi
je 0xaa86
movq %rdi, %r15
movq %r8, 0x8(%rsp)
movq %r9, 0x10(%rsp)
movl $0x80000001, %r14d      # imm = 0x80000001
xorl %r13d, %r13d
xorl %ebx, %ebx
movq 0x8(%r15), %rbp
testq %rbp, %rbp
je 0xaa6c
movq %rbp, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0xa90b
testl %eax, %eax
je 0xaa56
movl 0x18(%r12), %eax
subl 0x20(%r15), %eax
jns 0xaa29
leal (,%rax,8), %ecx
negl %ecx
cmpl $-0x3, %eax
movl $0x1, %eax
cmovael %ecx, %eax
cmpl $0x1, 0x4(%rsp)
cmovnel %ecx, %eax
imull %ecx, %eax
movl 0x28(%r12), %ecx
subl 0x30(%r15), %ecx
leal (,%rcx,8), %edx
negl %edx
testl %ecx, %ecx
cmovnsl %ecx, %edx
imull %edx, %edx
addl %eax, %edx
negl %edx
cmpl %edx, %r14d
cmovlel %edx, %r14d
cmovlq %r15, %rbx
cmovlq %r12, %r13
movq 0x8(%r12), %r12
testq %r12, %r12
jne 0xa9f0
movq %rbp, %r15
testq %rbp, %rbp
jne 0xa9e4
movq 0x8(%rsp), %rax
movq %rbx, (%rax)
movq 0x10(%rsp), %rax
movq %r13, (%rax)
xorl %eax, %eax
testq %rbx, %rbx
setne %al
jmp 0xaa88
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_O3/icebert[P]pblat/jkOwnLib/fuzzyFind.c
// Function: mergeProtoGenes
void mergeProtoGenes(struct protoGene **pList, struct protoGene *a, struct protoGene *b)
/* Absorb protoGene b into protoGene a. */
{
ffUnlink((struct ffAli**)pList, (struct ffAli *)b);
ffCat(&a->hits, &b->hits);
if (a->hStart > b->hStart)
    a->hStart = b->hStart;
if (a->nStart > b->nStart)
    a->nStart = b->nStart;
if (a->hEnd < b->hEnd)
    a->hEnd = b->hEnd;
if (a->nEnd < b->nEnd)
    a->nEnd = b->nEnd;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq (%rdx), %rax
movq 0x8(%rdx), %rcx
cmpq %rdx, (%rdi)
jne 0xaab0
movq %rcx, (%rdi)
testq %rcx, %rcx
je 0xaab8
movq %rax, (%rcx)
testq %rax, %rax
je 0xaac1
movq %rcx, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
leaq 0x10(%rbx), %rdi
leaq 0x10(%r14), %rsi
callq 0x1600c
movq 0x18(%r14), %rax
cmpq %rax, 0x18(%rbx)
jbe 0xaae3
movq %rax, 0x18(%rbx)
movq 0x28(%r14), %rax
cmpq %rax, 0x28(%rbx)
jbe 0xaaf1
movq %rax, 0x28(%rbx)
movq 0x20(%r14), %rax
cmpq %rax, 0x20(%rbx)
jae 0xaaff
movq %rax, 0x20(%rbx)
movq 0x30(%r14), %rax
cmpq %rax, 0x30(%rbx)
jae 0xab0d
movq %rax, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/jkOwnLib/fuzzyFind.c
// Function: lumpHits
struct protoGene *lumpHits(struct ffAli **pHitList, DNA *ns, DNA *hs, struct lm **ffMemPool)
/* Lump together as many hits as can. Criteria - they must be close
 * to same "diagonal." That is the distance between them must be
 * nearly the same in the needle and the haystack. */
{
    struct protoGene proto;
    struct protoGene *retProto;
    struct ffAli *ali, *nextAli;
    int dif, lastDif;
    int lumpCount = 1;

    if ((ali = *pHitList) == NULL)
        return NULL;

    /* Move first hit onto our crude exon. */
    nextAli = ali->right;
    proto.left = proto.right = NULL;
    unlinkAli(pHitList, ali);
    proto.hits = ali;
    proto.hStart = ali->hStart;
    proto.hEnd = ali->hEnd;
    proto.nStart = ali->nStart;
    proto.nEnd = ali->nEnd;
    lastDif = ali->hStart - ali->nStart;

    /* Go through rest of list and put others that are close to
     * on the same diagonal onto this exon. */
    while ((ali = nextAli) != NULL)
    {
        nextAli = ali->right;
        dif = ali->hStart - ali->nStart;
        if (lastDif - 2 <= dif && dif <= lastDif + 2)
        {
            lastDif = dif;
            unlinkAli(pHitList, ali);
            ali->left = proto.hits;
            proto.hits = ali;
            proto.hEnd = ali->hEnd;
            proto.nEnd = ali->nEnd;
            ++lumpCount;
        }
    }
    proto.hits = ffMakeRightLinks(proto.hits);
    retProto = ffNeedMem(sizeof(*retProto), ffMemPool);
    memcpy(retProto, &proto, sizeof(*retProto));
    return retProto;
}

// Assembly:
movq %rdi, %rax
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xac79
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq (%rdi), %rdx
movq 0x8(%rdi), %rcx
movq %rcx, (%rax)
testq %rcx, %rcx
je 0xaba8
movq %rdx, (%rcx)
testq %rdx, %rdx
je 0xabb1
movq %rcx, 0x8(%rdx)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq 0x20(%rdi), %r15
movq 0x28(%rdi), %rbp
movq 0x10(%rdi), %r12
movq 0x18(%rdi), %r13
testq %rcx, %rcx
je 0xac3b
movl %r15d, %r8d
subl %r12d, %r8d
movq 0x20(%rcx), %rsi
subq 0x10(%rcx), %rsi
movq 0x8(%rcx), %rdx
leal -0x2(%r8), %r9d
cmpl %esi, %r9d
setg %r9b
leal 0x2(%r8), %r10d
cmpl %esi, %r10d
setl %r10b
orb %r9b, %r10b
je 0xabfe
movl %r8d, %esi
jmp 0xac30
movq (%rcx), %r8
cmpq %rcx, (%rax)
jne 0xac09
movq %rdx, (%rax)
testq %rdx, %rdx
je 0xac11
movq %r8, (%rdx)
testq %r8, %r8
je 0xac1a
movq %rdx, 0x8(%r8)
movq $0x0, 0x8(%rcx)
movq %rdi, (%rcx)
movq 0x18(%rcx), %r13
movq 0x28(%rcx), %rbp
movq %rcx, %rdi
movl %esi, %r8d
movq %rdx, %rcx
testq %rdx, %rdx
jne 0xabd2
callq 0x28293
movq %rax, %r14
movq (%rbx), %rdi
movl $0x40, %esi
callq 0x2c325
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %r14, 0x10(%rax)
movq %r15, 0x18(%rax)
movq %rbp, 0x20(%rax)
movq %r12, 0x28(%rax)
movq %r13, 0x30(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/jkOwnLib/fuzzyFind.c
// Function: thinProtoList
void thinProtoList(struct protoGene **pList, int maxToTake)
/* Reduce list to only top scoring members.  At this
 * point protoList is singly linked on left. */
{
struct protoGene *newList = NULL, *pg, *next;
int i;

slSort(pList, cmpProtoScore);
for (pg=*pList, i=0; pg != NULL && i < maxToTake; pg = next, ++i)
    {
    next = pg->left;
    pg->left = newList;
    newList = pg;
    }
*pList = newList;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq -0x38d(%rip), %rsi      # 0xa8fe
callq 0x201c4
movq (%rbx), %rax
testq %rax, %rax
sete %cl
testl %ebp, %ebp
setle %dl
orb %cl, %dl
jne 0xacc5
movl $0x1, %edx
xorl %esi, %esi
movq %rax, %rcx
movq (%rax), %rax
movq %rsi, (%rcx)
testq %rax, %rax
je 0xacc7
leal 0x1(%rdx), %edi
movq %rcx, %rsi
cmpl %ebp, %edx
movl %edi, %edx
jl 0xaca9
jmp 0xacc7
xorl %ecx, %ecx
movq %rcx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/jkOwnLib/fuzzyFind.c
// Function: ffFindAndScore
boolean ffFindAndScore(DNA *needle, int needleSize, DNA *haystack, int haySize,
    enum ffStringency stringency, struct ffAli **pAli, boolean *pRcNeedle, int *pScore)
/* Return TRUE if find an allignment using needle, or reverse complement of 
 * needle to search haystack. DNA must be lower case. If pScore is non-NULL returns
 * score of alignment. */
{
int fScore, rScore;
struct ffAli *fAli, *rAli;

/* Get forward alignment and score it. */
fAli = ffFind(needle, needle+needleSize, haystack, haystack+haySize, stringency);
fScore = ffScore(fAli,stringency);

/* Get reverse alignment and score it. */
reverseComplement(needle, needleSize);
rAli = ffFind(needle, needle+needleSize, haystack, haystack+haySize, stringency);
rScore = ffScore(rAli,stringency);
reverseComplement(needle, needleSize);

/* If no good alignment on either strand return FALSE. */
if (fAli == NULL && rAli == NULL)
    {
    *pAli = NULL;
    return FALSE;
    }

/* Return TRUE with best alignment.  Free the other one. */
if (fScore > rScore)
    {
    *pAli = fAli;
    *pRcNeedle = FALSE;
    if (pScore != NULL)
        *pScore = fScore;
    ffFreeAli(&rAli);
    }   
else
    {
    *pAli = rAli;
    *pRcNeedle = TRUE;
    if (pScore != NULL)
        *pScore = rScore;
    ffFreeAli(&fAli);
    }
return TRUE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, 0x8(%rsp)
movl %r8d, %r13d
movq %rdx, %rbx
movq %rdi, %r15
movslq %esi, %r12
leaq (%rdi,%r12), %rsi
movq %rsi, 0x10(%rsp)
movslq %ecx, %rbp
addq %rdx, %rbp
movq %rbp, %rcx
callq 0xacd1
movq %rax, %r14
movq %rax, 0x20(%rsp)
movq %rax, %rdi
movl %r13d, %esi
callq 0x2877d
movl %eax, 0x4(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x25423
movq %r15, %rdi
movq 0x10(%rsp), %rsi
movq %rbx, %rdx
movq %rbp, %rcx
movl %r13d, %r8d
callq 0xacd1
movq %rax, %rbx
movq %rax, 0x18(%rsp)
movq %rax, %rdi
movl %r13d, %esi
callq 0x2877d
movl %eax, %r13d
movq %r15, %rdi
movq %r12, %rsi
callq 0x25423
movq %r14, %rax
orq %rbx, %rax
jne 0xb1f6
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
xorl %eax, %eax
jmp 0xb245
movq 0x8(%rsp), %rdx
movq 0x68(%rsp), %rax
movq 0x60(%rsp), %rcx
movl 0x4(%rsp), %esi
cmpl %r13d, %esi
jle 0xb225
movq %r14, (%rdx)
movl $0x0, (%rcx)
testq %rax, %rax
je 0xb21e
movl %esi, (%rax)
leaq 0x18(%rsp), %rdi
jmp 0xb23b
movq %rbx, (%rdx)
movl $0x1, (%rcx)
testq %rax, %rax
je 0xb236
movl %r13d, (%rax)
leaq 0x20(%rsp), %rdi
callq 0x281f8
movl $0x1, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq