LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/linearSat/linearSat.c
// Function: mostCommonMonomerWord
void mostCommonMonomerWord(struct slRef *refList, char **retWord, int *retCount)
/* Given refs to dlNodes containing monomers, find word associated with most common monomer. */
{
/* Make up a hash that contains counts of all monomers. */
struct hash *countHash = hashNew(0);
struct slRef *ref;
for (ref = refList; ref != NULL; ref = ref->next)
    {
    struct dlNode *node = ref->val;
    struct monomer *monomer = node->val;
    hashIncInt(countHash, monomer->word);
    }

/* Iterate through hash finding max value. */
char *maxWord = NULL;
int maxCount = 0;
struct hashEl *hel;
struct hashCookie cookie = hashFirst(countHash);
while ((hel = hashNext(&cookie)) != NULL)
    {
    int count = ptToInt(hel->val);
    if (count > maxCount)
        {
	maxCount = count;
	maxWord = hel->name;
	}
    }
*retWord = maxWord;
*retCount = maxCount;
hashFree(&countHash);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r13d, %r13d
xorl %edi, %edi
movl $0x1, %esi
callq 0xc1ee
movq %rax, %r12
movq %rax, 0x8(%rsp)
testq %r15, %r15
je 0x48f9
movq 0x8(%r15), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq %r12, %rdi
callq 0xc14e
movq (%r15), %r15
jmp 0x48db
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0xc44e
movq %r15, %rdi
callq 0xc48e
testq %rax, %rax
je 0x494c
movq %rax, %r12
xorl %ebp, %ebp
leaq 0x10(%rsp), %r15
xorl %r13d, %r13d
movq 0x10(%r12), %rdi
callq 0xf9e5
cmpl %r13d, %eax
jle 0x493a
movq 0x8(%r12), %rbp
movl %eax, %r13d
movq %r15, %rdi
callq 0xc48e
movq %rax, %r12
testq %rax, %rax
jne 0x4923
jmp 0x494e
xorl %ebp, %ebp
movq %rbp, (%r14)
movl %r13d, (%rbx)
leaq 0x8(%rsp), %rdi
callq 0xc51f
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/linearSat/linearSat.c
// Function: subCenterInNeighborhood
boolean subCenterInNeighborhood(struct alphaStore *store, 
    struct monomer *center, struct monomerRef *neighborhood, struct dlList *ll)
/* Scan ll for cases where neighborhood around center matches.  Replace one of these 
 * cases with center. */
{
int size = slCount(neighborhood);
assert(size == 3 || size == 2);
if (subCommonCenter(store, center, neighborhood, ll))
   return TRUE;
if (size == 3)
    {
    if (subCommonCenter(store, center, neighborhood->next, ll))
       return TRUE;
    struct monomerRef *third = neighborhood->next->next;
    neighborhood->next->next = NULL;
    boolean ok = subCommonCenter(store, center, neighborhood, ll);
    neighborhood->next->next = third;
    return ok;
    }
else
    return FALSE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movq %rdx, %rdi
callq 0x65f4
movl %eax, %ecx
andl $-0x2, %ecx
cmpl $0x2, %ecx
jne 0x4bed
cmpl $0x3, %eax
setne %bpl
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x496d
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setne %cl
orb %cl, %bpl
je 0x4b9e
movb %cl, %al
jmp 0x4bde
movq (%rbx), %rdx
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0x496d
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x4bde
movq (%rbx), %rax
movq (%rax), %r13
movq $0x0, (%rax)
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x496d
movq (%rbx), %rcx
movq %r13, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x13e94(%rip), %rdi     # 0x18a88
leaq 0x13abc(%rip), %rsi     # 0x186b7
leaq 0x13e9d(%rip), %rcx     # 0x18a9f
movl $0x3d8, %edx            # imm = 0x3D8
callq 0x32e0
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/linearSat/linearSat.c
// Function: subIntoFirstMostCommonOfType
boolean subIntoFirstMostCommonOfType(struct alphaStore *store, struct monomer *unused, 
    struct dlList *ll)
/* Substitute unused for first occurence of most common monomer of same type. */
{
struct monomer *common = mostCommonInType(unused->type);
if (common == NULL)
    {
    verbose(3, "No monomers of type %s used at all!\n", unused->type->name);
    return FALSE;
    }
if (common->subbedOutCount < 2)
    {
    verbose(3, "Trying to sub in %s, but there's no monomers of type %s that are used more than once.\n", 
	unused->word, unused->type->name);
    return FALSE;
    }
struct dlNode *node;
for (node = ll->head; !dlEnd(node); node = node->next)
    {
    struct monomer *monomer = node->val;
    if (monomer == common)
        {
	verbose(3, "Subbing %s for %s of type %s\n", unused->word, monomer->word, unused->type->name);
	node->val = unused;
	unused->subbedOutCount += 1;
	monomer->subbedOutCount -= 1;
	break;
	}
    }
return TRUE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x20(%rsi), %rax
movq 0x10(%rax), %rsi
testq %rsi, %rsi
je 0x4c96
xorl %ecx, %ecx
xorl %edi, %edi
movq 0x8(%rsi), %r8
movq (%rsi), %r9
movl 0x30(%r8), %esi
cmpl %edi, %esi
cmovgl %esi, %edi
cmovgq %r8, %rcx
movq %r9, %rsi
testq %r9, %r9
jne 0x4c50
testq %rcx, %rcx
je 0x4c96
cmpl $0x2, 0x30(%rcx)
jge 0x4cbc
movq 0x8(%rbx), %rdx
movq 0x8(%rax), %rcx
leaq 0x13ea7(%rip), %rsi     # 0x18b2d
xorl %ebp, %ebp
movl $0x3, %edi
xorl %eax, %eax
callq 0x12a31
jmp 0x4caf
movq 0x8(%rax), %rdx
leaq 0x13e67(%rip), %rsi     # 0x18b08
xorl %ebp, %ebp
movl $0x3, %edi
xorl %eax, %eax
callq 0x12a31
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq (%rdx), %rdx
movl $0x1, %ebp
movq %rdx, %r14
movq (%rdx), %rdx
testq %rdx, %rdx
je 0x4caf
movq 0x10(%r14), %r15
cmpq %rcx, %r15
jne 0x4cc4
movq 0x8(%rbx), %rdx
movq 0x8(%r15), %rcx
movq 0x8(%rax), %r8
leaq 0x13e99(%rip), %rsi     # 0x18b84
movl $0x3, %edi
xorl %eax, %eax
callq 0x12a31
movq %rbx, 0x10(%r14)
incl 0x30(%rbx)
decl 0x30(%r15)
jmp 0x4caf
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/linearSat/linearSat.c
// Function: subInMissing
void subInMissing(struct alphaStore *store, struct dlList *ll)
/* Go figure out missing monomers in ll, and attempt to substitute them in somewhere they would fit. */
{
setInitialSubbedOutCount(store, ll);
struct slRef *unusedList = listUnusedMonomers(store, ll);
verbose(3, "%d monomers, %d unused\n", slCount(store->monomerList), slCount(unusedList));
struct slRef *unusedRef;
for (unusedRef = unusedList; unusedRef != NULL; unusedRef = unusedRef->next)
    {
    struct monomer *unused = unusedRef->val;
    struct monomerRef *neighborhood = findNeighborhoodFromReads(unused);
    if (!subCenterInNeighborhood(store, unused, neighborhood, ll))
	{
	verbose(3, "Couldn't substitute in %s with context, falling back to type logic\n", 
	    unused->word);
        subIntoFirstMostCommonOfType(store, unused, ll);
	}
    slFreeList(&neighborhood);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rcx
movq (%rcx), %rax
testq %rax, %rax
je 0x4d4a
movq 0x10(%rcx), %rcx
incl 0x30(%rcx)
movq %rax, %rcx
movq (%rax), %rax
jmp 0x4d36
movq %r14, %rdi
movq %rbx, %rsi
callq 0x459a
movq %rax, %r15
movq (%r14), %rdi
callq 0x65f4
movl %eax, %ebp
movq %r15, %rdi
callq 0x65f4
leaq 0x13e31(%rip), %rsi     # 0x18ba2
movl $0x3, %edi
movl %ebp, %edx
movl %eax, %ecx
xorl %eax, %eax
callq 0x12a31
testq %r15, %r15
je 0x4de3
leaq 0x13e2d(%rip), %r12     # 0x18bba
movq %rsp, %r13
movq 0x8(%r15), %rbp
movq %rbp, %rdi
callq 0x4679
movq %rax, (%rsp)
movq %r14, %rdi
movq %rbp, %rsi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x4b4b
testl %eax, %eax
jne 0x4dd3
movq 0x8(%rbp), %rdx
movl $0x3, %edi
movq %r12, %rsi
xorl %eax, %eax
callq 0x12a31
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x4c35
movq %r13, %rdi
callq 0x66de
movq (%r15), %r15
testq %r15, %r15
jne 0x4d90
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/linearSat/linearSat.c
// Function: alphaStoreNew
struct alphaStore *alphaStoreNew(int maxChainSize)
/* Allocate and initialize a new word store. */
{
struct alphaStore *store;
AllocVar(store);
store->maxChainSize = maxChainSize;
store->monomerHash = hashNew(0);
store->typeHash = hashNew(0);
store->readHash = hashNew(0);
return store;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movl $0x58, %edi
callq 0xee10
movq %rax, %r14
movl %ebx, 0x30(%rax)
xorl %edi, %edi
movl $0x1, %esi
callq 0xc1ee
movq %rax, 0x8(%r14)
xorl %edi, %edi
movl $0x1, %esi
callq 0xc1ee
movq %rax, 0x40(%r14)
xorl %edi, %edi
movl $0x1, %esi
callq 0xc1ee
movq %rax, 0x18(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/linearSat/linearSat.c
// Function: alphaStoreAddMonomer
struct monomer *alphaStoreAddMonomer(struct alphaStore *store, char *word)
/* Add word to store,  incrementing it's useCount if it's already there, otherwise
 * making up a new record for it. */
{
struct monomer *monomer = hashFindVal(store->monomerHash, word);
if (monomer == NULL)
    {
    AllocVar(monomer);
    hashAddSaveName(store->monomerHash, word, monomer, &monomer->word);
    slAddHead(&store->monomerList, monomer);
    }
monomer->useCount += 1;
monomer->outTarget = monomer->useCount;	    /* Set default value, may be renormalized. */
return monomer;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0xc0b1
movq %rax, %r14
testq %rax, %rax
jne 0x4e88
movl $0x38, %edi
callq 0xee10
movq %rax, %r14
movq 0x8(%rbx), %rdi
leaq 0x8(%rax), %rcx
movq %r15, %rsi
movq %rax, %rdx
callq 0xbf9e
movq (%rbx), %rax
movq %rax, (%r14)
movq %r14, (%rbx)
movl 0x10(%r14), %eax
incl %eax
movl %eax, 0x10(%r14)
movl %eax, 0x14(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/linearSat/linearSat.c
// Function: connectReadsToMonomers
void connectReadsToMonomers(struct alphaStore *store)
/* Add each read monomer appears in to monomer's readList. */
{
struct alphaRead *read;
for (read = store->readList; read != NULL; read = read->next)
    {
    struct monomerRef *ref;
    for (ref = read->list; ref != NULL; ref = ref->next)
        {
	struct monomer *monomer = ref->val;
	refAdd(&monomer->readList, read);
	}
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x10(%rdi), %rbx
testq %rbx, %rbx
je 0x4ecf
movq 0x10(%rbx), %r14
testq %r14, %r14
je 0x4eca
movq 0x8(%r14), %rdi
addq $0x28, %rdi
movq %rbx, %rsi
callq 0x754a
movq (%r14), %r14
jmp 0x4eb0
movq (%rbx), %rbx
jmp 0x4ea7
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/linearSat/linearSat.c
// Function: alphaReadListFromFile
void alphaReadListFromFile(char *fileName, struct alphaStore *store)
/* Read in file and turn it into a list of alphaReads. */
{
/* Stuff for processing file a line at a time. */
struct lineFile *lf = lineFileOpen(fileName, TRUE);
char *line, *word;

/* Loop through each line of file making up a read for it. */
struct alphaRead *readList = NULL;
while (lineFileNextReal(lf, &line))
    {
    /* Parse out first word of line into name, and rest into list. */
    char *name = nextWord(&line);
    struct monomerRef *list = NULL;
    while ((word = nextWord(&line)) != NULL)
        {
	struct monomer *monomer = alphaStoreAddMonomer(store, word);
	struct monomerRef *ref;
	AllocVar(ref);
	ref->val = monomer;
	slAddHead(&list, ref);
	}
    slReverse(&list);
    if (list == NULL)
	errAbort("Line %d of %s has no alpha monomers.", lf->lineIx, lf->fileName);

    /* Create data structure and add read to list and hash */
    if (hashLookup(store->readHash, name))
        errAbort("Read ID %s is repeated line %d of %s", name, lf->lineIx, lf->fileName);
    struct alphaRead *read;
    AllocVar(read);
    read->list = list;
    hashAddSaveName(store->readHash, name, read, &read->name);
    slAddHead(&readList, read);
    }
slReverse(&readList);
store->readList = readList;
if (store->readList == NULL)
    errAbort("%s contains no reads", lf->fileName);
lineFileClose(&lf);
connectReadsToMonomers(store);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movl $0x1, %esi
callq 0xcef9
movq %rax, %r14
movq %rax, 0x20(%rsp)
movq $0x0, 0x10(%rsp)
leaq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0xd937
testl %eax, %eax
je 0x5006
leaq 0x18(%rsp), %r15
xorl %r12d, %r12d
movq %r15, %rdi
callq 0x7292
movq %rax, %r13
movq $0x0, 0x8(%rsp)
movq %r15, %rdi
callq 0x7292
testq %rax, %rax
je 0x4f6c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4e43
movq %rax, %rbp
movl $0x10, %edi
callq 0xee10
movq %rbp, 0x8(%rax)
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
movq %rax, 0x8(%rsp)
jmp 0x4f34
leaq 0x8(%rsp), %rdi
callq 0x66bb
cmpq $0x0, 0x8(%rsp)
jne 0x4f94
movl 0x28(%r14), %esi
movq 0x8(%r14), %rdx
leaq 0x13c71(%rip), %rdi     # 0x18bfe
xorl %eax, %eax
callq 0xb6c8
movq 0x18(%rbx), %rdi
movq %r13, %rsi
callq 0xbb8c
testq %rax, %rax
je 0x4fbe
movl 0x28(%r14), %edx
movq 0x8(%r14), %rcx
leaq 0x13c6f(%rip), %rdi     # 0x18c23
movq %r13, %rsi
xorl %eax, %eax
callq 0xb6c8
movl $0x18, %edi
callq 0xee10
movq %rax, %rbp
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rbp)
movq 0x18(%rbx), %rdi
leaq 0x8(%rbp), %rcx
movq %r13, %rsi
movq %rbp, %rdx
callq 0xbf9e
movq %r12, (%rbp)
movq %rbp, 0x10(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0xd937
movq %rbp, %r12
testl %eax, %eax
jne 0x4f20
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x66bb
movq (%r15), %rax
movq %rax, 0x10(%rbx)
testq %rax, %rax
jne 0x5031
movq 0x8(%r14), %rsi
leaq 0x13c1e(%rip), %rdi     # 0x18c48
xorl %eax, %eax
callq 0xb6c8
leaq 0x20(%rsp), %rdi
callq 0xd560
movq %rbx, %rdi
callq 0x4e9f
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/linearSat/linearSat.c
// Function: findOrphanStarts
struct alphaOrphan *findOrphanStarts(struct alphaRead *readList, struct alphaStore *store)
/* Return list of monomers that are found only at start of reads. */
{
struct alphaOrphan *orphanList = NULL;

/* Build up hash of things seen later in reads. */
struct alphaRead *read;
struct hash *later = hashNew(0);    /* Hash of monomers found later. */
for (read = readList; read != NULL; read = read->next)
    {
    struct monomerRef *ref;
    for (ref = read->list->next; ref != NULL; ref = ref->next)
        {
	hashAdd(later, ref->val->word, NULL);
	}
    }

/* Pass through again collecting orphans. */
struct hash *orphanHash = hashNew(0);
for (read = readList; read != NULL; read = read->next)
    {
    struct monomer *monomer = read->list->val;
    char *word = monomer->word;
    if (!hashLookup(later, word))
        {
	struct alphaOrphan *orphan = hashFindVal(orphanHash, word);
	if (orphan == NULL)
	    {
	    AllocVar(orphan);
	    orphan->monomer = monomer;
	    slAddHead(&orphanList, orphan);
	    hashAdd(orphanHash, word, orphan);
	    verbose(3, "Adding orphan start %s\n", word);
	    }
	}
    }
hashFree(&later);
hashFree(&orphanHash);
slReverse(&orphanList);
return orphanList;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq $0x0, 0x8(%rsp)
xorl %edi, %edi
movl $0x1, %esi
callq 0xc1ee
movq %rax, 0x10(%rsp)
testq %rbx, %rbx
je 0x514e
movq %rax, %r14
movq %rbx, %r15
movq 0x10(%r15), %rax
movq (%rax), %r12
testq %r12, %r12
je 0x50b1
movq 0x8(%r12), %rax
movq 0x8(%rax), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0xbe46
movq (%r12), %r12
jmp 0x5093
movq (%r15), %r15
testq %r15, %r15
jne 0x508c
xorl %edi, %edi
movl $0x1, %esi
callq 0xc1ee
movq %rax, (%rsp)
testq %rbx, %rbx
je 0x515e
movq %rax, %r15
xorl %ebp, %ebp
movq 0x10(%rbx), %rax
movq 0x8(%rax), %r12
movq 0x8(%r12), %r13
movq %r14, %rdi
movq %r13, %rsi
callq 0xbb8c
testq %rax, %rax
jne 0x5144
movq %r15, %rdi
movq %r13, %rsi
callq 0xc0b1
testq %rax, %rax
jne 0x5144
movl $0x18, %edi
callq 0xee10
movq %rbp, %rcx
movq %rax, %rbp
movq %r12, 0x8(%rax)
movq %rcx, (%rax)
movq %rax, 0x8(%rsp)
movq %r15, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0xbe46
movl $0x3, %edi
leaq 0x13b23(%rip), %rsi     # 0x18c5d
movq %r13, %rdx
xorl %eax, %eax
callq 0x12a31
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x50d7
jmp 0x515e
xorl %edi, %edi
movl $0x1, %esi
callq 0xc1ee
movq %rax, (%rsp)
leaq 0x10(%rsp), %rdi
callq 0xc51f
movq %rsp, %rdi
callq 0xc51f
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x66bb
movq (%rbx), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/linearSat/linearSat.c
// Function: findOrphanEnds
struct alphaOrphan *findOrphanEnds(struct alphaRead *readList, struct alphaStore *store)
/* Return list of monomers that are found only at end of reads. */
{
struct alphaOrphan *orphanList = NULL;

/* Build up hash of things seen sooner in reads. */
struct alphaRead *read;
struct hash *sooner = hashNew(0);    /* Hash of monomers found sooner. */
for (read = readList; read != NULL; read = read->next)
    {
    struct monomerRef *ref;
    /* Loop over all but last. */
    for (ref = read->list; ref->next != NULL; ref = ref->next)
        {
	hashAdd(sooner, ref->val->word, NULL);
	}
    }

/* Pass through again collecting orphans. */
struct hash *orphanHash = hashNew(0);
for (read = readList; read != NULL; read = read->next)
    {
    struct monomerRef *lastRef = slLastEl(read->list);
    struct monomer *monomer = lastRef->val;
    if (!hashLookup(sooner, monomer->word))
        {
	struct alphaOrphan *orphan = hashFindVal(orphanHash, monomer->word);
	if (orphan == NULL)
	    {
	    AllocVar(orphan);
	    orphan->monomer = monomer;
	    slAddHead(&orphanList, orphan);
	    hashAdd(orphanHash, monomer->word, orphan);
	    verbose(3, "Adding orphan end %s\n", monomer->word);
	    }
	}
    }
hashFree(&sooner);
slReverse(&orphanList);
hashFree(&orphanHash);
return orphanList;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq $0x0, 0x8(%rsp)
xorl %edi, %edi
movl $0x1, %esi
callq 0xc1ee
movq %rax, 0x10(%rsp)
testq %rbx, %rbx
je 0x5292
movq %rax, %r14
movq %rbx, %r15
movq 0x10(%r15), %r12
cmpq $0x0, (%r12)
je 0x51ed
movq 0x8(%r12), %rax
movq 0x8(%rax), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0xbe46
movq (%r12), %r12
jmp 0x51cd
movq (%r15), %r15
testq %r15, %r15
jne 0x51c9
xorl %edi, %edi
movl $0x1, %esi
callq 0xc1ee
movq %rax, (%rsp)
testq %rbx, %rbx
je 0x52a2
movq %rax, %r15
xorl %ebp, %ebp
movq 0x10(%rbx), %rdi
callq 0x6639
movq 0x8(%rax), %r12
movq 0x8(%r12), %rsi
movq %r14, %rdi
callq 0xbb8c
testq %rax, %rax
jne 0x5288
movq 0x8(%r12), %rsi
movq %r15, %rdi
callq 0xc0b1
testq %rax, %rax
jne 0x5288
movl $0x18, %edi
callq 0xee10
movq %rax, %r13
movq %r12, 0x8(%rax)
movq %rbp, (%rax)
movq %rax, 0x8(%rsp)
movq 0x8(%r12), %rsi
movq %r15, %rdi
movq %rax, %rdx
callq 0xbe46
movq 0x8(%r12), %rdx
movl $0x3, %edi
leaq 0x139f7(%rip), %rsi     # 0x18c75
xorl %eax, %eax
callq 0x12a31
movq %r13, %rbp
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x5213
jmp 0x52a2
xorl %edi, %edi
movl $0x1, %esi
callq 0xc1ee
movq %rax, (%rsp)
leaq 0x10(%rsp), %rdi
callq 0xc51f
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x66bb
movq %rsp, %rdi
callq 0xc51f
movq (%rbx), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/linearSat/linearSat.c
// Function: addReadOfTwo
struct alphaRead *addReadOfTwo(struct alphaStore *store, struct monomer *a, struct monomer *b)
/* Make up a fake read that goes from a to b and add it to store. */
{
/* Create fake name and start fake read with it. */
static int fakeId = 0;
char name[32];
safef(name, sizeof(name), "fake%d", ++fakeId);

/* Allocate fake read. */
struct alphaRead *read;
AllocVar(read);

/* Add a and b to the read. */
struct monomerRef *aRef, *bRef;
AllocVar(aRef);
aRef->val = a;
AllocVar(bRef);
bRef->val = b;
aRef->next = bRef;
read->list = aRef;

/* Add read to the store. */
slAddHead(&store->readList, read);
hashAddSaveName(store->readHash, name, read, &read->name);

/* Add read to the monomers. */
refAdd(&a->readList, read);
refAdd(&b->readList, read);

a->useCount += 1;
b->useCount += 1;
return read;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movl 0x22534(%rip), %ecx     # 0x27824
incl %ecx
movl %ecx, 0x2252c(%rip)     # 0x27824
leaq 0x1398c(%rip), %rdx     # 0x18c8b
movq %rsp, %r13
movq %r13, %rdi
movl $0x20, %esi
xorl %eax, %eax
callq 0xa0ca
movl $0x18, %edi
callq 0xee10
movq %rax, %r15
movl $0x10, %edi
callq 0xee10
movq %rax, %rbp
movq %r14, 0x8(%rax)
movl $0x10, %edi
callq 0xee10
movq %rbx, 0x8(%rax)
movq %rax, (%rbp)
movq %rbp, 0x10(%r15)
movq 0x10(%r12), %rax
movq %rax, (%r15)
movq %r15, 0x10(%r12)
movq 0x18(%r12), %rdi
leaq 0x8(%r15), %rcx
movq %r13, %rsi
movq %r15, %rdx
callq 0xbf9e
leaq 0x28(%r14), %rdi
movq %r15, %rsi
callq 0x754a
leaq 0x28(%rbx), %rdi
movq %r15, %rsi
callq 0x754a
incl 0x10(%r14)
incl 0x10(%rbx)
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/linearSat/linearSat.c
// Function: wordTreeSort
static void wordTreeSort(struct wordTree *wt)
/* Sort all children lists in tree. */
{
slSort(&wt->children, wordTreeCmpWord);
struct wordTree *child;
for (child = wt->children; child != NULL; child = child->next)
    wordTreeSort(child);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x8, %rdi
leaq -0x1c19(%rip), %rsi     # 0x3ac7
callq 0x670c
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
je 0x56fb
movq %rbx, %rdi
callq 0x56d1
movq (%rbx), %rbx
jmp 0x56e9
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/linearSat/linearSat.c
// Function: wordTreeWrite
void wordTreeWrite(struct wordTree *wt, int maxChainSize, char *fileName)
/* Write out tree to file */
{
FILE *f = mustOpen(fileName, "w");
fprintf(f, "#level\tuseCount\toutTarget\toutCount\tnormVal\tmonomers\n");
wordTreeDump(0, wt, maxChainSize, f);
carefulClose(&f);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x14322(%rip), %rsi     # 0x19a33
movq %rdx, %rdi
callq 0x932b
movq %rax, %r15
movq %rsp, %r12
movq %rax, (%r12)
leaq 0x13620(%rip), %rdi     # 0x18d4a
movl $0x34, %esi
movl $0x1, %edx
movq %rax, %rcx
callq 0x36f0
xorl %edi, %edi
movq %r14, %rsi
movl %ebx, %edx
movq %r15, %rcx
callq 0x3eb7
movq %r12, %rdi
callq 0x99bb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/linearSat/linearSat.c
// Function: crossCheckMonomerOrderAndReads
void crossCheckMonomerOrderAndReads(struct alphaStore *store, char *orderedPrefix, char *readFile, char *typeFile)
/* Make sure all monomer that begin with ordered prefix are present in monomer order file. */
{
/* Make hash of all monomers that have type info. */
struct hash *orderHash = hashNew(0);
struct monomerType *type;
for (type = store->typeList; type != NULL; type = type->next)
     {
     struct monomerRef *ref;
     for (ref = type->list; ref != NULL; ref = ref->next)
         hashAdd(orderHash, ref->val->word, ref->val);
     }

/* Go through all monomers and make sure ones with correct prefix are in list. */
struct monomer *mon;
for (mon = store->monomerList; mon != NULL; mon = mon->next)
    {
    char *word = mon->word;
    if (startsWith(orderedPrefix, word) && !hashLookup(orderHash, word))
        {
	errAbort("%s is in %s but not %s", word, readFile, typeFile);
	}
    }
hashFree(&orderHash);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
xorl %edi, %edi
movl $0x1, %esi
callq 0xc1ee
movq %rax, %r12
movq %rax, 0x10(%rsp)
movq %r13, 0x8(%rsp)
movq 0x38(%r13), %rbp
testq %rbp, %rbp
je 0x59e1
movq 0x10(%rbp), %r13
testq %r13, %r13
je 0x59db
movq 0x8(%r13), %rdx
movq 0x8(%rdx), %rsi
movq %r12, %rdi
callq 0xbe46
movq (%r13), %r13
jmp 0x59c0
movq (%rbp), %rbp
jmp 0x59b7
movq 0x8(%rsp), %rax
movq (%rax), %r13
testq %r13, %r13
je 0x5a2e
movq 0x8(%r13), %rbp
movq %r15, %rdi
movq %rbp, %rsi
callq 0x8038
testl %eax, %eax
je 0x5a28
movq %r12, %rdi
movq %rbp, %rsi
callq 0xbb8c
testq %rax, %rax
jne 0x5a28
leaq 0x1338e(%rip), %rdi     # 0x18da6
movq %rbp, %rsi
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0xb6c8
movq (%r13), %r13
jmp 0x59e9
leaq 0x10(%rsp), %rdi
callq 0xc51f
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/linearSat/linearSat.c
// Function: monomerListNormalise
void monomerListNormalise(struct monomer *list, int totalCount, int outputSize)
/* Set outTarget field in all of list to be normalized to outputSize */
{
struct monomer *monomer;
double scale = (double)outputSize/totalCount;
for (monomer = list; monomer != NULL; monomer = monomer->next)
    {
    monomer->outCount = 0;
    monomer->outTarget = round(scale * monomer->useCount);
    }
}

// Assembly:
testq %rdi, %rdi
je 0x5a86
cvtsi2sd %edx, %xmm0
cvtsi2sd %esi, %xmm1
divsd %xmm1, %xmm0
movsd 0x125a8(%rip), %xmm1    # 0x18008
movl $0x0, 0x18(%rdi)
xorps %xmm2, %xmm2
cvtsi2sdl 0x10(%rdi), %xmm2
mulsd %xmm0, %xmm2
addsd %xmm1, %xmm2
cvttsd2si %xmm2, %eax
movl %eax, 0x14(%rdi)
movq (%rdi), %rdi
testq %rdi, %rdi
jne 0x5a60
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/linearSat/linearSat.c
// Function: fillInTypes
void fillInTypes(struct alphaStore *store)
/* We have types for most but not all monomers. Try and fill out types for most of
 * the rest by looking for position in reads they are in that do contain known types */
{
/* Do first pass on ones defined - just have to look them up in hash. */
struct monomer *monomer;
for (monomer = store->monomerList; monomer != NULL; monomer = monomer->next)
    monomer->type = hashFindVal(store->typeHash, monomer->word);

/* Do second pass on ones that are not yet defined */
for (monomer = store->monomerList; monomer != NULL; monomer = monomer->next)
    {
    if (monomer->type == NULL)
	{
	monomer->type = fillInTypeFromReads(monomer, store);
	}
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
testq %r14, %r14
je 0x5d5a
movq %rdi, %rbx
movq 0x40(%rbx), %rdi
movq 0x8(%r14), %rsi
callq 0xc0b1
movq %rax, 0x20(%r14)
movq (%r14), %r14
testq %r14, %r14
jne 0x5d1e
movq (%rbx), %r14
testq %r14, %r14
je 0x5d5a
cmpq $0x0, 0x20(%r14)
jne 0x5d55
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5afa
movq %rax, 0x20(%r14)
movq (%r14), %r14
jmp 0x5d3a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/linearSat/linearSat.c
// Function: countMissingMonomers
int countMissingMonomers(struct dlList *ll, struct monomer *monomerList)
/* Set the outCounts in monomer list to match how often they occur in ll.
 * Return number of monomers that do not occur at all in ll. */
{
/* Zero out output counts. */
struct monomer *monomer;
for (monomer = monomerList; monomer != NULL; monomer = monomer->next)
    monomer->outCount = 0;

/* Increase output count each time a monomer is used. */
struct dlNode *node;
for (node = ll->head; !dlEnd(node); node = node->next)
    {
    monomer = node->val;
    monomer->outCount += 1;
    }

/* Count up unused. */
int missing = 0;
for (monomer = monomerList; monomer != NULL; monomer = monomer->next)
    if (monomer->outCount == 0 && !sameString(monomer->word, ""))
        missing += 1;

return missing;
}

// Assembly:
testq %rsi, %rsi
je 0x5f6a
movq %rsi, %rax
movl $0x0, 0x18(%rax)
movq (%rax), %rax
testq %rax, %rax
jne 0x5f5b
movq (%rdi), %rcx
movq (%rcx), %rax
testq %rax, %rax
je 0x5f84
movq 0x10(%rcx), %rcx
incl 0x18(%rcx)
movq %rax, %rcx
movq (%rax), %rax
jmp 0x5f70
xorl %eax, %eax
testq %rsi, %rsi
je 0x5fa0
cmpl $0x0, 0x18(%rsi)
jne 0x5f9b
movq 0x8(%rsi), %rcx
cmpb $0x1, (%rcx)
sbbl $-0x1, %eax
movq (%rsi), %rsi
jmp 0x5f86
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/linearSat/linearSat.c
// Function: main
int main(int argc, char *argv[])
/* Process command line. */
{
optionInit(&argc, argv, options);
if (argc != 4)
    usage();
maxChainSize = optionInt("size", maxChainSize);
initialOutSize = optionInt("initialOutSize", initialOutSize);
maxOutSize = optionInt("maxOutSize", initialOutSize);  // Defaults to same as initialOutSize
if (maxOutSize < initialOutSize)
    errAbort("maxOutSize (%d) needs to be bigger than initialOutSize (%d)\n", 
	maxOutSize, initialOutSize);
maxToMiss = optionInt("maxToMiss", maxToMiss);
fullOnly = optionExists("fullOnly");
pseudoCount = optionInt("pseudoCount", pseudoCount);
betweens = optionExists("betweens");
int seed = optionInt("seed", 0);
srand(seed);
linearSat(argv[1], argv[2], argv[3]);
return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x4(%rsp), %r14
movl %edi, (%r14)
leaq 0x2118b(%rip), %rdx     # 0x27400
movq %r14, %rdi
callq 0x10a12
cmpl $0x4, (%r14)
je 0x62aa
movl 0x2116b(%rip), %esi     # 0x273f4
movl 0x21169(%rip), %edx     # 0x273f8
movl 0x2137b(%rip), %ecx     # 0x27610
movl 0x21154(%rip), %r8d     # 0x273f0
leaq 0x11d8d(%rip), %rdi     # 0x18030
xorl %eax, %eax
callq 0xb6c8
movl 0x21144(%rip), %esi     # 0x273f4
leaq 0x12e21(%rip), %rdi     # 0x190d8
callq 0x10ad1
movl %eax, 0x21132(%rip)     # 0x273f4
movl 0x21130(%rip), %esi     # 0x273f8
leaq 0x12e0e(%rip), %rdi     # 0x190dd
callq 0x10ad1
movl %eax, 0x2111e(%rip)     # 0x273f8
leaq 0x12e0b(%rip), %rdi     # 0x190ec
movl %eax, %esi
callq 0x10ad1
movl %eax, 0x2153a(%rip)     # 0x27828
movl 0x21104(%rip), %edx     # 0x273f8
cmpl %edx, %eax
jge 0x6308
leaq 0x12df8(%rip), %rdi     # 0x190f7
movl %eax, %esi
xorl %eax, %eax
callq 0xb6c8
movl 0x21302(%rip), %esi     # 0x27610
leaq 0x12e1f(%rip), %rdi     # 0x19134
callq 0x10ad1
movl %eax, 0x212f0(%rip)     # 0x27610
leaq 0x12e17(%rip), %rdi     # 0x1913e
callq 0x10d0b
movl %eax, 0x212e2(%rip)     # 0x27614
movl 0x210b8(%rip), %esi     # 0x273f0
leaq 0x12e08(%rip), %rdi     # 0x19147
callq 0x10ad1
movl %eax, 0x210a6(%rip)     # 0x273f0
leaq 0x12e02(%rip), %rdi     # 0x19153
callq 0x10d0b
movl %eax, 0x212bc(%rip)     # 0x27618
leaq 0x12df9(%rip), %rdi     # 0x1915c
xorl %esi, %esi
callq 0x10ad1
movl %eax, %edi
callq 0x33e0
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
callq 0x5fa1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: cloneString
char *cloneString(const char *s)
/* Make copy of string in dynamic memory */
{
int size = 0;
if (s == NULL)
    return NULL;
size = strlen(s);
return cloneStringZExt(s, size, size);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x643c
movq %rdi, %rbx
callq 0x3200
movq %rax, %r15
incl %eax
movslq %eax, %rdi
callq 0xee10
movq %rax, %r14
movslq %r15d, %r15
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x34a0
movb $0x0, (%r14,%r15)
jmp 0x643f
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: reverseBytes
void reverseBytes(char *bytes, long length)
{
long halfLen = (length>>1);
char *end = bytes+length;
char c;
while (--halfLen >= 0)
    {
    c = *bytes;
    *bytes++ = *--end;
    *end = c;
    }
}

// Assembly:
movq %rsi, %rax
sarq %rax
testq %rax, %rax
jle 0x6518
leaq (%rsi,%rdi), %rcx
decq %rcx
incq %rax
movb (%rdi), %dl
movb (%rcx), %sil
movb %sil, (%rdi)
incq %rdi
movb %dl, (%rcx)
decq %rcx
decq %rax
cmpq $0x1, %rax
ja 0x64ff
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: reverseInts
void reverseInts(int *a, int length)
/* Reverse the order of the integer array. */
{
int halfLen = (length>>1);
int *end = a+length;
int c;
while (--halfLen >= 0)
    {
    c = *a;
    *a++ = *--end;
    *end = c;
    }
}

// Assembly:
movl %esi, %eax
sarl %eax
testl %eax, %eax
jle 0x6544
movl %esi, %ecx
leaq (%rdi,%rcx,4), %rcx
addq $-0x4, %rcx
incl %eax
movl (%rdi), %edx
movl (%rcx), %esi
movl %esi, (%rdi)
addq $0x4, %rdi
movl %edx, (%rcx)
addq $-0x4, %rcx
decl %eax
cmpl $0x1, %eax
ja 0x652d
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: reverseUnsigned
void reverseUnsigned(unsigned *a, int length)
/* Reverse the order of the unsigned array. */
{
int halfLen = (length>>1);
unsigned *end = a+length;
unsigned c;
while (--halfLen >= 0)
    {
    c = *a;
    *a++ = *--end;
    *end = c;
    }
}

// Assembly:
movl %esi, %eax
sarl %eax
testl %eax, %eax
jle 0x6570
movl %esi, %ecx
leaq (%rdi,%rcx,4), %rcx
addq $-0x4, %rcx
incl %eax
movl (%rdi), %edx
movl (%rcx), %esi
movl %esi, (%rdi)
addq $0x4, %rdi
movl %edx, (%rcx)
addq $-0x4, %rcx
decl %eax
cmpl $0x1, %eax
ja 0x6559
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: reverseDoubles
void reverseDoubles(double *a, int length)
/* Reverse the order of the double array. */
{
int halfLen = (length>>1);
double *end = a+length;
double c;
while (--halfLen >= 0)
    {
    c = *a;
    *a++ = *--end;
    *end = c;
    }
}

// Assembly:
movl %esi, %eax
sarl %eax
testl %eax, %eax
jle 0x65a4
movl %esi, %ecx
leaq (%rdi,%rcx,8), %rcx
addq $-0x8, %rcx
incl %eax
movsd (%rdi), %xmm0
movsd (%rcx), %xmm1
movsd %xmm1, (%rdi)
addq $0x8, %rdi
movsd %xmm0, (%rcx)
addq $-0x8, %rcx
decl %eax
cmpl $0x1, %eax
ja 0x6585
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: reverseStrings
void reverseStrings(char **a, int length)
/* Reverse the order of the char* array. */
{
int halfLen = (length>>1);
char **end = a+length;
char *c;
while (--halfLen >= 0)
    {
    c = *a;
    *a++ = *--end;
    *end = c;
    }
}

// Assembly:
movl %esi, %eax
sarl %eax
testl %eax, %eax
jle 0x65d4
movl %esi, %ecx
leaq (%rdi,%rcx,8), %rcx
addq $-0x8, %rcx
incl %eax
movq (%rdi), %rdx
movq (%rcx), %rsi
movq %rsi, (%rdi)
addq $0x8, %rdi
movq %rdx, (%rcx)
addq $-0x8, %rcx
decl %eax
cmpl $0x1, %eax
ja 0x65b9
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: swapBytes
void swapBytes(char *a, char *b, int length)
{
char c;
int i;

for (i=0; i<length; ++i)
    {
    c = a[i];
    a[i] = b[i];
    b[i] = c;
    }
}

// Assembly:
testl %edx, %edx
jle 0x65f3
movl %edx, %eax
xorl %ecx, %ecx
movb (%rdi,%rcx), %dl
movb (%rsi,%rcx), %r8b
movb %r8b, (%rdi,%rcx)
movb %dl, (%rsi,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0x65dd
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: slFreeList
void slFreeList(void *listPt)
/* Free list */
{
struct slList **ppt = (struct slList**)listPt;
struct slList *next = *ppt;
struct slList *el;

while (next != NULL)
    {
    el = next;
    next = el->next;
    freeMem((char*)el);
    }
*ppt = NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x66fd
movq (%rdi), %r14
callq 0xeebc
movq %r14, %rdi
testq %r14, %r14
jne 0x66ed
movq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: slSort
void slSort(void *pList, int (*compare )(const void *elem1,  const void *elem2))
/* Sort a singly linked list with Qsort and a temporary array. */
{
struct slList **pL = (struct slList **)pList;
struct slList *list = *pL;
int count;
count = slCount(list);
if (count > 1)
    {
    struct slList *el;
    struct slList **array;
    int i;
    array = needLargeMem(count * sizeof(*array));
    for (el = list, i=0; el != NULL; el = el->next, i++)
        array[i] = el;
    qsort(array, count, sizeof(array[0]), compare);
    list = NULL;
    for (i=0; i<count; ++i)
        {
        array[i]->next = list;
        list = array[i];
        }
    freeMem(array);
    slReverse(&list);
    *pL = list;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq (%rdi), %r13
testq %r13, %r13
je 0x67ae
movq %rsi, %r15
movq %rdi, %rbx
xorl %edi, %edi
xorl %r14d, %r14d
movq %r13, %rax
movq (%rax), %rax
incq %r14
addq $0x8, %rdi
testq %rax, %rax
jne 0x672f
cmpl $0x1, %r14d
je 0x67ae
callq 0xec18
movq %rax, %r12
movq %r13, (%rax)
movq (%r13), %r13
addq $0x8, %rax
testq %r13, %r13
jne 0x674c
movl $0x8, %edx
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x3120
xorl %r15d, %r15d
movq %r12, %rax
movq (%rax), %rcx
movq %r15, (%rcx)
movq (%rax), %r15
addq $0x8, %rax
decq %r14
jne 0x6775
movq %r12, %rdi
callq 0xeebc
testq %r15, %r15
je 0x67a9
xorl %ecx, %ecx
movq %r15, %rax
movq (%r15), %r15
movq %rcx, (%rax)
movq %rax, %rcx
testq %r15, %r15
jne 0x6796
jmp 0x67ab
xorl %eax, %eax
movq %rax, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: slUniqify
void slUniqify(void *pList, int (*compare )(const void *elem1,  const void *elem2), void (*free)())
/* Return sorted list with duplicates removed.
 * Compare should be same type of function as slSort's compare (taking
 * pointers to pointers to elements.  Free should take a simple
 * pointer to dispose of duplicate element, and can be NULL. */
{
struct slList **pSlList = (struct slList **)pList;
struct slList *oldList = *pSlList;
struct slList *newList = NULL, *el;

slSort(&oldList, compare);
while ((el = slPopHead(&oldList)) != NULL)
    {
    if ((newList == NULL) || (compare(&newList, &el) != 0))
        slAddHead(&newList, el);
    else if (free != NULL)
        free(el);
    }
slReverse(&newList);
*pSlList = newList;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rax
leaq 0x10(%rsp), %r12
movq %rax, (%r12)
movq $0x0, (%rsp)
movq %r12, %rdi
callq 0x670c
movq (%r12), %rbp
testq %rbp, %rbp
je 0x687a
movq %rsp, %r12
leaq 0x8(%rsp), %r13
movq %rbp, %rax
movq (%rbp), %rbp
movq $0x0, (%rax)
movq %rax, 0x8(%rsp)
cmpq $0x0, (%rsp)
je 0x6832
movq %r12, %rdi
movq %r13, %rsi
callq *%r15
testl %eax, %eax
je 0x6842
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
jmp 0x6834
xorl %ecx, %ecx
movq %rcx, (%rax)
movq %rax, (%rsp)
testq %rbp, %rbp
jne 0x6800
jmp 0x6853
testq %r14, %r14
je 0x683b
movq 0x8(%rsp), %rdi
xorl %eax, %eax
callq *%r14
jmp 0x683b
movq (%rsp), %rax
movq $0x0, 0x8(%rsp)
testq %rax, %rax
je 0x687a
xorl %edx, %edx
movq %rax, %rcx
movq (%rax), %rax
movq %rdx, (%rcx)
movq %rcx, %rdx
testq %rax, %rax
jne 0x6867
jmp 0x687c
xorl %ecx, %ecx
movq %rcx, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: slRemoveEl
boolean slRemoveEl(void *vpList, void *vToRemove)
/* Remove element from doubly linked list.  Usage:
 *    slRemove(&list, el);
 * Returns TRUE if element in list.  */
{
struct slList **pList = vpList;
struct slList *toRemove = vToRemove;
struct slList *el, *next, *newList = NULL;
boolean didRemove = FALSE;

for (el = *pList; el != NULL; el = next)
    {
    next = el->next;
    if (el != toRemove)
	{
	slAddHead(&newList, el);
	}
    else
        didRemove = TRUE;
    }
slReverse(&newList);
*pList = newList;
return didRemove;
}

// Assembly:
movq (%rdi), %rdx
xorl %eax, %eax
testq %rdx, %rdx
je 0x690b
xorl %ecx, %ecx
movq (%rdx), %r8
cmpq %rsi, %rdx
je 0x68e9
movq %rcx, (%rdx)
movq %rdx, %rcx
jmp 0x68ee
movl $0x1, %eax
movq %r8, %rdx
testq %r8, %r8
jne 0x68d9
xorl %edx, %edx
testq %rcx, %rcx
je 0x690d
movq %rdx, %rsi
movq %rcx, %rdx
movq (%rcx), %rcx
movq %rsi, (%rdx)
jmp 0x68f8
xorl %edx, %edx
movq %rdx, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: doubleMedian
double doubleMedian(int count, double *array)
/* Return median value in array.  This will sort
 * the array as a side effect. */
{
double median;
doubleSort(count, array);
if ((count&1) == 1)
    median = array[count>>1];
else
    {
    count >>= 1;
    median = (array[count] + array[count-1]) * 0.5;
    }
return median;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
cmpl $0x2, %edi
jl 0x69b9
movl %ebp, %esi
leaq -0x38(%rip), %rcx       # 0x6974
movl $0x8, %edx
movq %rbx, %rdi
callq 0x3120
movl %ebp, %eax
sarl %eax
cltq
movsd (%rbx,%rax,8), %xmm0
testb $0x1, %bpl
jne 0x69d8
addsd -0x8(%rbx,%rax,8), %xmm0
mulsd 0x11630(%rip), %xmm0    # 0x18008
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: doubleBoxWhiskerCalc
void doubleBoxWhiskerCalc(int count, double *array, double *retMin,
                          double *retQ1, double *retMedian, double *retQ3, double *retMax)
/* Calculate what you need to draw a box and whiskers plot from an array of doubles. */
{
doubleSort(count, array);
*retMin = array[0];
*retQ1 = array[(count+2)/4];
int halfCount = count>>1;
if ((count&1) == 1)
    *retMedian = array[halfCount];
else
    {
    *retMedian = (array[halfCount] + array[halfCount-1]) * 0.5;
    }
*retQ3 = array[(3*count+2)/4];
*retMax = array[count-1];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %r14
movl %edi, %r15d
cmpl $0x2, %edi
jl 0x6a18
movl %r15d, %esi
leaq -0x97(%rip), %rcx       # 0x6974
movl $0x8, %edx
movq %r14, %rdi
callq 0x3120
movq 0x40(%rsp), %rax
movsd (%r14), %xmm0
movsd %xmm0, (%rbp)
leal 0x2(%r15), %ecx
leal 0x5(%r15), %edx
testl %ecx, %ecx
cmovnsl %ecx, %edx
sarl $0x2, %edx
movslq %edx, %rcx
movsd (%r14,%rcx,8), %xmm0
movsd %xmm0, (%r13)
movl %r15d, %ecx
sarl %ecx
movslq %ecx, %rcx
movsd (%r14,%rcx,8), %xmm0
testb $0x1, %r15b
jne 0x6a69
addsd -0x8(%r14,%rcx,8), %xmm0
mulsd 0x1159f(%rip), %xmm0    # 0x18008
leal (%r15,%r15,2), %ecx
addl $0x2, %ecx
leal (%r15,%r15,2), %edx
addl $0x5, %edx
testl %ecx, %ecx
cmovnsl %ecx, %edx
movsd %xmm0, (%r12)
sarl $0x2, %edx
movslq %edx, %rcx
movsd (%r14,%rcx,8), %xmm0
movsd %xmm0, (%rbx)
movslq %r15d, %rcx
movsd -0x8(%r14,%rcx,8), %xmm0
movsd %xmm0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: slDoubleMedian
double slDoubleMedian(struct slDouble *list)
/* Return median value on list. */
{
int i,count = slCount(list);
struct slDouble *el;
double *array, median;
if (count == 0)
    errAbort("Can't take median of empty list");
AllocArray(array,count);
for (i=0, el=list; i<count; ++i, el=el->next)
    array[i] = el->val;
median = doubleMedian(count, array);
freeMem(array);
return median;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0x6b15
xorl %ebp, %ebp
movq %rbx, %rax
incl %ebp
movq (%rax), %rax
testq %rax, %rax
jne 0x6b09
jmp 0x6b25
leaq 0x126bb(%rip), %rdi     # 0x191d7
xorl %ebp, %ebp
xorl %eax, %eax
callq 0xb6c8
movslq %ebp, %r15
leaq (,%r15,8), %rdi
callq 0xec7f
movq %rax, %r14
testl %r15d, %r15d
jle 0x6b57
movl %ebp, %eax
xorl %ecx, %ecx
movsd 0x8(%rbx), %xmm0
movsd %xmm0, (%r14,%rcx,8)
incq %rcx
movq (%rbx), %rbx
cmpq %rcx, %rax
jne 0x6b41
movl %ebp, %edi
movq %r14, %rsi
callq 0x6996
movsd %xmm0, (%rsp)
movq %r14, %rdi
callq 0xeebc
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: slDoubleBoxWhiskerCalc
void slDoubleBoxWhiskerCalc(struct slDouble *list, double *retMin,
                            double *retQ1, double *retMedian, double *retQ3, double *retMax)
/* Calculate what you need to draw a box and whiskers plot from a list of slDoubles. */
{
int i,count = slCount(list);
struct slDouble *el;
double *array;
if (count == 0)
    errAbort("Can't take do slDoubleBoxWhiskerCalc of empty list");
AllocArray(array,count);
for (i=0, el=list; i<count; ++i, el=el->next)
    array[i] = el->val;
doubleBoxWhiskerCalc(count, array, retMin, retQ1, retMedian, retQ3, retMax);
freeMem(array);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r12
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, %r13
movq %rdi, %rbp
testq %rdi, %rdi
je 0x6bba
xorl %ebx, %ebx
movq %rbp, %rax
incl %ebx
movq (%rax), %rax
testq %rax, %rax
jne 0x6bae
jmp 0x6bca
leaq 0x12636(%rip), %rdi     # 0x191f7
xorl %ebx, %ebx
xorl %eax, %eax
callq 0xb6c8
movslq %ebx, %r15
leaq (,%r15,8), %rdi
callq 0xec7f
movq %rax, %r14
testl %r15d, %r15d
jle 0x6bfd
movl %ebx, %eax
xorl %ecx, %ecx
movsd 0x8(%rbp), %xmm0
movsd %xmm0, (%r14,%rcx,8)
incq %rcx
movq (%rbp), %rbp
cmpq %rcx, %rax
jne 0x6be6
movq %r12, (%rsp)
movl %ebx, %edi
movq %r14, %rsi
movq %r13, %rdx
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %r8
movq 0x20(%rsp), %r9
callq 0x69df
movq %r14, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xeebc
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: intMedian
int intMedian(int count, int *array)
/* Return median value in array.  This will sort
 * the array as a side effect. */
{
int median;
intSort(count, array);
if ((count&1) == 1)
    median = array[count>>1];
else
    {
    count >>= 1;
    median = (array[count] + array[count-1]) * 0.5;
    }
return median;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
cmpl $0x2, %edi
jl 0x6c87
movl %ebp, %esi
leaq -0x28(%rip), %rcx       # 0x6c52
movl $0x4, %edx
movq %rbx, %rdi
callq 0x3120
movl %ebp, %eax
sarl %eax
movslq %eax, %rcx
movl (%rbx,%rcx,4), %eax
testb $0x1, %bpl
jne 0x6cab
addl -0x4(%rbx,%rcx,4), %eax
cvtsi2sd %eax, %xmm0
mulsd 0x11361(%rip), %xmm0    # 0x18008
cvttsd2si %xmm0, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/JimKent[P]linearSat/lib/common.c
// Function: newSlName
struct slName *newSlName(char *name)
/* Return a new name. */
{
struct slName *sn;
if (name != NULL)
    {
    int len = strlen(name);
    sn = needMem(sizeof(*sn)+len);
    strcpy(sn->name, name);
    return sn;
    }
else
    {
    AllocVar(sn);
    }
return sn;
}

// Assembly:
testq %rdi, %rdi
je 0x6ce9
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3200
movslq %eax, %rdi
addq $0x10, %rdi
callq 0xee10
movq %rax, %r14
leaq 0x8(%rax), %rdi
movq %rbx, %rsi
callq 0x30e0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
jmp 0xee10