LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/Matthias-Wandel[P]imgcomp/src/jpeg2mem.c
// Function: WritePpmFile
void WritePpmFile(char * FileName, MemImage_t *MemImage)
{
    FILE * outfile;
    outfile = fopen(FileName,"wb");
    if (outfile == NULL){
        fprintf(Log,"could not open outfile\n");
        return;
    }
    fprintf(outfile, "P%c\n%d %d\n%d\n", MemImage->components == 3 ? '6' : '5',  
            MemImage->width, MemImage->height, 255);
    fwrite(MemImage->pixels, 1, MemImage->width * MemImage->height*MemImage->components, outfile);
    fclose(outfile);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
leaq 0x5bcf(%rip), %rsi      # 0xcb03
callq 0x3440
testq %rax, %rax
je 0x6f9d
movq %rax, %rbx
xorl %edx, %edx
cmpl $0x3, 0x8(%r14)
sete %dl
addl $0x35, %edx
movl (%r14), %ecx
movl 0x4(%r14), %r8d
leaq 0x5bc2(%rip), %rsi      # 0xcb1e
movq %rax, %rdi
movl $0xff, %r9d
xorl %eax, %eax
callq 0x32a0
leaq 0xc(%r14), %rdi
movslq (%r14), %rax
movslq 0x4(%r14), %rcx
imulq %rax, %rcx
movslq 0x8(%r14), %rdx
imulq %rcx, %rdx
pushq $0x1
popq %rsi
movq %rbx, %rcx
callq 0x34b0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3110
leaq 0xc024(%rip), %rax      # 0x12fc8
movq (%rax), %rcx
leaq 0x5b58(%rip), %rdi      # 0xcb06
pushq $0x17
popq %rsi
pushq $0x1
popq %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x34b0
// File: /workspace/github_c_makefile_star2_O2/Matthias-Wandel[P]imgcomp/src/jpgfile.c
// Function: ErrNonfatal
void ErrNonfatal(const char * msg, int a1, int a2)
{
    if (SupressNonFatalErrors) return;

    fprintf(Log,"\nNonfatal Error : ");
    fprintf(Log, msg, a1, a2);
    fprintf(Log, "\n");
}

// Assembly:
cmpl $0x0, 0xc49d(%rip)      # 0x13464
je 0x6fca
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
leaq 0xbfe9(%rip), %r15      # 0x12fc8
movq (%r15), %rcx
leaq 0x5b43(%rip), %rdi      # 0xcb2c
pushq $0x12
popq %rsi
pushq $0x1
popq %rdx
callq 0x34b0
movq (%r15), %rdi
movq %r14, %rsi
movl %ebp, %edx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x32a0
movq (%r15), %rsi
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3200
// File: /workspace/github_c_makefile_star2_O2/Matthias-Wandel[P]imgcomp/src/exif.c
// Function: Get32s
int Get32s(void * Long)
{
    if (MotorolaOrder){
        return  ((( char *)Long)[0] << 24) | (((uchar *)Long)[1] << 16)
              | (((uchar *)Long)[2] << 8 ) | (((uchar *)Long)[3] << 0 );
    }else{
        return  ((( char *)Long)[3] << 24) | (((uchar *)Long)[2] << 16)
              | (((uchar *)Long)[1] << 8 ) | (((uchar *)Long)[0] << 0 );
    }
}

// Assembly:
cmpl $0x0, 0xd20d(%rip)      # 0x1452c
je 0x733f
movzbl (%rdi), %eax
shll $0x18, %eax
movzbl 0x1(%rdi), %edx
shll $0x10, %edx
orl %eax, %edx
movzbl 0x2(%rdi), %ecx
shll $0x8, %ecx
orl %edx, %ecx
addq $0x3, %rdi
jmp 0x7358
movzbl 0x3(%rdi), %eax
shll $0x18, %eax
movzbl 0x2(%rdi), %edx
shll $0x10, %edx
orl %eax, %edx
movzbl 0x1(%rdi), %ecx
shll $0x8, %ecx
orl %edx, %ecx
movzbl (%rdi), %eax
orl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/Matthias-Wandel[P]imgcomp/src/exif.c
// Function: Put32u
void Put32u(void * Value, unsigned PutValue)
{
    if (MotorolaOrder){
        ((uchar *)Value)[0] = (uchar)(PutValue>>24);
        ((uchar *)Value)[1] = (uchar)(PutValue>>16);
        ((uchar *)Value)[2] = (uchar)(PutValue>>8);
        ((uchar *)Value)[3] = (uchar)PutValue;
    }else{
        ((uchar *)Value)[0] = (uchar)PutValue;
        ((uchar *)Value)[1] = (uchar)(PutValue>>8);
        ((uchar *)Value)[2] = (uchar)(PutValue>>16);
        ((uchar *)Value)[3] = (uchar)(PutValue>>24);
    }
}

// Assembly:
movl %esi, %eax
shrl $0x10, %eax
cmpl $0x0, 0xd1c2(%rip)      # 0x1452c
je 0x737a
movl %esi, %ecx
shrl $0x18, %ecx
movl %eax, %edx
movl %esi, %eax
shrl $0x8, %eax
jmp 0x7384
movl %esi, %edx
shrl $0x8, %edx
movl %esi, %ecx
shrl $0x18, %esi
movb %cl, (%rdi)
movb %dl, 0x1(%rdi)
movb %al, 0x2(%rdi)
movb %sil, 0x3(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/Matthias-Wandel[P]imgcomp/src/exif.c
// Function: ConvertAnyFormat
double ConvertAnyFormat(void * ValuePtr, int Format)
{
    double Value;
    Value = 0;

    switch(Format){
        case FMT_SBYTE:     Value = *(signed char *)ValuePtr;  break;
        case FMT_BYTE:      Value = *(uchar *)ValuePtr;        break;

        case FMT_USHORT:    Value = Get16u(ValuePtr);          break;
        case FMT_ULONG:     Value = Get32u(ValuePtr);          break;

        case FMT_URATIONAL:
        case FMT_SRATIONAL: 
            {
                int Num,Den;
                Num = Get32s(ValuePtr);
                Den = Get32s(4+(char *)ValuePtr);
                if (Den == 0){
                    Value = 0;
                }else{
                    if (Format == FMT_SRATIONAL){
                        Value = (double)Num/Den;
                    }else{
                        Value = (double)(unsigned)Num/(double)(unsigned)Den;
                    }
                }
                break;
            }

        case FMT_SSHORT:    Value = (signed short)Get16u(ValuePtr);  break;
        case FMT_SLONG:     Value = Get32s(ValuePtr);                break;

        // Not sure if this is correct (never seen float used in Exif format)
        case FMT_SINGLE:    Value = (double)*(float *)ValuePtr;      break;
        case FMT_DOUBLE:    Value = *(double *)ValuePtr;             break;

        default:
            ErrNonfatal("Illegal format code %d in Exif header",Format,0);
    }
    return Value;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
leal -0x1(%r14), %eax
cmpl $0xb, %eax
ja 0x75b1
movq %rdi, %rbx
leaq 0x5717(%rip), %rcx      # 0xcc60
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
callq 0x7318
movl %eax, %ebp
addq $0x4, %rbx
movq %rbx, %rdi
callq 0x7318
testl %eax, %eax
je 0x75c2
cmpl $0xa, %r14d
jne 0x75ed
cvtsi2sd %ebp, %xmm0
cvtsi2sd %eax, %xmm1
jmp 0x75fb
movsbl (%rbx), %eax
jmp 0x760a
movq %rbx, %rdi
callq 0x7318
movl %eax, %eax
cvtsi2sd %rax, %xmm0
jmp 0x760e
cmpl $0x0, 0xcf90(%rip)      # 0x1452c
je 0x7601
movzwl (%rbx), %eax
rolw $0x8, %ax
jmp 0x7604
movq %rbx, %rdi
callq 0x7318
jmp 0x760a
leaq 0x58af(%rip), %rdi      # 0xce67
movl %r14d, %esi
xorl %edx, %edx
callq 0x6fc0
xorps %xmm0, %xmm0
jmp 0x760e
movzbl (%rbx), %eax
jmp 0x760a
cmpl $0x0, 0xcf59(%rip)      # 0x1452c
je 0x7607
movzwl (%rbx), %eax
rolw $0x8, %ax
movzwl %ax, %eax
jmp 0x760a
movsd (%rbx), %xmm0
jmp 0x760e
cvtss2sd (%rbx), %xmm0
jmp 0x760e
movl %ebp, %ecx
cvtsi2sd %rcx, %xmm0
movl %eax, %eax
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
jmp 0x760e
movzwl (%rbx), %eax
cwtl
jmp 0x760a
movzwl (%rbx), %eax
cvtsi2sd %eax, %xmm0
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Matthias-Wandel[P]imgcomp/src/exif.c
// Function: Exif2tm
int Exif2tm(struct tm * timeptr, char * ExifTime)
{
    int a;

    timeptr->tm_wday = -1;

    // Check for format: YYYY:MM:DD HH:MM:SS format.
    // Date and time normally separated by a space, but also seen a ':' there, so
    // skip the middle space with '%*c' so it can be any character.
    timeptr->tm_sec = 0;
    a = sscanf(ExifTime, "%d%*c%d%*c%d%*c%d:%d:%d",
            &timeptr->tm_year, &timeptr->tm_mon, &timeptr->tm_mday,
            &timeptr->tm_hour, &timeptr->tm_min, &timeptr->tm_sec);

    if (a >= 5){
        if (timeptr->tm_year <= 12 && timeptr->tm_mday > 2000 && ExifTime[2] == '.'){
            // LG Electronics VX-9700 seems to encode the date as 'MM.DD.YYYY HH:MM'
            // can't these people read the standard?  At least they left enough room
            // in the header to put an Exif format date in there.
            int tmp;
            tmp = timeptr->tm_year;
            timeptr->tm_year = timeptr->tm_mday;
            timeptr->tm_mday = timeptr->tm_mon;
            timeptr->tm_mon = tmp;
        }

        // Accept five or six parameters.  Some cameras do not store seconds.
        timeptr->tm_isdst = -1;  
        timeptr->tm_mon -= 1;      // Adjust for unix zero-based months 
        timeptr->tm_year -= 1900;  // Adjust for year starting at 1900 
        return TRUE; // worked. 
    }

    return FALSE; // Wasn't in Exif date format.
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
orl $-0x1, 0x18(%rdi)
andl $0x0, (%rdi)
leaq 0x14(%rdi), %r13
leaq 0x10(%rdi), %r14
leaq 0xc(%rdi), %r12
leaq 0x8(%rdi), %r9
leaq 0x4(%rdi), %r10
leaq 0x4e3c(%rip), %rsi      # 0xcf4c
xorl %ebp, %ebp
movq %r15, %rdi
movq %r13, %rdx
movq %r14, %rcx
movq %r12, %r8
xorl %eax, %eax
pushq %rbx
pushq %r10
callq 0x3380
addq $0x10, %rsp
cmpl $0x5, %eax
jl 0x816c
movl (%r13), %ecx
cmpl $0xc, %ecx
jg 0x8158
movl (%r12), %eax
cmpl $0x7d1, %eax            # imm = 0x7D1
jl 0x8158
cmpb $0x2e, 0x2(%r15)
jne 0x8158
movl (%r14), %edx
movl %edx, (%r12)
movl %ecx, (%r14)
jmp 0x815a
movl %ecx, %eax
orl $-0x1, 0x20(%rbx)
decl 0x10(%rbx)
addl $0xfffff894, %eax       # imm = 0xFFFFF894
movl %eax, 0x14(%rbx)
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Matthias-Wandel[P]imgcomp/src/exif.c
// Function: ShowConciseImageInfo
void ShowConciseImageInfo(void)
{
    printf("\"%s\"",ImageInfo.FileName);

    printf(" %dx%d",ImageInfo.Width, ImageInfo.Height);

    if (ImageInfo.ExposureTime){
        if (ImageInfo.ExposureTime <= 0.5){
            printf(" (1/%d)",(int)(0.5 + 1/ImageInfo.ExposureTime));
        }else{
            printf(" (%1.1f)",ImageInfo.ExposureTime);
        }
    }

    if (ImageInfo.ApertureFNumber){
        printf(" f/%3.1f",(double)ImageInfo.ApertureFNumber);
    }

    if (ImageInfo.FocalLength35mmEquiv){
        printf(" f(35)=%dmm",ImageInfo.FocalLength35mmEquiv);
    }

    if (ImageInfo.FlashUsed >= 0 && ImageInfo.FlashUsed & 1){
        printf(" (flash)");
    }

    printf("\n");
}

// Assembly:
pushq %rbx
leaq 0x2ad9(%rip), %rdi      # 0xb1ab
leaq 0xad8f(%rip), %rbx      # 0x13468
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3170
movl 0x1064(%rbx), %edx
movl 0x1068(%rbx), %esi
leaq 0x4ca9(%rip), %rdi      # 0xd39f
xorl %eax, %eax
callq 0x3170
movss 0x1080(%rbx), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x870f
jnp 0x875d
movss 0x4711(%rip), %xmm1     # 0xce28
ucomiss %xmm0, %xmm1
jae 0x8730
cvtss2sd %xmm0, %xmm0
leaq 0x4c7f(%rip), %rdi      # 0xd3a6
movb $0x1, %al
callq 0x3170
jmp 0x875a
movss 0x46ec(%rip), %xmm1     # 0xce24
divss %xmm0, %xmm1
cvtss2sd %xmm1, %xmm0
addsd 0x3fb0(%rip), %xmm0     # 0xc6f8
cvttsd2si %xmm0, %esi
leaq 0x4ba9(%rip), %rdi      # 0xd2fc
xorl %eax, %eax
callq 0x3170
xorps %xmm1, %xmm1
movss 0x1084(%rbx), %xmm0
ucomiss %xmm1, %xmm0
jne 0x876c
jnp 0x877e
cvtss2sd %xmm0, %xmm0
leaq 0x4c38(%rip), %rdi      # 0xd3af
movb $0x1, %al
callq 0x3170
movl 0x1094(%rbx), %esi
testl %esi, %esi
je 0x8796
leaq 0x4c29(%rip), %rdi      # 0xd3b8
xorl %eax, %eax
callq 0x3170
movl $0x80000001, %eax       # imm = 0x80000001
andl 0x1078(%rbx), %eax
cmpl $0x1, %eax
jne 0x87b4
leaq 0x4c17(%rip), %rdi      # 0xd3c4
xorl %eax, %eax
callq 0x3170
pushq $0xa
popq %rdi
popq %rbx
jmp 0x3050
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/Matthias-Wandel[P]imgcomp/src/start_camera_prog.c
// Function: do_launch_program
static pid_t do_launch_program(char * cmd_string)
{
    char * Arguments[51];
    int narg;
    int a;
    int wasblank = 1;

    // Note: NOT handling quoted strings or anything for arguments with spaces in them.
    narg=0;
    for (a=0;cmd_string[a];a++){
        if (cmd_string[a] != ' '){
            if (wasblank){
                if (narg >= 50){
                    fprintf(stderr, "too many command line arguments\n");
                    exit(0);
                }
                Arguments[narg++] = &cmd_string[a];
            }
            wasblank = 0;
        }else{
            cmd_string[a] = '\0';
            wasblank = 1;
        }
    }
    Arguments[narg] = NULL;

    //printf("%d arguments\n",narg);
    //for (a=0;a<narg;a++){
    //    printf("'%s'\n",Arguments[a]);
    //}
    
    int pid = fork();
    if (pid == -1){
        // Failed to fork.
        fprintf(Log,"Failed to fork off child process\n");
        return -1;
    }

    if(pid == 0){
        // Child takes this branch.
        execvp(Arguments[0], Arguments);
        fprintf(Log,"Failed to execute: %s\n",Arguments[0]);
        perror("Reason");
        exit(errno);
        return -1;
    }
    return pid;
}

// Assembly:
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
pushq $0x1
popq %rax
xorl %ecx, %ecx
movl %eax, %esi
movzbl (%rdi), %edx
cmpl $0x20, %edx
je 0x8a0f
movslq %ecx, %r8
testl %edx, %edx
je 0x8a1b
xorl %edx, %edx
testl %esi, %esi
je 0x8a14
cmpl $0x32, %ecx
jge 0x8a98
incl %ecx
movq %rdi, (%rsp,%r8,8)
jmp 0x8a14
movb $0x0, (%rdi)
movl %eax, %edx
incq %rdi
movl %edx, %esi
jmp 0x89e9
andq $0x0, (%rsp,%r8,8)
callq 0x3500
movl %eax, %ebx
cmpl $-0x1, %eax
je 0x8a71
testl %ebx, %ebx
jne 0x8a8d
movq %rsp, %rbx
movq (%rbx), %rdi
movq %rbx, %rsi
callq 0x3460
leaq 0xa583(%rip), %rax      # 0x12fc8
movq (%rax), %rdi
movq (%rbx), %rdx
leaq 0x57a9(%rip), %rsi      # 0xe1fb
xorl %eax, %eax
callq 0x32a0
leaq 0x57b2(%rip), %rdi      # 0xe212
callq 0x3450
callq 0x3070
movl (%rax), %edi
callq 0x34a0
leaq 0xa550(%rip), %rax      # 0x12fc8
movq (%rax), %rcx
leaq 0x5757(%rip), %rdi      # 0xe1d9
pushq $0x21
popq %rsi
pushq $0x1
popq %rdx
callq 0x34b0
movl %ebx, %eax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
retq
movq 0x9559(%rip), %rax      # 0x11ff8
movq (%rax), %rcx
leaq 0x570f(%rip), %rdi      # 0xe1b8
pushq $0x20
popq %rsi
pushq $0x1
popq %rdx
callq 0x34b0
xorl %edi, %edi
callq 0x34a0
// File: /workspace/github_c_makefile_star2_O2/Matthias-Wandel[P]imgcomp/src/util.c
// Function: CatPath
char * CatPath(char *Dir, char * FileName)
{
    static char catpath[502];
    int pathlen;

    pathlen = strlen(Dir);
    if (pathlen > 300){
        fprintf(Log, "path too long!");
        exit(-1);
    }
    memcpy(catpath, Dir, pathlen+1);
    if (catpath[pathlen-1] != '/' && catpath[pathlen-1] != '\\'){
        catpath[pathlen] = '/';
        pathlen += 1;
    }
    strncpy(catpath+pathlen, FileName,256);
    return catpath;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r12
callq 0x3130
movq %rax, %r15
cmpl $0x12d, %r15d           # imm = 0x12D
jge 0x8f43
movl %r15d, %r13d
leal 0x1(%r13), %ebp
movslq %ebp, %rdx
leaq 0xb7bd(%rip), %r14      # 0x146a0
movq %r14, %rdi
movq %r12, %rsi
callq 0x32d0
shlq $0x20, %r15
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
addq %r15, %rax
sarq $0x20, %rax
movzbl (%rax,%r14), %eax
cmpl $0x2f, %eax
je 0x8f1e
cmpl $0x5c, %eax
je 0x8f1e
sarq $0x20, %r15
movb $0x2f, (%r15,%r14)
movl %ebp, %r13d
movslq %r13d, %rdi
addq %r14, %rdi
movl $0x100, %edx            # imm = 0x100
movq %rbx, %rsi
callq 0x3090
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa07e(%rip), %rax      # 0x12fc8
movq (%rax), %rcx
leaq 0x52d0(%rip), %rdi      # 0xe224
pushq $0xe
popq %rsi
pushq $0x1
popq %rdx
callq 0x34b0
pushq $-0x1
popq %rdi
callq 0x34a0
// File: /workspace/github_c_makefile_star2_O2/Matthias-Wandel[P]imgcomp/src/util.c
// Function: CopyFile
static int CopyFile(char * src, char * dest)
{
    int inputFd, outputFd, openFlags;
    int filePerms;
    struct stat statbuf;
    size_t numRead;
    #define BUF_SIZE 8192
    char buf[BUF_SIZE];

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

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

    filePerms = 0x1ff;

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

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

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

    close(inputFd);
    close(outputFd);

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20a0, %rsp           # imm = 0x20A0
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %rsi
callq 0x32c0
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x3430
cmpl $-0x1, %eax
je 0x967b
movl %eax, %ebp
movq %rbx, %rdi
movl $0x241, %esi            # imm = 0x241
movl $0x1ff, %edx            # imm = 0x1FF
xorl %eax, %eax
callq 0x3430
cmpl $-0x1, %eax
je 0x9691
movl %eax, %r14d
leaq 0xa0(%rsp), %r15
movl $0x2000, %edx           # imm = 0x2000
movl %ebp, %edi
movq %r15, %rsi
callq 0x3210
testq %rax, %rax
je 0x9640
movq %rax, %r12
movl %r14d, %edi
movq %r15, %rsi
movq %rax, %rdx
callq 0x30f0
cmpq %r12, %rax
je 0x95f3
leaq 0x99a4(%rip), %rax      # 0x12fc8
movq (%rax), %rdi
leaq 0x4dcc(%rip), %rsi      # 0xe3fa
movq %rbx, %rdx
xorl %eax, %eax
callq 0x32a0
pushq $-0x1
popq %rdi
callq 0x34a0
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 0x9946(%rip), %rax      # 0x12fc8
movq (%rax), %rdi
leaq 0x4d2d(%rip), %rsi      # 0xe3b9
movq %r14, %rdx
jmp 0x9631
leaq 0x9930(%rip), %rax      # 0x12fc8
movq (%rax), %rdi
leaq 0x4d37(%rip), %rsi      # 0xe3d9
jmp 0x962e
// File: /workspace/github_c_makefile_star2_O2/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:
movl 0xc172(%rip), %eax      # 0x15ac0
testl %eax, %eax
je 0x9a08
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0xe(%rsp), %rbx
movw $0x46c1, (%rbx)         # imm = 0x46C1
movw %dx, 0x2(%rbx)
movw %di, 0x4(%rbx)
movw %si, 0x6(%rbx)
movw %cx, 0x8(%rbx)
leaq 0xc14b(%rip), %r14      # 0x15ad0
pushq $0xa
popq %r15
pushq $0x10
popq %rbp
xorl %r12d, %r12d
cltq
cmpq %rax, %r12
jge 0x99f9
movl 0xc128(%rip), %edi      # 0x15ac4
movq %rbx, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
movq %r14, %r8
movl %ebp, %r9d
callq 0x31c0
movq %rax, %r13
cmpl $-0x1, %r13d
je 0x99eb
cmpl $0x9, %r13d
jg 0x99dc
movq 0x860b(%rip), %rax      # 0x11fd0
movq (%rax), %rdi
leaq 0x4ab8(%rip), %rsi      # 0xe487
movl %r13d, %edx
pushq $0xa
popq %rcx
xorl %eax, %eax
callq 0x32a0
incq %r12
movl 0xc0db(%rip), %eax      # 0x15ac0
addq $0x10, %r14
jmp 0x998f
leaq 0x4a83(%rip), %rdi      # 0xe475
callq 0x3450
jmp 0x99be
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x85e9(%rip), %rax      # 0x11ff8
movq (%rax), %rcx
leaq 0x4a47(%rip), %rdi      # 0xe460
pushq $0x14
popq %rsi
pushq $0x1
popq %rdx
jmp 0x34b0
// File: /workspace/github_c_makefile_star2_O2/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 0x2c46(%rip), %rbx      # 0x40f0
testq %rbx, %rbx
je 0x14c5
xorl %edi, %edi
callq 0x1040
testq %rbx, %rbx
je 0x14c5
movq 0x10(%rbx), %rdi
movq 0x8(%rbx), %rbx
jmp 0x14b1
callq 0x1170
movl 0x2c10(%rip), %esi      # 0x40e0
leaq 0xb4d(%rip), %rdi       # 0x2024
xorl %eax, %eax
popq %rbx
jmp 0x1090
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x18
popq %rdi
callq 0x1120
testq %rax, %rax
je 0x1551
movl %ebp, (%rax)
andq $0x0, 0x8(%rax)
movq 0x2bf7(%rip), %rcx      # 0x40f8
testq %rcx, %rcx
je 0x150a
movq %rax, 0x8(%rcx)
movq %rcx, 0x10(%rax)
movq %rax, 0x2be3(%rip)      # 0x40f8
movq 0x2bd4(%rip), %rdi      # 0x40f0
testq %rdi, %rdi
jne 0x152b
movq %rax, 0x2bc8(%rip)      # 0x40f0
movq %rax, %rdi
testl %ebx, %ebx
je 0x154a
movq 0x8(%rdi), %rax
movq %rax, 0x2bb6(%rip)      # 0x40f0
andq $0x0, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1040
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
pushq $0x1
popq %rdi
callq 0x1160
// File: /workspace/github_c_makefile_star2_O2/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 0x2a78(%rip), %r14      # 0x3fe0
movq (%r14), %rax
testq %rax, %rax
je 0x1582
movswq 0x4(%rax), %r15
decq %r15
movswq 0x6(%rax), %r12
decq %r12
jmp 0x1589
pushq $-0x3
popq %r15
movq %r15, %r12
movq (%r14), %rbx
callq 0x1100
cqto
idivq %r15
leal 0x1(%rdx), %ebp
callq 0x1100
cqto
idivq %r12
incl %edx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1130
movq (%r14), %rdi
callq 0x1110
cmpl $0x20, %eax
jne 0x1589
movq (%r14), %rcx
testq %rcx, %rcx
je 0x15cd
movswl (%rcx), %eax
movswl 0x2(%rcx), %ecx
jmp 0x15d2
pushq $-0x1
popq %rax
movl %eax, %ecx
movl %eax, 0x2b28(%rip)      # 0x4100
movl %ecx, 0x2b26(%rip)      # 0x4104
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x29e4(%rip), %r15      # 0x3fe0
movq (%r15), %rdi
callq 0x1030
movq (%r15), %rdi
andl $0x0, 0x10(%rsp)
andl $0x0, 0x8(%rsp)
andl $0x0, (%rsp)
pushq $0x7c
popq %rdx
pushq $0x2d
popq %rcx
movl %edx, %esi
movl %ecx, %r8d
xorl %r9d, %r9d
callq 0x1060
movl 0x2ab6(%rip), %ebx      # 0x40e4
leaq 0x2ac3(%rip), %r12      # 0x40f8
movl 0x2aad(%rip), %ebp      # 0x40e8
leaq 0x9d2(%rip), %r13       # 0x2014
pushq $0x23
popq %r14
movq (%r12), %r12
movq (%r15), %rdi
testq %r12, %r12
je 0x1693
movl %ebx, %esi
movl %ebp, %edx
callq 0x1130
cmpl $-0x1, %eax
je 0x166b
movq (%r15), %rdi
movl %r14d, %esi
callq 0x1150
movl (%r12), %eax
cmpq $0x3, %rax
ja 0x168d
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
incl %ebx
jmp 0x168d
incl %ebp
jmp 0x168d
decl %ebp
jmp 0x168d
decl %ebx
addq $0x10, %r12
jmp 0x1646
movl 0x2a67(%rip), %esi      # 0x4100
movl 0x2a65(%rip), %edx      # 0x4104
callq 0x1130
cmpl $-0x1, %eax
je 0x16b4
movq (%r15), %rdi
pushq $0x40
popq %rsi
callq 0x1150
movq (%r15), %rdi
movl 0x2a27(%rip), %esi      # 0x40e4
movl 0x2a25(%rip), %edx      # 0x40e8
callq 0x1130
movq (%r15), %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10b0
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x169b
movq %rsi, %rbx
leaq 0x2a56(%rip), %rdi      # 0x40a0
movl $0x20000, %edx          # imm = 0x20000
movl $0xdd, %esi
callq 0x1060
callq 0x15f5
movq 0x8(%rbx), %rdi
leaq 0xa29(%rip), %rsi       # 0x2092
callq 0x1090
testq %rax, %rax
je 0x16b9
movq %rax, %r14
movq %rax, %rdi
callq 0x16d8
testl %eax, %eax
je 0x1687
pushq $0x1
popq %rax
jmp 0x1696
movq %r14, %rdi
callq 0x1040
callq 0x1247
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x2956(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0x9cd(%rip), %rdi       # 0x2079
pushq $0x18
popq %rsi
pushq $0x1
popq %rdx
callq 0x10c0
jmp 0x1682
movq 0x2938(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq 0x8(%rbx), %rdx
leaq 0x9c7(%rip), %rsi       # 0x2095
xorl %eax, %eax
callq 0x1080
jmp 0x1682
nop
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x20
popq %rdx
callq 0x1080
// File: /workspace/github_c_makefile_star2_O2/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)
pushq $0x1
popq %rbx
callq 0x1228
subsd (%rsp), %xmm0
movsd 0x2de4(%rip), %xmm1     # 0x4088
ucomisd %xmm0, %xmm1
jbe 0x12b3
movl %ebx, %edi
callq 0x10e0
jmp 0x1292
callq 0x1228
movsd %xmm0, 0x8(%rsp)
movups 0xd84(%rip), %xmm0      # 0x2049
leaq 0x10(%rsp), %rbx
movaps %xmm0, (%rbx)
movups 0xd85(%rip), %xmm0      # 0x2059
movaps %xmm0, 0x10(%rbx)
movl $0xa0d3e, 0x20(%rbx)    # imm = 0xA0D3E
leaq 0xd87(%rip), %rsi       # 0x206d
movq %rbx, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x10c0
movsd 0x8(%rsp), %xmm0
subsd (%rsp), %xmm0
leaq 0xda3(%rip), %rsi       # 0x20a8
movq %rbx, %rdi
movq %rbx, %rdx
movb $0x1, %al
callq 0x10c0
movq %rbx, %rdi
callq 0x1050
leaq 0xdaa(%rip), %rdi       # 0x20cb
movq %rax, %rsi
xorl %eax, %eax
callq 0x1060
leaq 0xdb2(%rip), %rdi       # 0x20e4
callq 0x1040
leaq 0xda3(%rip), %rdi       # 0x20e1
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1060
movq 0x2c91(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x1090
xorl %edi, %edi
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/blatSrc/blat.c
// Function: searchOneStrand
void searchOneStrand(struct dnaSeq *seq, struct genoFind *gf, FILE *psl,
                     boolean isRc, struct hash *maskHash, Bits *qMaskBits, struct gfOutput *gvo)
/* Search for seq in index, align it, and write results to psl. */
{
    if (fastMap && (seq->size > MAXSINGLEPIECESIZE))
        errAbort("Maximum single piece size (%d) exceeded by query %s of size (%d). "
        "Larger pieces will have to be split up until no larger than this limit "
        "when the -fastMap option is used."	
        , MAXSINGLEPIECESIZE, seq->name, seq->size);
    
    gfLongDnaInMem(seq, gf, isRc, minScore, qMaskBits, gvo, fastMap, optionExists("fine"));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movl %ecx, %ebp
movq %rsi, %r15
movq %rdi, %r12
movl 0xaded4(%rip), %r14d    # 0xb4ea4
testl %r14d, %r14d
je 0x7003
movl 0x18(%r12), %ecx
cmpl $0x1389, %ecx           # imm = 0x1389
jl 0x7006
movq 0x8(%r12), %rdx
leaq 0x754a4(%rip), %rdi     # 0x7c492
movl $0x1388, %esi           # imm = 0x1388
xorl %eax, %eax
callq 0x223fb
movl 0xadea3(%rip), %r14d    # 0xb4ea4
jmp 0x7006
xorl %r14d, %r14d
movl 0xac75f(%rip), %r13d    # 0xb376c
leaq 0x75460(%rip), %rdi     # 0x7c474
callq 0x2ed1c
movq %r12, %rdi
movq %r15, %rsi
movl %ebp, %edx
movl %r13d, %ecx
movq %rbx, %r8
movq 0x40(%rsp), %r9
pushq %rax
pushq %r14
callq 0xf64a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x26f00
leaq 0x18(%rsp), %r12
movq %rax, (%r12)
leaq 0xc(%rsp), %rcx
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xcb6d
leaq 0x10(%rsp), %r13
movq %rax, (%r13)
movl 0xac6e0(%rip), %r8d     # 0xb376c
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
movq %rbx, %r9
callq 0xe02e
movq %r13, %rdi
callq 0xba5e
movq %r12, %rdi
callq 0x26fa2
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0xaddc8(%rip)     # 0xb4e8c
jle 0x7102
movl 0xac894(%rip), %eax     # 0xb3960
leal -0x1(%rax), %ecx
movl %ecx, 0xac88b(%rip)     # 0xb3960
cmpl $0x1, %eax
jg 0x7102
pushq %rbx
movq 0xabece(%rip), %rbx     # 0xb2fb0
movq (%rbx), %rsi
pushq $0x2e
popq %rdi
callq 0x6930
movq (%rbx), %rdi
callq 0x6870
movl 0xadd91(%rip), %eax     # 0xb4e8c
movl %eax, 0xac85f(%rip)     # 0xb3960
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x70bd
testl %ebx, %ebx
je 0x7142
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rcx
callq 0x7043
jmp 0x7189
movq %rbp, 0x30(%r14)
movq %r14, (%rsp)
movq %r15, %rdi
movq %r13, %rsi
xorl %ecx, %ecx
movq %r12, %r9
callq 0x6fb3
movq 0x10(%r15), %rdi
movslq 0x18(%r15), %rsi
callq 0x20d38
movq %r14, (%rsp)
pushq $0x1
popq %rcx
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %r9
callq 0x6fb3
movq 0x10(%r15), %rdi
movslq 0x18(%r15), %rsi
callq 0x20d38
movq %r14, %rdi
movq 0x10(%rsp), %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x11a84
// File: /workspace/github_c_makefile_star2_O2/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, 0xadcd1(%rip)     # 0xb4ea0
je 0x71db
movq %rbx, %rdi
movl %ebp, %esi
callq 0x214e5
movl 0xadcbb(%rip), %eax     # 0xb4e9c
orl 0xadcb1(%rip), %eax     # 0xb4e98
je 0x7209
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2144b
cmpl $0x0, 0xadca2(%rip)     # 0xb4e9c
je 0x7209
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_O2/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 0x78bb0(%rip), %rsi     # 0x7fddb
pushq $0x2
popq %rdi
xorl %eax, %eax
callq 0x3c521
testl %r15d, %r15d
je 0x724b
movq 0x10(%rbx), %rdi
movl 0x18(%rbx), %esi
callq 0x2330e
xorl %r14d, %r14d
jmp 0x727c
testl %r14d, %r14d
je 0x726d
testl %ebp, %ebp
je 0x7260
movq 0x10(%rbx), %rdi
movl 0x18(%rbx), %esi
callq 0x1dfc1
movq %rbx, %rdi
callq 0x209d5
movq %rax, %r14
jmp 0x7270
xorl %r14d, %r14d
movq 0x10(%rbx), %rdi
movl 0x18(%rbx), %esi
callq 0x23357
movl 0x18(%rbx), %edx
cmpl $0x4c4b41, %edx         # imm = 0x4C4B41
jl 0x7299
movq 0x8(%rbx), %rsi
leaq 0x752ab(%rip), %rdi     # 0x7c53d
xorl %eax, %eax
callq 0x22186
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xadc01(%rip), %rdi     # 0xb4ed0
xorl %ebx, %ebx
testq %rdi, %rdi
setne %bl
je 0x72ee
leaq 0x75293(%rip), %rsi     # 0x7c573
callq 0x1cd23
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
jmp 0x72f0
xorl %ecx, %ecx
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x720e
movq %rax, %rbx
movq %rax, 0x18(%rsp)
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
andq $0x0, 0x20(%rsi)
movq %r14, %rdi
callq 0x71a4
movl 0xadb92(%rip), %eax     # 0xb4eb8
cmpl $0x4, %eax
je 0x7330
cmpl $0x1, %eax
jne 0x7344
movq 0x30(%rsp), %rdi
movl 0x38(%rsp), %esi
pushq $0x75
popq %rdx
pushq $0x74
popq %rcx
callq 0x1e2a1
movq 0x88(%rsp), %rax
movq %rax, (%rsp)
leaq 0x20(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
movl %ebp, %ecx
movq %r15, %r8
movq %rbx, %r9
callq 0x7103
movslq 0x18(%r14), %rax
movq 0x10(%rsp), %rcx
addq %rax, (%rcx)
movq 0x80(%rsp), %rax
incl (%rax)
leaq 0x18(%rsp), %rdi
callq 0x183fd
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/icebert[P]pblat/blatSrc/blat.c
// Function: seqListToTrans3List
struct trans3 *seqListToTrans3List(struct dnaSeq *seqList, aaSeq *transLists[3], struct hash **retHash)
/* Convert sequence list to a trans3 list and lists for each of three frames. */
{
    int frame;
    struct dnaSeq *seq;
    struct trans3 *t3List = NULL, *t3;
    struct hash *hash = newHash(0);

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
andq $0x0, (%rsp)
xorl %ebp, %ebp
pushq $0x1
popq %rsi
xorl %edi, %edi
callq 0x245c9
movq %rax, %r15
testq %r12, %r12
je 0x785b
movq %r12, %rdi
callq 0x12f80
movq %rax, %r13
movq 0x8(%rax), %rsi
movq %r15, %rdi
movq %rax, %rdx
callq 0x243b8
movq %rbp, (%r13)
movq %r13, (%rsp)
xorl %eax, %eax
cmpq $0x3, %rax
je 0x7852
movq 0x18(%r13,%rax,8), %rcx
movq (%r14,%rax,8), %rdx
movq %rdx, (%rcx)
movq %rcx, (%r14,%rax,8)
incq %rax
jmp 0x7837
movq (%r12), %r12
movq %r13, %rbp
jmp 0x780e
movq %rsp, %rdi
callq 0x1c567
xorl %r12d, %r12d
cmpq $0x18, %r12
je 0x787b
leaq (%r14,%r12), %rdi
callq 0x1c567
addq $0x8, %r12
jmp 0x7866
movq %r15, (%rbx)
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rax
movl %r8d, %ebx
movl %ecx, 0x4(%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x40(%rsp), %rax
movl $0x1, 0x28(%rax)
xorl %r13d, %r13d
testl %r8d, %r8d
sete %r13b
xorl %ebp, %ebp
cmpl %ebx, %ebp
jg 0x7921
movl 0xabe81(%rip), %eax     # 0xb376c
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebp, %ecx
movl 0x4(%rsp), %r8d
movl %r13d, %r9d
pushq 0x40(%rsp)
pushq %rax
callq 0xfd7b
popq %rax
popq %rcx
testl %ebx, %ebx
je 0x791d
movq 0x10(%r12), %rdi
movslq 0x18(%r12), %rsi
callq 0x20d38
incl %ebp
jmp 0x78e1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq 0x18(%rdi), %rcx
movq 0x28(%rdi), %rsi
movl 0xac366(%rip), %r9d     # 0xb4ee0
addq $0x3, %rsi
addq $0x3, %rcx
xorl %eax, %eax
movl $0x1, %r10d
leaq -0x3(%rsi), %r11
leaq -0x3(%rcx), %rbx
cmpq %rdx, %rbx
jae 0x8bfc
cmpq %r8, %r11
jae 0x8bfc
movb (%rbx), %r14b
movb (%r11), %bpl
cmpb %bpl, %r14b
je 0x8bf1
cmpb $0x6e, %r14b
jne 0x8bd0
testl %r9d, %r9d
jne 0x8bf1
cmpq %rdx, %rcx
jae 0x8bf1
cmpb $0x6e, -0x2(%rcx)
jne 0x8bf1
cmpb $0x6e, -0x1(%rcx)
jne 0x8bf1
cmpb $0x6e, (%rcx)
jne 0x8bf1
cmpb $0x6e, %bpl
je 0x8bdb
jmp 0x8bfc
cmpb $0x6e, %bpl
jne 0x8bfc
testl %r9d, %r9d
jne 0x8bf1
cmpq %r8, %rsi
jae 0x8bf1
cmpb $0x6e, -0x2(%rsi)
jne 0x8bf1
cmpb $0x6e, -0x1(%rsi)
jne 0x8bf1
cmpb $0x6e, (%rsi)
je 0x8bfc
incq %rsi
incq %rcx
movl %r10d, %eax
jmp 0x8b8a
movq %rbx, 0x18(%rdi)
movq %r11, 0x28(%rdi)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq 0x10(%rdi), %r8
movq 0x20(%rdi), %rdx
xorl %r9d, %r9d
movl 0xac2c1(%rip), %r10d    # 0xb4ee0
movl $0x1, %r11d
xorl %eax, %eax
leaq (%r8,%r9), %rbx
decq %rbx
cmpq %rsi, %rbx
jb 0x8cba
leaq (%rdx,%r9), %r14
decq %r14
cmpq %rcx, %r14
jb 0x8cba
movb (%rbx), %bpl
movb (%r14), %bl
cmpb %bl, %bpl
je 0x8caf
cmpb $0x6e, %bpl
jne 0x8c83
testl %r10d, %r10d
jne 0x8caf
leaq (%r8,%r9), %r14
addq $-0x4, %r14
cmpq %rsi, %r14
jb 0x8caf
cmpb $0x6e, -0x2(%r8,%r9)
jne 0x8caf
cmpb $0x6e, -0x3(%r8,%r9)
jne 0x8caf
cmpb $0x6e, (%r14)
jne 0x8caf
cmpb $0x6e, %bl
je 0x8c8d
jmp 0x8cba
cmpb $0x6e, %bl
jne 0x8cba
testl %r10d, %r10d
jne 0x8caf
leaq (%rdx,%r9), %rbx
addq $-0x4, %rbx
cmpq %rcx, %rbx
jb 0x8caf
cmpb $0x6e, -0x2(%rdx,%r9)
jne 0x8caf
cmpb $0x6e, -0x3(%rdx,%r9)
jne 0x8caf
cmpb $0x6e, (%rbx)
je 0x8cba
decq %r9
movl %r11d, %eax
jmp 0x8c27
addq %r9, %r8
movq %r8, 0x10(%rdi)
addq %r9, %rdx
movq %rdx, 0x20(%rdi)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
movq %rdx, %r15
movq %rdi, %r14
subl %r14d, %esi
movb (%rdi), %bpl
incq %r14
movslq %esi, %rax
subq %rax, %rbx
decl %eax
movslq %eax, %r12
cmpq %rbx, %r15
jae 0x8d1a
movq %r15, %r13
incq %r15
cmpb %bpl, (%r13)
jne 0x8cf5
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x6710
testl %eax, %eax
jne 0x8cf5
jmp 0x8d1d
xorl %r13d, %r13d
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq