LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/filePath.c
// Function: pathRelativeToFile
char *pathRelativeToFile(char *baseFile, char *relPath)
/* Given a base file name and a path relative to that, return
 * relative path interpreted as if it were seen from the
 * same directory holding the baseFile.  
 *   An example of using this would be in processing include
 * files.  In this case the baseFile would be the current
 * source file, and the relPath would be from the include
 * statement.  The returned result could then be used to
 * open the include file. */
{
char dir[PATH_LEN];
splitPath(baseFile, dir, NULL, NULL);
int dirLen = strlen(dir);
if (dirLen > 0 && dir[dirLen-1] == '/')
     dir[dirLen-1] = 0;
return expandRelativePath(dir, relPath);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %rbx
movq %rsp, %r14
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x288ae
movq %r14, %rdi
callq 0x62d0
testl %eax, %eax
jle 0x28bf5
decl %eax
cmpb $0x2f, (%rsp,%rax)
jne 0x28bf5
movb $0x0, (%rsp,%rax)
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x289fb
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/filePath.c
// Function: mustPathRelativeToFile
char *mustPathRelativeToFile(char *baseFile, char *relPath)
/* Make Path Relative To File or Abort. */
{
char *path = pathRelativeToFile(baseFile, relPath);
verbose(3, "baseFile=%s\nrelPath=%s\npath=%s\n", baseFile, relPath, path);
if (!path)
    errAbort("Too many .. in symlink path %s to make relative to %s\n", relPath, baseFile);
return path;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x28bc1
movq %rax, %r15
leaq 0x6814b(%rip), %rsi     # 0x90d70
movl $0x3, %edi
movq %rbx, %rdx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x427e5
testq %r15, %r15
jne 0x28c53
leaq 0x6814a(%rip), %rdi     # 0x90d90
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x26e94
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/hash.c
// Function: hashResize
void hashResize(struct hash *hash, int powerOfTwoSize)
/* Resize the hash to a new size */
{
int oldHashSize = hash->size;
struct hashEl **oldTable = hash->table;

if (powerOfTwoSize == 0)
    powerOfTwoSize = 12;
if (powerOfTwoSize > hashMaxSize)
    powerOfTwoSize =  hashMaxSize;
if (hash->powerOfTwoSize == powerOfTwoSize)
    return;

assert(powerOfTwoSize <= hashMaxSize && powerOfTwoSize > 0);
hash->powerOfTwoSize = powerOfTwoSize;
hash->size = (1<<powerOfTwoSize);
hash->mask = hash->size-1;

AllocArray(hash->table, hash->size);

int i;
struct hashEl *hel, *next;
for (i=0; i<oldHashSize; ++i)
    {
    for (hel = oldTable[i]; hel != NULL; hel = next)
	{
	next = hel->next;
	int hashVal = hel->hashVal & hash->mask;
	hel->next = hash->table[hashVal];
	hash->table[hashVal] = hel;
	}
    }
/* restore original list order */
hashReverseAllBucketLists(hash);

freeMem(oldTable);
hash->numResizes++;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpl $0x1c, %esi
movl $0x1c, %eax
cmovll %esi, %eax
testl %esi, %esi
movl $0xc, %ecx
cmovnel %eax, %ecx
cmpl %ecx, 0x18(%rdi)
je 0x2911d
testl %ecx, %ecx
jle 0x29123
movq %rdi, %rbx
movl 0x1c(%rdi), %r15d
movq 0x10(%rdi), %r14
movl %ecx, 0x18(%rdi)
movl $0x1, %edi
shll %cl, %edi
movl %edi, 0x1c(%rbx)
leal -0x1(%rdi), %eax
movl %eax, 0x8(%rbx)
shlq $0x3, %rdi
callq 0x2de63
movq %rax, 0x10(%rbx)
testl %r15d, %r15d
jle 0x2910a
xorl %eax, %eax
movq (%r14,%rax,8), %rcx
testq %rcx, %rcx
je 0x29102
movslq 0x8(%rbx), %rdx
movq (%rcx), %rsi
movslq 0x18(%rcx), %rdi
andq %rdx, %rdi
movq 0x10(%rbx), %r8
movq (%r8,%rdi,8), %r9
movq %r9, (%rcx)
movq %rcx, (%r8,%rdi,8)
movq %rsi, %rcx
testq %rsi, %rsi
jne 0x290e1
incq %rax
cmpq %r15, %rax
jne 0x290d4
movq %rbx, %rdi
callq 0x29596
movq %r14, %rdi
callq 0x2e0a0
incl 0x34(%rbx)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x67d22(%rip), %rdi     # 0x90e4c
leaq 0x67d4f(%rip), %rsi     # 0x90e80
leaq 0x67d75(%rip), %rcx     # 0x90ead
movl $0x191, %edx            # imm = 0x191
callq 0x6460
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/hash.c
// Function: hashReverseAllBucketLists
void hashReverseAllBucketLists(struct hash *hash)
/* Reverse all hash bucket list.  You might do this to
 * get them back in the same order things were added to the hash */
{
int i;
for (i=0; i<hash->size; ++i)
    {
    struct hashEl *hel = hash->table[i];
    if (hel != NULL && hel->next != NULL)	    
	slReverse(&hash->table[i]);
    }
}

// Assembly:
movl 0x1c(%rdi), %eax
testl %eax, %eax
jle 0x295dd
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x10(%rbx), %rdi
movq (%rdi,%r14), %rcx
testq %rcx, %rcx
je 0x295c9
cmpq $0x0, (%rcx)
je 0x295c9
addq %r14, %rdi
callq 0x20173
movl 0x1c(%rbx), %eax
incq %r15
movslq %eax, %rcx
addq $0x8, %r14
cmpq %rcx, %r15
jl 0x295ab
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/hash.c
// Function: hashFromSlNameList
struct hash *hashFromSlNameList(void *list)
/* Create a hash out of a list of slNames. */
{
struct hash *hash = NULL;
struct slName *namedList = list, *item;
if (!list)
    return NULL;
hash = newHash(0);
for (item = namedList; item != NULL; item = item->next)
    hashAdd(hash, item->name, item);
return hash;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x29620
movq %rdi, %rbx
xorl %edi, %edi
movl $0x1, %esi
callq 0x294ea
movq %rax, %r14
leaq 0x8(%rbx), %r15
movq %r15, %rdi
callq 0x62d0
movq %r14, %rdi
movq %r15, %rsi
movl %eax, %edx
movq %rbx, %rcx
callq 0x28f80
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x295fa
jmp 0x29623
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/hash.c
// Function: hashSetFromSlNameList
struct hash *hashSetFromSlNameList(void *list)
/* Create a hashSet (hash with only keys) out of a list of slNames. */
{
struct hash *hash = NULL;
struct slName *namedList = list, *item;
if (!list)
    return NULL;
hash = newHash(0);
for (item = namedList; item != NULL; item = item->next)
    hashAdd(hash, item->name, NULL);
return hash;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x2966d
movq %rdi, %rbx
xorl %edi, %edi
movl $0x1, %esi
callq 0x294ea
movq %rax, %r14
leaq 0x8(%rbx), %r15
movq %r15, %rdi
callq 0x62d0
movq %r14, %rdi
movq %r15, %rsi
movl %eax, %edx
xorl %ecx, %ecx
callq 0x28f80
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x29648
jmp 0x29670
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/hash.c
// Function: hashFromString
struct hash *hashFromString(char *string)
/* parse a whitespace-separated string with tuples in the format name=val or
 * name="val" to a hash name->val */
{
if (string==NULL)
    return NULL;

struct slPair *keyVals = slPairListFromString(string, TRUE);
if (keyVals==NULL)
    return NULL;

struct hash *nameToVal = newHash(0);
struct slPair *kv;
for (kv = keyVals; kv != NULL; kv = kv->next)
    hashAdd(nameToVal, kv->name, kv->val);
return nameToVal;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x29dc6
movl $0x1, %esi
callq 0x2128e
testq %rax, %rax
je 0x29dc6
movq %rax, %r14
xorl %edi, %edi
movl $0x1, %esi
callq 0x294ea
movq %rax, %rbx
movq 0x8(%r14), %r15
movq 0x10(%r14), %r12
movq %r15, %rdi
callq 0x62d0
movq %rbx, %rdi
movq %r15, %rsi
movl %eax, %edx
movq %r12, %rcx
callq 0x28f80
movq (%r14), %r14
testq %r14, %r14
jne 0x29d9c
jmp 0x29dc8
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/hash.c
// Function: hashFromNameArray
struct hash *hashFromNameArray(char **nameArray, int nameCount)
/* Create a NULL valued hash on all names in array */
{
struct hash *hash = hashNew(0);
int i;
for (i=0; i<nameCount; ++i)
    hashAdd(hash, nameArray[i], NULL);
return hash;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
xorl %edi, %edi
movl $0x1, %esi
callq 0x294ea
movq %rax, %r14
testl %ebp, %ebp
jle 0x29e23
movl %ebp, %r12d
xorl %r13d, %r13d
movq (%rbx,%r13,8), %r15
movq %r15, %rdi
callq 0x62d0
movq %r14, %rdi
movq %r15, %rsi
movl %eax, %edx
xorl %ecx, %ecx
callq 0x28f80
incq %r13
cmpq %r13, %r12
jne 0x29e00
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/hash.c
// Function: hashFromNameValArray
struct hash *hashFromNameValArray(char *nameVal[][2], int nameValCount)
/* Make up a hash from nameVal array */
{
struct hash *hash = newHash(0);
int i;
for (i=0; i<nameValCount; ++i)
    hashAdd(hash, nameVal[i][0], nameVal[i][1]);
return hash;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
xorl %edi, %edi
movl $0x1, %esi
callq 0x294ea
movq %rax, %r14
testl %ebp, %ebp
jle 0x29e8b
movl %ebp, %r13d
shlq $0x4, %r13
xorl %ebp, %ebp
movq (%rbx,%rbp), %r15
movq 0x8(%rbx,%rbp), %r12
movq %r15, %rdi
callq 0x62d0
movq %r14, %rdi
movq %r15, %rsi
movl %eax, %edx
movq %r12, %rcx
callq 0x28f80
addq $0x10, %rbp
cmpq %rbp, %r13
jne 0x29e61
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/linefile.c
// Function: lineFileSetTabixRegion
boolean lineFileSetTabixRegion(struct lineFile *lf, char *seqName, int start, int end)
/* Assuming lf was created by lineFileTabixMayOpen, tell tabix to seek to the specified region
 * and return TRUE (or if there are no items in region, return FALSE). */
{
if (lf->tabix == NULL)
    errAbort("lineFileSetTabixRegion: lf->tabix is NULL.  Did you open lf with lineFileTabixMayOpen?");
if (seqName == NULL)
    return FALSE;
int tabixSeqId = ti_get_tid(lf->tabix, seqName);
if (tabixSeqId < 0 && startsWith("chr", seqName))
    // We will get some files that have chr-less Ensembl chromosome names:
    tabixSeqId = ti_get_tid(lf->tabix, seqName+strlen("chr"));
if (tabixSeqId < 0)
    return FALSE;
ti_iter_t *iter = ti_queryi((tbx_t *)lf->tabix, tabixSeqId, start, end);
if (iter == NULL)
    return FALSE;
if (lf->tabixIter != NULL)
    ti_iter_destroy(lf->tabixIter);
lf->tabixIter = iter;
lf->bytesInBuf = 0;
lf->lineIx = -1;
lf->lineStart = 0;
lf->lineEnd = 0;
return TRUE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r14d
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %rbx
cmpq $0x0, 0x70(%rdi)
jne 0x2a41a
leaq 0x66bd4(%rip), %rdi     # 0x90fe7
xorl %eax, %eax
callq 0x26e94
xorl %ebp, %ebp
testq %r12, %r12
je 0x2a4aa
movq 0x70(%rbx), %rdi
movq %r12, %rsi
callq 0x528fc
testl %eax, %eax
js 0x2a483
movq 0x70(%rbx), %rcx
movq 0x18(%rcx), %rdi
leaq 0x287d4(%rip), %r8      # 0x52c18
movl %eax, %esi
movl %r15d, %edx
movl %r14d, %ecx
callq 0x50f9e
testq %rax, %rax
je 0x2a4aa
movq %rax, %r14
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x2a467
callq 0x517a9
movq %r14, 0x78(%rbx)
xorl %eax, %eax
movl %eax, 0x20(%rbx)
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movq %rcx, 0x28(%rbx)
movl %eax, 0x30(%rbx)
movl $0x1, %ebp
jmp 0x2a4aa
leaq 0x66bb4(%rip), %rdi     # 0x9103e
movq %r12, %rsi
callq 0x21b23
testl %eax, %eax
je 0x2a4aa
movq 0x70(%rbx), %rdi
addq $0x3, %r12
movq %r12, %rsi
callq 0x528fc
testl %eax, %eax
jns 0x2a435
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/linefile.c
// Function: lineFileUdcMayOpen
struct lineFile *lineFileUdcMayOpen(char *fileOrUrl, bool zTerm)
/* Create a line file object with an underlying UDC cache. NULL if not found. */
{
if (fileOrUrl == NULL)
    errAbort("lineFileUdcMayOpen: fileOrUrl is NULL");

if (udcIsLocal(fileOrUrl))
     return lineFileOpen(fileOrUrl, zTerm);
else
    {
    struct udcFile *udcFile = udcFileMayOpen(fileOrUrl, NULL);
    if (udcFile == NULL)
	return NULL;
    struct lineFile *lf;
    AllocVar(lf);
    lf->fileName = cloneString(fileOrUrl);
    lf->fd = -1;
    lf->bufSize = 0;
    lf->buf = NULL;
    lf->zTerm = zTerm;
    lf->udcFile = udcFile;
    return lf;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
testq %rdi, %rdi
jne 0x2a4d5
leaq 0x66b74(%rip), %rdi     # 0x91042
xorl %eax, %eax
callq 0x26e94
movq %r14, %rdi
callq 0x4219d
testl %eax, %eax
je 0x2a4f7
movsbl %bl, %esi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2a550
xorl %r15d, %r15d
movq %r14, %rdi
xorl %esi, %esi
callq 0x405d1
testq %rax, %rax
je 0x2a541
movq %rax, %r12
movl $0xc8, %edi
callq 0x2dff4
movq %rax, %r15
movq %r14, %rdi
callq 0x1feba
movq %rax, 0x8(%r15)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, 0x10(%r15)
movq $0x0, 0x40(%r15)
movb %bl, 0x34(%r15)
movq %r12, 0x88(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/linefile.c
// Function: lineFileSeek
void lineFileSeek(struct lineFile *lf, off_t offset, int whence)
/* Seek to read next line from given position. */
{
noTabixSupport(lf, "lineFileSeek");
if (lf->checkSupport)
    lf->checkSupport(lf, "lineFileSeek");
if (lf->pl != NULL)
    errnoAbort("Can't lineFileSeek on a compressed file: %s", lf->fileName);
lf->reuse = FALSE;
if (lf->udcFile)
    {
    udcSeek(lf->udcFile, offset);
    return;
    }
lf->lineStart = lf->lineEnd = lf->bytesInBuf = 0;
if ((lf->bufOffsetInFile = lseek(lf->fd, offset, whence)) == -1)
    errnoAbort("Couldn't lineFileSeek %s", lf->fileName);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x70(%rdi)
je 0x2a6b5
leaq 0x67021(%rip), %rsi     # 0x916c5
leaq 0x66a27(%rip), %rdx     # 0x910d2
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2adbb
movq 0xb0(%rbx), %rax
testq %rax, %rax
je 0x2a6cd
leaq 0x66a0a(%rip), %rsi     # 0x910d2
movq %rbx, %rdi
callq *%rax
cmpq $0x0, 0x48(%rbx)
je 0x2a6e6
movq 0x8(%rbx), %rsi
leaq 0x66a00(%rip), %rdi     # 0x910df
xorl %eax, %eax
callq 0x26fc7
movb $0x0, 0x3c(%rbx)
movq 0x88(%rbx), %rdi
testq %rdi, %rdi
je 0x2a702
movq %r14, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x41dfc
movl $0x0, 0x20(%rbx)
movq $0x0, 0x2c(%rbx)
movl 0x10(%rbx), %edi
movq %r14, %rsi
movl %ebp, %edx
callq 0x65b0
movq %rax, 0x18(%rbx)
cmpq $-0x1, %rax
je 0x2a72d
popq %rbx
popq %r14
popq %rbp
retq
movq 0x8(%rbx), %rsi
leaq 0x669d3(%rip), %rdi     # 0x9110b
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x26fc7
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/linefile.c
// Function: determineNlType
static void determineNlType(struct lineFile *lf, char *buf, int bufSize)
/* determine type of newline used for the file, assumes buffer not empty */
{
char *c = buf;
if (bufSize==0) return;
if (lf->nlType != nlt_undet) return;  /* if already determined just exit */
while (c < buf+bufSize)
    {
    if (*c=='\r')
	{
    	lf->nlType = nlt_mac;
	if (++c < buf+bufSize)
    	    if (*c == '\n')
    		lf->nlType = nlt_dos;
	return;
	}
    if (*(c++) == '\n')
	{
        lf->nlType = nlt_unix;
	return;
	}
    }
}

// Assembly:
testl %edx, %edx
je 0x2ac0b
cmpl $0x0, 0x38(%rdi)
je 0x2ac0c
retq
movslq %edx, %rax
addq %rsi, %rax
incq %rsi
leaq -0x1(%rsi), %rcx
cmpq %rax, %rcx
jae 0x2ac0b
movb (%rcx), %cl
cmpb $0xd, %cl
je 0x2ac34
incq %rsi
cmpb $0xa, %cl
jne 0x2ac15
movl $0x1, %eax
jmp 0x2ac4a
movl $0x3, 0x38(%rdi)
cmpq %rax, %rsi
jae 0x2ac0b
movl $0x2, %eax
cmpb $0xa, (%rsi)
jne 0x2ac0b
movl %eax, 0x38(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/linefile.c
// Function: findNextNewline
static boolean findNextNewline(struct lineFile *lf, char *buf, int bytesInBuf, int *pEndIx)
/* Return TRUE if able to find next end of line in buf, starting at buf[*pEndIx], up to bytesInBuf.
 * When done set *pEndIx to the start of the next line if applicable, otherwise bytesInBuf. */
{
boolean gotLf = FALSE;
int endIx = *pEndIx;
switch (lf->nlType)
    {
    case nlt_unix:
    case nlt_dos:
        for (endIx = *pEndIx; endIx < bytesInBuf; ++endIx)
            {
            if (buf[endIx] == '\n')
                {
                gotLf = TRUE;
                endIx += 1;
                break;
                }
            }
        break;
    case nlt_mac:
        for (endIx = *pEndIx; endIx < bytesInBuf; ++endIx)
            {
            if (buf[endIx] == '\r')
                {
                gotLf = TRUE;
                endIx += 1;
                break;
                }
            }
        break;
    case nlt_mixed:
    case nlt_undet:
        for (endIx = *pEndIx; endIx < bytesInBuf; ++endIx)
            {
            char c = buf[endIx];
            if (c == '\r' || c == '\n')
                {
                gotLf = TRUE;
                if (lf->zTerm)
                    buf[endIx] = '\0';
                endIx += 1;
                if (c == '\r' && buf[endIx] == '\n')
                    {
                    if (lf->zTerm)
                        buf[endIx] = '\0';
                    endIx += 1;
                    }
                break;
                }
            }
        break;
    }
*pEndIx = endIx;
return gotLf;
}

// Assembly:
movl (%rcx), %r8d
movl 0x38(%rdi), %r10d
xorl %eax, %eax
cmpq $0x4, %r10
ja 0x2ad3e
movslq %r8d, %r9
leaq 0x662c5(%rip), %r11     # 0x90f30
movslq (%r11,%r10,4), %r10
addq %r11, %r10
jmpq *%r10
movl %r8d, %r10d
subl %edx, %r10d
jge 0x2ad3e
addq %rsi, %r9
xorl %eax, %eax
movzbl (%r9), %r11d
cmpl $0xd, %r11d
je 0x2ad04
cmpl $0xa, %r11d
je 0x2ad04
incq %r9
decl %eax
cmpl %eax, %r10d
jne 0x2ac86
xorl %eax, %eax
jmp 0x2ad3b
cmpl %edx, %r8d
jge 0x2ad3e
incl %r8d
addq %r9, %rsi
movl %edx, %edi
negl %edi
cmpb $0xa, (%rsi)
je 0x2acfd
incq %rsi
leal (%rdi,%r8), %r9d
incl %r9d
incl %r8d
cmpl $0x1, %r9d
jne 0x2acba
jmp 0x2ad3b
cmpl %edx, %r8d
jge 0x2ad3e
incl %r8d
addq %r9, %rsi
movl %edx, %edi
negl %edi
cmpb $0xd, (%rsi)
je 0x2acfd
incq %rsi
leal (%rdi,%r8), %r9d
incl %r9d
incl %r8d
cmpl $0x1, %r9d
jne 0x2ace3
jmp 0x2ad3b
movl $0x1, %eax
jmp 0x2ad3e
cmpb $0x0, 0x34(%rdi)
je 0x2ad0e
movb $0x0, (%r9)
subl %eax, %r8d
leal 0x1(%r8), %edx
movl $0x1, %eax
cmpb $0xd, %r11b
jne 0x2ad3b
movslq %edx, %r9
cmpb $0xa, (%rsi,%r9)
jne 0x2ad3b
cmpb $0x0, 0x34(%rdi)
je 0x2ad35
movb $0x0, (%rsi,%r9)
addl $0x2, %r8d
jmp 0x2ad3e
movl %edx, %r8d
movl %r8d, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/linefile.c
// Function: lineFileClose
void lineFileClose(struct lineFile **pLf)
/* Close up a line file. */
{
struct lineFile *lf;
if ((lf = *pLf) != NULL)
    {
    struct pipeline *pl = lf->pl;
    if (pl != NULL)
        {
        pipelineClose(&lf->pl);
        }
    else if (lf->fd > 0 && lf->fd != fileno(stdin))
	{
	close(lf->fd);
	freeMem(lf->buf);
	}
    else if (lf->tabix != NULL)
	{
	if (lf->tabixIter != NULL)
	    ti_iter_destroy(lf->tabixIter);
	ti_close(lf->tabix);
        hts_close(lf->htsFile);
        kstring_t *kline = lf->kline;
        free(kline->s);
	}
    else if (lf->udcFile != NULL)
        udcFileClose(&lf->udcFile);

    if (lf->closeCallBack)
        lf->closeCallBack(lf);
    freeMem(lf->fileName);
    metaDataFree(lf);
    freez(pLf);
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x2ae97
movq %rdi, %rbx
cmpq $0x0, 0x48(%r14)
je 0x2ae9c
leaq 0x48(%r14), %rdi
callq 0x35e31
jmp 0x2af1f
popq %rbx
popq %r14
popq %rbp
retq
movl 0x10(%r14), %ebp
testl %ebp, %ebp
jle 0x2aeb7
movq 0x94125(%rip), %rax     # 0xbefd0
movq (%rax), %rdi
callq 0x6750
cmpl %eax, %ebp
jne 0x2aef5
movq 0x70(%r14), %rdi
testq %rdi, %rdi
je 0x2af09
movq 0x78(%r14), %rax
testq %rax, %rax
je 0x2aed5
movq %rax, %rdi
callq 0x517a9
movq 0x70(%r14), %rdi
callq 0x530f3
movq 0x68(%r14), %rdi
callq 0x4e788
movq 0x80(%r14), %rax
movq 0x10(%rax), %rdi
callq 0x68a0
jmp 0x2af1f
movl 0x10(%r14), %edi
callq 0x6e80
movq 0x40(%r14), %rdi
callq 0x2e0a0
jmp 0x2af1f
cmpq $0x0, 0x88(%r14)
je 0x2af1f
leaq 0x88(%r14), %rdi
callq 0x40ff7
movq 0xc0(%r14), %rax
testq %rax, %rax
je 0x2af30
movq %r14, %rdi
callq *%rax
movq 0x8(%r14), %rdi
callq 0x2e0a0
cmpb $0x0, 0x58(%r14)
je 0x2af53
cmpq $0x0, 0x60(%r14)
je 0x2af53
addq $0x60, %r14
movq %r14, %rdi
callq 0x298bd
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2e0b0
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/localmem.c
// Function: lmCloneRowExt
char **lmCloneRowExt(struct lm *lm, char **row, int rowOutSize, int rowInSize)
/* Allocate an array of strings with rowOutSize elements.  Clone the first rowInSize elements
 * of row into the new array, leaving others NULL if rowOutSize is greater than rowInSize.
 * rowOutSize must be greater than or equal to rowInSize. */
{
if (rowOutSize < rowInSize)
    errAbort("lmCloneRowExt: rowOutSize (%d) must be greater than or equal to rowInSize (%d)",
             rowOutSize, rowInSize);
char **rowClone = NULL;
lmAllocArray(lm, rowClone, rowOutSize);
int i;
for (i = 0;  i < rowInSize;  i++)
    rowClone[i] = lmCloneString(lm, row[i]);
return rowClone;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
cmpl %ecx, %edx
jge 0x2c56f
leaq 0x651a5(%rip), %rdi     # 0x91708
movl %r15d, %esi
movl %ebp, %edx
xorl %eax, %eax
callq 0x26e94
movslq %r15d, %rsi
shlq $0x3, %rsi
movq %r14, %rdi
callq 0x2c325
movq %rax, %r15
testl %ebp, %ebp
jle 0x2c5a3
movl %ebp, %r12d
xorl %r13d, %r13d
movq (%rbx,%r13,8), %rsi
movq %r14, %rdi
callq 0x2c424
movq %rax, (%r15,%r13,8)
incq %r13
cmpq %r13, %r12
jne 0x2c58b
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/maf.c
// Function: mafMayOpen
struct mafFile *mafMayOpen(char *fileName)
/* Open up a maf file and verify header. */
{
struct mafFile *mf;
struct lineFile *lf;
char *line, *word;
char *sig = "##maf";

if ( hasProtocol(fileName))
    lf = lineFileUdcMayOpen(fileName, TRUE);
else
    lf = lineFileMayOpen(fileName, TRUE);

if (lf == NULL)
    return NULL;
AllocVar(mf);
mf->lf = lf;

lineFileNeedNext(lf, &line, NULL);
if (!startsWith(sig, line))
    {
    errAbort("%s does not start with %s", fileName, sig);
    }
line += strlen(sig);

while ((word = nextWord(&line)) != NULL)
    {
    /* Parse name=val. */
    char *name = word;
    char *val = strchr(word, '=');
    if (val == NULL)
       errAbort("Missing = after %s line 1 of %s\n", name, fileName);
    *val++ = 0;

    if (sameString(name, "version"))
        mf->version = atoi(val);
    else if (sameString(name, "scoring"))
        mf->scoring = cloneString(val);
    }
if (mf->version == 0)
    errAbort("No version line 1 of %s\n", fileName);
return mf;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbp
callq 0x31591
movq %rbp, %rdi
movl $0x1, %esi
testl %eax, %eax
je 0x2c5e2
callq 0x2a4b5
jmp 0x2c5e7
callq 0x2a603
movq %rax, %rbx
testq %rax, %rax
je 0x2c6f9
movl $0x28, %edi
callq 0x2dff4
movq %rax, %r14
movq %rbx, 0x20(%rax)
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x2ae51
movq (%r15), %rsi
leaq 0x65161(%rip), %rdi     # 0x9177f
callq 0x21b23
testl %eax, %eax
jne 0x2c63f
leaq 0x65157(%rip), %rdi     # 0x91785
leaq 0x6514a(%rip), %rdx     # 0x9177f
movq %rbp, %rsi
xorl %eax, %eax
callq 0x26e94
movq %rsp, %rdi
addq $0x5, (%rdi)
callq 0x22cf1
testq %rax, %rax
je 0x2c6df
movq %rax, %r15
leaq 0x678fa(%rip), %r12     # 0x93f58
movq %rsp, %r13
movq %r15, %rdi
movl $0x3d, %esi
callq 0x6270
movq %rax, %rbx
testq %rax, %rax
jne 0x2c68a
leaq 0x65122(%rip), %rdi     # 0x9179f
movq %r15, %rsi
movq %rbp, %rdx
xorl %eax, %eax
callq 0x26e94
movq %rbx, %rax
incq %rbx
movb $0x0, (%rax)
movq %r15, %rdi
movq %r12, %rsi
callq 0x6a50
testl %eax, %eax
je 0x2c6c3
movq %r15, %rdi
leaq 0x65114(%rip), %rsi     # 0x917c0
callq 0x6a50
testl %eax, %eax
jne 0x2c6cf
movq %rbx, %rdi
callq 0x1feba
movq %rax, 0x10(%r14)
jmp 0x2c6cf
movq %rbx, %rdi
callq 0x6bd0
movl %eax, 0x8(%r14)
movq %r13, %rdi
callq 0x22cf1
movq %rax, %r15
testq %rax, %rax
jne 0x2c661
cmpl $0x0, 0x8(%r14)
jne 0x2c6fc
leaq 0x650db(%rip), %rdi     # 0x917c8
movq %rbp, %rsi
xorl %eax, %eax
callq 0x26e94
jmp 0x2c6fc
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/maf.c
// Function: mafOpen
struct mafFile *mafOpen(char *fileName)
/* Open up a maf file.  Squawk and die if there's a problem. */
{
struct mafFile *mf = mafMayOpen(fileName);
if (mf == NULL)
    errnoAbort("Couldn't open %s\n", fileName);
return mf;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x2c5bc
movq %rax, %rbx
testq %rax, %rax
jne 0x2c733
leaq 0x650b8(%rip), %rdi     # 0x917e1
movq %r14, %rsi
xorl %eax, %eax
callq 0x26fc7
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/maf.c
// Function: mafReadAll
struct mafFile *mafReadAll(char *fileName)
/* Read all elements in a maf file */
{
struct mafFile *mf = mafOpen(fileName);
struct mafAli *ali;
while ((ali = mafNext(mf)) != NULL)
    {
    slAddHead(&mf->alignments, ali);
    }
slReverse(&mf->alignments);
return mf;
}

// Assembly:
pushq %rbx
callq 0x2c70e
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
callq 0x2c763
testq %rax, %rax
je 0x2cca8
movq 0x18(%rbx), %rcx
movq %rcx, (%rax)
movq %rax, 0x18(%rbx)
movq %rbx, %rdi
jmp 0x2cc8c
movq %rbx, %rdi
addq $0x18, %rdi
callq 0x20173
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/maf.c
// Function: mafWriteStart
void mafWriteStart(FILE *f, char *scoring)
/* Write maf header and scoring scheme name (may be null) */
{
fprintf(f, "##maf version=1");
if (scoring != NULL)
    fprintf(f, " scoring=%s", scoring);
fprintf(f, "\n");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x64c3c(%rip), %rdi     # 0x91906
movl $0xf, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x6e70
testq %r14, %r14
je 0x2ccf5
leaq 0x64c2e(%rip), %rsi     # 0x91916
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x6a90
movl $0xa, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6930
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/maf.c
// Function: mafWriteAll
void mafWriteAll(struct mafFile *mf, char *fileName)
/* Write out full mafFile. */
{
FILE *f = mustOpen(fileName, "w");
struct mafAli *ali;
mafWriteStart(f, mf->scoring);
for (ali = mf->alignments; ali != NULL; ali = ali->next)
    mafWrite(f, ali);
mafWriteEnd(f);
carefulClose(&f);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %r14
leaq 0x61db9(%rip), %rsi     # 0x8ed49
movq %rax, %rdi
callq 0x23072
movq %rax, %rbx
movq %rax, (%rsp)
movq 0x10(%r14), %rsi
movq %rax, %rdi
callq 0x2ccb9
movq 0x18(%r14), %r14
testq %r14, %r14
je 0x2cfd6
movq %rbx, %rdi
movq %r14, %rsi
movl $0xa, %edx
callq 0x2cd09
movl $0xa, %edi
movq %rbx, %rsi
callq 0x6930
movq (%r14), %r14
jmp 0x2cfaf
movq %rsp, %rdi
callq 0x2371e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/maf.c
// Function: mafCompFree
void mafCompFree(struct mafComp **pObj)
/* Free up a maf component. */
{
struct mafComp *obj = *pObj;
if (obj == NULL)
    return;
freeMem(obj->src);
freeMem(obj->text);
freeMem(obj->quality);
freez(pObj);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
testq %r14, %r14
je 0x2d01f
movq %rdi, %rbx
movq 0x8(%r14), %rdi
callq 0x2e0a0
movq 0x20(%r14), %rdi
callq 0x2e0a0
movq 0x28(%r14), %rdi
callq 0x2e0a0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2e0b0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/maf.c
// Function: mafCompFreeList
void mafCompFreeList(struct mafComp **pList)
/* Free up a list of maf components. */
{
struct mafComp *el, *next;

for (el = *pList; el != NULL; el = next)
    {
    next = el->next;
    mafCompFree(&el);
    }
*pList = NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %r15
movq %r15, 0x8(%rsp)
testq %r15, %r15
je 0x2d05a
leaq 0x8(%rsp), %r14
movq (%r15), %r15
movq %r14, %rdi
callq 0x2cfe6
movq %r15, 0x8(%rsp)
testq %r15, %r15
jne 0x2d045
movq $0x0, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/maf.c
// Function: mafCompGetSrcDb
char *mafCompGetSrcDb(struct mafComp *mc, char *buf, int bufSize)
/* parse the srcDb name from the mafComp src name, return NULL if no srcDb */
{
char *e = strchr(mc->src, '.');
if (e == NULL)
    return NULL;
int len = e - mc->src;
if (len >= bufSize-1)
    errAbort("srcDb name in \"%s\" overflows buffer length of %d", mc->src, bufSize);
strncpy(buf, mc->src, len);
buf[len] = '\0';
return buf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %r13d
movq %rsi, %rbx
movq %rdi, %r12
movq 0x8(%rdi), %r14
movq %r14, %rdi
movl $0x2e, %esi
callq 0x6270
testq %rax, %rax
je 0x2d0d3
movq %rax, %r15
subq %r14, %r15
leal -0x1(%r13), %eax
cmpl %r15d, %eax
jg 0x2d0bb
leaq 0x648f6(%rip), %rdi     # 0x9199f
movq %r14, %rsi
movl %r13d, %edx
xorl %eax, %eax
callq 0x26e94
movq 0x8(%r12), %r14
movslq %r15d, %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x6380
movb $0x0, (%rbx,%r15)
jmp 0x2d0d5
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/maf.c
// Function: mafAliFree
void mafAliFree(struct mafAli **pObj)
/* Free up a maf alignment. */
{
struct mafAli *obj = *pObj;
if (obj == NULL)
    return;
mafCompFreeList(&obj->components);
mafRegDefFree(&obj->regDef);
freez(pObj);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
testq %r14, %r14
je 0x2d14d
movq %rdi, %rbx
leaq 0x10(%r14), %rdi
callq 0x2d027
addq $0x20, %r14
movq %r14, %rdi
callq 0x2d155
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2e0b0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/maf.c
// Function: mafRegDefFree
void mafRegDefFree(struct mafRegDef **mrdPtr)
/* Free a mafRegDef object */
{
struct mafRegDef *mrd = *mrdPtr;
if (mrd != NULL)
    {
    freeMem(mrd->id);
    freeMem(mrd);
    *mrdPtr = NULL;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
testq %r14, %r14
je 0x2d17c
movq %rdi, %rbx
movq 0x10(%r14), %rdi
callq 0x2e0a0
movq %r14, %rdi
callq 0x2e0a0
movq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/maf.c
// Function: mafAliFreeList
void mafAliFreeList(struct mafAli **pList)
/* Free up a list of maf alignmentx. */
{
struct mafAli *el, *next;

for (el = *pList; el != NULL; el = next)
    {
    next = el->next;
    mafAliFree(&el);
    }
*pList = NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %r15
movq %r15, 0x8(%rsp)
testq %r15, %r15
je 0x2d1b7
leaq 0x8(%rsp), %r14
movq (%r15), %r15
movq %r14, %rdi
callq 0x2d11a
movq %r15, 0x8(%rsp)
testq %r15, %r15
jne 0x2d1a2
movq $0x0, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/maf.c
// Function: mafFileFree
void mafFileFree(struct mafFile **pObj)
/* Free up a maf file. */
{
struct mafFile *obj = *pObj;
if (obj == NULL)
    return;
lineFileClose(&obj->lf);
freeMem(obj->scoring);
mafAliFreeList(&obj->alignments);
freez(pObj);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
testq %r14, %r14
je 0x2d204
movq %rdi, %rbx
leaq 0x20(%r14), %rdi
callq 0x2ae73
movq 0x10(%r14), %rdi
callq 0x2e0a0
addq $0x18, %r14
movq %r14, %rdi
callq 0x2d184
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2e0b0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/maf.c
// Function: mafFileFreeList
void mafFileFreeList(struct mafFile **pList)
/* Free up a list of maf files. */
{
struct mafFile *el, *next;

for (el = *pList; el != NULL; el = next)
    {
    next = el->next;
    mafFileFree(&el);
    }
*pList = NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %r15
movq %r15, 0x8(%rsp)
testq %r15, %r15
je 0x2d23f
leaq 0x8(%rsp), %r14
movq (%r15), %r15
movq %r14, %rdi
callq 0x2d1c8
movq %r15, 0x8(%rsp)
testq %r15, %r15
jne 0x2d22a
movq $0x0, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/maf.c
// Function: mafMayFindComponentDb
struct mafComp *mafMayFindComponentDb(struct mafAli *maf, char *db)
/* Find component of given database, allowing component to be 
 * labeled "db", or "db.chrom" . Return NULL if not found. */
{
struct mafComp *mc;
char *p, *q;
for (mc = maf->components; mc != NULL; mc = mc->next)
    {
    for (p = mc->src, q = db; *p && *q; p++, q++)
        {
        if (*p != *q)
            break;
        }
    if (*p == '.' && *q == 0)
        return mc;
    if (*p == *q)
        return mc;
    }
return NULL;
}

// Assembly:
movq %rdi, %rax
addq $0x10, %rax
movq (%rax), %rax
testq %rax, %rax
je 0x2d2cf
movq 0x8(%rax), %rdi
movb (%rdi), %cl
testb %cl, %cl
je 0x2d2b8
incq %rdi
movq %rsi, %rdx
movb (%rdx), %r8b
cmpb %r8b, %cl
jne 0x2d2bf
incq %rdx
movb (%rdi), %cl
incq %rdi
testb %cl, %cl
jne 0x2d2a0
xorl %ecx, %ecx
jmp 0x2d2cb
xorl %ecx, %ecx
movq %rsi, %rdx
jmp 0x2d2cb
cmpb $0x2e, %cl
jne 0x2d2cb
movb $0x2e, %cl
testb %r8b, %r8b
je 0x2d2cf
cmpb (%rdx), %cl
jne 0x2d288
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/maf.c
// Function: mafFindComponent
struct mafComp *mafFindComponent(struct mafAli *maf, char *src)
/* Find component of given source or die trying. */
{
struct mafComp *mc = mafMayFindComponent(maf, src);
if (mc == NULL)
    errAbort("Couldn't find %s in maf", src);
return mc;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x10, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x2d2f8
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x6a50
testl %eax, %eax
jne 0x2d2de
jmp 0x2d309
leaq 0x646d1(%rip), %rdi     # 0x919d0
movq %r14, %rsi
xorl %eax, %eax
callq 0x26e94
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/maf.c
// Function: mafMayFindCompSpecies
struct mafComp *mafMayFindCompSpecies(struct mafAli *maf, char *species, char sepChar)
/* Find component of given source that starts with species possibly followed by sepChar or \0 .
   Return NULL if not found. */
{
struct mafComp *mc;
int speciesLen = strlen(species);

for (mc = maf->components; mc != NULL; mc = mc->next)
    {
    if (startsWith(species, mc->src) )
	{
	char endChar = mc->src[speciesLen];

	if ((endChar == '\0') || (endChar == sepChar))
	    return mc;
	}
    }
return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x10(%rdi), %rbx
testq %rbx, %rbx
je 0x2d35d
movl %edx, %ebp
movq %rsi, %r14
movq %rsi, %rdi
callq 0x62d0
movslq %eax, %r15
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x21b23
testl %eax, %eax
je 0x2d355
movq 0x8(%rbx), %rax
movb (%rax,%r15), %al
testb %al, %al
je 0x2d35f
cmpb %bpl, %al
je 0x2d35f
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x2d334
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/maf.c
// Function: mafFindCompSpecies
struct mafComp *mafFindCompSpecies(struct mafAli *maf, char *species, char sepChar)
/* Find component of given source that starts with species followed by sepChar
   or die trying. */
{
struct mafComp *mc = mafMayFindCompSpecies(maf, species, sepChar);
if (mc == NULL)
    errAbort("Couldn't find %s%c or just %s... in maf", species,sepChar,species);
return mc;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
callq 0x2d314
movq %rax, %r14
testq %rax, %rax
jne 0x2d39b
movsbl %bpl, %edx
leaq 0x6465a(%rip), %rdi     # 0x919e8
movq %rbx, %rsi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x26e94
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/maf.c
// Function: mafMayFindCompPrefix
struct mafComp *mafMayFindCompPrefix(struct mafAli *maf, char *pre, char *sep)
/* Find component of given source that starts with pre followed by sep.
   Return NULL if not found. */
{
struct mafComp *mc;
char prefix[256];

if (sep == NULL)
    sep = "";
snprintf(prefix, 256, "%s%s", pre, sep);

for (mc = maf->components; mc != NULL; mc = mc->next)
    {
    if (startsWith(prefix, mc->src))
        return mc;
    }
return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rsi, %rcx
movq %rdi, %rbx
testq %rdx, %rdx
leaq 0x6b097(%rip), %r8      # 0x98454
cmovneq %rdx, %r8
leaq 0x6407c(%rip), %rdx     # 0x91444
movq %rsp, %r14
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
xorl %eax, %eax
callq 0x6c20
addq $0x10, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x2d3f6
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x21b23
testl %eax, %eax
je 0x2d3de
movq %rbx, %rax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/maf.c
// Function: mafFindCompPrefix
struct mafComp *mafFindCompPrefix(struct mafAli *maf, char *pre, char *sep)
/* Find component of given source that starts with pre followed by sep
   or die trying. */
{
struct mafComp *mc = mafMayFindCompPrefix(maf, pre, sep);
if (mc == NULL)
    errAbort("Couldn't find %s%s... in maf", pre,sep);
return mc;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
callq 0x2d3a3
movq %rax, %r15
testq %rax, %rax
jne 0x2d430
leaq 0x645ed(%rip), %rdi     # 0x91a10
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x26e94
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/maf.c
// Function: mafMayFindSpeciesInHash
struct mafComp *mafMayFindSpeciesInHash(struct mafAli *maf, struct hash *cHash, char sepChar) 
/* Find arbitrary component of given who's source prefix (ended by sep)
   matches matches any string in the cHash.  Return NULL if not found. */
{
struct mafComp *mc;

for (mc = maf->components; mc != NULL; mc = mc->next)
    {
    char *sep = strchr(mc->src, sepChar);
    if (sep != NULL)
        *sep = '\0';
    boolean hit = hashFindVal(cHash, mc->src) != NULL;
    if (sep != NULL)
        *sep = sepChar;
    if (hit)
        return mc;
    }
return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x10(%rdi), %rbx
testq %rbx, %rbx
je 0x2d4cc
movl %edx, %ebp
movq %rsi, %r14
movsbl %bpl, %r15d
movq 0x8(%rbx), %r13
movq %r13, %rdi
movl %r15d, %esi
callq 0x6270
testq %rax, %rax
je 0x2d4b4
movq %rax, %r12
movb $0x0, (%rax)
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x293ad
movb %bpl, (%r12)
jmp 0x2d4bf
movq %r14, %rdi
movq %r13, %rsi
callq 0x293ad
testq %rax, %rax
jne 0x2d4ce
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x2d488
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/maf.c
// Function: mafMayFindAllComponents
boolean mafMayFindAllComponents(struct mafAli *maf, struct hash *cHash) 
/* Find component of given source that starts matches any string in the cHash.
   Return NULL if not found. */
{
struct hashCookie cookie = hashFirst(cHash);
struct hashEl *el;

while ((el = hashNext(&cookie)) != NULL)
    if (mafMayFindComponent(maf, el->name) == NULL)
	return FALSE;
return TRUE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x297ec
movq %r14, %rdi
callq 0x2982c
movl $0x1, %ebp
testq %rax, %rax
je 0x2d549
addq $0x10, %rbx
leaq 0x8(%rsp), %r14
movq 0x8(%rax), %r15
movq %rbx, %r12
movq (%r12), %r12
testq %r12, %r12
je 0x2d547
movq 0x8(%r12), %rdi
movq %r15, %rsi
callq 0x6a50
testl %eax, %eax
jne 0x2d51e
movq %r14, %rdi
callq 0x2982c
testq %rax, %rax
jne 0x2d517
jmp 0x2d549
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/maf.c
// Function: mafNeedSubset
boolean mafNeedSubset(struct mafAli *maf, char *componentSource,
	int newStart, int newEnd)
/* Return TRUE if maf only partially fits between newStart/newEnd
 * in given component. */
{
struct mafComp *mcMaster = mafFindComponent(maf, componentSource);

/* Reverse complement input range if necessary. */
if (mcMaster->strand == '-')
    reverseIntRange(&newStart, &newEnd, mcMaster->srcSize);

return newStart > mcMaster->start || newEnd < mcMaster->start + mcMaster->size;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movl %edx, 0xc(%rsp)
movl %ecx, 0x8(%rsp)
callq 0x2d2d0
movq %rax, %rbx
cmpb $0x2d, 0x14(%rax)
jne 0x2d7b6
movl 0x10(%rbx), %edx
leaq 0xc(%rsp), %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x25472
movl (%r14), %ebp
movl 0x18(%rbx), %ecx
movl $0x1, %eax
cmpl %ecx, %ebp
jg 0x2d7ce
addl 0x1c(%rbx), %ecx
xorl %eax, %eax
cmpl %ecx, 0x8(%rsp)
setl %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/maf.c
// Function: mafFlipStrand
void mafFlipStrand(struct mafAli *maf)
/* Reverse complement maf. */
{
struct mafComp *mc;
for (mc = maf->components; mc != NULL; mc = mc->next)
    {
    int e = mc->start + mc->size;
    reverseIntRange(&mc->start, &e, mc->srcSize);
    if (mc->text != NULL)
        reverseComplement(mc->text, maf->textSize);
    if (mc->quality != NULL)
	reverseBytes(mc->quality, maf->textSize);
    if (mc->strand == '-')
        mc->strand = '+';
    else
        mc->strand = '-';
    char holdStatus = mc->leftStatus;
    mc->leftStatus = mc->rightStatus;
    mc->rightStatus = holdStatus;
    int holdLen = mc->leftLen;
    mc->leftLen = mc->rightLen;
    mc->rightLen = holdLen;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0x10(%rdi), %r15
testq %r15, %r15
je 0x2d86e
movq %rdi, %rbx
leaq 0xc(%rsp), %r14
leaq 0x18(%r15), %rdi
movl 0x1c(%r15), %eax
addl 0x18(%r15), %eax
movl %eax, 0xc(%rsp)
movl 0x10(%r15), %edx
movq %r14, %rsi
callq 0x25472
movq 0x20(%r15), %rdi
testq %rdi, %rdi
je 0x2d823
movslq 0x18(%rbx), %rsi
callq 0x25423
movq 0x28(%r15), %rdi
testq %rdi, %rdi
je 0x2d835
movslq 0x18(%rbx), %rsi
callq 0x1ffa2
movb 0x30(%r15), %al
cmpb $0x2d, 0x14(%r15)
setne %cl
addb %cl, %cl
addb $0x2b, %cl
movb %cl, 0x14(%r15)
movb 0x38(%r15), %cl
movb %cl, 0x30(%r15)
movb %al, 0x38(%r15)
movl 0x34(%r15), %eax
movl 0x3c(%r15), %ecx
movl %ecx, 0x34(%r15)
movl %eax, 0x3c(%r15)
movq (%r15), %r15
testq %r15, %r15
jne 0x2d7f5
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/maf.c
// Function: mafSrcDb
void mafSrcDb(char *name, char *retDb, int retDbSize)
/* Parse out just database part of name (up to but not including
 * first dot). If dot found, return entire name */
{
int len;
char *e = strchr(name, '.');
/* Put prefix up to dot into buf. */
len = (e == NULL ? strlen(name) : e - name);
if (len >= retDbSize)
     len = retDbSize-1;
memcpy(retDb, name, len);
retDb[len] = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
movl $0x2e, %esi
callq 0x6270
testq %rax, %rax
je 0x2d89a
subq %r14, %rax
jmp 0x2d8a2
movq %r14, %rdi
callq 0x62d0
leal -0x1(%r15), %ecx
cmpl %r15d, %eax
cmovll %eax, %ecx
movslq %ecx, %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x6570
movb $0x0, (%rbx,%r15)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/maf.c
// Function: mafColumnEmpty
boolean mafColumnEmpty(struct mafAli *maf, int col)
/* Return TRUE if the column is all '-' or '.' */
{
assert(col < maf->textSize);
struct mafComp *comp;
for (comp = maf->components; comp != NULL; comp = comp->next)
    if (comp->text != NULL)
        {
        char c = comp->text[col];
        if (c != '.' && c != '-')
            return FALSE;
        }
return TRUE;
}

// Assembly:
pushq %rax
cmpl %esi, 0x18(%rdi)
jle 0x2d904
movq 0x10(%rdi), %rcx
movl $0x1, %eax
testq %rcx, %rcx
je 0x2d902
movslq %esi, %rdx
movq 0x20(%rcx), %rsi
testq %rsi, %rsi
je 0x2d8f6
movb (%rsi,%rdx), %sil
addb $-0x2d, %sil
cmpb $0x1, %sil
ja 0x2d900
movq (%rcx), %rcx
testq %rcx, %rcx
jne 0x2d8df
jmp 0x2d902
xorl %eax, %eax
popq %rcx
retq
leaq 0x64122(%rip), %rdi     # 0x91a2d
leaq 0x6412f(%rip), %rsi     # 0x91a41
leaq 0x64132(%rip), %rcx     # 0x91a4b
movl $0x315, %edx            # imm = 0x315
callq 0x6460
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/maf.c
// Function: mafStripEmptyColumns
void mafStripEmptyColumns(struct mafAli *maf)
/* Remove columns that are all '-' or '.' from  maf. */
{
/* Selectively copy over non-empty columns. */
int readIx=0, writeIx = 0;
struct mafComp *comp;
for (readIx=0; readIx < maf->textSize; ++readIx)
    {
    if (!mafColumnEmpty(maf, readIx))
        {
        for (comp = maf->components; comp != NULL; comp = comp->next) 
            {
            if(comp->text != NULL)
                comp->text[writeIx] = comp->text[readIx];
            if (comp->quality != NULL)
                comp->quality[writeIx] = comp->quality[readIx];
            }
        ++writeIx;
        }
    }
/* Zero terminate text, and update textSize. */
for (comp = maf->components; comp != NULL; comp = comp->next)
    {
    if (comp->text != NULL)
        comp->text[writeIx] = 0;
    if (comp->quality != NULL)
        comp->quality[writeIx] = 0;
    }
maf->textSize = writeIx;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x18(%rdi)
jle 0x2d98a
xorl %r14d, %r14d
xorl %ebp, %ebp
movq %rbx, %rdi
movl %r14d, %esi
callq 0x2d8c8
testl %eax, %eax
jne 0x2d97c
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x2d97a
movslq %ebp, %rcx
movq 0x20(%rax), %rdx
testq %rdx, %rdx
je 0x2d961
movb (%rdx,%r14), %sil
movb %sil, (%rdx,%rcx)
movq 0x28(%rax), %rdx
testq %rdx, %rdx
je 0x2d972
movb (%rdx,%r14), %sil
movb %sil, (%rdx,%rcx)
movq (%rax), %rax
testq %rax, %rax
jne 0x2d950
incl %ebp
incq %r14
movslq 0x18(%rbx), %rax
cmpq %rax, %r14
jl 0x2d935
jmp 0x2d98c
xorl %ebp, %ebp
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x2d9ba
movslq %ebp, %rcx
movq 0x20(%rax), %rdx
testq %rdx, %rdx
je 0x2d9a5
movb $0x0, (%rdx,%rcx)
movq 0x28(%rax), %rdx
testq %rdx, %rdx
je 0x2d9b2
movb $0x0, (%rdx,%rcx)
movq (%rax), %rax
testq %rax, %rax
jne 0x2d998
movl %ebp, 0x18(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/icebert[P]pblat/lib/maf.c
// Function: mafRegDefNew
struct mafRegDef *mafRegDefNew(char *type, int size, char *id)
/* construct a new mafRegDef object */
{
struct mafRegDef *mrd;
AllocVar(mrd);
if (sameString(type, mafRegDefTxUpstream))
    mrd->type = mafRegDefTxUpstream;
else
    errAbort("invalid mafRefDef type: %s", type);
mrd->size = size;
mrd->id = cloneString(id);
return mrd;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r15
movl $0x18, %edi
callq 0x2dff4
movq %rax, %r14
movq 0x93212(%rip), %r12     # 0xc0bf8
movq %r15, %rdi
movq %r12, %rsi
callq 0x6a50
testl %eax, %eax
je 0x2da08
leaq 0x64078(%rip), %rdi     # 0x91a74
movq %r15, %rsi
xorl %eax, %eax
callq 0x26e94
jmp 0x2da0b
movq %r12, (%r14)
movl %ebp, 0x8(%r14)
movq %rbx, %rdi
callq 0x1feba
movq %rax, 0x10(%r14)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq