LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/kyz[P]amostools/dumpamos.c
// Function: amos_banks
void amos_banks(char *fname, uint8_t *src, size_t len) {
    if (len < 6) {
        fprintf(stderr, "%s: file too short to be AMOS banks\n", fname);
    }
    else {
        uint32_t num_banks = amos_deek(&src[4]), bank_pos = 6;
        while (num_banks--) {
            uint32_t bank_len = bank_length(&src[bank_pos], len - bank_pos);
            uint32_t bank_num = bank_number(&src[bank_pos], bank_len);
            char *type = bank_type(&src[bank_pos], bank_len), *outname;
            if (bank_num > 0) {
                if ((outname = output_fname(fname, "bank%02X.abk", bank_num))) {
                    printf("%s: extracting bank %d (%s) as %s (%d bytes)\n",
                           fname, bank_num, type, outname, bank_len);
                    write_file(outname, &src[bank_pos], bank_len);
                    amos_bank(outname, &src[bank_pos], bank_len);
                    free(outname);
                }
                else {
                    perror(fname);
                }
            }
            bank_pos += bank_len;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x6, -0x18(%rbp)
jae 0x2dfc
movq 0x320e(%rip), %rax      # 0x5ff0
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x137a(%rip), %rsi      # 0x416a
movb $0x0, %al
callq 0x10e0
jmp 0x2f1a
movq -0x10(%rbp), %rax
movzbl 0x4(%rax), %eax
shll $0x8, %eax
movq -0x10(%rbp), %rcx
movzbl 0x5(%rcx), %ecx
orl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl $0x6, -0x20(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x2f18
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %eax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movl -0x20(%rbp), %eax
subq %rax, %rsi
callq 0x1600
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %eax
addq %rax, %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x1840
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %eax
addq %rax, %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x1940
movq %rax, -0x30(%rbp)
cmpl $0x0, -0x28(%rbp)
jbe 0x2f0a
movq -0x8(%rbp), %rdi
movl -0x28(%rbp), %edx
leaq 0x12fd(%rip), %rsi      # 0x418f
movb $0x0, %al
callq 0x1420
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x2eff
movq -0x8(%rbp), %rsi
movl -0x28(%rbp), %edx
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
movl -0x24(%rbp), %r9d
leaq 0x12df(%rip), %rdi      # 0x419c
movb $0x0, %al
callq 0x10b0
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x20(%rbp), %eax
addq %rax, %rsi
movl -0x24(%rbp), %eax
movl %eax, %edx
callq 0x13a0
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x20(%rbp), %eax
addq %rax, %rsi
movl -0x24(%rbp), %eax
movl %eax, %edx
callq 0x2c00
movq -0x38(%rbp), %rdi
callq 0x1030
jmp 0x2f08
movq -0x8(%rbp), %rdi
callq 0x1130
jmp 0x2f0a
movl -0x24(%rbp), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x2e1b
jmp 0x2f1a
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/kyz[P]amostools/dumpamos.c
// Function: amos_source
void amos_source(char *fname, uint8_t *src, size_t len) {
    if (len < 30) {
        fprintf(stderr, "%s: file too short to be AMOS source code\n", fname);
    }
    else {
        uint32_t src_len = amos_leek(&src[16]) + 20;
        char hdr[17] = {0};
        memcpy(hdr, src, 16);
        printf("%s: AMOS source code with header '%s'\n", fname, hdr);

        /* parse banks after source code */
        if (src_len < len) {
            amos_banks(fname, &src[src_len], len - src_len);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x1e, -0x18(%rbp)
jae 0x2f5c
movq 0x30ae(%rip), %rax      # 0x5ff0
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x127a(%rip), %rsi      # 0x41ca
movb $0x0, %al
callq 0x10e0
jmp 0x2ff2
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
shll $0x18, %eax
movq -0x10(%rbp), %rcx
movzbl 0x11(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x10(%rbp), %rcx
movzbl 0x12(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x10(%rbp), %rcx
movzbl 0x13(%rcx), %ecx
orl %ecx, %eax
addl $0x14, %eax
movl %eax, -0x1c(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x11, %edx
callq 0x10c0
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdx
leaq 0x1232(%rip), %rdi      # 0x41f5
movb $0x0, %al
callq 0x10b0
movl -0x1c(%rbp), %eax
cmpq -0x18(%rbp), %rax
jae 0x2ff0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %eax
addq %rax, %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %eax
subq %rax, %rdx
callq 0x2dc0
jmp 0x2ff2
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kyz[P]amostools/dumpamos.c
// Function: amos_file
void amos_file(char *fname, uint8_t *src, size_t len) {
    if (len < 4) {
        fprintf(stderr, "%s: file too short to be an AMOS file\n", fname);
    }
    else {
        switch (amos_leek(src)) {
        case ID_AMOS:
            amos_source(fname, src, len);
            break;

        case ID_AmBs:
            printf("%s: AMOS banks\n", fname);
            amos_banks(fname, src, len);
            break;

        case ID_AmBk:
        case ID_AmSp:
        case ID_AmIc:
            printf("%s: AMOS bank (%s)\n", fname, bank_type(src, len));
            amos_bank(fname, src, len);
            break;

        default:
            fprintf(stderr, "%s: not an AMOS source file or bank\n", fname);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x4, -0x18(%rbp)
jae 0x303c
movq 0x2fce(%rip), %rax      # 0x5ff0
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x11ec(%rip), %rsi      # 0x421c
movb $0x0, %al
callq 0x10e0
jmp 0x3113
movq -0x10(%rbp), %rax
movl (%rax), %eax
bswapl %eax
movl %eax, -0x1c(%rbp)
subl $0x414d4f53, %eax       # imm = 0x414D4F53
je 0x3080
jmp 0x3050
movl -0x1c(%rbp), %eax
subl $0x416d426b, %eax       # imm = 0x416D426B
je 0x30b8
jmp 0x305c
movl -0x1c(%rbp), %eax
subl $0x416d4273, %eax       # imm = 0x416D4273
je 0x3093
jmp 0x3068
movl -0x1c(%rbp), %eax
subl $0x416d4963, %eax       # imm = 0x416D4963
je 0x30b8
jmp 0x3074
movl -0x1c(%rbp), %eax
subl $0x416d5370, %eax       # imm = 0x416D5370
je 0x30b8
jmp 0x30f5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2f20
jmp 0x3111
movq -0x8(%rbp), %rsi
leaq 0x11a5(%rip), %rdi      # 0x4243
movb $0x0, %al
callq 0x10b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2dc0
jmp 0x3111
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1940
movq -0x28(%rbp), %rsi
movq %rax, %rdx
leaq 0x1178(%rip), %rdi      # 0x4253
movb $0x0, %al
callq 0x10b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2c00
jmp 0x3111
movq 0x2ef4(%rip), %rax      # 0x5ff0
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x115d(%rip), %rsi      # 0x4267
movb $0x0, %al
callq 0x10e0
jmp 0x3113
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/kyz[P]amostools/dumpamos.c
// Function: main
int main(int argc, char *argv[]) {
    if (argc <= 1) {
        printf("Extract the contents of AMOS source code and memory banks.\n");
        printf("Usage: %s [-p] <file.AMOS, file.abk, file.abs, ...>\n", argv[0]);
        printf("Options:\n"
               "  -p     Prefix removal\n");
        return 1;
    }

    for (int i = 1; i < argc; i++) {
        if (!strcmp(argv[i], "-p")) {
            use_prefix = 1;
        }
        else {
            char *fname = argv[i];
            uint8_t *buf;
            size_t len;
            if ((buf = read_file(fname, &len))) {
                amos_file(fname, buf, len);
                free(buf);
            }
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jg 0x3179
leaq 0x1149(%rip), %rdi      # 0x428c
movb $0x0, %al
callq 0x10b0
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0x1170(%rip), %rdi      # 0x42c8
movb $0x0, %al
callq 0x10b0
leaq 0x1197(%rip), %rdi      # 0x42fd
movb $0x0, %al
callq 0x10b0
movl $0x1, -0x4(%rbp)
jmp 0x320b
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x3204
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x1184(%rip), %rsi      # 0x431f
callq 0x10d0
cmpl $0x0, %eax
jne 0x31b1
movl $0x1, 0x2f1d(%rip)      # 0x60cc
jmp 0x31f4
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1270
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x31f2
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x3000
movq -0x28(%rbp), %rdi
callq 0x1030
jmp 0x31f4
jmp 0x31f6
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3180
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/linearSat/linearSat.c
// Function: wordTreeFindInList
struct wordTree *wordTreeFindInList(struct wordTree *list, struct monomer *monomer)
/* Return wordTree element in list that has given word, or NULL if none. */
{
struct wordTree *wt;
for (wt = list; wt != NULL; wt = wt->next)
    if (wt->monomer == monomer)
        break;
return wt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x396a
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x395b
jmp 0x396a
jmp 0x395d
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x3944
movq -0x18(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/linearSat/linearSat.c
// Function: wordTreeAddFollowing
struct wordTree *wordTreeAddFollowing(struct wordTree *wt, struct monomer *monomer)
/* Make word follow wt in tree.  If word already exists among followers
 * return it and bump use count.  Otherwise create new one. */
{
struct wordTree *child = wordTreeFindInList(wt->children, monomer);
if (child == NULL)
    {
    child = wordTreeNew(monomer);
    child->parent = wt;
    slAddHead(&wt->children, child);
    }
child->useCount += 1;
return child;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x3930
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x39c6
movq -0x10(%rbp), %rdi
callq 0x38b0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
callq 0x39e0
movq -0x18(%rbp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/linearSat/../inc/common.h
// Function: slAddHead
INLINE void slAddHead(void *listPt, void *node)
/* Add new node to start of list.
 * Usage:
 *    slAddHead(&list, node);
 * where list and nodes are both pointers to structure
 * that begin with a next pointer.
 */
{
struct slList **ppt = (struct slList **)listPt;
struct slList *n = (struct slList *)node;
n->next = *ppt;
*ppt = n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/linearSat/linearSat.c
// Function: wordTreeSumUseCounts
int wordTreeSumUseCounts(struct wordTree *list)
/* Sum up useCounts in list */
{
int total = 0;
struct wordTree *wt;
for (wt = list; wt != NULL; wt = wt->next)
    total += wt->useCount;
return total;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3a58
movq -0x18(%rbp), %rax
movl 0x20(%rax), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x3a37
movl -0xc(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/linearSat/linearSat.c
// Function: wordTreeSumOutTargets
int wordTreeSumOutTargets(struct wordTree *list)
/* Sum up useCounts in list */
{
int total = 0;
struct wordTree *wt;
for (wt = list; wt != NULL; wt = wt->next)
    total += wt->outTarget;
return total;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3a98
movq -0x18(%rbp), %rax
movl 0x24(%rax), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x3a77
movl -0xc(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/linearSat/linearSat.c
// Function: addChainToTree
void addChainToTree(struct wordTree *wt, struct dlList *chain)
/* Add chain of words to tree. */
{
struct dlNode *node;
wt->useCount += 1;
for (node = chain->head; !dlEnd(node); node = node->next)
    {
    struct monomer *monomer = node->val;
    verbose(4, "  adding %s\n", monomer->word);
    wt = wordTreeAddFollowing(wt, monomer);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x3adb
jmp 0x3b20
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdx
movl $0x4, %edi
leaq 0x1fb86(%rip), %rsi     # 0x23681
movb $0x0, %al
callq 0x1adf0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3970
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x3ac8
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/linearSat/linearSat.c
// Function: useCountInTree
int useCountInTree(struct wordTree *wt, struct dlNode *nodeList, int chainSize)
/* Return number of times chainSize successive nodes from nodeList are found
 * in wt,  0 if not found. */
{
int i;
struct wordTree *subTree = wt;
struct dlNode *node = nodeList;
for (i=0; i<chainSize; ++i)
    {
    struct monomer *monomer = node->val;
    subTree = wordTreeFindInList(subTree->children, monomer);
    if (subTree == NULL)
        return FALSE;
    node = node->next;
    }
return subTree->useCount;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x3ba9
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x38(%rbp), %rsi
callq 0x3930
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x3b93
movl $0x0, -0x4(%rbp)
jmp 0x3bb3
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3b5a
movq -0x28(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/linearSat/linearSat.c
// Function: findLongestSupportingMarkovChain
void findLongestSupportingMarkovChain(struct wordTree *wt, struct dlNode *node,
    int *retChainSize, int *retReadCount)
/* See if chain of words is in tree tree. */
{
struct dlNode *start = node;
int chainSize = 1;
int readCount = 0;
for (;;)
    {
    int useCount = useCountInTree(wt, start, chainSize);
    if (useCount == 0)
        break;
    readCount = useCount;
    chainSize += 1;
    start = start->prev;
    if (dlStart(start))
        break;
    }
*retChainSize = chainSize;
*retReadCount = readCount;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x1, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x2c(%rbp), %edx
callq 0x3b30
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x3c09
jmp 0x3c33
movl -0x34(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x3c31
jmp 0x3c33
jmp 0x3bee
movl -0x2c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x30(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/linearSat/linearSat.c
// Function: wordTreeAddPseudoCount
int wordTreeAddPseudoCount(struct wordTree *wt, int pseudo)
/* Add pseudo to all leaves of tree and propagate counts up to parents. */
{
if (wt->children == NULL)
    {
    wt->useCount += pseudo;
    return wt->useCount;
    }
else
    {
    struct wordTree *child;
    int oldChildTotal = 0;
    for (child = wt->children; child != NULL; child = child->next)
	oldChildTotal += child->useCount;
    int oldDiff = wt->useCount - oldChildTotal;
    if (oldDiff < 0) oldDiff = 0;  // Necessary in rare cases, not sure why.

    int total = 0;
    for (child = wt->children; child != NULL; child = child->next)
	total += wordTreeAddPseudoCount(child, pseudo);
    wt->useCount = total + oldDiff + pseudo;
    return total;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x3c86
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
addl 0x20(%rax), %ecx
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x3d23
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3cba
movq -0x20(%rbp), %rax
movl 0x20(%rax), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x3c99
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
subl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jge 0x3cd4
movl $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3d0d
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x3c50
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x3ce7
movl -0x2c(%rbp), %ecx
addl -0x28(%rbp), %ecx
addl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x20(%rax)
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/linearSat/linearSat.c
// Function: wordTreeNormalize
void wordTreeNormalize(struct wordTree *wt, double outTarget, double normVal)
/* Recursively set wt->normVal  and wt->outTarget so each branch gets its share */
{
if (pseudoCount > 0)
    wordTreeAddPseudoCount(wt, pseudoCount);
wt->normVal = normVal;
wt->outTarget = outTarget;
wt->outCount = 0;
int childrenTotalUses = wordTreeSumUseCounts(wt->children);
struct wordTree *child;
for (child = wt->children; child != NULL; child = child->next)
    {
    double childRatio = (double)child->useCount / childrenTotalUses;
    wordTreeNormalize(child, childRatio*outTarget, childRatio*normVal);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
cmpl $0x0, 0x2e683(%rip)     # 0x323d0
jle 0x3d5e
movq -0x8(%rbp), %rdi
movl 0x2e677(%rip), %esi     # 0x323d0
callq 0x3c50
movsd -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x30(%rax)
cvttsd2si -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3a20
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x3de7
movq -0x28(%rbp), %rax
cvtsi2sdl 0x20(%rax), %xmm0
cvtsi2sdl -0x1c(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movsd -0x30(%rbp), %xmm0
mulsd -0x10(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
mulsd -0x18(%rbp), %xmm1
callq 0x3d30
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x3d9f
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/linearSat/linearSat.c
// Function: wordTreeString
char *wordTreeString(struct wordTree *wt)
/* Return something like '(a b c)' where c would be the value at wt itself, and
 * a and b would be gotten by following parents. */
{
struct slName *list = NULL, *el;
for (;wt != NULL; wt = wt->parent)
    {
    char *word = wt->monomer->word;
    if (!isEmpty(word))   // Avoid blank great grandparent at root of tree.
	slNameAddHead(&list, word);
    }

struct dyString *dy = dyStringNew(0);
dyStringAppendC(dy, '(');
for (el = list; el != NULL; el = el->next)
   {
   dyStringPrintf(dy, "%s", el->name);
   if (el->next != NULL)
       dyStringAppendC(dy, ' ');
   }
dyStringAppendC(dy, ')');
slFreeList(&list);
return dyStringCannibalize(&dy);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3e4b
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3e3b
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x3e3b
movq -0x20(%rbp), %rsi
leaq -0x10(%rbp), %rdi
callq 0x8c20
jmp 0x3e3d
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x3e04
xorl %edi, %edi
callq 0xf030
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl $0x28, %esi
callq 0xf2b0
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3eb4
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rdx
addq $0x8, %rdx
leaq 0x20726(%rip), %rsi     # 0x245ac
movb $0x0, %al
callq 0xf550
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x3ea5
movq -0x28(%rbp), %rdi
movl $0x20, %esi
callq 0xf2b0
jmp 0x3ea7
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x3e6c
movq -0x28(%rbp), %rdi
movl $0x29, %esi
callq 0xf2b0
leaq -0x10(%rbp), %rdi
callq 0x7c10
leaq -0x28(%rbp), %rdi
callq 0xf0d0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/linearSat/linearSat.c
// Function: dlListFragWords
char *dlListFragWords(struct dlNode *head)
/* Return string containing all words in list pointed to by head. */
{
struct dyString *dy = dyStringNew(0);
dyStringAppendC(dy, '{');
struct dlNode *node;
for (node = head; !dlEnd(node); node = node->next)
    {
    if (node != head)
       dyStringAppendC(dy, ' ');
    struct monomer *monomer = node->val;
    dyStringAppend(dy, monomer->word);
    }
dyStringAppendC(dy, '}');
return dyStringCannibalize(&dy);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
xorl %edi, %edi
callq 0xf030
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x7b, %esi
callq 0xf2b0
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x3f20
jmp 0x3f62
movq -0x18(%rbp), %rax
cmpq -0x8(%rbp), %rax
je 0x3f38
movq -0x10(%rbp), %rdi
movl $0x20, %esi
callq 0xf2b0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xf3c0
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x3f0d
movq -0x10(%rbp), %rdi
movl $0x7d, %esi
callq 0xf2b0
leaq -0x10(%rbp), %rdi
callq 0xf0d0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/linearSat/linearSat.c
// Function: wordTreeDump
void wordTreeDump(int level, struct wordTree *wt, int maxChainSize, FILE *f)
/* Write out wordTree to file. */
{
static char *words[64];
int i;
assert(level < ArraySize(words));

words[level] = wt->monomer->word;
if (!fullOnly || level == maxChainSize)
    {
    fprintf(f, "%d\t%d\t%d\t%d\t%f\t", 
	    level, wt->useCount, wt->outTarget, wt->outCount, wt->normVal);
    
    for (i=1; i<=level; ++i)
	{
	spaceOut(f, level*2);
	fprintf(f, "%s ", words[i]);
	}
    fprintf(f, "\n");
    }
struct wordTree *child;
for (child = wt->children; child != NULL; child = child->next)
    wordTreeDump(level+1, child, maxChainSize, f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movslq -0x4(%rbp), %rax
cmpq $0x40, %rax
jae 0x3fa2
jmp 0x3fc1
leaq 0x1f6e5(%rip), %rdi     # 0x2368e
leaq 0x1f6f7(%rip), %rsi     # 0x236a7
movl $0x1a8, %edx            # imm = 0x1A8
leaq 0x1f6f7(%rip), %rcx     # 0x236b3
callq 0x32d0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rdx
movslq -0x4(%rbp), %rcx
leaq 0x2e668(%rip), %rax     # 0x32640
movq %rdx, (%rax,%rcx,8)
cmpl $0x0, 0x2e651(%rip)     # 0x32634
je 0x3ff1
movl -0x4(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x4081
movq -0x20(%rbp), %rdi
movl -0x4(%rbp), %edx
movq -0x10(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x10(%rbp), %rax
movl 0x24(%rax), %r8d
movq -0x10(%rbp), %rax
movl 0x28(%rax), %r9d
movq -0x10(%rbp), %rax
movsd 0x30(%rax), %xmm0
leaq 0x1f6cb(%rip), %rsi     # 0x236ea
movb $0x1, %al
callq 0x3440
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x4(%rbp), %eax
jg 0x406f
movq -0x20(%rbp), %rdi
movl -0x4(%rbp), %esi
shll %esi
callq 0xbf60
movq -0x20(%rbp), %rdi
movslq -0x24(%rbp), %rcx
leaq 0x2e5ee(%rip), %rax     # 0x32640
movq (%rax,%rcx,8), %rdx
leaq 0x22596(%rip), %rsi     # 0x265f3
movb $0x0, %al
callq 0x3440
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x402d
movq -0x20(%rbp), %rdi
leaq 0x23461(%rip), %rsi     # 0x274db
movb $0x0, %al
callq 0x3440
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x40b7
movl -0x4(%rbp), %edi
addl $0x1, %edi
movq -0x30(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
callq 0x3f80
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x408d
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/linearSat/linearSat.c
// Function: predictNextFromAllPredecessors
struct wordTree *predictNextFromAllPredecessors(struct wordTree *wt, struct dlNode *list)
/* Predict next word given tree and recently used word list.  If tree doesn't
 * have statistics for what comes next given the words in list, then it returns
 * NULL. */
{
if (verboseLevel() >= 4)
    verbose(4, "  predictNextFromAllPredecessors(%s, %s)\n", wordTreeString(wt), dlListFragWords(list));
struct dlNode *node;
for (node = list; !dlEnd(node); node = node->next)
    {
    struct monomer *monomer = node->val;
    wt = wordTreeFindInList(wt->children, monomer);
    if (verboseLevel() >= 4)
	verbose(4, "   wordTreeFindInList(%s) = %p %s\n", monomer->word, wt, wordTreeString(wt));
    if (wt == NULL || wt->children == NULL)
        break;
    }
struct wordTree *result = NULL;
if (wt != NULL && wt->children != NULL)
    result = pickWeightedRandomFromList(wt->children);
return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, %al
callq 0x1b100
cmpl $0x4, %eax
jl 0x446c
movq -0x8(%rbp), %rdi
callq 0x3df0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3ee0
movq -0x30(%rbp), %rdx
movq %rax, %rcx
movl $0x4, %edi
leaq 0x1f388(%rip), %rsi     # 0x237ed
movb $0x0, %al
callq 0x1adf0
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x448a
jmp 0x4518
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x3930
movq %rax, -0x8(%rbp)
movb $0x0, %al
callq 0x1b100
cmpl $0x4, %eax
jl 0x44f2
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3df0
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq %rax, %r8
movl $0x4, %edi
leaq 0x1f32c(%rip), %rsi     # 0x23817
movb $0x0, %al
callq 0x1adf0
cmpq $0x0, -0x8(%rbp)
je 0x4504
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x4506
jmp 0x4518
jmp 0x4508
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x4474
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4543
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x4543
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x40c0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/linearSat/linearSat.c
// Function: predictFromWordTree
struct wordTree *predictFromWordTree(struct wordTree *wt, struct dlNode *recent)
/* Predict next word given tree and recently used word list.  Will use all words in
 * recent list if can,  but if there is not data in tree, will back off, and use
 * progressively less previous words. */
{
struct dlNode *node;
if (verboseLevel() >= 4)
    verbose(4, " predictNextFromWordTree(%s)\n", wordTreeString(wt));

for (node = recent; !dlEnd(node); node = node->next)
    {
    struct wordTree *result = predictNextFromAllPredecessors(wt, node);
    if (result != NULL)
        return result;
    }
return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb $0x0, %al
callq 0x1b100
cmpl $0x4, %eax
jl 0x458b
movq -0x10(%rbp), %rdi
callq 0x3df0
movq %rax, %rdx
movl $0x4, %edi
leaq 0x1f2b6(%rip), %rsi     # 0x2383a
movb $0x0, %al
callq 0x1adf0
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x45a6
jmp 0x45d7
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4420
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x45c8
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x45df
jmp 0x45ca
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x4593
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/linearSat/linearSat.c
// Function: nodesFromTail
struct dlNode *nodesFromTail(struct dlList *list, int count)
/* Return count nodes from tail of list.  If list is shorter than count, it returns the
 * whole list. */
{
int i;
struct dlNode *node;
for (i=0, node = list->tail; i<count; ++i)
    {
    if (dlStart(node))
        return list->head;
    node = node->prev;
    }
return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x4645
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x462e
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x464d
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x460e
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/linearSat/linearSat.c
// Function: typeAfter
struct monomerType *typeAfter(struct alphaStore *store, struct monomerType *oldType,
    int amount)
/* Skip forward amount in typeList from oldType.  If get to end of list start
 * again at the beginning */
{
int i;
struct monomerType *type = oldType;
for (i=0; i<amount; ++i)
    {
    type = type->next;
    if (type == NULL)
	type = store->typeList;
    }
return type;
}

// 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)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x46b1
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x46a4
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x46a6
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x467e
movq -0x20(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/linearSat/linearSat.c
// Function: typeBefore
struct monomerType *typeBefore(struct alphaStore *store, struct monomerType *oldType, int amount)
/* Pick type that comes amount before given type. */
{
int typeIx = ptArrayIx(oldType, store->typeArray, store->typeCount);
typeIx -= amount;
while (typeIx < 0)
    typeIx += store->typeCount;
return store->typeArray[typeIx];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rsi
movq -0x8(%rbp), %rax
movl 0x48(%rax), %edx
callq 0xc490
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %ecx
movl -0x18(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x470e
movq -0x8(%rbp), %rax
movl 0x48(%rax), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x46f9
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/linearSat/linearSat.c
// Function: predictNext
struct wordTree *predictNext(struct alphaStore *store, struct dlList *past)
/* Given input data store and what is known from the past, predict the next word. */
{
struct dlNode *recent = nodesFromTail(past, store->maxChainSize);
struct wordTree *pick =  predictFromWordTree(store->markovChains, recent);
if (pick == NULL)
    pick = predictFromPreviousTypes(store, past);
if (pick == NULL)
    {
    pick = pickWeightedRandomFromList(store->markovChains->children);
    verbose(3, "in predictNext() last resort pick of %s\n", pick->monomer->word);
    }
return pick;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x30(%rax), %esi
callq 0x45f0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x4550
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x4941
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4730
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x497c
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x40c0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rdx
movl $0x3, %edi
leaq 0x1ef9e(%rip), %rsi     # 0x23913
movb $0x0, %al
callq 0x1adf0
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/linearSat/linearSat.c
// Function: decrementOutputCountsInTree
void decrementOutputCountsInTree(struct wordTree *wt)
/* Decrement output count of self and parents. */
{
while (wt != NULL)
    {
    /* Decrement target count, but don't let it fall below sum of counts of all children. 
     * This can happen with incomplete data if we don't prevent it.  This
     * same code also prevents us from having negative outTarget. */
    int outTarget = wt->outTarget - 1;
    int kidSum = wordTreeSumOutTargets(wt->children);
    if (outTarget < kidSum)
        outTarget = kidSum;
    wt->outTarget = outTarget;

    /* Always bump outCount to help us debug (only real use of outCount). */
    wt->outCount += 1;
    wt = wt->parent;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x49f3
movq -0x8(%rbp), %rax
movl 0x24(%rax), %eax
subl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3a60
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x49ce
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x8(%rbp), %rax
movl 0x28(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x499c
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/linearSat/linearSat.c
// Function: listUnusedMonomers
struct slRef *listUnusedMonomers(struct alphaStore *store, struct dlList *ll)
/* Return list of references to monomers that are in store but not on ll. */
{
struct slRef *refList = NULL, *ref;
struct hash *usedHash = hashNew(0);
struct dlNode *node;
/* Make hash of used monomers. */
for (node = ll->head; !dlEnd(node); node = node->next)
    {
    struct monomer *monomer = node->val;
    hashAdd(usedHash, monomer->word, monomer);
    }

/* Stream through all monomers looking for ones not used and adding to list. */
struct monomer *monomer;
for (monomer = store->monomerList; monomer != NULL; monomer = monomer->next)
    {
    if (isEmpty(monomer->word))
        continue;
    if (!hashLookup(usedHash, monomer->word))
	{
	AllocVar(ref);
	ref->val = monomer;
	slAddHead(&refList, ref);
	}
    }
hashFree(&usedHash);
slReverse(&refList);
return refList;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
xorl %edi, %edi
movl $0x1, %esi
callq 0x10f70
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x4a46
jmp 0x4a74
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x38(%rbp), %rdx
callq 0x10900
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x4a33
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x4af0
movq -0x40(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x4aa1
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x4aa3
jmp 0x4ae3
movq -0x28(%rbp), %rdi
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x104b0
cmpq $0x0, %rax
jne 0x4ae1
movl $0x10, %edi
callq 0x152f0
movq %rax, -0x20(%rbp)
movq -0x40(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x39e0
jmp 0x4ae3
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x4a7f
leaq -0x28(%rbp), %rdi
callq 0x11620
leaq -0x18(%rbp), %rdi
callq 0x7bb0
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/linearSat/linearSat.c
// Function: monomerRefIx
int monomerRefIx(struct monomerRef *list, struct monomer *monomer)
/* Return index of monomer in list. */
{
int i;
struct monomerRef *ref;
for (i=0, ref = list; ref != NULL; ref = ref->next, ++i)
    {
    if (ref->val == monomer)
        return i;
    }
errAbort("Monomer %s not on list\n", monomer->word);
return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x4b64
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x4b4c
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x4b81
jmp 0x4b4e
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4b2f
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x1edc9(%rip), %rdi     # 0x2393c
movb $0x0, %al
callq 0xfd50
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/linearSat/linearSat.c
// Function: matchExceptCenter
struct dlNode *matchExceptCenter(struct dlNode *node, struct monomerRef *neighborhood, struct monomer *center)
/* Return center node if node matches neighborhood except for center. */
{
struct dlNode *centerNode = NULL;
struct monomerRef *neighbor;
struct dlNode *n;
for (n = node, neighbor=neighborhood; ; n = n->next, neighbor = neighbor->next)
    {
    if (neighbor == NULL)
        break;
    if (dlEnd(n))
        return NULL;
    if (neighbor->val == center)
        centerNode = n;
    else if (n->val != neighbor->val)
        return NULL;
    }
return centerNode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x4d61
jmp 0x4dc5
movq -0x38(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x4d75
movq $0x0, -0x8(%rbp)
jmp 0x4dcd
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x20(%rbp), %rax
jne 0x4d8d
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x4dab
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x30(%rbp), %rcx
cmpq 0x8(%rcx), %rax
je 0x4da9
movq $0x0, -0x8(%rbp)
jmp 0x4dcd
jmp 0x4dab
jmp 0x4dad
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x4d58
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/linearSat/linearSat.c
// Function: printMonomerRefList
void printMonomerRefList(struct monomerRef *refList, FILE *f)
/* Print out a line to file with the list of monomers. */
{
struct monomerRef *ref;
for (ref = refList; ref != NULL; ref = ref->next)
    fprintf(f, "%s ", ref->val->word);
fprintf(f, "\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4e2a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdx
leaq 0x217dd(%rip), %rsi     # 0x265f3
movb $0x0, %al
callq 0x3440
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x4df8
movq -0x10(%rbp), %rdi
leaq 0x226a6(%rip), %rsi     # 0x274db
movb $0x0, %al
callq 0x3440
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/JimKent[P]linearSat/linearSat/linearSat.c
// Function: refsToPossibleCenters
struct slRef *refsToPossibleCenters(struct monomer *center, struct monomerRef *neighborhood, struct dlList *ll)
/* Return a list of dlNodes where neighborhood, but not center matches. */
{
struct slRef *list = NULL;
struct dlNode *node;
for (node = ll->head; !dlEnd(node); node = node->next)
    {
    struct dlNode *centerNode = matchExceptCenter(node, neighborhood, center);
    if (centerNode != NULL)
	refAdd(&list, centerNode);
    }
return list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x4e8a
jmp 0x4ec2
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
callq 0x4d30
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x4eb3
movq -0x30(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x9440
jmp 0x4eb5
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x4e77
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
xorl %edi, %edi
movl $0x1, %esi
callq 0x10f70
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x4f39
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x10e80
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x4efc
movq $0x0, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x11400
leaq -0x68(%rbp), %rdi
callq 0x114b0
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x4f94
movq -0x50(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x163b0
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
cmpl -0x44(%rbp), %eax
jle 0x4f92
movl -0x6c(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x4f55
movq -0x40(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x44(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
leaq -0x20(%rbp), %rdi
callq 0x11620
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x78f0
movl %eax, -0x2c(%rbp)
cmpl $0x3, -0x2c(%rbp)
je 0x5290
cmpl $0x2, -0x2c(%rbp)
jne 0x5292
jmp 0x52b1
leaq 0x1e7df(%rip), %rdi     # 0x23a78
leaq 0x1e407(%rip), %rsi     # 0x236a7
movl $0x3d8, %edx            # imm = 0x3D8
leaq 0x1e7e3(%rip), %rcx     # 0x23a8f
callq 0x32d0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x4fc0
cmpl $0x0, %eax
je 0x52d4
movl $0x1, -0x4(%rbp)
jmp 0x5351
cmpl $0x3, -0x2c(%rbp)
jne 0x534a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
movq -0x28(%rbp), %rcx
callq 0x4fc0
cmpl $0x0, %eax
je 0x5300
movl $0x1, -0x4(%rbp)
jmp 0x5351
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x4fc0
movl %eax, -0x3c(%rbp)
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x5351
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)