LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/nib.c
// Function: parseSubrange
static void parseSubrange(char *subrange, char *name, 
	unsigned *start, unsigned *end)
/* parse the subrange specification */
{
char *rangePart = strchr(subrange+1, ':');
if (rangePart != NULL)
    {
    /* :seqId:start-end form */
    *rangePart = '\0';
    strcpy(name, subrange+1);
    *rangePart = ':';
    rangePart++;
    }
else
    {
    /* :start-end form */
    rangePart = subrange+1;
    strcpy(name, ""); 
    }
if ((sscanf(rangePart, "%u-%u", start, end) != 2) || (*start > *end))
    errAbort("can't parse nib file subsequence specification: %s",
             subrange);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
addq $0x1, %rdi
movl $0x3a, %esi
callq 0x6260
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x46532
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x1, %rsi
callq 0x6680
movq -0x28(%rbp), %rax
movb $0x3a, (%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x4654e
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x9eebd(%rip), %rsi     # 0xe5406
callq 0x6680
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq 0x96464(%rip), %rsi     # 0xdc9c5
movb $0x0, %al
callq 0x66d0
cmpl $0x2, %eax
jne 0x4657b
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jbe 0x4658d
movq -0x8(%rbp), %rsi
leaq 0x964a1(%rip), %rdi     # 0xdca27
movb $0x0, %al
callq 0x35d40
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/nib.c
// Function: nibLoadPartMasked
struct dnaSeq *nibLoadPartMasked(int options, char *fileName, int start, int size)
/* Load part of an .nib file, with control over handling of masked positions */
{
struct dnaSeq *seq;
FILE *f;
int seqSize;
nibOpenVerify(fileName, &f, &seqSize);
seq = nibLdPartMasked(options, fileName, f, seqSize, start, size);
fclose(f);
return seq;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
callq 0x465a0
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl -0x2c(%rbp), %ecx
movl -0x14(%rbp), %r8d
movl -0x18(%rbp), %r9d
callq 0x46890
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rdi
callq 0x66e0
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/nib.c
// Function: nibLoadAllMasked
struct dnaSeq *nibLoadAllMasked(int options, char *fileName)
/* Load part of a .nib file, with control over handling of masked
 * positions. Subranges of nib files may specified in the file name
 * using the syntax:
 *    /path/file.nib:seqid:start-end
 * or\n"
 *    /path/file.nib:start-end
 * With the first form, seqid becomes the id of the subrange, with the second
 * form, a sequence id of file:start-end will be used.
 */
{
struct dnaSeq *seq;
FILE *f;
int seqSize;
char filePath[PATH_LEN];
char name[PATH_LEN];
unsigned start, end;

nibParseName(options, fileName, filePath, name, &start, &end);
nibOpenVerify(filePath, &f, &seqSize);
if (end == 0)
    end = seqSize;
seq = nibInput(options, fileName, name, f, seqSize, start, end-start);
fclose(f);
return seq;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x440, %rsp            # imm = 0x440
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq -0x230(%rbp), %rdx
leaq -0x430(%rbp), %rcx
leaq -0x434(%rbp), %r8
leaq -0x438(%rbp), %r9
callq 0x46340
leaq -0x230(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x24(%rbp), %rdx
callq 0x465a0
cmpl $0x0, -0x438(%rbp)
jne 0x46d90
movl -0x24(%rbp), %eax
movl %eax, -0x438(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq -0x430(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %r8d
movl -0x434(%rbp), %r9d
movl -0x438(%rbp), %eax
subl -0x434(%rbp), %eax
movl %eax, (%rsp)
callq 0x46910
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rdi
callq 0x66e0
movq -0x18(%rbp), %rax
addq $0x440, %rsp            # imm = 0x440
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/nib.c
// Function: nibStreamOpen
struct nibStream *nibStreamOpen(char *fileName)
/* Create a new nib stream.  Open file and stuff. */
{
struct nibStream *ns;
FILE *f;

dnaUtilOpen();
AllocVar(ns);
ns->f = f = mustOpen(fileName, "wb");
ns->fileName = cloneString(fileName);

/* Write header - initially zero.  Will fix it up when we close. */
writeOne(f, ns->size);
writeOne(f, ns->size);

return ns;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, %al
callq 0x34580
movl $0x20, %edi
callq 0x40c50
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x95959(%rip), %rsi     # 0xdca15
callq 0x2f780
movq %rax, %rcx
movq %rcx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
callq 0x2a450
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
movl $0x4, %edx
callq 0x2f8b0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
movl $0x4, %edx
callq 0x2f8b0
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/nib.c
// Function: nibStreamClose
void nibStreamClose(struct nibStream **pNs)
/* Close a nib stream.  Flush last nibble if need be.  Fix up header. */
{
struct nibStream *ns = *pNs;
FILE *f;
bits32 sig = nibSig;
if (ns == NULL)
    return;
f = ns->f;
if (ns->size&1)
    writeOne(f, ns->byte);
fseek(f,  0L, SEEK_SET);
writeOne(f, sig);
writeOne(f, ns->size);
fclose(f);
freeMem(ns->fileName);
freez(pNs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x6be93d3a, -0x1c(%rbp) # imm = 0x6BE93D3A
cmpq $0x0, -0x10(%rbp)
jne 0x4714a
jmp 0x471d1
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x4717b
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x1c, %rsi
movl $0x1, %edx
callq 0x2f8b0
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x67c0
movq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
movl $0x4, %edx
callq 0x2f8b0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
movl $0x4, %edx
callq 0x2f8b0
movq -0x18(%rbp), %rdi
callq 0x66e0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x40d40
movq -0x8(%rbp), %rdi
callq 0x40d70
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/nib.c
// Function: nibStreamOne
void nibStreamOne(struct nibStream *ns, DNA base)
/* Write out one base to nibStream. */
{
UBYTE ub = ntVal5[(int)base];

if ((++ns->size&1) == 0)
    {
    ub += ns->byte;
    writeOne(ns->f, ub);
    }
else
    {
    ns->byte = (ub<<4);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movsbl -0x9(%rbp), %eax
movslq %eax, %rcx
leaq 0xc1ad0(%rip), %rax     # 0x108cd0
movl (%rax,%rcx,4), %eax
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rcx
movl 0x18(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x18(%rcx)
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x47244
movq -0x8(%rbp), %rax
movzbl 0x1c(%rax), %ecx
movzbl -0xa(%rbp), %eax
addl %ecx, %eax
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
leaq -0xa(%rbp), %rsi
movl $0x1, %edx
callq 0x2f8b0
jmp 0x47254
movzbl -0xa(%rbp), %eax
shll $0x4, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x1c(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/nib.c
// Function: nibIsFile
boolean nibIsFile(char *fileName)
/* Return TRUE if file is a nib file. */
{
boolean isANib;
char *subrange = findNibSubrange(fileName);
if (subrange != NULL)
    *subrange = '\0';
isANib = endsWith(fileName, ".nib") || endsWith(fileName, ".NIB");
if (subrange != NULL)
    *subrange = ':';
return isANib;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x46470
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x472d7
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rdi
leaq 0x95740(%rip), %rsi     # 0xdca22
callq 0x2d9a0
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
jne 0x4730c
movq -0x8(%rbp), %rdi
leaq 0x9571a(%rip), %rsi     # 0xdca18
callq 0x2d9a0
cmpl $0x0, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0xc(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x47325
movq -0x18(%rbp), %rax
movb $0x3a, (%rax)
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/nib.c
// Function: nibIsRange
boolean nibIsRange(char *fileName)
/* Return TRUE if file specifies a subrange of a nib file. */
{
boolean isANib;
char *subrange = findNibSubrange(fileName);;
if (subrange == NULL)
    return FALSE;
*subrange = '\0';
isANib = endsWith(fileName, ".nib") || endsWith(fileName, ".NIB");
*subrange = ':';
return isANib;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x46470
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x47359
movl $0x0, -0x4(%rbp)
jmp 0x473ad
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rdi
leaq 0x956b7(%rip), %rsi     # 0xdca22
callq 0x2d9a0
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x21(%rbp)
jne 0x47395
movq -0x10(%rbp), %rdi
leaq 0x95691(%rip), %rsi     # 0xdca18
callq 0x2d9a0
cmpl $0x0, %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
movb $0x3a, (%rax)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/nib.c
// Function: nibInfoNew
struct nibInfo *nibInfoNew(char *path)
/* Make a new nibInfo with open nib file. */
{
struct nibInfo *nib;
AllocVar(nib);
nib->fileName = cloneString(path);
nibOpenVerify(path, &nib->f, &nib->size);
return nib;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x20, %edi
callq 0x40c50
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2a450
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
movq -0x10(%rbp), %rdx
addq $0x10, %rdx
callq 0x465a0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/nib.c
// Function: nibInfoFree
void nibInfoFree(struct nibInfo **pNib)
/* Free up nib info and close file if open. */
{
struct nibInfo *nib = *pNib;
if (nib != NULL)
    {
    carefulClose(&nib->f);
    freeMem(nib->fileName);
    freez(pNib);
    }
}

// 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)
je 0x47461
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x301d0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x40d40
movq -0x8(%rbp), %rdi
callq 0x40d70
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/nib.c
// Function: nibInfoFromCache
struct nibInfo *nibInfoFromCache(struct hash *hash, char *nibDir, char *nibName)
/* Get nibInfo on nibDir/nibName.nib from cache, filling cache if need be. */
{
struct nibInfo *nib;
char path[PATH_LEN];
safef(path, sizeof(path), "%s/%s.nib", nibDir, nibName);
nib = hashFindVal(hash, path);
if (nib == NULL)
    {
    nib = nibInfoNew(path);
    hashAdd(hash, path, nib);
    }
return nib;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x220(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
movl $0x200, %esi            # imm = 0x200
leaq 0x9557b(%rip), %rdx     # 0xdca1d
movb $0x0, %al
callq 0x31090
movq -0x8(%rbp), %rdi
leaq -0x220(%rbp), %rsi
callq 0x39630
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x474e8
leaq -0x220(%rbp), %rdi
callq 0x473c0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x220(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x39230
movq -0x20(%rbp), %rax
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/obscure.c
// Function: hashTwoColumnFile
struct hash *hashTwoColumnFile(char *fileName)
/* Given a two column file (key, value) return a hash. */
{
struct lineFile *lf = lineFileOpen(fileName, TRUE);
struct hash *hash = hashNew(16);
char *row[3];
int fields = 0;
while ((fields = lineFileChop(lf, row)) != 0)
    {
    lineFileExpectWords(lf, 2, fields);
    char *name = row[0];
    char *value = lmCloneString(hash->lm, row[1]);
    hashAdd(hash, name, value);
    }
lineFileClose(&lf);
return hash;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x3b290
movq %rax, -0x10(%rbp)
movl $0x10, %edi
movl $0x1, %esi
callq 0x398a0
movq %rax, -0x18(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x3, %edx
callq 0x3c920
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
je 0x47a23
movq -0x10(%rbp), %rdi
movl -0x34(%rbp), %edx
movl $0x2, %esi
callq 0x3c2f0
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x3e050
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x39230
jmp 0x479c8
leaq -0x10(%rbp), %rdi
callq 0x3c110
movq -0x18(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/obscure.c
// Function: slPairTwoColumnFile
struct slPair *slPairTwoColumnFile(char *fileName)
/* Read in a two column file into an slPair list */
{
char *row[2];
struct slPair *list = NULL;
struct lineFile *lf = lineFileOpen(fileName, TRUE);
while (lineFileRow(lf, row))
    slPairAdd(&list, row[0], cloneString(row[1]));
lineFileClose(&lf);
slReverse(&list);
return list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x3b290
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl $0x2, %edx
callq 0x3caf0
cmpl $0x0, %eax
je 0x47aa0
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2a450
movq -0x38(%rbp), %rsi
movq %rax, %rdx
leaq -0x28(%rbp), %rdi
callq 0x2c420
jmp 0x47a66
leaq -0x30(%rbp), %rdi
callq 0x3c110
leaq -0x28(%rbp), %rdi
callq 0x2aad0
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/obscure.c
// Function: slNameListOfUniqueWords
struct slName *slNameListOfUniqueWords(char *text,boolean respectQuotes)
/* Return list of unique words found by parsing string delimited by whitespace.
 * If respectQuotes then ["Lucy and Ricky" 'Fred and Ethyl'] will yield 2 slNames no quotes */
{
struct slName *list = NULL;
char *word = NULL;
while (text != NULL)
    {
    if (respectQuotes)
        word = nextQuotedWord(&text);
    else
        word = nextWord(&text);
    if (word)
        slNameStore(&list, word);
    else
        break;
    }
slReverse(&list);
return list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x481a2
cmpl $0x0, -0xc(%rbp)
je 0x4817b
leaq -0x8(%rbp), %rdi
callq 0x480a0
movq %rax, -0x20(%rbp)
jmp 0x48188
leaq -0x8(%rbp), %rdi
callq 0x2f230
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4819e
movq -0x20(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x2bbb0
jmp 0x481a0
jmp 0x481a2
jmp 0x4815f
leaq -0x18(%rbp), %rdi
callq 0x2aad0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/obscure.c
// Function: shuffleArrayOfInts
void shuffleArrayOfInts(int *array, int arraySize)
/* Shuffle array of ints of given size given number of times. */
{
int c;
int i, randIx;

/* Randomly permute an array using the method from Cormen, et al */
for (i=0; i<arraySize; ++i)
    {
    randIx = i + (rand() % (arraySize - i));
    c = array[i];
    array[i] = array[randIx];
    array[randIx] = c;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x48bf7
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
callq 0x61c0
movl -0xc(%rbp), %ecx
subl -0x14(%rbp), %ecx
cltd
idivl %ecx
movl -0x1c(%rbp), %eax
addl %edx, %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x48b96
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/obscure.c
// Function: slListRandomReduce
void *slListRandomReduce(void *list, double reduceRatio)
/* Reduce list to approximately reduceRatio times original size. Destroys original list. */
{
if (reduceRatio >= 1.0)
    return list;
int threshold = RAND_MAX * reduceRatio;
struct slList *newList = NULL, *next, *el;
for (el = list; el != NULL; el = next)
    {
    next = el->next;
    if (rand() <= threshold)
        {
	slAddHead(&newList, el);
	}
    }
return newList;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movsd 0x8eaca(%rip), %xmm1    # 0xd7888
ucomisd %xmm1, %xmm0
jb 0x48dce
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x48e2f
movsd 0x93d92(%rip), %xmm0    # 0xdcb68
mulsd -0x18(%rbp), %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x48e27
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
callq 0x61c0
cmpl -0x1c(%rbp), %eax
jg 0x48e1b
movq -0x38(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x47b40
jmp 0x48e1d
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x48df2
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/obscure.c
// Function: slListRandomSample
void *slListRandomSample(void *list, int maxCount)
/* Return a sublist of list with at most maxCount. Destroy list in process */
{
if (list == NULL)
    return list;
int initialCount = slCount(list);
if (initialCount <= maxCount)
    return list;
double reduceRatio = (double)maxCount/initialCount;
if (reduceRatio < 0.9)
    {
    double conservativeReduceRatio = reduceRatio * 1.05;
    list = slListRandomReduce(list, conservativeReduceRatio);
    }
int midCount = slCount(list);
if (midCount <= maxCount)
    return list;
shuffleList(list);
struct slList *lastEl = slElementFromIx(list, maxCount-1);
lastEl->next = NULL;
return list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x48e63
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x48f17
movq -0x10(%rbp), %rdi
callq 0x2a810
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0x48e84
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x48f17
cvtsi2sdl -0x14(%rbp), %xmm0
cvtsi2sdl -0x18(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd 0x8f5e9(%rip), %xmm0    # 0xd8488
ucomisd -0x20(%rbp), %xmm0
jbe 0x48eca
movsd 0x93cc2(%rip), %xmm0    # 0xdcb70
mulsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movsd -0x28(%rbp), %xmm0
callq 0x48da0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2a810
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0x48ee8
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x48f17
movq -0x10(%rbp), %rdi
callq 0x48c90
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
subl $0x1, %esi
callq 0x2a850
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/obscure.c
// Function: currentVmPeak
long long currentVmPeak()
/* return value of peak Vm memory usage (if /proc/ business exists) */
{
long long vmPeak = 0;

pid_t pid = getpid();
char temp[256];
safef(temp, sizeof(temp), "/proc/%d/status", (int) pid);
struct lineFile *lf = lineFileMayOpen(temp, TRUE);
if (lf)
    {
    char *line;
    while (lineFileNextReal(lf, &line))
	{	// typical line: 'VmPeak:     62646196 kB'
		// seems to always be kB
	if (stringIn("VmPeak", line))
	    {
	    char *words[3];
	    chopByWhite(line, words, 3);
	    vmPeak = sqlLongLong(words[1]);	// assume always 2nd word
	    break;
	    }
	}
    lineFileClose(&lf);
    }

return vmPeak;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq $0x0, -0x8(%rbp)
callq 0x6ac0
movl %eax, -0xc(%rbp)
leaq -0x110(%rbp), %rdi
movl -0xc(%rbp), %ecx
movl $0x100, %esi            # imm = 0x100
leaq 0x93c54(%rip), %rdx     # 0xdcd45
movb $0x0, %al
callq 0x31090
leaq -0x110(%rbp), %rdi
movl $0x1, %esi
callq 0x3b3a0
movq %rax, -0x118(%rbp)
cmpq $0x0, -0x118(%rbp)
je 0x49185
jmp 0x4911c
movq -0x118(%rbp), %rdi
leaq -0x120(%rbp), %rsi
callq 0x3c840
cmpl $0x0, %eax
je 0x49179
movq -0x120(%rbp), %rdi
leaq 0x93c13(%rip), %rsi     # 0xdcd55
callq 0x6170
cmpq $0x0, %rax
je 0x49177
movq -0x120(%rbp), %rdi
leaq -0x140(%rbp), %rsi
movl $0x3, %edx
callq 0x2e900
movq -0x138(%rbp), %rdi
callq 0x56000
movq %rax, -0x8(%rbp)
jmp 0x49179
jmp 0x4911c
leaq -0x118(%rbp), %rdi
callq 0x3c110
movq -0x8(%rbp), %rax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/obscure.c
// Function: endsWithWordComma
boolean endsWithWordComma(char *string, char *word)
/* Return TRUE if string ends with word possibly followed by a comma, and the beginning
 * of word within string is the beginning of string or follows a comma. */
{
int stringLen = strlen(string);
int wordLen = strlen(word);
int commaSize = (stringLen > wordLen && string[stringLen-1] == ',') ? 1 : 0;
if (stringLen < wordLen + commaSize)
    return FALSE;
int wordOffset = stringLen - commaSize - wordLen;
if (sameStringN(string + wordOffset, word, wordLen) &&
    (wordOffset == 0 || string[wordOffset-1] == ','))
    return TRUE;
return FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x62c0
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x62c0
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %ecx
xorl %eax, %eax
cmpl -0x20(%rbp), %ecx
movb %al, -0x29(%rbp)
jle 0x493af
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2c, %eax
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x24(%rbp)
movl -0x1c(%rbp), %eax
movl -0x20(%rbp), %ecx
addl -0x24(%rbp), %ecx
cmpl %ecx, %eax
jge 0x493d8
movl $0x0, -0x4(%rbp)
jmp 0x4942d
movl -0x1c(%rbp), %eax
subl -0x24(%rbp), %eax
subl -0x20(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x28(%rbp), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movslq -0x20(%rbp), %rdx
callq 0x6320
cmpl $0x0, %eax
jne 0x49426
cmpl $0x0, -0x28(%rbp)
je 0x4941d
movq -0x10(%rbp), %rax
movl -0x28(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2c, %eax
jne 0x49426
movl $0x1, -0x4(%rbp)
jmp 0x4942d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/obscure.c
// Function: ensureNamesCaseUnique
void ensureNamesCaseUnique(struct slName *fieldList)
/* Ensure that there would be no name conflicts in fieldList if all fields were lower-cased. */
{
struct slName *field;
struct hash *hash = hashNew(0);
for (field = fieldList; field != NULL; field = field->next)
    {
    char *s = field->name;
    int len = strlen(s);
    assert(len<512);  // avoid stack overflow
    char lower[len+1];
    strcpy(lower, s);
    strLower(lower);
    char *conflict = hashFindVal(hash, lower);
    if (conflict)
	 {
	 if (sameString(conflict,s))
	     errAbort("Duplicate symbol %s", s);
	 else
	     errAbort("Conflict between symbols with different cases: %s vs %s",
		conflict, s);
	 }
    hashAdd(hash, lower, s);
    }
hashFree(&hash);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
xorl %edi, %edi
movl $0x1, %esi
callq 0x398a0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x49569
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x62c0
movl %eax, -0x24(%rbp)
cmpl $0x200, -0x24(%rbp)     # imm = 0x200
jge 0x49492
jmp 0x494b1
leaq 0x938f4(%rip), %rdi     # 0xdcd8d
leaq 0x9387e(%rip), %rsi     # 0xdcd1e
movl $0x3ac, %edx            # imm = 0x3AC
leaq 0x938e9(%rip), %rcx     # 0xdcd95
callq 0x6450
movl -0x24(%rbp), %eax
incl %eax
movq %rsp, %rcx
movq %rcx, -0x30(%rbp)
movq %rax, %rcx
addq $0xf, %rcx
andq $-0x10, %rcx
movq %rsp, %rdi
subq %rcx, %rdi
movq %rdi, -0x48(%rbp)
movq %rdi, %rsp
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rsi
callq 0x6680
movq -0x48(%rbp), %rdi
callq 0x2e1c0
movq -0x48(%rbp), %rsi
movq -0x18(%rbp), %rdi
callq 0x39630
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x49541
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6a40
cmpl $0x0, %eax
jne 0x49529
movq -0x20(%rbp), %rsi
leaq 0x938a1(%rip), %rdi     # 0xdcdc1
movb $0x0, %al
callq 0x35d40
jmp 0x4953f
movq -0x40(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq 0x9389d(%rip), %rdi     # 0xdcdd5
movb $0x0, %al
callq 0x35d40
jmp 0x49541
movq -0x48(%rbp), %rsi
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rdx
callq 0x39230
movq -0x30(%rbp), %rax
movq %rax, %rsp
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x49464
leaq -0x18(%rbp), %rdi
callq 0x3a080
movq %rbp, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/obscure.c
// Function: readAndIgnore
boolean readAndIgnore(char *fileName)
/* Read a byte from fileName, so its access time is updated. */
{
boolean ret = FALSE;
char buf[256];
FILE *f = fopen(fileName, "r");
if ( f && (fread(buf, 1, 1, f) == 1 ) )
    ret = TRUE;
if (f)
    fclose(f);
return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x967f5(%rip), %rsi     # 0xdfd96
callq 0x67e0
movq %rax, -0x118(%rbp)
cmpq $0x0, -0x118(%rbp)
je 0x495df
leaq -0x110(%rbp), %rdi
movq -0x118(%rbp), %rcx
movl $0x1, %edx
movq %rdx, %rsi
callq 0x6b20
cmpq $0x1, %rax
jne 0x495df
movl $0x1, -0xc(%rbp)
cmpq $0x0, -0x118(%rbp)
je 0x495f5
movq -0x118(%rbp), %rdi
callq 0x66e0
movl -0xc(%rbp), %eax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/options.c
// Function: optionInit
void optionInit(int *pArgc, char *argv[], struct optionSpec *optionSpecs)
/* Read options in command line into options hash.
 * Options come in three forms:
 *      -option         words starting with dash
 *      option=val      words with = in the middle
 *      -option=val     combining the two.
 * The resulting hash will be keyed by the option name with the val
 * string for value.  For '-option' types the value is 'on'.
 * The words in argv are parsed in assending order.  If a word of
 * "--" is encountered, argument parsing stops.
 * If optionSpecs is not NULL, it is an array of optionSpec that are
 * used to validate the options.  An option must exist in the array
 * and the value must be convertable to the type specified in flags.
 * Boolean options must no value, all other options must have one.
 * Array is terminated by a optionSpec with a NULL name.
 * If array NULL, no validation is done.
 */
{
if (options == NULL)
    {
    struct hash *hash = parseOptions(pArgc, argv, FALSE, optionSpecs, FALSE);
    setOptions(hash);
    optionSpecification = optionSpecs;
    verbose(2, "### %s ###\n", srcVersion);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, 0xc0364(%rip)     # 0x109c50
jne 0x49937
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
xorl %r8d, %r8d
movl %r8d, %edx
callq 0x49640
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x49830
movq -0x18(%rbp), %rax
movq %rax, 0xc033b(%rip)     # 0x109c58
movq 0xbd46c(%rip), %rdx     # 0x106d90
movl $0x2, %edi
leaq 0x934dd(%rip), %rsi     # 0xdce0d
movb $0x0, %al
callq 0x60040
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/osunix.c
// Function: getTempDir
char *getTempDir(void)
/* get temporary directory to use for programs.  This first checks TMPDIR environment
 * variable, then /data/tmp, /scratch/tmp, /var/tmp, /tmp.  Return is static and
 * only set of first call */
{
static char *checkTmpDirs[] = {"/data/tmp", "/scratch/tmp", "/var/tmp", "/tmp", NULL};

static char* tmpDir = NULL;
if (tmpDir == NULL)
    {
    tmpDir = getenv("TMPDIR");
    if (tmpDir != NULL)
        tmpDir = cloneString(tmpDir);  // make sure it's stable
    else
        {
        int i;
        for (i = 0; (checkTmpDirs[i] != NULL) && (tmpDir == NULL); i++)
            {
            if (fileSize(checkTmpDirs[i]) >= 0)
                tmpDir = checkTmpDirs[i];
            }
        }
    }
if (tmpDir == NULL)
    errAbort("BUG: can't find a tmp directory");
return tmpDir;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0xbf410(%rip)     # 0x10a310
jne 0x4afae
leaq 0x923bf(%rip), %rdi     # 0xdd2cc
callq 0x68d0
movq %rax, 0xbf3f7(%rip)     # 0x10a310
cmpq $0x0, 0xbf3ef(%rip)     # 0x10a310
je 0x4af38
movq 0xbf3e6(%rip), %rdi     # 0x10a310
callq 0x2a450
movq %rax, 0xbf3da(%rip)     # 0x10a310
jmp 0x4afac
movl $0x0, -0x4(%rbp)
movslq -0x4(%rbp), %rdx
xorl %eax, %eax
leaq 0xbbe74(%rip), %rcx     # 0x106dc0
cmpq $0x0, (%rcx,%rdx,8)
movb %al, -0x5(%rbp)
je 0x4af64
cmpq $0x0, 0xbf3b2(%rip)     # 0x10a310
sete %al
movb %al, -0x5(%rbp)
movb -0x5(%rbp), %al
testb $0x1, %al
jne 0x4af6d
jmp 0x4afaa
movslq -0x4(%rbp), %rcx
leaq 0xbbe48(%rip), %rax     # 0x106dc0
movq (%rax,%rcx,8), %rdi
callq 0x4a3e0
cmpq $0x0, %rax
jl 0x4af9d
movslq -0x4(%rbp), %rcx
leaq 0xbbe2e(%rip), %rax     # 0x106dc0
movq (%rax,%rcx,8), %rax
movq %rax, 0xbf373(%rip)     # 0x10a310
jmp 0x4af9f
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x4af3f
jmp 0x4afac
jmp 0x4afae
cmpq $0x0, 0xbf35a(%rip)     # 0x10a310
jne 0x4afc6
leaq 0x92314(%rip), %rdi     # 0xdd2d3
movb $0x0, %al
callq 0x35d40
movq 0xbf343(%rip), %rax     # 0x10a310
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/osunix.c
// Function: execPStack
static void execPStack(pid_t ppid)
/* exec pstack on the specified pid */
{
char *cmd[3], pidStr[32];
safef(pidStr, sizeof(pidStr), "%ld", (long)ppid);
cmd[0] = "pstack";
cmd[1] = pidStr;
cmd[2] = NULL;

// redirect stdout to stderr
if (dup2(2, 1) < 0)
    errAbort("dup2 failed");

execvp(cmd[0], cmd);

childExecFailedExit(cmd[0]); // cannot use the normal errAbort.

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
leaq -0x40(%rbp), %rdi
movslq -0x4(%rbp), %rcx
movl $0x20, %esi
leaq 0x91dd7(%rip), %rdx     # 0xdd586
movb $0x0, %al
callq 0x31090
leaq 0x91ca6(%rip), %rax     # 0xdd463
movq %rax, -0x20(%rbp)
leaq -0x40(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x2, %edi
movl $0x1, %esi
callq 0x6670
cmpl $0x0, %eax
jge 0x4b7f3
leaq 0x91d9e(%rip), %rdi     # 0xdd58a
movb $0x0, %al
callq 0x35d40
movq -0x20(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x6510
movq -0x20(%rbp), %rdi
callq 0x4b5f0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/osunix.c
// Function: maybeTouchFile
boolean maybeTouchFile(char *fileName)
/* If file exists, set its access and mod times to now.  If it doesn't exist, create it.
 * Return FALSE if we have a problem doing so (e.g. when qateam is gdb'ing and code tries 
 * to touch some file owned by www). */
{
if (fileExists(fileName))
    {
    int ret = utime(fileName, NULL);
    if (ret != 0)
	{
	warn("utime(%s) failed (ownership?)", fileName);
	return FALSE;
	}
    }
else
    {
    FILE *f = fopen(fileName, "w");
    if (f == NULL)
	return FALSE;
    else
	carefulClose(&f);
    }
return TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30cb0
cmpl $0x0, %eax
je 0x4b8fd
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6390
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x4b8fb
movq -0x10(%rbp), %rsi
leaq 0x91bbb(%rip), %rdi     # 0xdd4a6
movb $0x0, %al
callq 0x358e0
movl $0x0, -0x4(%rbp)
jmp 0x4b933
jmp 0x4b92c
movq -0x10(%rbp), %rdi
leaq 0x8d246(%rip), %rsi     # 0xd8b4e
callq 0x67e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x4b921
movl $0x0, -0x4(%rbp)
jmp 0x4b933
leaq -0x20(%rbp), %rdi
callq 0x301d0
jmp 0x4b92c
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/osunix.c
// Function: touchFileFromFile
void touchFileFromFile(const char *oldFile, const char *newFile)
/* Set access and mod time of newFile from oldFile. */
{
    struct stat buf;
    if (stat(oldFile, &buf) != 0)
        errnoAbort("stat failed on %s", oldFile);
    struct utimbuf puttime;
    puttime.modtime = buf.st_mtime;
    puttime.actime = buf.st_atime;
    if (utime(newFile, &puttime) != 0)
	errnoAbort("utime failed on %s", newFile);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x6d00
cmpl $0x0, %eax
je 0x4b97a
movq -0x8(%rbp), %rsi
leaq 0x91b51(%rip), %rdi     # 0xdd4c4
movb $0x0, %al
callq 0x35ee0
movq -0x48(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x10(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x6390
cmpl $0x0, %eax
je 0x4b9b7
movq -0x10(%rbp), %rsi
leaq 0x91b26(%rip), %rdi     # 0xdd4d6
movb $0x0, %al
callq 0x35ee0
addq $0xb0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/osunix.c
// Function: isDirectory
boolean isDirectory(char *pathName)
/* Return TRUE if pathName is a directory. */
{
struct stat st;

if (stat(pathName, &st) < 0)
    return FALSE;
if (S_ISDIR(st.st_mode))
    return TRUE;
return FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x6d00
cmpl $0x0, %eax
jge 0x4b9ed
movl $0x0, -0x4(%rbp)
jmp 0x4ba0f
movl -0x88(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x4ba08
movl $0x1, -0x4(%rbp)
jmp 0x4ba0f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/osunix.c
// Function: mustReadSymlinkExt
char *mustReadSymlinkExt(char *path, struct stat *sb)
/* Read symlink or abort. FreeMem the returned value. */
{
ssize_t nbytes, bufsiz;
// determine whether the buffer returned was truncated.
bufsiz = sb->st_size + 1;
char *symPath = needMem(bufsiz);
nbytes = readlink(path, symPath, bufsiz);
if (nbytes == -1) 
    errnoAbort("readlink failure on symlink %s", path);
if (nbytes == bufsiz)
    errAbort("readlink returned buffer truncated\n");
return symPath;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x40c50
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x6760
movq %rax, -0x18(%rbp)
cmpq $-0x1, -0x18(%rbp)
jne 0x4badb
movq -0x8(%rbp), %rsi
leaq 0x91a15(%rip), %rdi     # 0xdd4e9
movb $0x0, %al
callq 0x35ee0
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x4baf3
leaq 0x91a1c(%rip), %rdi     # 0xdd508
movb $0x0, %al
callq 0x35d40
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/osunix.c
// Function: mustReadSymlink
char *mustReadSymlink(char *path)
/* Read symlink or abort. Checks that path is a symlink. 
FreeMem the returned value. */
{
struct stat sb;
if (lstat(path, &sb) == -1)
    errnoAbort("lstat failure on %s", path);
if ((sb.st_mode & S_IFMT) != S_IFLNK)
    errnoAbort("path %s not a symlink.", path);
return mustReadSymlinkExt(path, &sb);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x6a60
cmpl $-0x1, %eax
jne 0x4bb36
movq -0x8(%rbp), %rsi
leaq 0x919fd(%rip), %rdi     # 0xdd52c
movb $0x0, %al
callq 0x35ee0
movl -0x80(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0xa000, %eax           # imm = 0xA000
je 0x4bb57
movq -0x8(%rbp), %rsi
leaq 0x919f0(%rip), %rdi     # 0xdd540
movb $0x0, %al
callq 0x35ee0
movq -0x8(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x4ba80
addq $0xa0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/pipeline.c
// Function: pipelineClose
int pipelineClose(struct pipeline **pPl)
/* Wait for pipeline to finish and free it. Same as pipelineWait then pipelineClose.
 * Returns pipelineWait result (normally 0). */
{
struct pipeline *pl = *pPl;
int ret = 0;
if (pl != NULL)
    {
    ret = pipelineWait(pl);
    pipelineFree(pPl);
    }
return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4c5ea
movq -0x10(%rbp), %rdi
callq 0x4c420
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4bbc0
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/pipeline.c
// Function: plProcSetup
static void plProcSetup(struct plProc* proc, int stdinFd, int stdoutFd, int stderrFd)
/* setup signal, error handling, and file descriptors after fork */
{
/* Optionally treat a closed pipe as an EOF rather than getting SIGPIPE */
if (signal(SIGPIPE, ((proc->pl->options & pipelineSigpipe) ? SIG_DFL : SIG_IGN)) == SIG_ERR)
    errnoAbort("error ignoring SIGPIPE");

if (setpgid(getpid(), proc->pl->groupLeader) != 0)
    errnoAbort("error from setpgid(%d, %d)", getpid(), proc->pl->groupLeader);

/* child, first setup stdio files */
if (stdinFd != STDIN_FILENO)
    {
    if (dup2(stdinFd, STDIN_FILENO) < 0)
        errnoAbort("can't dup2 to stdin");
    }
    
if (stdoutFd != STDOUT_FILENO)
    {
    if (dup2(stdoutFd, STDOUT_FILENO) < 0)
        errnoAbort("can't dup2 to stdout");
    }
    
if (stderrFd != STDERR_FILENO)
    {
    if (dup2(stderrFd, STDERR_FILENO) < 0)
        errnoAbort("can't dup2 to stderr");
    }
closeNonStdDescriptors();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x1c(%rax), %ecx
andl $0x20, %ecx
movl $0x1, %esi
xorl %eax, %eax
cmpl $0x0, %ecx
cmovneq %rax, %rsi
movl $0xd, %edi
callq 0x6870
movq $-0x1, %rcx
cmpq %rcx, %rax
jne 0x4ce75
leaq 0x90a09(%rip), %rdi     # 0xdd877
movb $0x0, %al
callq 0x35ee0
callq 0x6ac0
movl %eax, %edi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0xc(%rax), %esi
callq 0x6ca0
cmpl $0x0, %eax
je 0x4ceb1
callq 0x6ac0
movl %eax, %esi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0xc(%rax), %edx
leaq 0x909e4(%rip), %rdi     # 0xdd88e
movb $0x0, %al
callq 0x35ee0
cmpl $0x0, -0xc(%rbp)
je 0x4ced6
movl -0xc(%rbp), %edi
xorl %esi, %esi
callq 0x6670
cmpl $0x0, %eax
jge 0x4ced4
leaq 0x909dc(%rip), %rdi     # 0xdd8a9
movb $0x0, %al
callq 0x35ee0
jmp 0x4ced6
cmpl $0x1, -0x10(%rbp)
je 0x4cefe
movl -0x10(%rbp), %edi
movl $0x1, %esi
callq 0x6670
cmpl $0x0, %eax
jge 0x4cefc
leaq 0x909c8(%rip), %rdi     # 0xdd8bd
movb $0x0, %al
callq 0x35ee0
jmp 0x4cefe
cmpl $0x2, -0x14(%rbp)
je 0x4cf26
movl -0x14(%rbp), %edi
movl $0x2, %esi
callq 0x6670
cmpl $0x0, %eax
jge 0x4cf24
leaq 0x909b5(%rip), %rdi     # 0xdd8d2
movb $0x0, %al
callq 0x35ee0
jmp 0x4cf26
callq 0x4caf0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/pipeline.c
// Function: plProcHandleTerminate
static void plProcHandleTerminate(struct plProc* proc, int status)
/* handle one of the processes terminating, save exit status */
{
proc->pid = -1;
proc->status = status;
plProcStateTrans(proc, procStateDone);

if (WIFSIGNALED(proc->status))
    plProcHandleSignaled(proc, status);
else
    plProcHandleExited(proc, status);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x18(%rax) # imm = 0xFFFFFFFF
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x4ccd0
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
andl $0x7f, %eax
addl $0x1, %eax
movsbl %al, %eax
sarl %eax
cmpl $0x0, %eax
jle 0x4d027
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x4d0b0
jmp 0x4d033
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x4d160
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/pipeline.c
// Function: plProcHandleSignaled
static void plProcHandleSignaled(struct plProc* proc, int status)
/* handle one of the processes terminating on a signal */
{
assert(WIFSIGNALED(proc->status));
if (!((WTERMSIG(proc->status) == SIGPIPE) && (proc->pl->options & pipelineSigpipe)))
    {
    errAbort("process terminated on signal %d: \"%s\" in pipeline \"%s\"",
             WTERMSIG(proc->status), joinCmd(proc->cmd), proc->pl->procName);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
andl $0x7f, %eax
addl $0x1, %eax
movsbl %al, %eax
sarl %eax
cmpl $0x0, %eax
jle 0x4d0d8
jmp 0x4d0f7
leaq 0x90880(%rip), %rdi     # 0xdd95f
leaq 0x90697(%rip), %rsi     # 0xdd77d
movl $0xe7, %edx
leaq 0x90887(%rip), %rcx     # 0xdd979
callq 0x6450
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
andl $0x7f, %eax
cmpl $0xd, %eax
jne 0x4d119
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x1c(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
jne 0x4d153
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
andl $0x7f, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x4d240
movl -0x10(%rbp), %esi
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rcx
leaq 0x9085d(%rip), %rdi     # 0xdd9a9
movb $0x0, %al
callq 0x35d40
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/pipeline.c
// Function: plProcHandleExited
static void plProcHandleExited(struct plProc* proc, int status)
/* handle one of the processes terminating on an exit */
{
assert(WIFEXITED(proc->status));
if (WEXITSTATUS(proc->status) != 0)
    {
    // only print an error message if aborting
    if (!(proc->pl->options & pipelineNoAbort))
        fprintf(stderr, "process exited with %d: \"%s\" in pipeline \"%s\"\n",
                WEXITSTATUS(proc->status), joinCmd(proc->cmd), proc->pl->procName);
    exit(WEXITSTATUS(proc->status));  // pass back exit code
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
andl $0x7f, %eax
cmpl $0x0, %eax
jne 0x4d180
jmp 0x4d19f
leaq 0x90859(%rip), %rdi     # 0xdd9e0
leaq 0x905ef(%rip), %rsi     # 0xdd77d
movl $0xf2, %edx
leaq 0x9085e(%rip), %rcx     # 0xdd9f8
callq 0x6450
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
cmpl $0x0, %eax
je 0x4d22c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x1c(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
jne 0x4d217
movq 0xb7e03(%rip), %rax     # 0x104fd0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x4d240
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %edx
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %r8
leaq 0x90816(%rip), %rsi     # 0xdda26
movb $0x0, %al
callq 0x6a80
movq -0x8(%rbp), %rax
movl 0x20(%rax), %edi
andl $0xff00, %edi           # imm = 0xFF00
sarl $0x8, %edi
callq 0x68b0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/psl.c
// Function: pslxLoad
struct psl *pslxLoad(char **row)
/* Load a psl from row fetched with select * from psl
 * from database.  Dispose of this with pslFree(). */
{
struct psl *ret = pslLoad(row);
int retSize;
sqlStringDynamicArray(row[21],&ret->qSequence, &retSize);
sqlStringDynamicArray(row[22],&ret->tSequence, &retSize);
return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4d3e0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0xa8(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x78, %rsi
leaq -0x14(%rbp), %rdx
callq 0x57f20
movq -0x8(%rbp), %rax
movq 0xb0(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x80, %rsi
leaq -0x14(%rbp), %rdx
callq 0x57f20
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/icebert[P]pblat/lib/psl.c
// Function: pslFree
void pslFree(struct psl **pEl)
/* Free a single dynamically allocated psl such as created
 * with pslLoad(). */
{
struct psl *el;

if ((el = *pEl) == NULL) return;
freeMem(el->qName);
freeMem(el->tName);
freeMem(el->blockSizes);
freeMem(el->qStarts);
freeMem(el->tStarts);
if (el->qSequence)
    {
    freeMem(el->qSequence[0]);
    freeMem(el->qSequence);
    }
if (el->tSequence)
    {
    freeMem(el->tSequence[0]);
    freeMem(el->tSequence);
    }
freez(pEl);
}

// 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, %rax
jne 0x4da52
jmp 0x4daf5
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x40d40
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x40d40
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x40d40
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x40d40
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x40d40
movq -0x10(%rbp), %rax
cmpq $0x0, 0x78(%rax)
je 0x4dabb
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rax
movq (%rax), %rdi
callq 0x40d40
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rdi
callq 0x40d40
movq -0x10(%rbp), %rax
cmpq $0x0, 0x80(%rax)
je 0x4daec
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rax
movq (%rax), %rdi
callq 0x40d40
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rdi
callq 0x40d40
movq -0x8(%rbp), %rdi
callq 0x40d70
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)