LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/hash.c
// Function: hashPrintStats
void hashPrintStats(struct hash *hash, char *label, FILE *fh)
/* print statistic about a hash table */
{
// count up usage
int i, occupiedCnt = 0, maxBucket = 0;
for (i=0; i<hash->size; ++i)
    {
    if (hash->table[i] != NULL)
        occupiedCnt++;
    int sz = bucketLen(hash->table[i]);
    maxBucket = max(maxBucket, sz);
    }

fprintf(fh, "hashTable\t%s\n", label);
fprintf(fh, "tableSize\t%d\t%d\n", hash->size, hash->powerOfTwoSize);
fprintf(fh, "numElements\t%d\n", hash->elCount);
fprintf(fh, "occupied\t%d\t%0.4f\n", occupiedCnt, ((hash->size == 0) ? 0.0 : ((float)occupiedCnt)/hash->size));
fprintf(fh, "maxBucket\t%d\n", maxBucket);
fprintf(fh, "numResizes\t%d\n", hash->numResizes);
fprintf(fh, "\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jge 0x11940
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x1c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x11901
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x11870
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jle 0x11929
movl -0x24(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x1192f
movl -0x28(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x118d9
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x1331b(%rip), %rsi     # 0x24c6a
movb $0x0, %al
callq 0x3440
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %edx
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
leaq 0x13309(%rip), %rsi     # 0x24c78
movb $0x0, %al
callq 0x3440
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x28(%rax), %edx
leaq 0x13301(%rip), %rsi     # 0x24c89
movb $0x0, %al
callq 0x3440
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x1c(%rax)
jne 0x119b1
xorps %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
jmp 0x119cc
cvtsi2ssl -0x20(%rbp), %xmm0
movq -0x8(%rbp), %rax
cvtsi2ssl 0x1c(%rax), %xmm1
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
movl -0x30(%rbp), %edx
movq -0x38(%rbp), %rdi
movsd -0x40(%rbp), %xmm0
leaq 0x132ba(%rip), %rsi     # 0x24c99
movb $0x1, %al
callq 0x3440
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %edx
leaq 0x132b8(%rip), %rsi     # 0x24cac
movb $0x0, %al
callq 0x3440
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x34(%rax), %edx
leaq 0x132ad(%rip), %rsi     # 0x24cba
movb $0x0, %al
callq 0x3440
movq -0x18(%rbp), %rdi
leaq 0x15abc(%rip), %rsi     # 0x274db
movb $0x0, %al
callq 0x3440
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/hash.c
// Function: hashToRaString
char *hashToRaString(struct hash *hash)
/* Convert hash to string in ra format. */
{
struct hashEl *el, *list = hashElListHash(hash);
struct dyString *dy = dyStringNew(0);
slSort(&list, hashElCmp);
for (el = list; el != NULL; el = el->next)
   {
   dyStringAppend(dy, el->name);
   dyStringAppendC(dy, ' ');
   dyStringAppend(dy, el->val);
   dyStringAppendC(dy, '\n');
   }
hashElFreeList(&list);
return dyStringCannibalize(&dy);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x112f0
movq %rax, -0x18(%rbp)
xorl %edi, %edi
callq 0xf030
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x8cf(%rip), %rsi      # 0x111e0
callq 0x7c70
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x11b0e
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xf3c0
movq -0x20(%rbp), %rdi
movl $0x20, %esi
callq 0xf2b0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0xf3c0
movq -0x20(%rbp), %rdi
movl $0xa, %esi
callq 0xf2b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x11abc
leaq -0x18(%rbp), %rdi
callq 0x113e0
leaq -0x20(%rbp), %rdi
callq 0xf0d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/hash.c
// Function: hashNumEntries
int hashNumEntries(struct hash *hash)
/* count the number of entries in a hash */
{
int n = 0, i;
for (i=0; i<hash->size; ++i)
    n += bucketLen(hash->table[i]);
return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jge 0x11b7c
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x11870
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x11b4a
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/linefile.c
// Function: getFileNameFromHdrSig
char *getFileNameFromHdrSig(char *m)
/* Check if header has signature of supported compression stream,
   and return a phoney filename for it, or NULL if no sig found. */
{
char buf[20];
char *ext=NULL;
if (startsWith("\x1f\x8b",m)) ext = "gz";
else if (startsWith("\x1f\x9d\x90",m)) ext = "Z";
else if (startsWith("BZ",m)) ext = "bz2";
else if (startsWith("PK\x03\x04",m)) ext = "zip";
if (ext==NULL)
    return NULL;
safef(buf, sizeof(buf), "somefile.%s", ext);
return cloneString(buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x1313d(%rip), %rdi     # 0x24cec
callq 0xa4b0
cmpl $0x0, %eax
je 0x11bc6
leaq 0x13892(%rip), %rax     # 0x25452
movq %rax, -0x38(%rbp)
jmp 0x11c30
movq -0x10(%rbp), %rsi
leaq 0x1311e(%rip), %rdi     # 0x24cef
callq 0xa4b0
cmpl $0x0, %eax
je 0x11be8
leaq 0x13874(%rip), %rax     # 0x25456
movq %rax, -0x38(%rbp)
jmp 0x11c2e
movq -0x10(%rbp), %rsi
leaq 0x13100(%rip), %rdi     # 0x24cf3
callq 0xa4b0
cmpl $0x0, %eax
je 0x11c0a
leaq 0x13855(%rip), %rax     # 0x25459
movq %rax, -0x38(%rbp)
jmp 0x11c2c
movq -0x10(%rbp), %rsi
leaq 0x130e1(%rip), %rdi     # 0x24cf6
callq 0xa4b0
cmpl $0x0, %eax
je 0x11c2a
leaq 0x13838(%rip), %rax     # 0x2545e
movq %rax, -0x38(%rbp)
jmp 0x11c2c
jmp 0x11c2e
jmp 0x11c30
cmpq $0x0, -0x38(%rbp)
jne 0x11c41
movq $0x0, -0x8(%rbp)
jmp 0x11c69
leaq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rcx
movl $0x14, %esi
leaq 0x130a6(%rip), %rdx     # 0x24cfb
movb $0x0, %al
callq 0xdc90
leaq -0x30(%rbp), %rdi
callq 0x7530
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/JimKent[P]linearSat/lib/linefile.c
// Function: lineFileSetMetaDataOutput
void lineFileSetMetaDataOutput(struct lineFile *lf, FILE *f)
/* set file to write meta data to,
 * should be called before reading from input file */
{
struct metaOutput *meta = NULL;
if (lf == NULL)
    return;
AllocVar(meta);
meta->next = NULL;
meta->metaFile = f;
slAddHead(&lf->metaOutput, meta);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x11ca1
jmp 0x11cd7
movl $0x10, %edi
callq 0x152f0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
addq $0x50, %rdi
movq -0x18(%rbp), %rsi
callq 0x11ce0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/linefile.c
// Function: lineFileDecompress
struct lineFile *lineFileDecompress(char *fileName, bool zTerm)
/* open a linefile with decompression */
{
struct pipeline *pl;
struct lineFile *lf;
char *testName = NULL;
char *testbytes = NULL;    /* the header signatures for .gz, .bz2, .Z,
			    * .zip are all 2-4 bytes only */
if (fileName==NULL)
  return NULL;
testbytes=headerBytes(fileName,4);
if (!testbytes)
    return NULL;  /* avoid error from pipeline */
testName=getFileNameFromHdrSig(testbytes);
freez(&testbytes);
if (!testName)
    return NULL;  /* avoid error from pipeline */
pl = pipelineOpen1(getDecompressor(fileName), pipelineRead, fileName, NULL);
lf = lineFileAttach(fileName, zTerm, pipelineFd(pl));
lf->pl = pl;
return lf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x11d96
movq $0x0, -0x8(%rbp)
jmp 0x11e45
movq -0x10(%rbp), %rdi
movl $0x4, %esi
callq 0x11e50
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x11dbc
movq $0x0, -0x8(%rbp)
jmp 0x11e45
movq -0x38(%rbp), %rdi
callq 0x11b90
movq %rax, -0x30(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x15410
cmpq $0x0, -0x30(%rbp)
jne 0x11de3
movq $0x0, -0x8(%rbp)
jmp 0x11e45
movq -0x10(%rbp), %rdi
callq 0x11ee0
movq %rax, %rdi
movq -0x10(%rbp), %rdx
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %ecx
callq 0x19cb0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movb -0x11(%rbp), %al
movb %al, -0x39(%rbp)
movq -0x20(%rbp), %rdi
callq 0x19d70
movq -0x48(%rbp), %rdi
movl %eax, %edx
movb -0x39(%rbp), %al
movsbl %al, %esi
callq 0x12010
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/linefile.c
// Function: headerBytes
static char * headerBytes(char *fileName, int numbytes)
/* Return specified number of header bytes from file
 * if file exists as a string which should be freed. */
{
int fd,bytesread=0;
char *result = NULL;
if ((fd = open(fileName, O_RDONLY)) >= 0)
    {
    result=needMem(numbytes+1);
    if ((bytesread=read(fd,result,numbytes)) < numbytes)
	freez(&result);  /* file too short? can read numbytes */
    else
	result[numbytes]=0;
    close(fd);
    }
return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x3580
movl %eax, -0x10(%rbp)
cmpl $0x0, %eax
jl 0x11ecc
movl -0xc(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x152f0
movq %rax, -0x20(%rbp)
movl -0x10(%rbp), %edi
movq -0x20(%rbp), %rsi
movslq -0xc(%rbp), %rdx
callq 0x33a0
movl %eax, -0x14(%rbp)
cmpl -0xc(%rbp), %eax
jge 0x11eb8
leaq -0x20(%rbp), %rdi
callq 0x15410
jmp 0x11ec4
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x10(%rbp), %edi
callq 0x3330
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/linefile.c
// Function: getDecompressor
static char **getDecompressor(char *fileName)
/* if a file is compressed, return the command to decompress the
 * approriate format, otherwise return NULL */
{
static char *GZ_READ[] = {"gzip", "-dc", NULL};
static char *Z_READ[] = {"gzip", "-dc", NULL};
static char *BZ2_READ[] = {"bzip2", "-dc", NULL};
static char *ZIP_READ[] = {"gzip", "-dc", NULL};

char **result = NULL;
char *fileNameDecoded = cloneString(fileName);
if (startsWith("http://" , fileName)
 || startsWith("https://", fileName)
 || startsWith("ftp://",   fileName))
    cgiDecode(fileName, fileNameDecoded, strlen(fileName));

if      (endsWith(fileNameDecoded, ".gz"))
    result = GZ_READ;
else if (endsWith(fileNameDecoded, ".Z"))
    result = Z_READ;
else if (endsWith(fileNameDecoded, ".bz2"))
    result = BZ2_READ;
else if (endsWith(fileNameDecoded, ".zip"))
    result = ZIP_READ;

freeMem(fileNameDecoded);
return result;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7530
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x1352d(%rip), %rdi     # 0x25439
callq 0xa4b0
cmpl $0x0, %eax
jne 0x11f40
movq -0x8(%rbp), %rsi
leaq 0x13520(%rip), %rdi     # 0x25441
callq 0xa4b0
cmpl $0x0, %eax
jne 0x11f40
movq -0x8(%rbp), %rsi
leaq 0x13514(%rip), %rdi     # 0x2544a
callq 0xa4b0
cmpl $0x0, %eax
je 0x11f68
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x31f0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl %eax, %edx
callq 0x1bf60
movq -0x18(%rbp), %rdi
leaq 0x134de(%rip), %rsi     # 0x25451
callq 0xa990
cmpl $0x0, %eax
je 0x11f8a
leaq 0x2053c(%rip), %rax     # 0x324c0
movq %rax, -0x10(%rbp)
jmp 0x11ff4
movq -0x18(%rbp), %rdi
leaq 0x134c0(%rip), %rsi     # 0x25455
callq 0xa990
cmpl $0x0, %eax
je 0x11fac
leaq 0x2053a(%rip), %rax     # 0x324e0
movq %rax, -0x10(%rbp)
jmp 0x11ff2
movq -0x18(%rbp), %rdi
leaq 0x134a1(%rip), %rsi     # 0x25458
callq 0xa990
cmpl $0x0, %eax
je 0x11fce
leaq 0x20538(%rip), %rax     # 0x32500
movq %rax, -0x10(%rbp)
jmp 0x11ff0
movq -0x18(%rbp), %rdi
leaq 0x13484(%rip), %rsi     # 0x2545d
callq 0xa990
cmpl $0x0, %eax
je 0x11fee
leaq 0x20536(%rip), %rax     # 0x32520
movq %rax, -0x10(%rbp)
jmp 0x11ff0
jmp 0x11ff2
jmp 0x11ff4
movq -0x18(%rbp), %rdi
callq 0x153e0
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/linefile.c
// Function: lineFileAttach
struct lineFile *lineFileAttach(char *fileName, bool zTerm, int fd)
/* Wrap a line file around an open'd file. */
{
struct lineFile *lf;
AllocVar(lf);
lf->fileName = cloneString(fileName);
lf->fd = fd;
lf->bufSize = 64*1024;
lf->zTerm = zTerm;
lf->buf = needMem(lf->bufSize+1);
return lf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl %edx, -0x10(%rbp)
movl $0xa0, %edi
callq 0x152f0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7530
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x10(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rax
movl $0x10000, 0x14(%rax)    # imm = 0x10000
movb -0x9(%rbp), %cl
movq -0x18(%rbp), %rax
movb %cl, 0x34(%rax)
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x152f0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/linefile.c
// Function: lineFileDecompressFd
struct lineFile *lineFileDecompressFd(char *name, bool zTerm, int fd)
/* open a linefile with decompression from a file or socket descriptor */
{
struct pipeline *pl;
struct lineFile *lf;
pl = pipelineOpenFd1(getDecompressor(name), pipelineRead, fd, STDERR_FILENO);
lf = lineFileAttach(name, zTerm, pipelineFd(pl));
lf->pl = pl;
return lf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x11ee0
movq %rax, %rdi
movl -0x10(%rbp), %edx
movl $0x1, %esi
movl $0x2, %ecx
callq 0x19c70
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movb -0x9(%rbp), %al
movb %al, -0x21(%rbp)
movq -0x18(%rbp), %rdi
callq 0x19d70
movq -0x30(%rbp), %rdi
movl %eax, %edx
movb -0x21(%rbp), %al
movsbl %al, %esi
callq 0x12010
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/linefile.c
// Function: lineFileDecompressMem
struct lineFile *lineFileDecompressMem(bool zTerm, char *mem, long size)
/* open a linefile with decompression from a memory stream */
{
struct pipeline *pl;
struct lineFile *lf;
char *fileName = getFileNameFromHdrSig(mem);
if (fileName==NULL)
  return NULL;
pl = pipelineOpenMem1(getDecompressor(fileName), pipelineRead, mem, size, STDERR_FILENO);
lf = lineFileAttach(fileName, zTerm, pipelineFd(pl));
lf->pl = pl;
return lf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %dil, %al
movb %al, -0x9(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11b90
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x12144
movq $0x0, -0x8(%rbp)
jmp 0x121ac
movq -0x38(%rbp), %rdi
callq 0x11ee0
movq %rax, %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl $0x1, %esi
movl $0x2, %r8d
callq 0x19d00
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movb -0x9(%rbp), %al
movb %al, -0x39(%rbp)
movq -0x28(%rbp), %rdi
callq 0x19d70
movq -0x48(%rbp), %rdi
movl %eax, %edx
movb -0x39(%rbp), %al
movsbl %al, %esi
callq 0x12010
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/linefile.c
// Function: lineFileOnString
struct lineFile *lineFileOnString(char *name, bool zTerm, char *s)
/* Wrap a line file object around string in memory. This buffer
 * have zeroes written into it and be freed when the line file
 * is closed. */
{
struct lineFile *lf;
AllocVar(lf);
lf->fileName = cloneString(name);
lf->fd = -1;
lf->bufSize = lf->bytesInBuf = strlen(s);
lf->zTerm = zTerm;
lf->buf = s;
return lf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movl $0xa0, %edi
callq 0x152f0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7530
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
movq -0x18(%rbp), %rdi
callq 0x31f0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x20(%rbp), %rax
movl %ecx, 0x14(%rax)
movb -0x9(%rbp), %cl
movq -0x20(%rbp), %rax
movb %cl, 0x34(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/linefile.c
// Function: lineFileMayOpen
struct lineFile *lineFileMayOpen(char *fileName, bool zTerm)
/* Try and open up a lineFile. */
{
if (sameString(fileName, "stdin"))
    return lineFileStdin(zTerm);
else if (getDecompressor(fileName) != NULL)
    return lineFileDecompress(fileName, zTerm);
else
    {
    int fd = open(fileName, O_RDONLY);
    if (fd == -1)
        return NULL;
    return lineFileAttach(fileName, zTerm, fd);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x14065(%rip), %rsi     # 0x263e2
callq 0x3410
cmpl $0x0, %eax
jne 0x12396
movsbl -0x11(%rbp), %edi
callq 0x12320
movq %rax, -0x8(%rbp)
jmp 0x123ee
movq -0x10(%rbp), %rdi
callq 0x11ee0
cmpq $0x0, %rax
je 0x123b8
movq -0x10(%rbp), %rdi
movsbl -0x11(%rbp), %esi
callq 0x11d60
movq %rax, -0x8(%rbp)
jmp 0x123ee
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x3580
movl %eax, -0x18(%rbp)
cmpl $-0x1, -0x18(%rbp)
jne 0x123d8
movq $0x0, -0x8(%rbp)
jmp 0x123ee
movq -0x10(%rbp), %rdi
movb -0x11(%rbp), %al
movl -0x18(%rbp), %edx
movsbl %al, %esi
callq 0x12010
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/linefile.c
// Function: lineFileOpen
struct lineFile *lineFileOpen(char *fileName, bool zTerm)
/* Open up a lineFile or die trying. */
{
struct lineFile *lf = lineFileMayOpen(fileName, zTerm);
if (lf == NULL)
    errAbort("Couldn't open %s , %s", fileName, strerror(errno));
return lf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movsbl -0x9(%rbp), %esi
callq 0x12360
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x12453
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x30a0
movl (%rax), %edi
callq 0x36f0
movq -0x20(%rbp), %rsi
movq %rax, %rdx
leaq 0x12a25(%rip), %rdi     # 0x24e71
movb $0x0, %al
callq 0xfd50
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/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 (whence == SEEK_SET && offset >= lf->bufOffsetInFile
	&& offset < lf->bufOffsetInFile + lf->bytesInBuf)
    {
    lf->lineStart = lf->lineEnd = offset - lf->bufOffsetInFile;
    }
else
    {
    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 0x129e9(%rip), %rsi     # 0x24e87
callq 0x125a0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x88(%rax)
je 0x124c9
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rax
movq -0x8(%rbp), %rdi
leaq 0x129c0(%rip), %rsi     # 0x24e87
callq *%rax
movq -0x8(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x124ea
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x129b1(%rip), %rdi     # 0x24e94
movb $0x0, %al
callq 0xfed0
movq -0x8(%rbp), %rax
movb $0x0, 0x3c(%rax)
cmpl $0x0, -0x14(%rbp)
jne 0x12540
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jl 0x12540
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq -0x8(%rbp), %rdx
movslq 0x20(%rdx), %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jge 0x12540
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
subq 0x18(%rcx), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x8(%rbp), %rax
movl %ecx, 0x2c(%rax)
jmp 0x1259a
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 0x36d0
movq -0x8(%rbp), %rcx
movq %rax, 0x18(%rcx)
cmpq $-0x1, %rax
jne 0x12598
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x1292f(%rip), %rdi     # 0x24ec0
movb $0x0, %al
callq 0xfed0
jmp 0x1259a
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/linefile.c
// Function: lineFileLongNetRead
int lineFileLongNetRead(int fd, char *buf, int size)
/* Keep reading until either get no new characters or
 * have read size */
{
int oneSize, totalRead = 0;

while (size > 0)
    {
    oneSize = read(fd, buf, size);
    if (oneSize <= 0)
        break;
    totalRead += oneSize;
    buf += oneSize;
    size -= oneSize;
    }
return totalRead;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x12641
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x33a0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jg 0x1261a
jmp 0x12641
movl -0x18(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movl -0x18(%rbp), %ecx
movl -0x14(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x14(%rbp)
jmp 0x125f9
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/linefile.c
// Function: metaDataAdd
static void metaDataAdd(struct lineFile *lf, char *line)
/* write a line of metaData to output file
 * internal function called by lineFileNext */
{
struct metaOutput *meta = NULL;

if (lf->isMetaUnique)
    {
    /* suppress repetition of comments */
    if (hashLookup(lf->metaLines, line))
        {
        return;
        }
    hashAdd(lf->metaLines, line, NULL);
    }
for (meta = lf->metaOutput ; meta != NULL ; meta = meta->next)
    if (line != NULL && meta->metaFile != NULL)
        fprintf(meta->metaFile,"%s\n", line);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, 0x58(%rax)
je 0x12bf0
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x104b0
cmpq $0x0, %rax
je 0x12bdb
jmp 0x12c3e
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x10900
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x12c3e
cmpq $0x0, -0x10(%rbp)
je 0x12c2f
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x12c2f
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x1204c(%rip), %rsi     # 0x24c74
movb $0x0, %al
callq 0x3440
jmp 0x12c31
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x12bfc
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/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 */
lf->nlType = nlt_unix;  /* start with default of unix lf type */
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')
	{
	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 0x12c72
jmp 0x12d09
movq -0x8(%rbp), %rax
cmpl $0x0, 0x38(%rax)
je 0x12c81
jmp 0x12d09
movq -0x8(%rbp), %rax
movl $0x1, 0x38(%rax)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x12d09
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xd, %eax
jne 0x12cee
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 0x12cec
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x12cea
movq -0x8(%rbp), %rax
movl $0x2, 0x38(%rax)
jmp 0x12cec
jmp 0x12d09
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x12d07
jmp 0x12d09
jmp 0x12c8c
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/linefile.c
// Function: lineFileVaAbort
void lineFileVaAbort(struct lineFile *lf, char *format, va_list args)
/* Print file name, line number, and error message, and abort. */
{
struct dyString *dy = dyStringNew(0);
dyStringPrintf(dy,  "Error line %d of %s: ", lf->lineIx, lf->fileName);
dyStringVaPrintf(dy, format, args);
errAbort("%s", dy->string);
dyStringFree(&dy);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
xorl %edi, %edi
callq 0xf030
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x28(%rax), %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
leaq 0x121c1(%rip), %rsi     # 0x24f0a
movb $0x0, %al
callq 0xf550
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xf470
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x1183c(%rip), %rdi     # 0x245ac
movb $0x0, %al
callq 0xfd50
leaq -0x20(%rbp), %rdi
callq 0xf090
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/linefile.c
// Function: lineFileClose
void lineFileClose(struct lineFile **pLf)
/* Close up a line file. */
{
struct lineFile *lf;
if ((lf = *pLf) != NULL)
    {
    if (lf->pl != NULL)
        {
        pipelineWait(lf->pl);
        pipelineFree(&lf->pl);
        }
    else if (lf->fd > 0 && lf->fd != fileno(stdin))
	{
	close(lf->fd);
	freeMem(lf->buf);
	}
#ifdef USE_TABIX
    else if (lf->tabix != NULL)
	{
	if (lf->tabixIter != NULL)
	    ti_iter_destroy(lf->tabixIter);
	ti_close(lf->tabix);
	}
#endif // USE_TABIX
    if (lf->closeCallBack)
        lf->closeCallBack(lf);
    freeMem(lf->fileName);
    metaDataFree(lf);
    freez(pLf);
    }
}

// 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, %rax
je 0x12f6d
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x12ee8
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x19f00
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
callq 0x196a0
jmp 0x12f2f
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jle 0x12f2d
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x14(%rbp)
movq 0x1f0c5(%rip), %rax     # 0x31fc8
movq (%rax), %rdi
callq 0x34b0
movl %eax, %ecx
movl -0x14(%rbp), %eax
cmpl %ecx, %eax
je 0x12f2d
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edi
callq 0x3330
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x153e0
jmp 0x12f2f
movq -0x10(%rbp), %rax
cmpq $0x0, 0x98(%rax)
je 0x12f4e
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x153e0
movq -0x10(%rbp), %rdi
callq 0x12f80
movq -0x8(%rbp), %rdi
callq 0x15410
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/linefile.c
// Function: lineFileCloseList
void lineFileCloseList(struct lineFile **pList)
/* Close up a list of line files. */
{
struct lineFile *el, *next;

for (el = *pList; el != NULL; el = next)
    {
    next = el->next;
    lineFileClose(&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 0x12ffc
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x12ea0
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x12fd7
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/linefile.c
// Function: lineFileNextReal
boolean lineFileNextReal(struct lineFile *lf, char **retStart)
/* Fetch next line from file that is not blank and
 * does not start with a '#'. */
{
char *s, c;
while (lineFileNext(lf, retStart, NULL))
    {
    s = skipLeadingSpaces(*retStart);
    c = s[0];
    if (c != 0 && c != '#')
        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
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x12650
cmpl $0x0, %eax
je 0x1356c
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x9bb0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb (%rax), %al
movb %al, -0x21(%rbp)
movsbl -0x21(%rbp), %eax
cmpl $0x0, %eax
je 0x1356a
movsbl -0x21(%rbp), %eax
cmpl $0x23, %eax
je 0x1356a
movl $0x1, -0x4(%rbp)
jmp 0x13573
jmp 0x13520
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/linefile.c
// Function: lineFileNextFullReal
boolean lineFileNextFullReal(struct lineFile *lf, char **retStart)
// Fetch next line from file that is not blank and does not start with a '#'.
// Continuation lines (ending in '\') are joined into a single line.
{
while (lineFileNextFull(lf, retStart, NULL, NULL, NULL))
    {
    char *clippedText = skipLeadingSpaces(*retStart);
    if (clippedText[0] != '\0' && clippedText[0] != '#')
        return TRUE;
    }
return FALSE;
}

// 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, %r8d
movq %r8, %rdx
movq %r8, %rcx
callq 0x13130
cmpl $0x0, %eax
je 0x135e0
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x9bb0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x135de
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x23, %eax
je 0x135de
movl $0x1, -0x4(%rbp)
jmp 0x135e7
jmp 0x13590
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/linefile.c
// Function: lineFileChopNext
int lineFileChopNext(struct lineFile *lf, char *words[], int maxWords)
/* Return next non-blank line that doesn't start with '#' chopped into words. */
{
int lineSize, wordCount;
char *line;

while (lineFileNext(lf, &line, &lineSize))
    {
    if (line[0] == '#')
        continue;
    wordCount = chopByWhite(line, words, maxWords);
    if (wordCount != 0)
        return wordCount;
    }
return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x12650
cmpl $0x0, %eax
je 0x1364a
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x23, %eax
jne 0x13627
jmp 0x13603
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0xb840
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x13648
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x13651
jmp 0x13603
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/linefile.c
// Function: lineFileChopCharNext
int lineFileChopCharNext(struct lineFile *lf, char sep, char *words[], int maxWords)
/* Return next non-blank line that doesn't start with '#' chopped into
   words delimited by sep. */
{
int lineSize, wordCount;
char *line;

while (lineFileNext(lf, &line, &lineSize))
    {
    if (line[0] == '#')
        continue;
    wordCount = chopByChar(line, sep, words, maxWords);
    if (wordCount != 0)
        return wordCount;
    }
return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x12650
cmpl $0x0, %eax
je 0x136c6
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x23, %eax
jne 0x1369d
jmp 0x13679
movq -0x38(%rbp), %rdi
movb -0x11(%rbp), %al
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
movsbl %al, %esi
callq 0xbb30
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x136c4
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x136cd
jmp 0x13679
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/linefile.c
// Function: lineFileChopNextTab
int lineFileChopNextTab(struct lineFile *lf, char *words[], int maxWords)
/* Return next non-blank line that doesn't start with '#' chopped into words
 * on tabs */
{
int lineSize, wordCount;
char *line;

while (lineFileNext(lf, &line, &lineSize))
    {
    if (line[0] == '#')
        continue;
    wordCount = chopByChar(line, '\t', words, maxWords);
    if (wordCount != 0)
        return wordCount;
    }
return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x12650
cmpl $0x0, %eax
je 0x1373f
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x23, %eax
jne 0x13717
jmp 0x136f3
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl $0x9, %esi
callq 0xbb30
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x1373d
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x13746
jmp 0x136f3
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/linefile.c
// Function: lineFileNextCharRow
boolean lineFileNextCharRow(struct lineFile *lf, char sep, char *words[], int wordCount)
/* Return next non-blank line that doesn't start with '#' chopped into words
 * delimited by sep. Returns FALSE at EOF.  Aborts on error. */
{
int wordsRead;
wordsRead = lineFileChopCharNext(lf, sep, words, wordCount);
if (wordsRead == 0)
    return FALSE;
if (wordsRead < wordCount)
    lineFileExpectWords(lf, wordCount, wordsRead);
return TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movb -0x11(%rbp), %al
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
movsbl %al, %esi
callq 0x13660
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jne 0x13791
movl $0x0, -0x4(%rbp)
jmp 0x137af
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x137a8
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
movl -0x28(%rbp), %edx
callq 0x13010
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/linefile.c
// Function: lineFileNextRow
boolean lineFileNextRow(struct lineFile *lf, char *words[], int wordCount)
/* Return next non-blank line that doesn't start with '#' chopped into words.
 * Returns FALSE at EOF.  Aborts on error. */
{
int wordsRead;
wordsRead = lineFileChopNext(lf, words, wordCount);
if (wordsRead == 0)
    return FALSE;
if (wordsRead < wordCount)
    lineFileExpectWords(lf, wordCount, wordsRead);
return TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x135f0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x137f5
movl $0x0, -0x4(%rbp)
jmp 0x13813
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x1380c
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
callq 0x13010
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/linefile.c
// Function: lineFileNextRowTab
boolean lineFileNextRowTab(struct lineFile *lf, char *words[], int wordCount)
/* Return next non-blank line that doesn't start with '#' chopped into words
 * at tabs. Returns FALSE at EOF.  Aborts on error. */
{
int wordsRead;
wordsRead = lineFileChopNextTab(lf, words, wordCount);
if (wordsRead == 0)
    return FALSE;
if (wordsRead < wordCount)
    lineFileExpectWords(lf, wordCount, wordsRead);
return TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x136e0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x13855
movl $0x0, -0x4(%rbp)
jmp 0x13873
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x1386c
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
callq 0x13010
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/linefile.c
// Function: lineFileNeedFullNum
int lineFileNeedFullNum(struct lineFile *lf, char *words[], int wordIx)
/* Make sure that words[wordIx] is an ascii integer, and return
 * binary representation of it. Require all chars in word to be digits.*/
{
char *c;
for (c = words[wordIx]; *c; c++)
    {
    if (*c == '-' || isdigit(*c))
        /* NOTE: embedded '-' will be caught by lineFileNeedNum */
        continue;
    errAbort("Expecting integer field %d line %d of %s, got %s",
            wordIx+1, lf->lineIx, lf->fileName, words[wordIx]);
    }
return lineFileNeedNum(lf, words, wordIx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
je 0x13917
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x138d8
callq 0x3760
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x138da
jmp 0x13909
movl -0x14(%rbp), %esi
addl $0x1, %esi
movq -0x8(%rbp), %rax
movl 0x28(%rax), %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rdi
movq (%rax,%rdi,8), %r8
leaq 0x11744(%rip), %rdi     # 0x25046
movb $0x0, %al
callq 0xfd50
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x138a3
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x13930
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/linefile.c
// Function: lineFileNeedNum
int lineFileNeedNum(struct lineFile *lf, char *words[], int wordIx)
/* Make sure that words[wordIx] is an ascii integer, and return
 * binary representation of it. Conversion stops at first non-digit char. */
{
char *ascii = words[wordIx];
char c = ascii[0];
if (c != '-' && !isdigit(c))
    errAbort("Expecting number field %d line %d of %s, got %s",
    	wordIx+1, lf->lineIx, lf->fileName, ascii);
return atoi(ascii);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb (%rax), %al
movb %al, -0x21(%rbp)
movsbl -0x21(%rbp), %eax
cmpl $0x2d, %eax
je 0x139a9
callq 0x3760
movq (%rax), %rax
movsbl -0x21(%rbp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0x139a9
movl -0x14(%rbp), %esi
addl $0x1, %esi
movq -0x8(%rbp), %rax
movl 0x28(%rax), %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %r8
leaq 0x116d5(%rip), %rdi     # 0x25077
movb $0x0, %al
callq 0xfd50
movq -0x20(%rbp), %rdi
callq 0x3670
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/linefile.c
// Function: lineFileAllInts
void lineFileAllInts(struct lineFile *lf, char *words[], int wordIx, void *val,
  boolean isSigned,  int byteCount, char *typeString, boolean noNeg)
/* Returns long long integer from converting the input string. Aborts on error. */
{
char *s = words[wordIx];
char errMsg[256];
int res = lineFileCheckAllIntsNoAbort(s, val, isSigned, byteCount, typeString, noNeg, errMsg, sizeof errMsg);
if (res > 0)
    {
    errAbort("%s in field %d line %d of %s, got %s",
	errMsg, wordIx+1, lf->lineIx, lf->fileName, s);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
movl -0x28(%rbp), %ecx
movq 0x10(%rbp), %r8
movl 0x18(%rbp), %r9d
leaq -0x130(%rbp), %rax
movq %rax, (%rsp)
movl $0x100, 0x8(%rsp)       # imm = 0x100
callq 0x139c0
movl %eax, -0x134(%rbp)
cmpl $0x0, -0x134(%rbp)
jle 0x13eb4
leaq -0x130(%rbp), %rsi
movl -0x14(%rbp), %edx
addl $0x1, %edx
movq -0x8(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %r8
movq -0x30(%rbp), %r9
leaq 0x11327(%rip), %rdi     # 0x251d4
movb $0x0, %al
callq 0xfd50
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/linefile.c
// Function: lineFileAllIntsArray
int lineFileAllIntsArray(struct lineFile *lf, char *words[], int wordIx, void *array, int arraySize,
  boolean isSigned,  int byteCount, char *typeString, boolean noNeg)
/* Convert comma separated list of numbers to an array.  Pass in
 * array and max size of array. Aborts on error. Returns number of elements in parsed array. */
{
char *s = words[wordIx];
char errMsg[256];
unsigned count = 0;
char *cArray = array;
for (;;)
    {
    char *e;
    if (s == NULL || s[0] == 0 || count == arraySize)
        break;
    e = strchr(s, ',');
    if (e)
        *e = 0;
    int res = lineFileCheckAllIntsNoAbort(s, cArray, isSigned, byteCount, typeString, noNeg, errMsg, sizeof errMsg);
    if (res > 0)
	{
	errAbort("%s in column %d of array field %d line %d of %s, got %s",
	    errMsg, count, wordIx+1, lf->lineIx, lf->fileName, s);
	}
    if (cArray) // NULL means validation only.
	cArray += byteCount;  
    count++;
    if (e)  // restore input string
        *e++ = ',';
    s = e;
    }
return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
movl 0x20(%rbp), %eax
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x134(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x140(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x13f2f
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x13f2f
movl -0x134(%rbp), %eax
cmpl -0x24(%rbp), %eax
jne 0x13f34
jmp 0x14038
movq -0x30(%rbp), %rdi
movl $0x2c, %esi
callq 0x3250
movq %rax, -0x148(%rbp)
cmpq $0x0, -0x148(%rbp)
je 0x13f5d
movq -0x148(%rbp), %rax
movb $0x0, (%rax)
movq -0x30(%rbp), %rdi
movq -0x140(%rbp), %rsi
movl -0x28(%rbp), %edx
movl 0x10(%rbp), %ecx
movq 0x18(%rbp), %r8
movl 0x20(%rbp), %r9d
leaq -0x130(%rbp), %rax
movq %rax, (%rsp)
movl $0x100, 0x8(%rsp)       # imm = 0x100
callq 0x139c0
movl %eax, -0x14c(%rbp)
cmpl $0x0, -0x14c(%rbp)
jle 0x13fd6
leaq -0x130(%rbp), %rsi
movl -0x134(%rbp), %edx
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movq -0x8(%rbp), %rax
movl 0x28(%rax), %r8d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %r9
movq -0x30(%rbp), %rax
leaq 0x1122e(%rip), %rdi     # 0x251f9
movq %rax, (%rsp)
movb $0x0, %al
callq 0xfd50
cmpq $0x0, -0x140(%rbp)
je 0x13ff7
movl 0x10(%rbp), %ecx
movq -0x140(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x140(%rbp)
movl -0x134(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x134(%rbp)
cmpq $0x0, -0x148(%rbp)
je 0x14028
movq -0x148(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x148(%rbp)
movb $0x2c, (%rax)
movq -0x148(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x13f11
movl -0x134(%rbp), %eax
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/lib/linefile.c
// Function: lineFileNeedDouble
double lineFileNeedDouble(struct lineFile *lf, char *words[], int wordIx)
/* Make sure that words[wordIx] is an ascii double value, and return
 * binary representation of it. */
{
char *valEnd;
char *val = words[wordIx];
double doubleValue;

doubleValue = strtod(val, &valEnd);
if ((*val == '\0') || (*valEnd != '\0'))
    errAbort("Expecting double field %d line %d of %s, got %s",
    	wordIx+1, lf->lineIx, lf->fileName, val);
return doubleValue;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x3150
movsd %xmm0, -0x30(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x1409d
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x140c4
movl -0x14(%rbp), %esi
addl $0x1, %esi
movq -0x8(%rbp), %rax
movl 0x28(%rax), %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x28(%rbp), %r8
leaq 0x11174(%rip), %rdi     # 0x25231
movb $0x0, %al
callq 0xfd50
movsd -0x30(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nop