LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/ffScore.c
// Function: ffCalcCdnaGapPenalty
int ffCalcCdnaGapPenalty(int hGap, int nGap)
/* Return gap penalty for given h and n gaps. */
{
int acc = 2;
if (hGap > 400000)	/* Discourage really long introns. */
    {
    acc += (hGap - 400000)/3000;
    if (hGap > ffIntronMax)
        acc += (hGap - ffIntronMax)/2000;
    }
if (hGap < 0)   /* Discourage jumping back in haystack. */
    {
    hGap = -8*hGap;
    if (hGap > 48)
        hGap = (hGap*hGap);
    }
if (nGap < 0)   /* Jumping back in needle gets rid of previous alignment. */
    {
    acc += -nGap;
    nGap = 0;
    }
acc += digitsBaseTwo(hGap)/2;
if (nGap != 0)
    {
    acc += digitsBaseTwo(nGap);
    }
else
    {
    if (hGap > 30)
	acc -= 1;
    }
return acc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x2, -0xc(%rbp)
cmpl $0x61a80, -0x4(%rbp)    # imm = 0x61A80
jle 0x38058
movl -0x4(%rbp), %eax
subl $0x61a80, %eax          # imm = 0x61A80
movl $0xbb8, %ecx            # imm = 0xBB8
cltd
idivl %ecx
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %eax
cmpl 0xcec63(%rip), %eax     # 0x106ca0
jle 0x38056
movl -0x4(%rbp), %eax
subl 0xcec58(%rip), %eax     # 0x106ca0
movl $0x7d0, %ecx            # imm = 0x7D0
cltd
idivl %ecx
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x38058
cmpl $0x0, -0x4(%rbp)
jge 0x3807a
imull $0xfffffff8, -0x4(%rbp), %eax # imm = 0xFFFFFFF8
movl %eax, -0x4(%rbp)
cmpl $0x30, -0x4(%rbp)
jle 0x38078
movl -0x4(%rbp), %eax
imull -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3807a
cmpl $0x0, -0x8(%rbp)
jge 0x38092
xorl %eax, %eax
subl -0x8(%rbp), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl $0x0, -0x8(%rbp)
movslq -0x4(%rbp), %rdi
callq 0x475f0
movl $0x2, %ecx
cltd
idivl %ecx
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x380c0
movslq -0x8(%rbp), %rdi
callq 0x475f0
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x380d1
cmpl $0x1e, -0x4(%rbp)
jle 0x380cf
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x380d1
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/ffScore.c
// Function: ffCalcGapPenalty
int ffCalcGapPenalty(int hGap, int nGap, enum ffStringency stringency)
/* Return gap penalty for given h and n gaps. */
{
switch (stringency)
    {
    case ffCdna:
	return ffCalcCdnaGapPenalty(hGap, nGap);
    case ffTight:
	return calcTightGap(hGap,nGap);
    case ffLoose:
	return calcLooseGap(hGap,nGap);
    default:
        errAbort("Unknown stringency type %d", stringency);
	return 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
subl $0x1, %eax
je 0x38112
jmp 0x380fe
movl -0x14(%rbp), %eax
subl $0x2, %eax
je 0x38122
jmp 0x38108
movl -0x14(%rbp), %eax
subl $0x3, %eax
je 0x38132
jmp 0x38142
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0x38000
movl %eax, -0x4(%rbp)
jmp 0x3815a
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0x38170
movl %eax, -0x4(%rbp)
jmp 0x3815a
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0x38200
movl %eax, -0x4(%rbp)
jmp 0x3815a
movl -0x10(%rbp), %esi
leaq 0xa28f4(%rip), %rdi     # 0xdaa40
movb $0x0, %al
callq 0x35d40
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/ffScore.c
// Function: calcTightGap
static int calcTightGap(int hGap, int nGap)
/* Figure out gap penalty using tight model (gaps bad!) */
{
if (hGap == 0 && nGap == 0)
    return 0;
else
    {
    int overlap = min(hGap, nGap);
    int penalty = 8;
    if (overlap < 0)
	overlap = 0;

    if (hGap < 0)
	hGap = -8*hGap;
    if (nGap < 0)
	nGap = -2*nGap;
    penalty += (hGap-overlap + nGap-overlap) + overlap;
    return penalty;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x3818f
cmpl $0x0, -0xc(%rbp)
jne 0x3818f
movl $0x0, -0x4(%rbp)
jmp 0x381fa
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x3819f
movl -0x8(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x381a5
movl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x10(%rbp)
movl $0x8, -0x14(%rbp)
cmpl $0x0, -0x10(%rbp)
jge 0x381bf
movl $0x0, -0x10(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x381cf
imull $0xfffffff8, -0x8(%rbp), %eax # imm = 0xFFFFFFF8
movl %eax, -0x8(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x381df
imull $0xfffffffe, -0xc(%rbp), %eax # imm = 0xFFFFFFFE
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
subl -0x10(%rbp), %eax
addl -0xc(%rbp), %eax
subl -0x10(%rbp), %eax
addl -0x10(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/ffScore.c
// Function: calcLooseGap
static int calcLooseGap(int hGap, int nGap)
/* Figure out gap penalty using loose model (gaps not so bad) */
{
if (hGap == 0 && nGap == 0)
    return 0;
else
    {
    int overlap = min(hGap, nGap);
    int penalty = 8;
    if (overlap < 0)
	overlap = 0;

    if (hGap < 0)
	hGap = -8*hGap;
    if (nGap < 0)
	nGap = -2*nGap;
    penalty += log(hGap-overlap+1) + log(nGap-overlap+1);
    return penalty;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x38226
cmpl $0x0, -0xc(%rbp)
jne 0x38226
movl $0x0, -0x4(%rbp)
jmp 0x382be
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x38236
movl -0x8(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x3823c
movl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x10(%rbp)
movl $0x8, -0x14(%rbp)
cmpl $0x0, -0x10(%rbp)
jge 0x38256
movl $0x0, -0x10(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x38266
imull $0xfffffff8, -0x8(%rbp), %eax # imm = 0xFFFFFFF8
movl %eax, -0x8(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x38276
imull $0xfffffffe, -0xc(%rbp), %eax # imm = 0xFFFFFFFE
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
subl -0x10(%rbp), %eax
addl $0x1, %eax
cvtsi2sd %eax, %xmm0
callq 0x6550
movsd %xmm0, -0x20(%rbp)
movl -0xc(%rbp), %eax
subl -0x10(%rbp), %eax
addl $0x1, %eax
cvtsi2sd %eax, %xmm0
callq 0x6550
movsd -0x20(%rbp), %xmm1
addsd %xmm0, %xmm1
cvtsi2sdl -0x14(%rbp), %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/ffScore.c
// Function: ffScoreSomeAlis
int ffScoreSomeAlis(struct ffAli *ali, int count, enum ffStringency stringency)
/* Figure out score of count alis. */
{
int score = 0;
int oneScore;

while (--count >= 0)
    {
    int len = ali->hEnd - ali->hStart;
    struct ffAli *right = ali->right;
    oneScore = dnaScoreMatch(ali->hStart, ali->nStart, len);
    score += oneScore;
    if (count > 0)  /* Calculate gap penalty */
        score -= ffGapPenalty(ali, right,stringency);
    ali = right;
    }
return score;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
jl 0x38417
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rcx
subq %rcx, %rax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movl -0x1c(%rbp), %edx
callq 0x34030
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x3840d
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x10(%rbp), %edx
callq 0x38320
movl %eax, %ecx
movl -0x14(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x14(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x38399
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/ffScore.c
// Function: ffScoreSomething
int ffScoreSomething(struct ffAli *ali, enum ffStringency stringency,
   boolean isProt)
/* Score alignment. */
{
int score = 0;
int oneScore;
int (*scoreMatch)(char *a, char *b, int size);

if (ali == NULL)
    return -0x7FFFFFFF;
scoreMatch = (isProt ? aaScoreMatch : dnaScoreMatch );
while (ali->left != NULL) ali = ali->left;
while (ali != NULL)
    {
    int len = ali->hEnd - ali->hStart;
    struct ffAli *right = ali->right;
    oneScore = scoreMatch(ali->hStart, ali->nStart, len);
    score += oneScore;
    if (right)  /* Calculate gap penalty */
        {
        score -= ffGapPenalty(ali, right, stringency);
        }
    ali = right;
    }
return score;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3844c
movl $0x80000001, -0x4(%rbp) # imm = 0x80000001
jmp 0x38500
movl -0x18(%rbp), %edx
leaq -0x4426(%rip), %rax     # 0x34030
leaq -0x439d(%rip), %rcx     # 0x340c0
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x3847f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x38468
jmp 0x38481
cmpq $0x0, -0x10(%rbp)
je 0x384fa
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
subq %rcx, %rax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rdi
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rsi
movl -0x2c(%rbp), %edx
callq *%rax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x384f0
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x38320
movl %eax, %ecx
movl -0x1c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x38481
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/filePath.c
// Function: findSlashBefore
static char *findSlashBefore(char *start, char *e)
/* Return first slash before s (but not before start) */
{
while (--e >= start)
    {
    if (*e == '/')
         return e;
    }
return start;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
cmpq -0x10(%rbp), %rax
jb 0x38946
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x38944
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3894e
jmp 0x3891c
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/filePath.c
// Function: mustExpandRelativePath
char *mustExpandRelativePath(char *dir, char* relPath)
/* Given a dir and relative path, expand path.
 * Handy for processing symlinks. errAbort if expand fails.
 * Result should be freeMem'd.*/
{
char *path = expandRelativePath(dir, relPath);
verbose(3, "dir=%s\nrelPath=%s\npath=%s\n", dir, relPath, path);
if (!path)
    errAbort("Too many .. in path %s to make relative to submitDir %s\n", relPath, dir);
return path;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x38770
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
movl $0x3, %edi
leaq 0xa2133(%rip), %rsi     # 0xdaacc
movb $0x0, %al
callq 0x60040
cmpq $0x0, -0x18(%rbp)
jne 0x389bd
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
leaq 0xa2131(%rip), %rdi     # 0xdaae7
movb $0x0, %al
callq 0x35d40
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x210(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x385d0
leaq -0x210(%rbp), %rdi
callq 0x62c0
movl %eax, -0x214(%rbp)
cmpl $0x0, -0x214(%rbp)
jle 0x38a40
movl -0x214(%rbp), %eax
subl $0x1, %eax
cltq
movsbl -0x210(%rbp,%rax), %eax
cmpl $0x2f, %eax
jne 0x38a40
movl -0x214(%rbp), %eax
subl $0x1, %eax
cltq
movb $0x0, -0x210(%rbp,%rax)
leaq -0x210(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x38770
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x389d0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
movl $0x3, %edi
leaq 0xa2087(%rip), %rsi     # 0xdab20
movb $0x0, %al
callq 0x60040
cmpq $0x0, -0x18(%rbp)
jne 0x38abd
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
leaq 0xa208a(%rip), %rdi     # 0xdab40
movb $0x0, %al
callq 0x35d40
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x390f2
movl $0xc, -0xc(%rbp)
cmpl $0x1c, -0xc(%rbp)
jle 0x390ff
movl $0x1c, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x39110
jmp 0x3922a
cmpl $0x1c, -0xc(%rbp)
jg 0x3911e
cmpl $0x0, -0xc(%rbp)
jle 0x3911e
jmp 0x3913d
leaq 0xa1adc(%rip), %rdi     # 0xdac01
leaq 0xa1b09(%rip), %rsi     # 0xdac35
movl $0x191, %edx            # imm = 0x191
leaq 0xa1b2a(%rip), %rcx     # 0xdac62
callq 0x6450
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
movl -0xc(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %ecx
subl $0x1, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movslq 0x1c(%rax), %rdi
shlq $0x3, %rdi
callq 0x409d0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x3920b
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x391fe
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x8(%rbp), %rcx
andl 0x8(%rcx), %eax
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x34(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x391a6
jmp 0x39200
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3918e
movq -0x8(%rbp), %rdi
callq 0x399b0
movq -0x18(%rbp), %rdi
callq 0x40d40
movq -0x8(%rbp), %rax
movl 0x34(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x34(%rax)
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jge 0x39a19
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x39a0c
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x39a0c
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movslq -0xc(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x2aad0
jmp 0x39a0e
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x399c3
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x39a4d
movq $0x0, -0x8(%rbp)
jmp 0x39a96
xorl %edi, %edi
movl $0x1, %esi
callq 0x398a0
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x39a8e
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x8, %rsi
movq -0x28(%rbp), %rdx
callq 0x39230
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x39a65
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x39acd
movq $0x0, -0x8(%rbp)
jmp 0x39b16
xorl %edi, %edi
movl $0x1, %esi
callq 0x398a0
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x39b0e
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x8, %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x39230
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x39ae5
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3a60d
movq $0x0, -0x8(%rbp)
jmp 0x3a67d
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x2c680
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3a630
movq $0x0, -0x8(%rbp)
jmp 0x3a67d
xorl %edi, %edi
movl $0x1, %esi
callq 0x398a0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x3a675
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x39230
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x3a648
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
xorl %edi, %edi
movl $0x1, %esi
callq 0x398a0
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x3a6e2
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x39230
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3a6b6
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
xorl %edi, %edi
movl $0x1, %esi
callq 0x398a0
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x3a757
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdx
callq 0x39230
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3a716
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x70(%rax)
jne 0x3b0af
leaq 0x9fcf7(%rip), %rdi     # 0xdad9f
movb $0x0, %al
callq 0x35d40
cmpq $0x0, -0x18(%rbp)
jne 0x3b0c2
movl $0x0, -0x4(%rbp)
jmp 0x3b1a7
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x78be0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x3b109
movq -0x18(%rbp), %rsi
leaq 0x9fd0f(%rip), %rdi     # 0xdadf6
callq 0x2d3d0
cmpl $0x0, %eax
je 0x3b109
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x3, %rsi
callq 0x78be0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x3b11b
movl $0x0, -0x4(%rbp)
jmp 0x3b1a7
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rax
movq 0x18(%rax), %rdi
movl -0x24(%rbp), %esi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
leaq 0x3dff9(%rip), %r8      # 0x79130
callq 0x76200
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x3b150
movl $0x0, -0x4(%rbp)
jmp 0x3b1a7
movq -0x10(%rbp), %rax
cmpq $0x0, 0x78(%rax)
je 0x3b168
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rdi
callq 0x76b80
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x78(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x28(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movl $0x0, 0x2c(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x30(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3b1d7
leaq 0x9fc2a(%rip), %rdi     # 0xdadfa
movb $0x0, %al
callq 0x35d40
movq -0x10(%rbp), %rdi
callq 0x5eef0
cmpl $0x0, %eax
je 0x3b1fb
movq -0x10(%rbp), %rdi
movsbl -0x11(%rbp), %esi
callq 0x3b290
movq %rax, -0x8(%rbp)
jmp 0x3b282
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5cca0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3b21d
movq $0x0, -0x8(%rbp)
jmp 0x3b282
movl $0xc8, %edi
callq 0x40c50
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2a450
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
movq -0x28(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x40(%rax)
movb -0x11(%rbp), %cl
movq -0x28(%rbp), %rax
movb %cl, 0x34(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x88(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x9fa0c(%rip), %rsi     # 0xdae8a
callq 0x3b560
movq -0x8(%rbp), %rax
cmpq $0x0, 0xb0(%rax)
je 0x3b4a9
movq -0x8(%rbp), %rax
movq 0xb0(%rax), %rax
movq -0x8(%rbp), %rdi
leaq 0x9f9e3(%rip), %rsi     # 0xdae8a
callq *%rax
movq -0x8(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x3b4ca
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x9f9d4(%rip), %rdi     # 0xdae97
movb $0x0, %al
callq 0x35ee0
movq -0x8(%rbp), %rax
movb $0x0, 0x3c(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x88(%rax)
je 0x3b4f6
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x5ea30
jmp 0x3b54e
movq -0x8(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x2c(%rax)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %edi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x65b0
movq -0x8(%rbp), %rcx
movq %rax, 0x18(%rcx)
cmpq $-0x1, %rax
jne 0x3b54e
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x9f97c(%rip), %rdi     # 0xdaec3
movb $0x0, %al
callq 0x35ee0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x3bd52
jmp 0x3bdee
movq -0x8(%rbp), %rax
cmpl $0x0, 0x38(%rax)
je 0x3bd61
jmp 0x3bdee
jmp 0x3bd63
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x3bdee
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xd, %eax
jne 0x3bdc5
movq -0x8(%rbp), %rax
movl $0x3, 0x38(%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x3bdc3
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x3bdc1
movq -0x8(%rbp), %rax
movl $0x2, 0x38(%rax)
jmp 0x3bdc3
jmp 0x3bdee
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x3bde9
movq -0x8(%rbp), %rax
movl $0x1, 0x38(%rax)
jmp 0x3bdee
jmp 0x3bd63
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x3c25a
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3c156
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
callq 0x4c5b0
jmp 0x3c21c
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jle 0x3c19d
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x24(%rbp)
movq 0xc8e57(%rip), %rax     # 0x104fc8
movq (%rax), %rdi
callq 0x6740
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
je 0x3c19d
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edi
callq 0x6e90
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x40d40
jmp 0x3c21a
movq -0x10(%rbp), %rax
cmpq $0x0, 0x70(%rax)
je 0x3c1f8
movq -0x10(%rbp), %rax
cmpq $0x0, 0x78(%rax)
je 0x3c1c0
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rdi
callq 0x76b80
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x79810
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x723b0
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6880
jmp 0x3c218
movq -0x10(%rbp), %rax
cmpq $0x0, 0x88(%rax)
je 0x3c216
movq -0x10(%rbp), %rdi
addq $0x88, %rdi
callq 0x5d870
jmp 0x3c218
jmp 0x3c21a
jmp 0x3c21c
movq -0x10(%rbp), %rax
cmpq $0x0, 0xc0(%rax)
je 0x3c23b
movq -0x10(%rbp), %rax
movq 0xc0(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x40d40
movq -0x10(%rbp), %rdi
callq 0x3c260
movq -0x8(%rbp), %rdi
callq 0x40d70
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x3e242
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
leaq 0x9d285(%rip), %rdi     # 0xdb4c0
movb $0x0, %al
callq 0x35d40
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x14(%rbp), %rsi
shlq $0x3, %rsi
callq 0x3de60
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x3e29d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x3e050
movq %rax, %rdx
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3e266
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x9d244(%rip), %rax     # 0xdb537
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x45c50
cmpl $0x0, %eax
je 0x3e319
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x3b1b0
movq %rax, -0x20(%rbp)
jmp 0x3e32b
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x3b3a0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3e33f
movq $0x0, -0x8(%rbp)
jmp 0x3e480
movl $0x28, %edi
callq 0x40c50
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x3c0d0
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x2d3d0
cmpl $0x0, %eax
jne 0x3e392
movq -0x10(%rbp), %rsi
movq -0x38(%rbp), %rdx
leaq 0x9d1b2(%rip), %rdi     # 0xdb53d
movb $0x0, %al
callq 0x35d40
movq -0x38(%rbp), %rdi
callq 0x62c0
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2f230
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x3e45c
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
movl $0x3d, %esi
callq 0x6260
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x3e3f1
movq -0x40(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0x9d16d(%rip), %rdi     # 0xdb557
movb $0x0, %al
callq 0x35d40
movq -0x48(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x48(%rbp)
movb $0x0, (%rax)
movq -0x40(%rbp), %rdi
leaq 0x9f902(%rip), %rsi     # 0xddd10
callq 0x6a40
cmpl $0x0, %eax
jne 0x3e42c
movq -0x48(%rbp), %rdi
callq 0x6bd0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
jmp 0x3e457
movq -0x40(%rbp), %rdi
leaq 0x9d141(%rip), %rsi     # 0xdb578
callq 0x6a40
cmpl $0x0, %eax
jne 0x3e455
movq -0x48(%rbp), %rdi
callq 0x2a450
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x3e457
jmp 0x3e3a3
movq -0x18(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x3e478
movq -0x10(%rbp), %rsi
leaq 0x9d10f(%rip), %rdi     # 0xdb580
movb $0x0, %al
callq 0x35d40
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3e2e0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3e4c2
movq -0x8(%rbp), %rsi
leaq 0x9d0de(%rip), %rdi     # 0xdb599
movb $0x0, %al
callq 0x35ee0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/maf.c
// Function: nextLine
static boolean nextLine(struct lineFile *lf, char **pLine)
/* Get next line that is not a comment. */
{
for (;;)
    {
    if (!lineFileNext(lf, pLine, NULL))
        return FALSE;
    if (**pLine != '#')
        return TRUE;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x3b660
cmpl $0x0, %eax
jne 0x3eb4f
movl $0x0, -0x4(%rbp)
jmp 0x3eb69
movq -0x18(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x23, %eax
je 0x3eb67
movl $0x1, -0x4(%rbp)
jmp 0x3eb69
jmp 0x3eb30
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/maf.c
// Function: mafRegDefParse
static void mafRegDefParse(struct mafFile *mf, struct mafAli *ali, char *line)
/* parse a 'r' line of an 'a' paragraph. */
{
if (ali->regDef != NULL)
    errAbort("multiple 'r' lines in an alignment paragraph: %d of %s", mf->lf->lineIx, mf->lf->fileName);
char *row[3];
int wordCount = chopByWhite(line, row, ArraySize(row));
if (wordCount != 3)
    lineFileExpectWords(mf->lf, 3+1, wordCount+1); // +1 for 'r'
ali->regDef = mafRegDefNew(row[0], lineFileNeedFullNum(mf->lf, row, 1),
                           row[2]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x3ec04
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl 0x28(%rax), %esi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rdx
leaq 0x9cc4a(%rip), %rdi     # 0xdb847
movb $0x0, %al
callq 0x35d40
movq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x3, %edx
callq 0x2e900
movl %eax, -0x34(%rbp)
cmpl $0x3, -0x34(%rbp)
je 0x3ec37
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movl -0x34(%rbp), %edx
addl $0x1, %edx
movl $0x4, %esi
callq 0x3c2f0
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
leaq -0x30(%rbp), %rsi
movl $0x1, %edx
callq 0x3cbb0
movq -0x40(%rbp), %rdi
movl %eax, %esi
movq -0x20(%rbp), %rdx
callq 0x40200
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3e490
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3ec80
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x3ecdf
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
callq 0x3eb80
jmp 0x3ecb9
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x2aad0
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x9c9a3(%rip), %rsi     # 0xdb6be
movb $0x0, %al
callq 0x6a80
cmpq $0x0, -0x10(%rbp)
je 0x3ed3f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x9c996(%rip), %rsi     # 0xdb6ce
movb $0x0, %al
callq 0x6a80
movq -0x8(%rbp), %rdi
leaq 0x9a2cf(%rip), %rsi     # 0xd9019
movb $0x0, %al
callq 0x6a80
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x99a33(%rip), %rsi     # 0xd8b4e
callq 0x2f780
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x3ed00
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3f162
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3f0b0
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x3f141
movq -0x18(%rbp), %rdi
callq 0x3f0f0
leaq -0x18(%rbp), %rdi
callq 0x301d0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3f1a0
jmp 0x3f1d0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x40d40
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x40d40
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x40d40
movq -0x8(%rbp), %rdi
callq 0x40d70
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3f21c
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x3f180
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x3f1f7
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x2e, %esi
callq 0x6260
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x3f26a
movq $0x0, -0x8(%rbp)
jmp 0x3f2cb
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
subq %rcx, %rax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jl 0x3f2a2
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movl -0x1c(%rbp), %edx
leaq 0x9c4bc(%rip), %rdi     # 0xdb757
movb $0x0, %al
callq 0x35d40
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movslq -0x2c(%rbp), %rdx
callq 0x6370
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/maf.c
// Function: mafCompGetSrcName
char *mafCompGetSrcName(struct mafComp *mc)
/* parse the src sequence name from the mafComp src name */
{
char *e = strchr(mc->src, '.');
if (e == NULL)
    return mc->src;
else
    return e+1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x2e, %esi
callq 0x6260
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3f317
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x3f323
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)