LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x32b0
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x3410
cmpl $-0x1, %eax
je 0xa01a
movl %eax, %ebp
movq %rbx, %rdi
movl $0x241, %esi            # imm = 0x241
movl $0x1ff, %edx            # imm = 0x1FF
xorl %eax, %eax
callq 0x3410
cmpl $-0x1, %eax
je 0xa030
movl %eax, %r14d
leaq 0xa0(%rsp), %r15
movl $0x2000, %edx           # imm = 0x2000
movl %ebp, %edi
movq %r15, %rsi
callq 0x3210
testq %rax, %rax
je 0x9fdf
movq %rax, %r12
movl %r14d, %edi
movq %r15, %rsi
movq %rax, %rdx
callq 0x30f0
cmpq %r12, %rax
je 0x9f90
leaq 0x8ff7(%rip), %rax      # 0x12fb8
movq (%rax), %rdi
leaq 0x43ef(%rip), %rsi      # 0xe3ba
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3290
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x3480
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 0x8f97(%rip), %rax      # 0x12fb8
movq (%rax), %rdi
leaq 0x434e(%rip), %rsi      # 0xe379
movq %r14, %rdx
jmp 0x9fce
leaq 0x8f81(%rip), %rax      # 0x12fb8
movq (%rax), %rdi
leaq 0x4358(%rip), %rsi      # 0xe399
jmp 0x9fcb
// File: /workspace/github_c_makefile_star2_O1/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
cmpl $0x0, 0xb7cf(%rip)      # 0x15ab0
je 0xa39b
movq $0x0, 0x8(%rsp)
movw $0x46c1, 0x8(%rsp)      # imm = 0x46C1
movw %dx, 0xa(%rsp)
movw %di, 0xc(%rsp)
movw %si, 0xe(%rsp)
movw %cx, 0x10(%rsp)
cmpl $0x0, 0xb79e(%rip)      # 0x15ab0
jle 0xa3a0
leaq 0xb7a1(%rip), %rbx      # 0x15ac0
leaq 0x8(%rsp), %r14
movq 0x7ca5(%rip), %rbp      # 0x11fd0
leaq 0x4115(%rip), %r12      # 0xe447
xorl %r15d, %r15d
movl 0xb779(%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 0xa38d
cmpl $0x9, %r13d
jg 0xa378
movq (%rbp), %rdi
movq %r12, %rsi
movl %r13d, %edx
movl $0xa, %ecx
xorl %eax, %eax
callq 0x3290
incq %r15
movslq 0xb72e(%rip), %rax      # 0x15ab0
addq $0x10, %rbx
cmpq %rax, %r15
jl 0xa335
jmp 0xa3a0
leaq 0x40a1(%rip), %rdi      # 0xe435
callq 0x3430
jmp 0xa35c
callq 0x38d3
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2c48(%rip), %rbx      # 0x40f0
testq %rbx, %rbx
je 0x14d3
xorl %edi, %edi
testq %rdi, %rdi
je 0x14b9
callq 0x1040
movq 0x10(%rbx), %rdi
movq 0x8(%rbx), %rax
movq %rax, %rbx
testq %rax, %rax
jne 0x14af
testq %rdi, %rdi
je 0x14d3
callq 0x1040
callq 0x1170
movl 0x2c02(%rip), %esi      # 0x40e0
leaq 0xb3f(%rip), %rdi       # 0x2024
xorl %eax, %eax
popq %rbx
jmp 0x1090
// File: /workspace/github_c_makefile_star2_O1/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 0x1577
movl %ebp, (%rax)
movq $0x0, 0x8(%rax)
movq 0x2be4(%rip), %rcx      # 0x40f8
testq %rcx, %rcx
je 0x151d
movq %rax, 0x8(%rcx)
movq %rcx, 0x10(%rax)
movq %rax, 0x2bd0(%rip)      # 0x40f8
cmpq $0x0, 0x2bc0(%rip)      # 0x40f0
jne 0x1539
movq %rax, 0x2bb7(%rip)      # 0x40f0
testl %ebx, %ebx
setne %al
movq 0x2bab(%rip), %rdi      # 0x40f0
testq %rdi, %rdi
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x1570
movq 0x8(%rdi), %rax
movq %rax, 0x2b93(%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_O1/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 0x2a50(%rip), %r14      # 0x3fe0
movq (%r14), %rax
movq $-0x3, %r15
movq $-0x3, %r12
testq %rax, %rax
je 0x15ae
movswq 0x4(%rax), %r12
decq %r12
testq %rax, %rax
je 0x15bb
movswq 0x6(%rax), %r15
decq %r15
movq (%r14), %rbx
callq 0x1100
cqto
idivq %r12
leal 0x1(%rdx), %ebp
callq 0x1100
cqto
idivq %r15
incl %edx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1130
movq (%r14), %rdi
callq 0x1110
cmpl $0x20, %eax
jne 0x15bb
movq (%r14), %rax
testq %rax, %rax
je 0x1605
movswl (%rax), %ecx
movl %ecx, 0x2b01(%rip)      # 0x4100
movswl 0x2(%rax), %eax
jmp 0x1614
movl $0xffffffff, 0x2af1(%rip) # imm = 0xFFFFFFFF
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0x2aea(%rip)      # 0x4104
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x29ae(%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 0x2a8a(%rip), %r15      # 0x40f8
testq %r15, %r15
je 0x16cd
movl 0x2a6f(%rip), %ebx      # 0x40e8
movl 0x2a65(%rip), %ebp      # 0x40e4
leaq 0x98e(%rip), %r12       # 0x2014
movq (%r14), %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x1130
cmpl $-0x1, %eax
je 0x16a4
movq (%r14), %rdi
movl $0x23, %esi
callq 0x1150
movl (%r15), %eax
cmpq $0x3, %rax
ja 0x16c4
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
incl %ebp
jmp 0x16c4
incl %ebx
jmp 0x16c4
decl %ebx
jmp 0x16c4
decl %ebp
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0x1686
movq (%r14), %rdi
movl 0x2a2a(%rip), %esi      # 0x4100
movl 0x2a28(%rip), %edx      # 0x4104
callq 0x1130
cmpl $-0x1, %eax
je 0x16f3
movq (%r14), %rdi
movl $0x40, %esi
callq 0x1150
movq (%r14), %rdi
movl 0x29e8(%rip), %esi      # 0x40e4
movl 0x29e6(%rip), %edx      # 0x40e8
callq 0x1130
movq (%r14), %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x10b0
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x17d5
movq %rsi, %rbx
leaq 0x2936(%rip), %rdi      # 0x40a0
movl $0x20000, %edx          # imm = 0x20000
movl $0xdd, %esi
callq 0x1060
movw $0x3000, 0x2291e(%rip)  # imm = 0x3000
movw $0x2, 0x2905(%rip)      # 0x4090
movaps 0x8be(%rip), %xmm0      # 0x2050
movaps %xmm0, 0x22917(%rip)    # 0x240b0
movq 0x8(%rbx), %rdi
leaq 0x8ee(%rip), %rsi       # 0x2092
callq 0x1090
testq %rax, %rax
je 0x17dc
movq %rax, %r14
movq %rax, %rdi
callq 0x17f4
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x17ed
movq %r14, %rdi
callq 0x1040
callq 0x12a7
xorl %eax, %eax
jmp 0x17ed
callq 0x1103
jmp 0x17e8
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_O1/somethingnew2-0[P]CS537-P4/output.c
// Function: getargs
void getargs()
{
  char *buf, *p;

  /* Extract the four arguments */
  if ((buf = getenv("QUERY_STRING")) != NULL) {
    p = strtok(buf, "&");
    if (p == NULL) 
      return;
    spinfor = (double) atoi(p);
    return;
  }
}

// Assembly:
pushq %rax
leaq 0xe1c(%rip), %rdi       # 0x2010
callq 0x1030
testq %rax, %rax
je 0x1226
leaq 0xe18(%rip), %rsi       # 0x201d
movq %rax, %rdi
callq 0x10a0
testq %rax, %rax
je 0x1226
movq %rax, %rdi
callq 0x10b0
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x2e62(%rip)     # 0x4088
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/somethingnew2-0[P]CS537-P4/output.c
// Function: Time_GetSeconds
double Time_GetSeconds() {
    struct timeval t;
    int rc = gettimeofday(&t, NULL);
    assert(rc == 0);
    return (double) ((double)t.tv_sec + (double)t.tv_usec / 1e6);
}

// Assembly:
subq $0x18, %rsp
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x1070
testl %eax, %eax
jne 0x125b
cvtsi2sdq 0x8(%rsp), %xmm1
cvtsi2sdq 0x10(%rsp), %xmm0
divsd 0xdb6(%rip), %xmm0      # 0x2008
addsd %xmm1, %xmm0
addq $0x18, %rsp
retq
leaq 0xdbd(%rip), %rdi       # 0x201f
leaq 0xdbe(%rip), %rsi       # 0x2027
leaq 0xdc0(%rip), %rcx       # 0x2030
movl $0x20, %edx
callq 0x1080
// File: /workspace/github_c_makefile_star2_O1/somethingnew2-0[P]CS537-P4/output.c
// Function: main
int main(int argc, char *argv[])
{
  char content[MAXBUF];

  getargs();

  double t1 = Time_GetSeconds();
  while ((Time_GetSeconds() - t1) < spinfor)
      sleep(1);
  double t2 = Time_GetSeconds();

  /* Make the response body */
  sprintf(content, "<p>Welcome to the CGI program</p>\r\n");
  sprintf(content, "%s<p>My only purpose is to waste time on the server!</p>\r\n", content);
  sprintf(content, "%s<p>I spun for %.2f seconds</p>\r\n", content, t2 - t1);
  
  /* Generate the HTTP response */
  printf("Content-length: %lu\r\n", strlen(content));
  printf("Content-type: text/html\r\n\r\n");
  printf("%s", content);
  fflush(stdout);

  exit(0);
}

// Assembly:
pushq %rbx
subq $0x2010, %rsp           # imm = 0x2010
callq 0x11ec
callq 0x1228
movsd %xmm0, (%rsp)
callq 0x1228
subsd (%rsp), %xmm0
movsd 0x2de5(%rip), %xmm1     # 0x4088
ucomisd %xmm0, %xmm1
jbe 0x12b5
movl $0x1, %edi
callq 0x10e0
jmp 0x1291
callq 0x1228
movsd %xmm0, 0x8(%rsp)
movups 0xd82(%rip), %xmm0      # 0x2049
leaq 0x10(%rsp), %rbx
movaps %xmm0, (%rbx)
movups 0xd83(%rip), %xmm0      # 0x2059
movaps %xmm0, 0x10(%rbx)
movl $0xa0d3e, 0x20(%rbx)    # imm = 0xA0D3E
leaq 0xd85(%rip), %rsi       # 0x206d
movq %rbx, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x10c0
movsd 0x8(%rsp), %xmm0
subsd (%rsp), %xmm0
leaq 0xda1(%rip), %rsi       # 0x20a8
movq %rbx, %rdi
movq %rbx, %rdx
movb $0x1, %al
callq 0x10c0
movq %rbx, %rdi
callq 0x1050
leaq 0xda8(%rip), %rdi       # 0x20cb
movq %rax, %rsi
xorl %eax, %eax
callq 0x1060
leaq 0xdb0(%rip), %rdi       # 0x20e4
callq 0x1040
leaq 0xda1(%rip), %rdi       # 0x20e1
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1060
movq 0x2c8f(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x1090
xorl %edi, %edi
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x438, %rsp            # imm = 0x438
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 0x261d0
movq %rax, 0x8(%rsp)
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x47ac0
movq 0x8(%rsp), %rax
movl 0x14(%rax), %ecx
movl $0x3ff, %esi            # imm = 0x3FF
cmpl %esi, %ecx
cmovll %ecx, %esi
movq 0x8(%rax), %rdx
movslq %esi, %r14
leaq 0x30(%rsp), %rdi
movl $0x400, %esi            # imm = 0x400
movq %r14, %rcx
callq 0x23c98
movq 0x8(%rsp), %rax
cmpl $0x400, 0x14(%rax)      # imm = 0x400
jl 0x71ee
movw $0x5d, 0x2f(%rsp,%r14)
movl $0x2e2e2e5b, 0x2b(%rsp,%r14) # imm = 0x2E2E2E5B
leaq 0x8(%rsp), %rdi
callq 0x2620d
movq 0xb7db1(%rip), %rax     # 0xbefb0
movq (%rax), %rdi
leaq 0x89be2(%rip), %rsi     # 0x90deb
leaq 0x30(%rsp), %rdx
xorl %eax, %eax
callq 0x6a90
movq 0xb7dbc(%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 $0x438, %rsp            # imm = 0x438
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0xcd2bd(%rip)     # 0xd4668
jne 0x73c9
testb $0x1, 0xcd1b0(%rip)     # 0xd4564
jne 0x73c9
leaq 0x90381(%rip), %rdi     # 0x9773e
callq 0x48f43
movb $0x1, 0xcd29f(%rip)     # 0xd4668
leaq 0x90409(%rip), %rdi     # 0x977d9
callq 0x6bb0
movq 0xb7bd4(%rip), %r15     # 0xbefb0
movq (%r15), %rsi
leaq 0x8f5d0(%rip), %rdi     # 0x969b6
callq 0x6810
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7166
movq (%r15), %rsi
leaq 0x8f5ba(%rip), %rdi     # 0x969ba
callq 0x6810
leaq 0x903e4(%rip), %rdi     # 0x977f0
popq %rbx
popq %r14
popq %r15
jmp 0x6bb0
// File: /workspace/github_c_makefile_star2_O1/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 0xb758e(%rip), %r12     # 0xbefd8
movq (%r12), %rcx
leaq 0x9196e(%rip), %rdi     # 0x993c3
pushq $0xc
popq %rsi
pushq $0x1
popq %rdx
callq 0x6e70
leaq 0x882cf(%rip), %r14     # 0x8fd36
xorl %r15d, %r15d
movl (%rbx,%r15,4), %ecx
testl %ecx, %ecx
jne 0x7a80
incq %r15
cmpq $0x400, %r15            # imm = 0x400
jne 0x7a6a
jmp 0x7a93
movq (%r12), %rdi
movq %r14, %rsi
movl %r15d, %edx
xorl %eax, %eax
callq 0x6a90
jmp 0x7a72
cmpq $0x0, 0x1000(%rbx)
je 0x7b03
movq 0x1000(%rbx), %rax
cmpl $0x0, (%rax)
je 0x7b03
leaq 0x88286(%rip), %r14     # 0x8fd36
xorl %ebp, %ebp
xorl %r15d, %r15d
movq 0x10(%rax), %rcx
movl %r15d, %edx
shrl $0x4, %edx
movl (%rcx,%rdx,4), %edx
movl %ebp, %ecx
andb $0x1e, %cl
shrl %cl, %edx
testb $0x3, %dl
je 0x7ae2
incl %r15d
movq 0x1000(%rbx), %rax
addl $0x2, %ebp
cmpl (%rax), %r15d
jne 0x7ab5
jmp 0x7b03
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
jmp 0x7ace
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
cmpl $0x0, 0xb85f4(%rip)     # 0xc0e84
je 0x88b7
movl 0x18(%r12), %ecx
cmpl $0x1389, %ecx           # imm = 0x1389
jl 0x88b7
movq 0x8(%r12), %rdx
leaq 0x84be7(%rip), %rdi     # 0x8d492
movl $0x1388, %esi           # imm = 0x1388
xorl %eax, %eax
callq 0x26b6f
movl 0xb6eae(%rip), %r13d    # 0xbf76c
movl 0xb85bf(%rip), %r14d    # 0xc0e84
leaq 0x84ba8(%rip), %rdi     # 0x8d474
callq 0x34334
movq %r12, %rdi
movq %r15, %rsi
movl %ebp, %edx
movl %r13d, %ecx
movq %rbx, %r8
movq 0x40(%rsp), %r9
pushq %rax
pushq %r14
callq 0x11e08
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2bea4
leaq 0x18(%rsp), %r12
movq %rax, (%r12)
leaq 0xc(%rsp), %rcx
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xedb1
leaq 0x10(%rsp), %r13
movq %rax, (%r13)
movl 0xb6e28(%rip), %r8d     # 0xbf76c
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
movq %rbx, %r9
callq 0x104a6
movq %r13, %rdi
callq 0xdb1f
movq %r12, %rdi
callq 0x2bf4b
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0xb84f0(%rip)     # 0xc0e6c
jle 0x89bc
movl 0xb6fdc(%rip), %eax     # 0xbf960
leal -0x1(%rax), %ecx
movl %ecx, 0xb6fd3(%rip)     # 0xbf960
cmpl $0x1, %eax
jg 0x89bc
pushq %rbx
movq 0xb6616(%rip), %rbx     # 0xbefb0
movq (%rbx), %rsi
movl $0x2e, %edi
callq 0x6930
movq (%rbx), %rdi
callq 0x6870
movl 0xb84b7(%rip), %eax     # 0xc0e6c
movl %eax, 0xb6fa5(%rip)     # 0xbf960
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8975
testl %ebx, %ebx
je 0x89fc
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rcx
callq 0x88fb
jmp 0x8a45
movq %rbp, 0x30(%r14)
movq %r14, (%rsp)
movq %r15, %rdi
movq %r13, %rsi
xorl %ecx, %ecx
movq %r12, %r9
callq 0x8873
movq 0x10(%r15), %rdi
movslq 0x18(%r15), %rsi
callq 0x250f6
movq %r14, (%rsp)
movq %r15, %rdi
movq %r13, %rsi
movl $0x1, %ecx
movq %r12, %r9
callq 0x8873
movq 0x10(%r15), %rdi
movslq 0x18(%r15), %rsi
callq 0x250f6
movq %r14, %rdi
movq 0x10(%rsp), %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x14712
// File: /workspace/github_c_makefile_star2_O1/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, 0xb83f5(%rip)     # 0xc0e80
je 0x8a97
movq %rbx, %rdi
movl %ebp, %esi
callq 0x25ac9
movl 0xb83df(%rip), %eax     # 0xc0e7c
orl 0xb83d5(%rip), %eax     # 0xc0e78
je 0x8ac5
movq %rbx, %rdi
movl %ebp, %esi
callq 0x25a03
cmpl $0x0, 0xb83c6(%rip)     # 0xc0e7c
je 0x8ac5
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_O1/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 0x88304(%rip), %rsi     # 0x90deb
movl $0x2, %edi
xorl %eax, %eax
callq 0x4246e
testl %r15d, %r15d
je 0x8b09
movq 0x10(%rbx), %rdi
movl 0x18(%rbx), %esi
callq 0x27b26
xorl %r14d, %r14d
jmp 0x8b3a
testl %r14d, %r14d
je 0x8b2b
testl %ebp, %ebp
je 0x8b1e
movq 0x10(%rbx), %rdi
movl 0x18(%rbx), %esi
callq 0x21c9f
movq %rbx, %rdi
callq 0x24d6a
movq %rax, %r14
jmp 0x8b2e
xorl %r14d, %r14d
movq 0x10(%rbx), %rdi
movl 0x18(%rbx), %esi
callq 0x27b6c
movl 0x18(%rbx), %edx
cmpl $0x4c4b41, %edx         # imm = 0x4C4B41
jl 0x8b57
movq 0x8(%rbx), %rsi
leaq 0x849ed(%rip), %rdi     # 0x8d53d
xorl %eax, %eax
callq 0x268ca
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb8323(%rip), %rdi     # 0xc0eb0
xorl %ebx, %ebx
testq %rdi, %rdi
setne %bl
je 0x8bac
leaq 0x849d5(%rip), %rsi     # 0x8d573
callq 0x2054a
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
jmp 0x8bae
xorl %ecx, %ecx
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x8aca
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 0x8a60
movl 0xb82b4(%rip), %eax     # 0xc0e98
cmpl $0x4, %eax
je 0x8bee
cmpl $0x1, %eax
jne 0x8c06
movq 0x30(%rsp), %rdi
movl 0x38(%rsp), %esi
movl $0x75, %edx
movl $0x74, %ecx
callq 0x21fee
leaq 0x18(%rsp), %rbx
movq (%rbx), %r9
movq 0x88(%rsp), %rax
movq %rax, (%rsp)
leaq 0x20(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
movl %ebp, %ecx
movq %r15, %r8
callq 0x89bd
movslq 0x18(%r14), %rax
movq 0x10(%rsp), %rcx
addq %rax, (%rcx)
movq 0x80(%rsp), %rax
incl (%rax)
movq %rbx, %rdi
callq 0x1b79b
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq $0x0, 0x8(%rsp)
xorl %edi, %edi
movl $0x1, %esi
callq 0x29160
movq %rax, %r15
testq %r12, %r12
je 0x915e
movq %r12, %rdi
callq 0x15d78
movq %rax, %r13
movq 0x8(%rax), %rsi
movq %r15, %rdi
movq %rax, %rdx
callq 0x28ed0
movq 0x8(%rsp), %rax
movq %rax, (%r13)
movq %r13, 0x8(%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 0x913f
movq (%r12), %r12
jmp 0x9110
leaq 0x8(%rsp), %rdi
callq 0x1fcb3
xorl %r12d, %r12d
leaq (%r14,%r12), %rdi
callq 0x1fcb3
addq $0x8, %r12
cmpq $0x18, %r12
jne 0x916b
movq %r15, (%rbx)
movq 0x8(%rsp), %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9232
movl %r8d, %ebx
movq %rsi, %r15
movq %rdi, %r12
sete %al
movzbl %al, %r13d
leal 0x1(%rbx), %r14d
xorl %ebp, %ebp
movl 0xb6577(%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 0x125e3
addq $0x10, %rsp
testl %ebx, %ebx
je 0x922b
movq 0x10(%r12), %rdi
movslq 0x18(%r12), %rsi
callq 0x250f6
incl %ebp
cmpl %ebp, %r14d
jne 0x91ef
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa640
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
xorl %r10d, %r10d
movl 0xb6929(%rip), %r11d    # 0xc0ec0
xorl %eax, %eax
movq %rcx, %rbx
movq %r9, %rsi
movb (%rcx,%r10), %r14b
movb (%r9,%r10), %bpl
cmpb %bpl, %r14b
je 0xa608
cmpb $0x6e, %r14b
jne 0xa5da
testl %r11d, %r11d
jne 0xa608
leaq (%rcx,%r10), %r14
addq $0x3, %r14
cmpq %rdx, %r14
jae 0xa608
cmpb $0x6e, 0x1(%rcx,%r10)
jne 0xa608
cmpb $0x6e, 0x2(%rcx,%r10)
jne 0xa608
cmpb $0x6e, (%r14)
jne 0xa608
cmpb $0x6e, %bpl
jne 0xa645
testl %r11d, %r11d
jne 0xa608
leaq (%r9,%r10), %r14
addq $0x3, %r14
cmpq %r8, %r14
jae 0xa608
cmpb $0x6e, 0x1(%r9,%r10)
jne 0xa608
cmpb $0x6e, 0x2(%r9,%r10)
jne 0xa608
cmpb $0x6e, (%r14)
je 0xa65d
leaq (%r10,%rcx), %rax
incq %rax
incq %rsi
leaq 0x1(%r10), %r14
cmpq %rdx, %rax
jae 0xa636
incq %rbx
leaq (%r10,%r9), %r15
incq %r15
movl $0x1, %eax
movq %r14, %r10
cmpq %r8, %r15
jb 0xa59f
addq %r14, %rcx
movl $0x1, %eax
jmp 0xa64e
movq %r9, %rsi
jmp 0xa654
addq %r10, %rcx
addq %r10, %r9
movq %r9, %rsi
popq %rbx
popq %r14
popq %r15
popq %rbp
movq %rcx, 0x18(%rdi)
movq %rsi, 0x28(%rdi)
retq
movq %rbx, %rcx
jmp 0xa64e
// File: /workspace/github_c_makefile_star2_O1/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 0xa742
pushq %rbx
xorl %r9d, %r9d
movl 0xb6827(%rip), %r10d    # 0xc0ec0
xorl %eax, %eax
movb -0x1(%r8,%r9), %bl
movb -0x1(%rdx,%r9), %r11b
cmpb %r11b, %bl
je 0xa704
cmpb $0x6e, %bl
jne 0xa6d6
testl %r10d, %r10d
jne 0xa704
leaq (%r8,%r9), %rbx
addq $-0x4, %rbx
cmpq %rsi, %rbx
jb 0xa704
cmpb $0x6e, -0x2(%r8,%r9)
jne 0xa704
cmpb $0x6e, -0x3(%r8,%r9)
jne 0xa704
cmpb $0x6e, (%rbx)
jne 0xa704
cmpb $0x6e, %r11b
jne 0xa73b
testl %r10d, %r10d
jne 0xa704
leaq (%rdx,%r9), %r11
addq $-0x4, %r11
cmpq %rcx, %r11
jb 0xa704
cmpb $0x6e, -0x2(%rdx,%r9)
jne 0xa704
cmpb $0x6e, -0x3(%rdx,%r9)
jne 0xa704
cmpb $0x6e, (%r11)
je 0xa73b
leaq (%r8,%r9), %rax
addq $-0x2, %rax
leaq -0x1(%r9), %r11
cmpq %rsi, %rax
jb 0xa72e
leaq (%rdx,%r9), %rbx
addq $-0x2, %rbx
movl $0x1, %eax
movq %r11, %r9
cmpq %rcx, %rbx
jae 0xa69b
addq %r11, %rdx
addq %r11, %r8
movl $0x1, %eax
jmp 0xa741
addq %r9, %rdx
addq %r9, %r8
popq %rbx
movq %r8, 0x10(%rdi)
movq %rdx, 0x20(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa79b
movq %rdx, %rbx
movb (%r15), %bpl
incq %r15
decl %esi
movslq %esi, %r12
leaq 0x1(%rbx), %r13
cmpb %bpl, (%rbx)
jne 0xa793
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x6710
testl %eax, %eax
je 0xa79d
movq %r13, %rbx
cmpq %r14, %r13
jb 0xa778
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_O1/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 0xa74b
xorl %r13d, %r13d
testq %rax, %rax
je 0xa89a
movq %rax, %r14
xorl %r13d, %r13d
leaq 0x1(%r14), %rdx
movq %r12, %rdi
movq %rbp, %rsi
movq %rbx, %rcx
callq 0xa74b
testq %rax, %rax
je 0xa84f
cmpq 0x10(%rsp), %r12
jbe 0xa824
cmpq %rbp, %r12
jae 0xa81f
testb $0x1, %r13b
jne 0xa82b
decq %r12
jmp 0xa82e
cmpq 0x8(%rsp), %rbp
jae 0xa84a
incq %rbp
incl %r13d
movq %r12, %rdi
movq %rbp, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0xa74b
movq %rax, %r14
testq %rax, %rax
jne 0xa7f6
xorl %r13d, %r13d
jmp 0xa89a
movq 0x50(%rsp), %rax
movq (%rax), %rdi
movl $0x38, %esi
callq 0x2bfa9
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 0x160a9
movq %r13, %rdi
movq 0x8(%rsp), %rsi
movq %rbx, %rdx
callq 0x16069
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_O1/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 0xa940
subl %ecx, %r8d
imull %r9d, %r8d
cvtsi2sd %r8d, %xmm1
movq 0x8(%rsp), %rax
movsd 0x82faa(%rip), %xmm2    # 0x8d878
leaq 0xb6b8b(%rip), %rcx     # 0xc1460
movapd %xmm2, %xmm3
movq 0x10(%rdi), %rdx
movq 0x18(%rdi), %rsi
subq %rdx, %rsi
movapd %xmm2, %xmm0
testl %esi, %esi
jle 0xa915
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
xorl %r8d, %r8d
movapd %xmm2, %xmm0
movsbq (%rdx,%r8), %r9
movslq (%rcx,%r9,4), %r9
testq %r9, %r9
js 0xa90d
mulsd (%rax,%r9,8), %xmm0
incq %r8
cmpq %r8, %rsi
jne 0xa8f9
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 0xa8d9
retq
movsd 0x82f30(%rip), %xmm0    # 0x8d878
retq
// File: /workspace/github_c_makefile_star2_O1/icebert[P]pblat/jkOwnLib/fuzzyFind.c
// Function: canAdd
boolean canAdd(struct protoGene *a, struct protoGene *b)
/* Can b fit into a?  It can if it doesn't overlap
 * by more than 1/4 with what's already there. */
{
struct ffAli *pa;
DNA *bnEnd = b->nEnd;
DNA *bnStart = b->nStart;
DNA *bhEnd = b->hEnd;
DNA *bhStart = b->hStart;
int bSize = bnEnd - bnStart;
int maxOverlap;
for (pa = a->hits; pa != NULL; pa = pa->right)
    {
    int aSize = pa->nEnd - pa->nStart;
    DNA *start = (bnStart > pa->nStart ? bnStart : pa->nStart);
    DNA *end = (bnEnd < pa->nEnd ? bnEnd : pa->nEnd);
    maxOverlap = (aSize < bSize ? aSize : bSize) / 4;
    if (maxOverlap < 2) maxOverlap = 2;
    if (end - start >= maxOverlap)
       return FALSE;
    start = (bhStart > pa->hStart ? bhStart : pa->hStart);
    end = (bhEnd < pa->hEnd ? bhEnd : pa->hEnd);
    if (end - start >= maxOverlap)
        return FALSE;
    }
return TRUE;
}

// Assembly:
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0xaa66
pushq %r14
pushq %rbx
movq 0x30(%rsi), %rdx
movq 0x28(%rsi), %rdi
movq 0x18(%rsi), %r8
movq 0x20(%rsi), %rsi
movl %edx, %r9d
subl %edi, %r9d
movl $0x2, %r10d
movq 0x10(%rcx), %rax
movq 0x18(%rcx), %rbx
movl %ebx, %r14d
subl %eax, %r14d
cmpq %rax, %rdi
cmovaq %rdi, %rax
cmpq %rbx, %rdx
cmovbq %rdx, %rbx
cmpl %r9d, %r14d
cmovgel %r9d, %r14d
leal 0x3(%r14), %r11d
testl %r14d, %r14d
cmovnsl %r14d, %r11d
sarl $0x2, %r11d
cmpl $0x3, %r11d
cmovll %r10d, %r11d
subq %rax, %rbx
xorl %eax, %eax
cmpq %r11, %rbx
jge 0xaa62
movq 0x20(%rcx), %rbx
movq 0x28(%rcx), %r14
cmpq %rbx, %r8
cmovaq %r8, %rbx
cmpq %r14, %rsi
cmovbq %rsi, %r14
subq %rbx, %r14
cmpq %r11, %r14
jge 0xaa62
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
jne 0xa9f2
movl $0x1, %eax
popq %rbx
popq %r14
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0xab3f
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %r15
movq %r8, 0x8(%rsp)
movq %r9, 0x10(%rsp)
movl $0x80000001, %ebx       # imm = 0x80000001
xorl %r13d, %r13d
xorl %r14d, %r14d
movq 0x8(%r15), %r12
testq %r12, %r12
je 0xab0f
movq %r15, %rdi
movq %r12, %rsi
callq 0xa9c6
testl %eax, %eax
je 0xab08
movl 0x18(%r12), %eax
subl 0x20(%r15), %eax
jns 0xaadd
leal (,%rax,8), %ecx
negl %ecx
cmpl $-0x3, %eax
movl $0x1, %eax
cmovgel %ecx, %eax
cmpl $0x1, %ebp
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, %ebx
cmovlel %edx, %ebx
cmovlq %r15, %r14
cmovlq %r12, %r13
movq 0x8(%r12), %r12
jmp 0xaaa1
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0xaa9d
movq 0x8(%rsp), %rax
movq %r14, (%rax)
movq 0x10(%rsp), %rax
movq %r13, (%rax)
xorl %eax, %eax
testq %r14, %r14
setne %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xab5b
movq %rcx, (%rdi)
testq %rcx, %rcx
je 0xab63
movq %rax, (%rcx)
testq %rax, %rax
je 0xab6c
movq %rcx, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
leaq 0x10(%rbx), %rdi
leaq 0x10(%r14), %rsi
callq 0x15fc0
movq 0x18(%r14), %rax
cmpq %rax, 0x18(%rbx)
jbe 0xab8e
movq %rax, 0x18(%rbx)
movq 0x28(%r14), %rax
cmpq %rax, 0x28(%rbx)
jbe 0xab9c
movq %rax, 0x28(%rbx)
movq 0x20(%r14), %rax
cmpq %rax, 0x20(%rbx)
jae 0xabaa
movq %rax, 0x20(%rbx)
movq 0x30(%r14), %rax
cmpq %rax, 0x30(%rbx)
jae 0xabb8
movq %rax, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq