LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Matthias-Wandel[P]imgcomp/src/util.c
// Function: DestNameFromTime
static void DestNameFromTime(char * DestPath, const char * KeepPixDir, time_t PicTime, char * NameSuffix)
{
    struct tm tm;
    char * p;
    tm = *localtime(&PicTime);

    // %d  Day of month as decimal number (01 � 31)
    // %H	Hour in 24-hour format (00 � 23)
    // %j	Day of year as decimal number (001 � 366)
    // %m	Month as decimal number (01 � 12)
    // %M	Minute as decimal number (00 � 59)
    // %S	Second as decimal number (00 � 59)
    // %U	Week of year as decimal number, with Sunday as first day of week (00 � 53)
    // %w	Weekday as decimal number (0 � 6; Sunday is 0)
    // %y	Year without century, as decimal number (00 � 99)
    // %Y	Year with century, as decimal number

    p = DestPath+sprintf(DestPath, "%s/", KeepPixDir);

    // Using this rule, make a subdiretories for date and for hour.
    p += strftime(p, PATH_MAX, SaveNames, &tm);
    sprintf(p, "%s",NameSuffix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3060
movq %rax, %rsi
leaq -0x58(%rbp), %rdi
movl $0x38, %edx
callq 0x32c0
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x51cf(%rip), %rsi      # 0x11408
movb $0x0, %al
callq 0x3470
movl %eax, %ecx
movq -0x68(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
movl $0x1000, %esi           # imm = 0x1000
leaq 0x8950(%rip), %rdx      # 0x14bb0
leaq -0x58(%rbp), %rcx
callq 0x33f0
addq -0x60(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x3039(%rip), %rsi      # 0xf2b9
movb $0x0, %al
callq 0x3470
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
cmpl $0x0, 0xb115(%rip)      # 0x17b40
jne 0xca4a
movq 0x75bc(%rip), %rax      # 0x13ff0
movq (%rax), %rdi
leaq 0x4a76(%rip), %rsi      # 0x114b4
movb $0x0, %al
callq 0x3290
jmp 0xcb0a
leaq -0x22(%rbp), %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x31b0
movw $0x46c1, -0x22(%rbp)    # imm = 0x46C1
movl -0xc(%rbp), %eax
movw %ax, -0x20(%rbp)
movl -0x4(%rbp), %eax
movw %ax, -0x1e(%rbp)
movl -0x8(%rbp), %eax
movw %ax, -0x1c(%rbp)
movl -0x10(%rbp), %eax
movw %ax, -0x1a(%rbp)
movl $0xa, -0x18(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl 0xb0ad(%rip), %eax      # 0x17b40
jge 0xcb0a
movl 0xb0a9(%rip), %edi      # 0x17b44
movslq -0x18(%rbp), %rdx
movslq -0x28(%rbp), %rax
leaq 0xb0a6(%rip), %r8       # 0x17b50
shlq $0x4, %rax
addq %rax, %r8
leaq -0x22(%rbp), %rsi
xorl %ecx, %ecx
movl $0x10, %r9d
callq 0x31c0
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0xcad7
leaq 0x49f7(%rip), %rdi      # 0x114c9
callq 0x3430
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0xcafd
movq 0x74ea(%rip), %rax      # 0x13fd0
movq (%rax), %rdi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
leaq 0x49e5(%rip), %rsi      # 0x114db
movb $0x0, %al
callq 0x3290
jmp 0xcaff
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xca8a
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq $0x0, -0x10(%rbp)
cmpq $0x0, 0x2b48(%rip)      # 0x40f0
je 0x15f8
movq 0x2b3f(%rip), %rax      # 0x40f0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x15e6
cmpq $0x0, -0x10(%rbp)
je 0x15cc
movq -0x10(%rbp), %rdi
callq 0x1040
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x15b5
cmpq $0x0, -0x10(%rbp)
je 0x15f6
movq -0x10(%rbp), %rdi
callq 0x1040
jmp 0x15f8
callq 0x1170
movl 0x2add(%rip), %esi      # 0x40e0
leaq 0xa1a(%rip), %rdi       # 0x2024
movb $0x0, %al
callq 0x1090
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x18, %edi
callq 0x1120
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x164d
movl $0x1, %edi
callq 0x1160
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
cmpq $0x0, 0x2a8e(%rip)      # 0x40f8
je 0x167b
movq -0x10(%rbp), %rcx
movq 0x2a81(%rip), %rax      # 0x40f8
movq %rcx, 0x8(%rax)
movq 0x2a76(%rip), %rcx      # 0x40f8
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq %rax, 0x2a63(%rip)      # 0x40f8
cmpq $0x0, 0x2a53(%rip)      # 0x40f0
jne 0x16aa
movq -0x10(%rbp), %rax
movq %rax, 0x2a46(%rip)      # 0x40f0
cmpl $0x0, -0x8(%rbp)
je 0x16ef
cmpq $0x0, 0x2a38(%rip)      # 0x40f0
je 0x16ef
movq 0x2a2f(%rip), %rax      # 0x40f0
movq %rax, -0x18(%rbp)
movq 0x2a24(%rip), %rax      # 0x40f0
movq 0x8(%rax), %rax
movq %rax, 0x2a19(%rip)      # 0x40f0
movq 0x2a12(%rip), %rax      # 0x40f0
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rdi
callq 0x1040
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
xorl %eax, %eax
movq 0x28cf(%rip), %rcx      # 0x3fe0
cmpq (%rcx), %rax
je 0x172c
movq 0x28c3(%rip), %rax      # 0x3fe0
movq (%rax), %rax
movswl 0x4(%rax), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1736
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0xc(%rbp)
jmp 0x1736
movl -0xc(%rbp), %eax
movl %eax, -0x8(%rbp)
xorl %eax, %eax
movq 0x289b(%rip), %rcx      # 0x3fe0
cmpq (%rcx), %rax
je 0x1760
movq 0x288f(%rip), %rax      # 0x3fe0
movq (%rax), %rax
movswl 0x6(%rax), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x176a
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x10(%rbp)
jmp 0x176a
movl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
movq 0x2869(%rip), %rax      # 0x3fe0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
callq 0x1100
movl -0x8(%rbp), %ecx
subl $0x2, %ecx
movslq %ecx, %rcx
cqto
idivq %rcx
addq $0x1, %rdx
movl %edx, %eax
movl %eax, -0x14(%rbp)
callq 0x1100
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x4(%rbp), %ecx
subl $0x2, %ecx
movslq %ecx, %rcx
cqto
idivq %rcx
addq $0x1, %rdx
callq 0x1130
movq 0x281c(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x1110
cmpl $0x20, %eax
jne 0x1770
xorl %eax, %eax
movq 0x2806(%rip), %rcx      # 0x3fe0
cmpq (%rcx), %rax
je 0x17f1
movq 0x27fa(%rip), %rax      # 0x3fe0
movq (%rax), %rax
movswl (%rax), %eax
movl %eax, -0x24(%rbp)
jmp 0x17fb
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x24(%rbp)
jmp 0x17fb
movl -0x24(%rbp), %eax
movl %eax, 0x28fc(%rip)      # 0x4100
xorl %eax, %eax
movq 0x27d3(%rip), %rcx      # 0x3fe0
cmpq (%rcx), %rax
je 0x1825
movq 0x27c7(%rip), %rax      # 0x3fe0
movq (%rax), %rax
movswl 0x2(%rax), %eax
movl %eax, -0x28(%rbp)
jmp 0x182f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x28(%rbp)
jmp 0x182f
movl -0x28(%rbp), %eax
movl %eax, 0x28cc(%rip)      # 0x4104
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x2791(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x1030
movq 0x2782(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
movl $0x7c, %edx
movl $0x2d, %r8d
xorl %r9d, %r9d
movl %edx, %esi
movl %r8d, %ecx
movl $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
callq 0x1060
movl 0x284e(%rip), %eax      # 0x40e4
movl %eax, -0x4(%rbp)
movl 0x2849(%rip), %eax      # 0x40e8
movl %eax, -0x8(%rbp)
movq 0x284f(%rip), %rax      # 0x40f8
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1949
movq 0x2721(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
movl -0x4(%rbp), %esi
movl -0x8(%rbp), %edx
callq 0x1130
cmpl $-0x1, %eax
jne 0x18d4
jmp 0x18e8
movq 0x2705(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
movl $0x23, %esi
callq 0x1150
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x18(%rbp)
subq $0x3, %rax
ja 0x1936
movq -0x18(%rbp), %rax
leaq 0x711(%rip), %rcx       # 0x2014
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x1936
movl -0x4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x1936
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1936
movl -0x8(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1938
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x18ad
movq 0x2690(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
movl 0x27a7(%rip), %esi      # 0x4100
movl 0x27a5(%rip), %edx      # 0x4104
callq 0x1130
cmpl $-0x1, %eax
jne 0x196b
jmp 0x197f
movq 0x266e(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
movl $0x40, %esi
callq 0x1150
movq 0x265a(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
movl 0x2755(%rip), %esi      # 0x40e4
movl 0x2753(%rip), %edx      # 0x40e8
callq 0x1130
movq 0x263f(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x10b0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/dwelch67[P]lc3/lc3sim.c
// Function: docc
void docc ( unsigned short x)
{
    psr&=0x8000;
    if(x&0x8000)
    {
        psr|=(1<<2);
    }
    else
    {
        if(x==0)
        {
            psr|=(1<<1);
        }
        else
        {
            psr|=(1<<0);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %di, %ax
movw %ax, -0x2(%rbp)
movzwl 0x2dfe(%rip), %eax      # 0x4080
andl $0x8000, %eax           # imm = 0x8000
movw %ax, 0x2df2(%rip)       # 0x4080
movzwl -0x2(%rbp), %eax
andl $0x8000, %eax           # imm = 0x8000
cmpl $0x0, %eax
je 0x12af
movzwl 0x2ddd(%rip), %eax      # 0x4080
orl $0x4, %eax
movw %ax, 0x2dd3(%rip)       # 0x4080
jmp 0x12de
movzwl -0x2(%rbp), %eax
cmpl $0x0, %eax
jne 0x12cb
movzwl 0x2dc1(%rip), %eax      # 0x4080
orl $0x2, %eax
movw %ax, 0x2db7(%rip)       # 0x4080
jmp 0x12dc
movzwl 0x2dae(%rip), %eax      # 0x4080
orl $0x1, %eax
movw %ax, 0x2da4(%rip)       # 0x4080
jmp 0x12de
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/dwelch67[P]lc3/lc3sim.c
// Function: reset
void reset ( void )
{
    pc=0x3000;
    psr=2;
    reg[0]=0x1234;
    reg[1]=0x1234;
    reg[2]=0x1234;
    reg[3]=0x1234;
    reg[4]=0x1234;
    reg[5]=0x1234;
    reg[6]=0x1234;
    reg[7]=0x1234;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw $0x3000, 0x22633(%rip)  # imm = 0x3000
movw $0x2, 0x261a(%rip)      # 0x4080
movw $0x1234, 0x22631(%rip)  # imm = 0x1234
movw $0x1234, 0x2262a(%rip)  # imm = 0x1234
movw $0x1234, 0x22623(%rip)  # imm = 0x1234
movw $0x1234, 0x2261c(%rip)  # imm = 0x1234
movw $0x1234, 0x22615(%rip)  # imm = 0x1234
movw $0x1234, 0x2260e(%rip)  # imm = 0x1234
movw $0x1234, 0x22607(%rip)  # imm = 0x1234
movw $0x1234, 0x22600(%rip)  # imm = 0x1234
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0x1b40
movq 0x24d5(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x558(%rip), %rsi       # 0x2085
movb $0x0, %al
callq 0x1070
movl $0x1, -0x4(%rbp)
jmp 0x1bcf
leaq 0x2549(%rip), %rdi      # 0x4090
movl $0xdd, %esi
movl $0x20000, %edx          # imm = 0x20000
callq 0x1050
callq 0x1a50
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x534(%rip), %rsi       # 0x209e
callq 0x1080
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1ba3
movq 0x2477(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x50e(%rip), %rsi       # 0x20a1
movb $0x0, %al
callq 0x1070
movl $0x1, -0x4(%rbp)
jmp 0x1bcf
movq -0x18(%rbp), %rdi
callq 0x1be0
cmpl $0x0, %eax
je 0x1bba
movl $0x1, -0x4(%rbp)
jmp 0x1bcf
movq -0x18(%rbp), %rdi
callq 0x1030
callq 0x12e0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xe21(%rip), %rdi       # 0x2010
callq 0x1030
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
je 0x1230
movq -0x8(%rbp), %rdi
leaq 0xe14(%rip), %rsi       # 0x201d
callq 0x1090
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x121b
jmp 0x1230
movq -0x10(%rbp), %rdi
callq 0x10a0
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x2e50(%rip)     # 0x4080
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1060
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x1260
jmp 0x127f
leaq 0xdb8(%rip), %rdi       # 0x201f
leaq 0xdb9(%rip), %rsi       # 0x2027
movl $0x20, %edx
leaq 0xdb6(%rip), %rcx       # 0x2030
callq 0x1070
cvtsi2sdq -0x10(%rbp), %xmm0
cvtsi2sdq -0x8(%rbp), %xmm1
movsd 0xd75(%rip), %xmm2      # 0x2008
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x2020, %rsp           # imm = 0x2020
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x11e0
callq 0x1240
movsd %xmm0, -0x2018(%rbp)
callq 0x1240
movaps %xmm0, %xmm1
subsd -0x2018(%rbp), %xmm1
movsd 0x2d8d(%rip), %xmm0     # 0x4080
ucomisd %xmm1, %xmm0
jbe 0x1305
movl $0x1, %edi
callq 0x10d0
jmp 0x12db
callq 0x1240
movsd %xmm0, -0x2020(%rbp)
leaq -0x2010(%rbp), %rdi
leaq 0xd29(%rip), %rsi       # 0x2049
movb $0x0, %al
callq 0x10b0
leaq -0x2010(%rbp), %rdi
leaq -0x2010(%rbp), %rdx
leaq 0xd31(%rip), %rsi       # 0x206d
movb $0x0, %al
callq 0x10b0
leaq -0x2010(%rbp), %rdi
leaq -0x2010(%rbp), %rdx
movsd -0x2020(%rbp), %xmm0
subsd -0x2018(%rbp), %xmm0
leaq 0xd40(%rip), %rsi       # 0x20a8
movb $0x1, %al
callq 0x10b0
leaq -0x2010(%rbp), %rdi
callq 0x1040
movq %rax, %rsi
leaq 0xd46(%rip), %rdi       # 0x20cb
movb $0x0, %al
callq 0x1050
leaq 0xd4e(%rip), %rdi       # 0x20e1
movb $0x0, %al
callq 0x1050
leaq -0x2010(%rbp), %rsi
leaq 0xd55(%rip), %rdi       # 0x20fd
movb $0x0, %al
callq 0x1050
movq 0x2c2a(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x1080
xorl %edi, %edi
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
cmpl $0x0, 0x1002ca(%rip)    # 0x1072c4
je 0x702b
movq -0x8(%rbp), %rax
cmpl $0x1388, 0x18(%rax)     # imm = 0x1388
jle 0x702b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
leaq 0xd0483(%rip), %rdi     # 0xd74a2
movl $0x1388, %esi           # imm = 0x1388
movb $0x0, %al
callq 0x35d40
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x50(%rbp)
movl 0xfe725(%rip), %eax     # 0x10576c
movl %eax, -0x4c(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq 0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl 0x100264(%rip), %eax    # 0x1072c4
movl %eax, -0x34(%rbp)
leaq 0xd041a(%rip), %rdi     # 0xd7484
callq 0x49d80
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movl -0x50(%rbp), %edx
movl -0x4c(%rbp), %ecx
movq -0x48(%rbp), %r8
movq -0x40(%rbp), %r9
movl -0x34(%rbp), %r10d
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x144a0
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
xorl %edi, %edi
callq 0x3dc20
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x24(%rbp), %rcx
callq 0xf080
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x8(%rbp), %rdx
movl 0xfe67d(%rip), %r8d     # 0x10576c
movq -0x20(%rbp), %r9
xorl %ecx, %ecx
callq 0x12480
leaq -0x38(%rbp), %rdi
callq 0xe5f0
leaq -0x30(%rbp), %rdi
callq 0x3dd90
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
cmpl $0x0, 0x100181(%rip)    # 0x1072ac
jle 0x7172
movl 0xfe82d(%rip), %eax     # 0x105960
addl $-0x1, %eax
movl %eax, 0xfe824(%rip)     # 0x105960
cmpl $0x0, %eax
jg 0x7170
movq 0xfde68(%rip), %rax     # 0x104fb0
movq (%rax), %rsi
movl $0x2e, %edi
callq 0x6910
movq 0xfde54(%rip), %rax     # 0x104fb0
movq (%rax), %rdi
callq 0x6850
movl 0x100142(%rip), %eax    # 0x1072ac
movl %eax, 0xfe7f0(%rip)     # 0x105960
jmp 0x7172
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
callq 0x7120
cmpl $0x0, -0x1c(%rbp)
je 0x71c5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq 0x10(%rbp), %rcx
callq 0x70a0
jmp 0x7244
movq -0x28(%rbp), %rcx
movq 0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
movq 0x10(%rbp), %rax
xorl %ecx, %ecx
movq %rax, (%rsp)
callq 0x6fd0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x18(%rax), %rsi
callq 0x33300
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
movq 0x10(%rbp), %rax
movl $0x1, %ecx
movq %rax, (%rsp)
callq 0x6fd0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x18(%rax), %rsi
callq 0x33300
movq 0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x17600
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x28, %edx
callq 0x6570
cmpl $0x0, 0x100021(%rip)    # 0x1072c0
je 0x72ad
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x34480
cmpl $0x0, 0x100004(%rip)    # 0x1072b8
jne 0x72bf
cmpl $0x0, 0xfffff(%rip)     # 0x1072bc
je 0x72f9
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x342f0
movl %eax, -0x20(%rbp)
cmpl $0x0, 0xfffe7(%rip)     # 0x1072bc
je 0x72f7
movl -0x20(%rbp), %edx
movq -0x10(%rbp), %rax
movl 0x18(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x18(%rax)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl -0x20(%rbp), %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
jmp 0x72f9
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
movl $0x2, %edi
leaq 0xd395f(%rip), %rsi     # 0xdac90
movb $0x0, %al
callq 0x60040
cmpl $0x0, -0xc(%rbp)
je 0x7354
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x18(%rax), %esi
callq 0x374d0
jmp 0x7395
cmpl $0x0, -0x10(%rbp)
je 0x7381
cmpl $0x0, -0x14(%rbp)
je 0x7374
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x18(%rax), %esi
callq 0x2dce0
movq -0x8(%rbp), %rdi
callq 0x32c70
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x18(%rax), %esi
callq 0x37540
movq -0x8(%rbp), %rax
cmpl $0x4c4b40, 0x18(%rax)   # imm = 0x4C4B40
jle 0x73bf
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x8(%rbp), %rax
movl 0x18(%rax), %edx
leaq 0xd0195(%rip), %rdi     # 0xd754d
movb $0x0, %al
callq 0x358e0
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x80, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
cmpq $0x0, 0xffeee(%rip)     # 0x1072f0
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x34(%rbp)
xorl %eax, %eax
cmpq $0x0, 0xffed9(%rip)     # 0x1072f0
movb %al, -0x69(%rbp)
je 0x743a
movq 0xffecd(%rip), %rdi     # 0x1072f0
leaq 0xd0159(%rip), %rsi     # 0xd7583
callq 0x2b9f0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x69(%rbp)
movb -0x69(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x34(%rbp), %edx
movl -0x38(%rbp), %ecx
callq 0x7300
movq %rax, -0x40(%rbp)
leaq -0x68(%rbp), %rdi
movl $0x28, %esi
callq 0x7500
movq -0x8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x7260
cmpl $0x1, 0xffe5b(%rip)     # 0x1072d8
je 0x7488
cmpl $0x4, 0xffe52(%rip)     # 0x1072d8
jne 0x749e
movq -0x58(%rbp), %rdi
movl -0x50(%rbp), %esi
movl $0x75, %edx
movl $0x74, %ecx
callq 0x2e210
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0xc(%rbp), %ecx
movq -0x28(%rbp), %r8
movq -0x40(%rbp), %r9
movq 0x18(%rbp), %rax
leaq -0x68(%rbp), %rdi
movq %rax, (%rsp)
callq 0x7180
movq -0x8(%rbp), %rax
movslq 0x18(%rax), %rcx
movq -0x30(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq 0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
leaq -0x40(%rbp), %rdi
callq 0x23ad0
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x30(%rbp)
xorl %edi, %edi
movl $0x1, %esi
callq 0x398a0
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x7c82
movq -0x28(%rbp), %rdi
callq 0x1a4b0
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x38(%rbp), %rdx
callq 0x39400
movq -0x38(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x7cd0
movl $0x0, -0x1c(%rbp)
cmpl $0x3, -0x1c(%rbp)
jge 0x7c73
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x38(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rsi
callq 0x7cd0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7c41
jmp 0x7c75
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x7c04
leaq -0x30(%rbp), %rdi
callq 0x2aad0
movl $0x0, -0x1c(%rbp)
cmpl $0x3, -0x1c(%rbp)
jge 0x7cb7
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x2aad0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7c92
movq -0x40(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq 0x10(%rbp), %rax
movl $0x1, 0x28(%rax)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jg 0x7e00
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x2c(%rbp), %ecx
movl -0x1c(%rbp), %r8d
cmpl $0x0, -0x20(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %r9d
movl 0xfd9a6(%rip), %r10d    # 0x10576c
movq 0x10(%rbp), %rax
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x14ba0
cmpl $0x0, -0x20(%rbp)
je 0x7df3
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x18(%rax), %rsi
callq 0x33300
jmp 0x7df5
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x7d95
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x40(%rbp)
movq -0x30(%rbp), %rcx
xorl %eax, %eax
cmpq -0x18(%rbp), %rcx
movb %al, -0x41(%rbp)
jae 0x9734
movq -0x38(%rbp), %rax
cmpq -0x28(%rbp), %rax
setb %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x9740
jmp 0x9818
movq -0x30(%rbp), %rax
movb (%rax), %al
movb %al, -0x39(%rbp)
movq -0x38(%rbp), %rax
movb (%rax), %al
movb %al, -0x3a(%rbp)
movsbl -0x39(%rbp), %eax
movsbl -0x3a(%rbp), %ecx
cmpl %ecx, %eax
je 0x97f0
movsbl -0x39(%rbp), %eax
cmpl $0x6e, %eax
jne 0x97a9
cmpl $0x0, 0xfdb8e(%rip)     # 0x107300
jne 0x97f0
movq -0x30(%rbp), %rax
addq $0x3, %rax
cmpq -0x18(%rbp), %rax
jae 0x97f0
movq -0x30(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x6e, %eax
jne 0x97f0
movq -0x30(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x6e, %eax
jne 0x97f0
movq -0x30(%rbp), %rax
movsbl 0x3(%rax), %eax
cmpl $0x6e, %eax
jne 0x97f0
movsbl -0x3a(%rbp), %eax
cmpl $0x6e, %eax
jne 0x9811
cmpl $0x0, 0xfdb47(%rip)     # 0x107300
jne 0x97f0
movq -0x38(%rbp), %rax
addq $0x3, %rax
cmpq -0x28(%rbp), %rax
jae 0x97f0
movq -0x38(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x6e, %eax
jne 0x97f0
movq -0x38(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x6e, %eax
jne 0x97f0
movq -0x38(%rbp), %rax
movsbl 0x3(%rax), %eax
cmpl $0x6e, %eax
je 0x9811
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movl $0x1, -0x40(%rbp)
jmp 0x9813
jmp 0x9818
jmp 0x9717
movq -0x30(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movl -0x40(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
addq $-0x1, %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x40(%rbp)
movq -0x30(%rbp), %rcx
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0x41(%rbp)
jb 0x989c
movq -0x38(%rbp), %rax
cmpq -0x20(%rbp), %rax
setae %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x98a8
jmp 0x9980
movq -0x30(%rbp), %rax
movb (%rax), %al
movb %al, -0x39(%rbp)
movq -0x38(%rbp), %rax
movb (%rax), %al
movb %al, -0x3a(%rbp)
movsbl -0x39(%rbp), %eax
movsbl -0x3a(%rbp), %ecx
cmpl %ecx, %eax
je 0x9958
movsbl -0x39(%rbp), %eax
cmpl $0x6e, %eax
jne 0x9911
cmpl $0x0, 0xfda26(%rip)     # 0x107300
jne 0x9958
movq -0x30(%rbp), %rax
addq $-0x3, %rax
cmpq -0x10(%rbp), %rax
jb 0x9958
movq -0x30(%rbp), %rax
movsbl -0x1(%rax), %eax
cmpl $0x6e, %eax
jne 0x9958
movq -0x30(%rbp), %rax
movsbl -0x2(%rax), %eax
cmpl $0x6e, %eax
jne 0x9958
movq -0x30(%rbp), %rax
movsbl -0x3(%rax), %eax
cmpl $0x6e, %eax
jne 0x9958
movsbl -0x3a(%rbp), %eax
cmpl $0x6e, %eax
jne 0x9979
cmpl $0x0, 0xfd9df(%rip)     # 0x107300
jne 0x9958
movq -0x38(%rbp), %rax
addq $-0x3, %rax
cmpq -0x20(%rbp), %rax
jb 0x9958
movq -0x38(%rbp), %rax
movsbl -0x1(%rax), %eax
cmpl $0x6e, %eax
jne 0x9958
movq -0x38(%rbp), %rax
movsbl -0x2(%rax), %eax
cmpl $0x6e, %eax
jne 0x9958
movq -0x38(%rbp), %rax
movsbl -0x3(%rax), %eax
cmpl $0x6e, %eax
je 0x9979
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x38(%rbp)
movl $0x1, -0x40(%rbp)
jmp 0x997b
jmp 0x9980
jmp 0x987f
movq -0x30(%rbp), %rcx
addq $0x1, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rcx
addq $0x1, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movl -0x40(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb (%rax), %al
movb %al, -0x2d(%rbp)
movl -0x2c(%rbp), %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movl -0x2c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x9a53
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movsbl (%rax), %eax
movsbl -0x2d(%rbp), %ecx
cmpl %ecx, %eax
jne 0x9a51
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movslq -0x2c(%rbp), %rdx
callq 0x62d0
cmpl $0x0, %eax
jne 0x9a51
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x9a5b
jmp 0x9a09
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x30(%rbp)
movsd 0xcdc1e(%rip), %xmm0    # 0xd7888
movsd %xmm0, -0x38(%rbp)
movl -0x30(%rbp), %eax
imull -0x2c(%rbp), %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x40(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x9ce4
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
movl %eax, %esi
movq 0x10(%rbp), %rdx
callq 0x9cf0
mulsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd 0xcdbca(%rip), %xmm0    # 0xd7888
ucomisd -0x48(%rbp), %xmm0
jbe 0x9cd4
movsd -0x48(%rbp), %xmm0
mulsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
jmp 0x9cd6
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x9c7f
movsd -0x38(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/jkOwnLib/fuzzyFind.c
// Function: oligoProb
static double oligoProb(DNA *oligo, int size, double freq[4])
{
double prob = 1.0;
int i;
int baseVal;

for (i=0; i<size; ++i)
    {
    if ((baseVal = ntVal[(int)oligo[i]]) >= 0)
        prob *= freq[baseVal];
    }
return prob;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movsd 0xcdb81(%rip), %xmm0    # 0xd7888
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x9d60
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movslq %eax, %rcx
leaq 0xfdb6f(%rip), %rax     # 0x1078a0
movl (%rax,%rcx,4), %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, %eax
jl 0x9d53
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
mulsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x9d55
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x9d13
movsd -0x20(%rbp), %xmm0
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/jkOwnLib/fuzzyFind.c
// Function: ffUnlink
void ffUnlink(struct ffAli **pList, struct ffAli *el)
/* Unlink element from doubly linked list. If leftmost
 * element update list pointer. */
{
struct ffAli *list = *pList;
struct ffAli *right = el->right;
struct ffAli *left = el->left;

if (el == list)    /* If first element need to update list. */
    *pList = right;
if (right != NULL)
    right->left = left;
if (left != NULL)
    left->right = right;
el->left = el->right = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x9db3
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0x9dc5
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x9dd8
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/jkOwnLib/fuzzyFind.c
// Function: cmpProtoSize
int cmpProtoSize(const void *va, const void *vb)
/* Sort biggest size first. */
{
const struct protoGene *a = *((struct protoGene **)va);
const struct protoGene *b = *((struct protoGene **)vb);
int aSize, bSize;
aSize = a->nEnd - a->nStart;
bSize = b->nEnd - b->nStart;
return (bSize - aSize);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x28(%rcx), %rcx
subq %rcx, %rax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x28(%rcx), %rcx
subq %rcx, %rax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
subl -0x24(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9d70
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
movq -0x18(%rbp), %rsi
addq $0x10, %rsi
callq 0x1a870
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jbe 0xa2c8
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jbe 0xa2ea
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0xa30c
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x30(%rcx), %rax
jae 0xa32e
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)