LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/afi-lambda[P]a_little_smalltalk/src/memory.c
// Function: allocStr
object allocStr(register const char *str)
{
    register object newSym;
    newSym = allocByte(1 + strlen(str));
    strcpy(charPtr(newSym), str);
    return (newSym);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x20a0
movq %rax, %r14
addl $0x2, %eax
shrl $0x1f, %eax
leal (%r14,%rax), %edi
addl $0x2, %edi
sarl %edi
callq 0x2d15
movswl %ax, %ebp
notl %r14d
movl %ebp, %eax
shrl %eax
movswq %ax, %rax
shlq $0x4, %rax
leaq 0xb349(%rip), %rcx      # 0xe240
movw %r14w, 0x4(%rax,%rcx)
movw %bp, 0x2498c(%rip)      # 0x27890
movq 0x8(%rax,%rcx), %rdi
movq %rbx, %rsi
callq 0x2050
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/afi-lambda[P]a_little_smalltalk/src/memory.c
// Function: sysDecr
void sysDecr(object z)
{
    register struct objectStruct *p;
    register int i;
    int size;

    p = &objectTable[z >> 1];
    if (p->referenceCount < 0)
    {
        fprintf(stderr, "object %d\n", z);
        sysError("negative reference count", "");
    }
    decr(p->STclass);
    size = p->size;
    if (size < 0)
        size = ((-size) + 1) / 2;
    p->STclass = objectFreeList[size];
    objectFreeList[size] = z >> 1;
    if (size > 0)
    {
        if (p->size > 0)
            for (i = size; i;)
                decr(p->memory[--i]);
        for (i = size; i > 0;)
            p->memory[--i] = nilobj;
    }
    p->size = size;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebp
sarl %ebp
movslq %ebp, %rax
shlq $0x4, %rax
leaq 0xb2a6(%rip), %rcx      # 0xe240
leaq (%rcx,%rax), %rbx
cmpw $0x0, 0x2(%rax,%rcx)
js 0x303b
movswl (%rbx), %edi
callq 0x2f46
movswl 0x4(%rbx), %eax
movl $0x1, %r14d
subl %eax, %r14d
shrl %r14d
testl %eax, %eax
cmovnsl %eax, %r14d
leaq 0xa2d1(%rip), %rcx      # 0xd2a0
movzwl (%rcx,%r14,2), %edx
movw %dx, (%rbx)
movw %bp, (%rcx,%r14,2)
testl %r14d, %r14d
jle 0x302b
testw %ax, %ax
jle 0x2ffd
movl %r14d, %r15d
movq 0x8(%rbx), %rax
movswl -0x2(%rax,%r15,2), %edi
callq 0x2f46
decq %r15
jne 0x2fe9
testl %r14d, %r14d
movl $0x1, %eax
cmovlel %r14d, %eax
leal -0x1(%r14), %edi
movl %r14d, %ecx
subl %eax, %ecx
subq %rcx, %rdi
addq %rdi, %rdi
addq 0x8(%rbx), %rdi
leaq 0x2(,%rcx,2), %rdx
xorl %esi, %esi
callq 0x20d0
movw %r14w, 0x4(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x2585
jmp 0x2faa
// File: /workspace/github_c_makefile_star2_O1/afi-lambda[P]a_little_smalltalk/src/memory.c
// Function: byteAtPut
void byteAtPut(object z, int i, int x)
{
    byte *bp;

    if (isInteger(z))
        sysError("indexing integer", "byteAtPut");
    else if ((i <= 0) || (i > 2 * -sizeField(z)))
    {
        fprintf(stderr, "index %d size %d\n", i, sizeField(z));
        sysError("index out of range", "byteAtPut");
    }
    else
    {
        bp = bytePtr(z);
        bp[i - 1] = x;
    }
}

// Assembly:
testl $0x8001, %edi           # imm = 0x8001
je 0x3060
leaq 0x6148(%rip), %rdi      # 0x919c
leaq 0x6152(%rip), %rsi      # 0x91ad
jmp 0x4dfc
testl %esi, %esi
jle 0x309e
movzwl %di, %eax
shrl %eax
movl %eax, %r8d
shll $0x4, %r8d
leaq 0xb1c9(%rip), %rcx      # 0xe240
movswl 0x4(%r8,%rcx), %r8d
addl %r8d, %r8d
negl %r8d
cmpl %esi, %r8d
jl 0x309e
movw %di, 0x24801(%rip)      # 0x27890
shll $0x4, %eax
movq 0x8(%rax,%rcx), %rax
movl %esi, %ecx
movb %dl, -0x1(%rax,%rcx)
retq
pushq %rax
callq 0x25b4
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/afi-lambda[P]a_little_smalltalk/src/memory.c
// Function: visit
void visit(register object x)
{
    int i, s;
    object *p;

    if (x && !isInteger(x))
    {
        if (++(objectTable[x >> 1].referenceCount) == 1)
        {
            /* then it's the first time we've visited it, so: */
            visit(objectTable[x >> 1].STclass);
            s = sizeField(x);
            if (s > 0)
            {
                p = objectTable[x >> 1].memory;
                for (i = s; i; --i)
                    visit(*p++);
            }
        }
    }
}

// Assembly:
testw %di, %di
sete %al
testl $0x8001, %edi           # imm = 0x8001
setne %cl
orb %al, %cl
jne 0x30dc
andl $0xfffe, %edi           # imm = 0xFFFE
leaq 0xb177(%rip), %rax      # 0xe240
movzwl 0x2(%rax,%rdi,8), %ecx
movl %ecx, %edx
incl %edx
movw %dx, 0x2(%rax,%rdi,8)
testw %cx, %cx
je 0x30dd
retq
pushq %r15
pushq %r14
pushq %rbx
leaq (%rax,%rdi,8), %r14
movswl (%r14), %edi
callq 0x30a9
movzwl 0x4(%r14), %ebx
testw %bx, %bx
jle 0x3112
movq 0x8(%r14), %r14
xorl %r15d, %r15d
movswl (%r14,%r15,2), %edi
callq 0x30a9
incq %r15
cmpl %r15d, %ebx
jne 0x3100
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/afi-lambda[P]a_little_smalltalk/src/names.c
// Function: nameTableInsert
void nameTableInsert(object dict, int hash, object key, object value)
{
    object table, link, nwLink, nextLink, tablentry;

    /* first get the hash table */
    table = basicAt(dict, 1);

    if (sizeField(table) < 3)
        sysError("attempt to insert into", "too small name table");
    else
    {
        hash = 3 * (hash % (sizeField(table) / 3));
        tablentry = basicAt(table, hash+1);
        if ((tablentry == nilobj) || (tablentry == key))
        {
            basicAtPut(table, hash+1, key);
            basicAtPut(table, hash+2, value);
        }
        else
        {
            nwLink = newLink(key, value);
            incr(nwLink);
            link = basicAt(table, hash+3);
            if (link == nilobj)
            {
                basicAtPut(table, hash+3, nwLink);
            }
            else
                while (1)
                    if (basicAt(link,1) == key)
                    {
                        basicAtPut(link, 2, value);
                        break;
                    }
                    else if ((nextLink = basicAt(link, 3)) == nilobj)
                    {
                        basicAtPut(link, 3, nwLink);
                        break;
                    }
                    else
                        link = nextLink;
            decr(nwLink);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
shrl %edi
movswq %di, %rax
shlq $0x4, %rax
leaq 0xb0cc(%rip), %r12      # 0xe240
movq 0x8(%r12,%rax), %rax
movswl (%rax), %eax
shrl %eax
movswq %ax, %r13
shlq $0x4, %r13
movzwl 0x4(%r12,%r13), %eax
cmpw $0x2, %ax
jg 0x31b3
leaq 0x6030(%rip), %rdi      # 0x91c9
leaq 0x6040(%rip), %rsi      # 0x91e0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4dfc
movl %ecx, %ebx
movl %edx, %ebp
addq %r12, %r13
movzwl %ax, %eax
imull $0xaaab, %eax, %ecx     # imm = 0xAAAB
shrl $0x11, %ecx
movl %esi, %eax
cltd
idivl %ecx
leal (%rdx,%rdx,2), %ecx
movq 0x8(%r13), %rax
movslq %ecx, %r14
movzwl (%rax,%r14,2), %ecx
testw %cx, %cx
setne %dl
cmpw %bp, %cx
setne %cl
testb %cl, %dl
jne 0x3217
movw %bp, (%rax,%r14,2)
movswl %bp, %edi
callq 0x2f20
movq 0x8(%r13), %rax
movw %bx, 0x2(%rax,%r14,2)
movswl %bx, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2f20
movswl %bp, %edi
movswl %bx, %esi
callq 0x3ac5
movl %eax, %r15d
movswl %ax, %edi
movl %edi, 0x4(%rsp)
callq 0x2f20
movq 0x8(%r13), %rcx
movzwl 0x4(%rcx,%r14,2), %eax
testw %ax, %ax
je 0x3265
cwtl
shrl %eax
movswq %ax, %rax
shlq $0x4, %rax
movq 0x8(%r12,%rax), %rcx
cmpw %bp, (%rcx)
je 0x326d
movzwl 0x4(%rcx), %eax
testw %ax, %ax
jne 0x3240
movw %r15w, 0x4(%rcx)
jmp 0x3274
movw %r15w, 0x4(%rcx,%r14,2)
jmp 0x3274
movw %bx, 0x2(%rcx)
movl %ebx, %r15d
movswl %r15w, %edi
callq 0x2f20
movl 0x4(%rsp), %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2f46
// File: /workspace/github_c_makefile_star2_O1/afi-lambda[P]a_little_smalltalk/src/names.c
// Function: hashEachElement
object hashEachElement(object dict, register int hash, int(*fun)(object))
{
    object table, key, value, link;
    register object *hp;
    int tablesize;

    table = basicAt(dict, 1);

    /* now see if table is valid */
    if ((tablesize = sizeField(table)) < 3)
        sysError("system error", "lookup on null table");
    else
    {
        hash = 1 + (3 * (hash % (tablesize / 3)));
        hp = sysMemPtr(table) + (hash - 1);
        key = *hp++; /* table at: hash */
        value = *hp++; /* table at: hash + 1 */
        if ((key != nilobj) && (*fun)(key))
            return value;
        for (link = *hp; link != nilobj; link = *hp)
        {
            hp = sysMemPtr(link);
            key = *hp++; /* link at: 1 */
            value = *hp++; /* link at: 2 */
            if ((key != nilobj) && (*fun)(key))
                return value;
        }
    }
    return nilobj;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
shrl %edi
movswq %di, %rax
shlq $0x4, %rax
leaq 0xaf93(%rip), %r14      # 0xe240
movq 0x8(%r14,%rax), %rax
movswl (%rax), %eax
shrl %eax
movswq %ax, %rcx
shlq $0x4, %rcx
movzwl 0x4(%r14,%rcx), %eax
cmpw $0x2, %ax
jg 0x32e2
leaq 0x5f23(%rip), %rdi      # 0x91f5
leaq 0x5f29(%rip), %rsi      # 0x9202
callq 0x4dfc
xorl %ebp, %ebp
jmp 0x331c
movq %rdx, %rbx
addq %r14, %rcx
movzwl %ax, %eax
imull $0xaaab, %eax, %edi     # imm = 0xAAAB
shrl $0x11, %edi
movl %esi, %eax
cltd
idivl %edi
leal (%rdx,%rdx,2), %eax
movq 0x8(%rcx), %r15
movslq %eax, %r12
movzwl (%r15,%r12,2), %eax
testw %ax, %ax
je 0x3327
movzwl 0x2(%r15,%r12,2), %ebp
movswl %ax, %edi
callq *%rbx
testl %eax, %eax
je 0x3327
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movzwl 0x4(%r15,%r12,2), %eax
testw %ax, %ax
je 0x32de
cwtl
shrl %eax
movswq %ax, %rax
shlq $0x4, %rax
movq 0x8(%r14,%rax), %r15
movzwl (%r15), %eax
testw %ax, %ax
je 0x3359
movzwl 0x2(%r15), %ebp
movswl %ax, %edi
callq *%rbx
testl %eax, %eax
jne 0x331c
movzwl 0x4(%r15), %eax
jmp 0x332d
// File: /workspace/github_c_makefile_star2_O1/afi-lambda[P]a_little_smalltalk/src/names.c
// Function: strHash
int strHash(const char *str)
{
    register int hash;
    register const char *p;

    hash = 0;
    for (p = str; *p; p++)
        hash += *p;
    if (hash < 0)
        hash = -hash;
    /* make sure it can be a smalltalk integer */
    if (hash > 16384)
        hash >>= 2;
    return hash;
}

// Assembly:
movb (%rdi), %cl
testb %cl, %cl
je 0x337b
incq %rdi
xorl %eax, %eax
movsbl %cl, %ecx
addl %ecx, %eax
movb (%rdi), %cl
incq %rdi
testb %cl, %cl
jne 0x336b
jmp 0x337d
xorl %eax, %eax
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
movl %ecx, %eax
shrl $0x2, %eax
cmpl $0x4001, %ecx           # imm = 0x4001
cmovbl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/afi-lambda[P]a_little_smalltalk/src/names.c
// Function: globalKey
object globalKey(const char *str)
{
    objBuffer = nilobj;
    charBuffer = str;
    hashEachElement(symbols, strHash(str), strTest);
    return objBuffer;
}

// Assembly:
pushq %rax
movw $0x0, 0x24503(%rip)     # 0x278a0
movq %rdi, 0x24504(%rip)     # 0x278a8
leaq 0x244e9(%rip), %rax     # 0x27894
movzwl (%rax), %eax
movb (%rdi), %dl
testb %dl, %dl
je 0x33c9
incq %rdi
xorl %ecx, %ecx
movsbl %dl, %edx
addl %edx, %ecx
movb (%rdi), %dl
incq %rdi
testb %dl, %dl
jne 0x33b9
jmp 0x33cb
xorl %ecx, %ecx
movl %ecx, %edx
negl %edx
cmovsl %ecx, %edx
movl %edx, %esi
shrl $0x2, %esi
cmpl $0x4001, %edx           # imm = 0x4001
cmovbl %edx, %esi
movswl %ax, %edi
leaq 0xe(%rip), %rdx         # 0x33f8
callq 0x3294
movzwl 0x244aa(%rip), %eax     # 0x278a0
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/afi-lambda[P]a_little_smalltalk/src/names.c
// Function: initCommonSymbols
void initCommonSymbols()
{
    int i;

    trueobj = globalSymbol("true");
    falseobj = globalSymbol("false");
    for (i = 0; unStrs[i]; i++)
        unSyms[i] = newSymbol(unStrs[i]);
    for (i = 0; binStrs[i]; i++)
        binSyms[i] = newSymbol(binStrs[i]);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x243c8(%rip), %rbx     # 0x27894
movswl (%rbx), %edi
leaq 0x5c11(%rip), %rsi      # 0x90e7
callq 0x3478
leaq 0x24af0(%rip), %rcx     # 0x27fd2
movw %ax, (%rcx)
movswl (%rbx), %edi
leaq 0x5bfd(%rip), %rsi      # 0x90ec
callq 0x3478
leaq 0x24ad9(%rip), %rcx     # 0x27fd4
movw %ax, (%rcx)
movq 0x9c3b(%rip), %rdi      # 0xd140
testq %rdi, %rdi
je 0x3532
xorl %ebx, %ebx
leaq 0x2439d(%rip), %r14     # 0x278b0
leaq 0x9c26(%rip), %r15      # 0xd140
callq 0x37bd
movw %ax, (%rbx,%r14)
movq 0x8(%r15,%rbx,4), %rdi
addq $0x2, %rbx
testq %rdi, %rdi
jne 0x351a
movq 0x9c57(%rip), %rdi      # 0xd190
testq %rdi, %rdi
je 0x3566
xorl %ebx, %ebx
leaq 0x24389(%rip), %r14     # 0x278d0
leaq 0x9c42(%rip), %r15      # 0xd190
callq 0x37bd
movw %ax, (%rbx,%r14)
movq 0x8(%r15,%rbx,4), %rdi
addq $0x2, %rbx
testq %rdi, %rdi
jne 0x354e
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/afi-lambda[P]a_little_smalltalk/src/news.c
// Function: getClass
object getClass(register object obj)
{
    if (isInteger(obj))
    {
        if (intClass == nilobj)
            intClass = globalSymbol("Integer");
        return (intClass);
    }
    return (classField(obj));
}

// Assembly:
pushq %rbx
movl %edi, %ebx
callq 0x2f18
testl %eax, %eax
je 0x35c1
leaq 0x24374(%rip), %rbx     # 0x2790c
cmpw $0x0, 0x2436c(%rip)     # 0x2790c
jne 0x35d5
leaq 0x242eb(%rip), %rax     # 0x27894
movswl (%rax), %edi
leaq 0x5d30(%rip), %rsi      # 0x92e3
callq 0x3478
movw %ax, 0x2434d(%rip)      # 0x2790c
jmp 0x35d5
movswl %bx, %eax
shrl %eax
movswq %ax, %rbx
shlq $0x4, %rbx
addq 0x9a03(%rip), %rbx      # 0xcfd8
movzwl (%rbx), %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/afi-lambda[P]a_little_smalltalk/src/news.c
// Function: newArray
object newArray(int size)
{
    object newObj;

    newObj = allocObject(size);
    if (arrayClass == nilobj)
        arrayClass = globalSymbol("Array");
    setClass(newObj, arrayClass);
    return newObj;
}

// Assembly:
pushq %rbx
callq 0x2d15
movl %eax, %ebx
cmpw $0x0, 0x24324(%rip)     # 0x2790e
jne 0x3609
leaq 0x242a1(%rip), %rax     # 0x27894
movswl (%rax), %edi
leaq 0x5ac1(%rip), %rsi      # 0x90be
callq 0x3478
movw %ax, 0x24305(%rip)      # 0x2790e
movswl 0x242fe(%rip), %edi     # 0x2790e
movswl %bx, %eax
shrl %eax
movswq %ax, %rax
shlq $0x4, %rax
leaq 0xac1c(%rip), %rcx      # 0xe240
movw %di, (%rcx,%rax)
callq 0x2f20
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/afi-lambda[P]a_little_smalltalk/src/news.c
// Function: newChar
object newChar(int value)
{
    object newobj;

    newobj = allocObject(1);
    basicAtPut(newobj, 1, newInteger(value));
    setClass(newobj, globalSymbol("Char"));
    return (newobj);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebp
movl $0x1, %edi
callq 0x2d15
movswl %ax, %ebx
movl %ebp, %edi
callq 0x314c
movl %ebx, %ecx
shrl %ecx
movswq %cx, %r14
shlq $0x4, %r14
leaq 0xab56(%rip), %r15      # 0xe240
movq 0x8(%r15,%r14), %rcx
movw %ax, (%rcx)
movswl %ax, %edi
callq 0x2f20
leaq 0x24193(%rip), %rax     # 0x27894
movswl (%rax), %edi
leaq 0x5be6(%rip), %rsi      # 0x92f1
callq 0x3478
movw %ax, (%r15,%r14)
movswl %ax, %edi
callq 0x2f20
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/afi-lambda[P]a_little_smalltalk/src/news.c
// Function: newClass
object newClass(const char *name)
{
    object newObj, nameObj;

    newObj = allocObject(classSize);
    setClass(newObj, globalSymbol("Class"));

    /* now make name */
    nameObj = newSymbol(name);
    basicAtPut(newObj, nameInClass, nameObj);

    /* now put in global symbols table */
    nameTableInsert(symbols, strHash(name), nameObj, newObj);

    return newObj;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0x5, %edi
callq 0x2d15
movl %eax, %ebp
leaq 0x2414c(%rip), %r15     # 0x27894
movswl (%r15), %edi
leaq 0x595c(%rip), %rsi      # 0x90af
callq 0x3478
movswl %bp, %ebp
movl %ebp, %ecx
shrl %ecx
movswq %cx, %r14
shlq $0x4, %r14
leaq 0xaad2(%rip), %r12      # 0xe240
movw %ax, (%r12,%r14)
movswl %ax, %edi
callq 0x2f20
movq %rbx, %rdi
callq 0x37bd
movq 0x8(%r12,%r14), %rcx
movw %ax, (%rcx)
movswl %ax, %r14d
movl %r14d, %edi
callq 0x2f20
movswl (%r15), %r15d
movq %rbx, %rdi
callq 0x3360
movl %r15d, %edi
movl %eax, %esi
movl %r14d, %edx
movl %ebp, %ecx
callq 0x3158
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/afi-lambda[P]a_little_smalltalk/src/news.c
// Function: newSymbol
object newSymbol(const char *str)
{
    object newObj;

    /* first see if it is already there */
    newObj = globalKey(str);
    if (newObj)
        return newObj;

    /* not found, must make */
    newObj = allocStr(str);
    if (symbolClass == nilobj)
        symbolClass = globalSymbol("Symbol");
    setClass(newObj, symbolClass);
    nameTableInsert(symbols, strHash(str), newObj, nilobj);
    return newObj;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x3393
movl %eax, %ebx
testw %ax, %ax
jne 0x384b
movq %r14, %rdi
callq 0x2ebb
movl %eax, %ebx
cmpw $0x0, 0x2412d(%rip)     # 0x27912
jne 0x3804
leaq 0x240a6(%rip), %rax     # 0x27894
movswl (%rax), %edi
leaq 0x58b0(%rip), %rsi      # 0x90a8
callq 0x3478
movw %ax, 0x2410e(%rip)      # 0x27912
movswl 0x24107(%rip), %edi     # 0x27912
movswl %bx, %ebp
movl %ebp, %eax
shrl %eax
movswq %ax, %rax
shlq $0x4, %rax
leaq 0xaa1f(%rip), %rcx      # 0xe240
movw %di, (%rcx,%rax)
callq 0x2f20
leaq 0x24063(%rip), %rax     # 0x27894
movswl (%rax), %r15d
movq %r14, %rdi
callq 0x3360
movl %r15d, %edi
movl %eax, %esi
movl %ebp, %edx
xorl %ecx, %ecx
callq 0x3158
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/afi-lambda[P]a_little_smalltalk/src/news.c
// Function: copyFrom
object copyFrom(object obj, int start, int size)
{
    object newObj;
    int i;

    newObj = newArray(size);
    for (i = 1; i <= size; i++)
    {
        basicAtPut(newObj, i, basicAt(obj, start));
        start++;
    }
    return newObj;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r14d
movl %edi, %r15d
movl %edx, %edi
callq 0x35da
movl %eax, %ebx
testl %ebp, %ebp
jle 0x38d9
movswl %r15w, %eax
shrl %eax
movswq %ax, %rax
shlq $0x4, %rax
leaq 0xa9b3(%rip), %rcx      # 0xe240
leaq (%rcx,%rax), %r15
addq $0x8, %r15
movswl %bx, %eax
shrl %eax
movswq %ax, %rax
shlq $0x4, %rax
leaq (%rcx,%rax), %r12
addq $0x8, %r12
movslq %r14d, %rax
movl %ebp, %r14d
leaq -0x2(,%rax,2), %r13
xorl %ebp, %ebp
movq (%r15), %rax
addq %r13, %rax
movswl (%rax,%rbp,2), %edi
movq (%r12), %rax
movw %di, (%rax,%rbp,2)
callq 0x2f20
incq %rbp
cmpq %rbp, %r14
jne 0x38ba
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/afi-lambda[P]a_little_smalltalk/src/news.c
// Function: newContext
object newContext(int link, object method, object args, object temp)
{
    object newObj;

    newObj = allocObject(contextSize);
    setClass(newObj, globalSymbol("Context"));
    basicAtPut(newObj, linkPtrInContext, newInteger(link));
    basicAtPut(newObj, methodInContext, method);
    basicAtPut(newObj, argumentsInContext, args);
    basicAtPut(newObj, temporariesInContext, temp);
    return newObj;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r15d
movl %edi, 0x4(%rsp)
movl $0x6, %edi
callq 0x2d15
movswl %ax, %r14d
leaq 0x23f7f(%rip), %rax     # 0x27894
movswl (%rax), %edi
leaq 0x59d7(%rip), %rsi      # 0x92f6
callq 0x3478
movl %r14d, %ecx
shrl %ecx
movswq %cx, %r13
shlq $0x4, %r13
leaq 0xa908(%rip), %r12      # 0xe240
movw %ax, (%r12,%r13)
movswl %ax, %edi
callq 0x2f20
movl 0x4(%rsp), %edi
callq 0x314c
movq 0x8(%r12,%r13), %rcx
movw %ax, (%rcx)
movswl %ax, %edi
callq 0x2f20
movq 0x8(%r12,%r13), %rax
movw %r15w, 0x2(%rax)
movl %r15d, %edi
callq 0x2f20
movq 0x8(%r12,%r13), %rax
movw %bp, 0x4(%rax)
movl %ebp, %edi
callq 0x2f20
movq 0x8(%r12,%r13), %rax
movw %bx, 0x6(%rax)
movl %ebx, %edi
callq 0x2f20
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/afi-lambda[P]a_little_smalltalk/src/news.c
// Function: newDictionary
object newDictionary(int size)
{
    object newObj;

    newObj = allocObject(1);
    setClass(newObj, globalSymbol("Dictionary"));
    basicAtPut(newObj, 1, newArray(size));
    return newObj;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebp
movl $0x1, %edi
callq 0x2d15
movswl %ax, %ebx
leaq 0x23ed5(%rip), %rax     # 0x27894
movswl (%rax), %edi
leaq 0x56fb(%rip), %rsi      # 0x90c4
callq 0x3478
movl %ebx, %ecx
shrl %ecx
movswq %cx, %r14
shlq $0x4, %r14
leaq 0xa85f(%rip), %r15      # 0xe240
movw %ax, (%r15,%r14)
movswl %ax, %edi
callq 0x2f20
movl %ebp, %edi
callq 0x35da
movq 0x8(%r15,%r14), %rcx
movw %ax, (%rcx)
movswl %ax, %edi
callq 0x2f20
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/afi-lambda[P]a_little_smalltalk/src/news.c
// Function: newFloat
object newFloat(double d)
{
    object newObj;

    newObj = allocByte((int) sizeof(double));
    ncopy(charPtr(newObj), (char *) &d, (int) sizeof(double));
    setClass(newObj, globalSymbol("Float"));
    return newObj;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movl $0x8, %edi
callq 0x2e89
leaq 0x23e64(%rip), %r14     # 0x27890
movw %ax, (%r14)
movswl %ax, %ebx
movl %ebx, %edi
callq 0x2f18
movswl (%r14), %eax
shrl %eax
movswq %ax, %rax
shlq $0x4, %rax
leaq 0xa7f1(%rip), %r14      # 0xe240
movq 0x8(%r14,%rax), %rax
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
leaq 0x23e30(%rip), %rax     # 0x27894
movswl (%rax), %edi
leaq 0x5890(%rip), %rsi      # 0x92fe
callq 0x3478
movl %ebx, %ecx
shrl %ecx
movswq %cx, %rcx
shlq $0x4, %rcx
movw %ax, (%r14,%rcx)
movswl %ax, %edi
callq 0x2f20
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/afi-lambda[P]a_little_smalltalk/src/news.c
// Function: newLink
object newLink(object key, object value)
{
    object newObj;

    newObj = allocObject(3);
    setClass(newObj, globalSymbol("Link"));
    basicAtPut(newObj, 1, key);
    basicAtPut(newObj, 2, value);
    return newObj;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movl %edi, %r14d
movl $0x3, %edi
callq 0x2d15
movswl %ax, %ebp
leaq 0x23dae(%rip), %rax     # 0x27894
movswl (%rax), %edi
leaq 0x55c5(%rip), %rsi      # 0x90b5
callq 0x3478
movl %ebp, %ecx
shrl %ecx
movswq %cx, %r15
shlq $0x4, %r15
leaq 0xa738(%rip), %r12      # 0xe240
movw %ax, (%r12,%r15)
movswl %ax, %edi
callq 0x2f20
movq 0x8(%r12,%r15), %rax
movw %r14w, (%rax)
movl %r14d, %edi
callq 0x2f20
movq 0x8(%r12,%r15), %rax
movw %bx, 0x2(%rax)
movl %ebx, %edi
callq 0x2f20
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/afi-lambda[P]a_little_smalltalk/src/news.c
// Function: newStString
object newStString(const char *value)
{
    object newObj;

    newObj = allocStr(value);
    if (stringClass == nilobj)
        stringClass = globalSymbol("String");
    setClass(newObj, stringClass);
    return (newObj);
}

// Assembly:
pushq %rbx
callq 0x2ebb
movl %eax, %ebx
cmpw $0x0, 0x23d78(%rip)     # 0x27910
jne 0x3bb7
leaq 0x23cf3(%rip), %rax     # 0x27894
movswl (%rax), %edi
leaq 0x56a3(%rip), %rsi      # 0x924e
callq 0x3478
movw %ax, 0x23d59(%rip)      # 0x27910
movswl 0x23d52(%rip), %edi     # 0x27910
movswl %bx, %eax
shrl %eax
movswq %ax, %rax
shlq $0x4, %rax
leaq 0xa66e(%rip), %rcx      # 0xe240
movw %di, (%rcx,%rax)
callq 0x2f20
movl %ebx, %eax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/afi-lambda[P]a_little_smalltalk/src/interp.c
// Function: findMethod
static boolean findMethod(object *methodClassLocation)
{
    object methodTable, methodClass;

    method = nilobj;
    methodClass = *methodClassLocation;

    for (; methodClass != nilobj; methodClass
            = basicAt(methodClass, superClassInClass))
    {
        methodTable = basicAt(methodClass, methodsInClass);
        method = hashEachElement(methodTable, messageToSend, messTest);
        if (method != nilobj)
            break;
    }

    if (method == nilobj)   /* it wasn't found */
    {
        methodClass = *methodClassLocation;
        return false;
    }

    *methodClassLocation = methodClass;
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movw $0x0, 0x2325e(%rip)     # 0x27fd0
movzwl (%rdi), %ebp
testw %bp, %bp
je 0x4dcd
leaq 0x94bf(%rip), %r15      # 0xe240
leaq 0x64(%rip), %r14        # 0x4dec
movswl %bp, %eax
shrl %eax
movswq %ax, %r12
shlq $0x4, %r12
movq 0x8(%r15,%r12), %rax
movswl 0x4(%rax), %edi
movswl 0x23231(%rip), %esi     # 0x27fd6
movq %r14, %rdx
callq 0x3294
movw %ax, 0x2321c(%rip)      # 0x27fd0
testw %ax, %ax
jne 0x4dcd
leaq (%r15,%r12), %rax
addq $0x8, %rax
movq (%rax), %rax
movzwl 0x6(%rax), %ebp
testw %bp, %bp
jne 0x4d88
cmpw $0x0, 0x231fb(%rip)     # 0x27fd0
je 0x4de1
movw %bp, (%rbx)
movl $0x1, %eax
jmp 0x4de3
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/afi-lambda[P]a_little_smalltalk/src/tty.c
// Function: sysPrimitive
object sysPrimitive(int number, object *arguments)
{
    object returnedObject;

    /* someday there will be more here */
    switch (number - 150)
    {
    case 0: /* do a system() call */
        returnedObject = newInteger(system(
                                        charPtr(arguments[0])));
        break;

    default:
        sysError("unknown primitive", "sysPrimitive");
    }
    return (returnedObject);
}

// Assembly:
pushq %rbx
cmpl $0x96, %edi
jne 0x4e62
movswl (%rsi), %edi
leaq 0x22a5c(%rip), %rbx     # 0x27890
movw %di, (%rbx)
callq 0x2f18
movswl (%rbx), %eax
shrl %eax
movswq %ax, %rax
shlq $0x4, %rax
leaq 0x93f0(%rip), %rcx      # 0xe240
movq 0x8(%rcx,%rax), %rdi
callq 0x20b0
movl %eax, %edi
popq %rbx
jmp 0x314c
callq 0x273f
nop
// File: /workspace/github_c_makefile_star2_O1/afi-lambda[P]a_little_smalltalk/src/filein.c
// Function: findClass
static object findClass(char *name)
{
    object newobj;

    newobj = globalSymbol(name);
    if (newobj == nilobj)
        newobj = newClass(name);
    if (basicAt(newobj, sizeInClass) == nilobj)
    {
        basicAtPut(newobj, sizeInClass, newInteger(0));
    }
    return newobj;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x217a5(%rip), %rax     # 0x27894
movswl (%rax), %edi
leaq 0x223d7(%rip), %rsi     # 0x284d0
callq 0x3478
movl %eax, %ebx
testw %ax, %ax
jne 0x6113
leaq 0x223c4(%rip), %rdi     # 0x284d0
callq 0x372a
movl %eax, %ebx
movswl %bx, %eax
shrl %eax
movswq %ax, %rax
shlq $0x4, %rax
leaq 0x8119(%rip), %rcx      # 0xe240
movq 0x8(%rcx,%rax), %rdx
cmpw $0x0, 0x2(%rdx)
jne 0x6151
leaq (%rcx,%rax), %r14
addq $0x8, %r14
xorl %edi, %edi
callq 0x314c
movq (%r14), %rcx
movw %ax, 0x2(%rcx)
movswl %ax, %edi
callq 0x2f20
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/afi-lambda[P]a_little_smalltalk/src/lex.c
// Function: nextChar
static char nextChar()
{
    if (pushindex > 0)
        cc = pushBuffer[--pushindex];
    else if (*cp)
        cc = *cp++;
    else
        cc = '\0';
    return (cc);
}

// Assembly:
movl 0x21a51(%rip), %eax     # 0x284b0
testl %eax, %eax
jle 0x6a77
decl %eax
movl %eax, 0x21a45(%rip)     # 0x284b0
leaq 0x21abe(%rip), %rcx     # 0x28530
movb (%rax,%rcx), %al
jmp 0x6a92
movq 0x21a3a(%rip), %rcx     # 0x284b8
movb (%rcx), %al
testb %al, %al
je 0x6a90
incq %rcx
movq %rcx, 0x21a2a(%rip)     # 0x284b8
jmp 0x6a92
xorl %eax, %eax
movb %al, 0x21a28(%rip)      # 0x284c0
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/afi-lambda[P]a_little_smalltalk/src/parser.c
// Function: setInstanceVariables
void setInstanceVariables(object aClass)
{
    int i, limit;
    object vars;

    if (aClass == nilobj)
        instanceTop = 0;
    else
    {
        setInstanceVariables(basicAt(aClass, superClassInClass));
        vars = basicAt(aClass, variablesInClass);
        if (vars != nilobj)
        {
            limit = sizeField(vars);
            for (i = 1; i <= limit; i++)
                instanceName[++instanceTop] = charPtr(basicAt(vars, i));
        }
    }
}

// Assembly:
testw %di, %di
je 0x6b5f
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movswl %di, %eax
shrl %eax
movswq %ax, %r14
shlq $0x4, %r14
leaq 0x777c(%rip), %rbx      # 0xe240
movq 0x8(%rbx,%r14), %rax
movswl 0x6(%rax), %edi
callq 0x6a9c
movq 0x8(%rbx,%r14), %rax
movzwl 0x8(%rax), %eax
testw %ax, %ax
je 0x6b50
cwtl
shrl %eax
movswq %ax, %r14
shlq $0x4, %r14
movzwl 0x4(%rbx,%r14), %r15d
testw %r15w, %r15w
jle 0x6b50
addq %rbx, %r14
xorl %r12d, %r12d
leaq 0x20d8c(%rip), %r13     # 0x27890
leaq 0x21a45(%rip), %rbp     # 0x28550
movq 0x8(%r14), %rax
movswl (%rax,%r12,2), %edi
movw %di, (%r13)
callq 0x2f18
movswl (%r13), %eax
shrl %eax
movswq %ax, %rax
shlq $0x4, %rax
movq 0x8(%rbx,%rax), %rax
movslq 0x21a07(%rip), %rcx     # 0x28540
leaq 0x1(%rcx), %rdx
movl %edx, 0x219fd(%rip)     # 0x28540
movq %rax, 0x8(%rbp,%rcx,8)
incq %r12
cmpq %r12, %r15
jne 0x6b0b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x0, 0x219d7(%rip)     # 0x28540
retq
// File: /workspace/github_c_makefile_star2_O1/afi-lambda[P]a_little_smalltalk/src/parser.c
// Function: genInstruction
static void genInstruction(int high, int low)
{
    if (low >= 16)
    {
        genInstruction(Extended, high);
        genCode(low);
    }
    else
        genCode(high * 16 + low);
}

// Assembly:
pushq %rbx
movl %esi, %ebx
movl %edi, %esi
cmpl $0x10, %ebx
jl 0x7108
xorl %edi, %edi
callq 0x70d3
movslq 0x21c6d(%rip), %rax     # 0x28d58
cmpq $0x100, %rax            # imm = 0x100
jge 0x7117
leal 0x1(%rax), %ecx
movl %ecx, 0x21c5c(%rip)     # 0x28d58
leaq 0x21c6d(%rip), %rcx     # 0x28d70
movb %bl, (%rax,%rcx)
jmp 0x714b
movslq 0x21c49(%rip), %rax     # 0x28d58
cmpq $0x100, %rax            # imm = 0x100
jl 0x7132
leaq 0x21d52(%rip), %rdi     # 0x28e70
leaq 0x29a6(%rip), %rsi      # 0x9acb
leaq 0x2589(%rip), %rdx      # 0x96b5
popq %rbx
jmp 0x26d7
shll $0x4, %esi
addl %ebx, %esi
leal 0x1(%rax), %ecx
movl %ecx, 0x21c18(%rip)     # 0x28d58
leaq 0x21c29(%rip), %rcx     # 0x28d70
movb %sil, (%rax,%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/afi-lambda[P]a_little_smalltalk/src/parser.c
// Function: genMessage
static void genMessage(boolean toSuper, int argumentCount, object messagesym)
{
    boolean sent = false;
    int i;

    if ((!toSuper) && (argumentCount == 0))
        for (i = 0; (!sent) && unSyms[i]; i++)
            if (messagesym == unSyms[i])
            {
                genInstruction(SendUnary, i);
                sent = true;
            }

    if ((!toSuper) && (argumentCount == 1))
        for (i = 0; (!sent) && binSyms[i]; i++)
            if (messagesym == binSyms[i])
            {
                genInstruction(SendBinary, i);
                sent = true;
            }

    if (!sent)
    {
        genInstruction(MarkArguments, 1 + argumentCount);
        if (toSuper)
        {
            genInstruction(DoSpecial, SendToSuper);
            genCode(genLiteral(messagesym));
        }
        else
            genInstruction(SendMessage, genLiteral(messagesym));
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %edi, %r14d
xorl %r12d, %r12d
movl %esi, %eax
orl %edi, %eax
movl $0x0, %r13d
jne 0x741a
movl %esi, (%rsp)
movl %r14d, 0x4(%rsp)
xorl %r13d, %r13d
leaq 0x204d3(%rip), %rbp     # 0x278b0
xorl %r15d, %r15d
movzwl (%rbp,%r15,2), %r14d
testw %r14w, %r14w
setne %r12b
je 0x7412
cmpw %bx, %r14w
jne 0x7403
movl $0xa, %edi
movl %r15d, %esi
callq 0x70d3
incq %r15
cmpw %bx, %r14w
jne 0x73e0
movl $0x1, %r13d
movl 0x4(%rsp), %r14d
movl (%rsp), %esi
movl %esi, %eax
xorl $0x1, %eax
orl %r14d, %eax
movl $0x1, %ebp
cmovnel %r13d, %ebp
jne 0x7476
testb %r12b, %r12b
jne 0x7476
movl %esi, (%rsp)
movl %r14d, %r13d
xorl %ebp, %ebp
leaq 0x2048f(%rip), %r12     # 0x278d0
xorl %r15d, %r15d
movzwl (%r12,%r15,2), %r14d
testw %r14w, %r14w
je 0x7470
cmpw %bx, %r14w
jne 0x7462
movl $0xb, %edi
movl %r15d, %esi
callq 0x70d3
incq %r15
cmpw %bx, %r14w
jne 0x7444
movl $0x1, %ebp
movl %r13d, %r14d
movl (%rsp), %esi
testl %ebp, %ebp
je 0x7489
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
incl %esi
movl $0x8, %edi
callq 0x70d3
testl %r14d, %r14d
je 0x74c5
movslq 0x218b7(%rip), %rax     # 0x28d58
cmpq $0x100, %rax            # imm = 0x100
jl 0x74e7
leaq 0x219c0(%rip), %rdi     # 0x28e70
leaq 0x2614(%rip), %rsi      # 0x9acb
leaq 0x21f7(%rip), %rdx      # 0x96b5
callq 0x26d7
jmp 0x74fb
movswl %bx, %edi
callq 0x7a4b
movl $0x9, %edi
movl %eax, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x70d3
leal 0x1(%rax), %ecx
movl %ecx, 0x21868(%rip)     # 0x28d58
leaq 0x21879(%rip), %rcx     # 0x28d70
movb $-0x5, (%rax,%rcx)
movswl %bx, %edi
callq 0x7a4b
movslq 0x2184e(%rip), %rcx     # 0x28d58
cmpq $0x100, %rcx            # imm = 0x100
jl 0x753b
leaq 0x21956(%rip), %rdi     # 0x28e70
leaq 0x25aa(%rip), %rsi      # 0x9acb
leaq 0x218d(%rip), %rdx      # 0x96b5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x26d7
leal 0x1(%rcx), %edx
movl %edx, 0x21814(%rip)     # 0x28d58
leaq 0x21825(%rip), %rdx     # 0x28d70
movb %al, (%rcx,%rdx)
jmp 0x747a
// File: /workspace/github_c_makefile_star2_O1/afi-lambda[P]a_little_smalltalk/src/parser.c
// Function: expression
static void expression()
{
    boolean superTerm;
    char assignname[60];

    if (token == nameconst)   /* possible assignment */
    {
        strcpy(assignname, tokenString);
        nextToken();
        if ((token == binary) && streq(tokenString, "<-"))
        {
            nextToken();
            assignment(assignname);
        }
        else     /* not an assignment after all */
        {
            superTerm = nameTerm(assignname);
            continuation(superTerm);
        }
    }
    else
    {
        superTerm = term();
        if (parseok)
            continuation(superTerm);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
leaq 0x20fbc(%rip), %rbx     # 0x28520
cmpl $0x1, (%rbx)
jne 0x75ad
leaq 0x20f60(%rip), %rsi     # 0x284d0
movq %rsp, %rdi
callq 0x2050
callq 0x6172
cmpl $0x9, (%rbx)
jne 0x7599
leaq 0x20f47(%rip), %rdi     # 0x284d0
leaq 0x2483(%rip), %rsi      # 0x9a13
callq 0x2160
testl %eax, %eax
je 0x75d0
movq %rsp, %rdi
callq 0x771d
movl %eax, %edi
callq 0x7950
jmp 0x7712
callq 0x80af
cmpl $0x0, 0x21797(%rip)     # 0x28d50
je 0x7712
movl %eax, %edi
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7950
callq 0x6172
movslq 0x21784(%rip), %r14     # 0x28d60
testq %r14, %r14
jle 0x762f
leaq 0x222d8(%rip), %rax     # 0x298c0
leaq (%rax,%r14,8), %r15
xorl %ebp, %ebp
movq %rsp, %rbx
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x2160
testl %eax, %eax
jne 0x7618
callq 0x7553
leal -0x1(%r14), %esi
movl $0x7, %edi
callq 0x70d3
movl $0x1, %ebp
testl %ebp, %ebp
jne 0x7631
leaq -0x1(%r14), %rax
addq $-0x8, %r15
cmpq $0x1, %r14
movq %rax, %r14
jg 0x75f1
jmp 0x7631
xorl %ebp, %ebp
testl %ebp, %ebp
sete %al
jne 0x7693
cmpl $0x0, 0x20f01(%rip)     # 0x28540
jle 0x7693
movl $0x1, %r15d
leaq 0x20f02(%rip), %r14     # 0x28550
movq %rsp, %rbx
movq (%r14,%r15,8), %rsi
movq %rbx, %rdi
callq 0x2160
testl %eax, %eax
jne 0x7679
callq 0x7553
leal -0x1(%r15), %esi
movl $0x6, %edi
callq 0x70d3
movl $0x1, %ebp
testl %ebp, %ebp
sete %al
jne 0x7693
leaq 0x1(%r15), %rcx
movslq 0x20eb5(%rip), %rdx     # 0x28540
cmpq %rdx, %r15
movq %rcx, %r15
jl 0x7651
testb %al, %al
je 0x7712
movslq 0x216ba(%rip), %rax     # 0x28d58
cmpq $0x100, %rax            # imm = 0x100
jl 0x76c2
leaq 0x217c3(%rip), %rdi     # 0x28e70
leaq 0x2417(%rip), %rsi      # 0x9acb
leaq 0x1ffa(%rip), %rdx      # 0x96b5
callq 0x26d7
jmp 0x76d6
leal 0x1(%rax), %ecx
movl %ecx, 0x2168d(%rip)     # 0x28d58
leaq 0x2169e(%rip), %rcx     # 0x28d70
movb $0x20, (%rax,%rcx)
movq %rsp, %rdi
callq 0x37bd
movswl %ax, %edi
callq 0x7a4b
movl $0x4, %edi
movl %eax, %esi
callq 0x70d3
callq 0x7553
leaq 0x2318(%rip), %rdi      # 0x9a16
callq 0x37bd
movswl %ax, %edx
xorl %edi, %edi
movl $0x2, %esi
callq 0x73ac
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/afi-lambda[P]a_little_smalltalk/src/parser.c
// Function: continuation
static void continuation(boolean superReceiver)
{
    superReceiver = keyContinuation(superReceiver);

    while (parseok && (token == closing) && streq(tokenString, ";"))
    {
        genInstruction(DoSpecial, Duplicate);
        nextToken();
        keyContinuation(superReceiver);
        genInstruction(DoSpecial, PopTop);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x7a9f
cmpl $0x0, 0x213e9(%rip)     # 0x28d50
je 0x7a3c
movl %eax, %ebx
leaq 0x20baa(%rip), %rax     # 0x28520
cmpl $0xa, (%rax)
jne 0x7a3c
leaq 0x20b4a(%rip), %r14     # 0x284d0
leaq 0x20d5(%rip), %r15      # 0x9a62
leaq 0x2137(%rip), %r13      # 0x9acb
leaq 0x1d1a(%rip), %rbp      # 0x96b5
leaq 0x213ce(%rip), %r12     # 0x28d70
movq %r14, %rdi
movq %r15, %rsi
callq 0x2160
testl %eax, %eax
jne 0x7a3c
movslq 0x2139c(%rip), %rax     # 0x28d58
cmpq $0x100, %rax            # imm = 0x100
jl 0x79d8
leaq 0x214a5(%rip), %rdi     # 0x28e70
movq %r13, %rsi
movq %rbp, %rdx
callq 0x26d7
jmp 0x79e6
leal 0x1(%rax), %ecx
movl %ecx, 0x21377(%rip)     # 0x28d58
movb $-0xc, (%rax,%r12)
callq 0x6172
movl %ebx, %edi
callq 0x7a9f
movslq 0x2135f(%rip), %rax     # 0x28d58
cmpq $0x100, %rax            # imm = 0x100
jl 0x7a15
leaq 0x21468(%rip), %rdi     # 0x28e70
movq %r13, %rsi
movq %rbp, %rdx
callq 0x26d7
jmp 0x7a23
leal 0x1(%rax), %ecx
movl %ecx, 0x2133a(%rip)     # 0x28d58
movb $-0xb, (%rax,%r12)
cmpl $0x0, 0x21326(%rip)     # 0x28d50
je 0x7a3c
leaq 0x20aed(%rip), %rax     # 0x28520
cmpl $0xa, (%rax)
je 0x79a2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/afi-lambda[P]a_little_smalltalk/src/parser.c
// Function: genLiteral
static int genLiteral(object aLiteral)
{
    if (literalTop >= literalLimit)
        compilError(selector, "too many literals in method", "");
    else
    {
        literalArray[++literalTop] = aLiteral;
        incr(aLiteral);
    }
    return (literalTop - 1);
}

// Assembly:
pushq %rax
movslq 0x21311(%rip), %rax     # 0x28d64
cmpq $0x100, %rax            # imm = 0x100
jl 0x7a77
leaq 0x2140e(%rip), %rdi     # 0x28e70
leaq 0x1fbb(%rip), %rsi      # 0x9a24
leaq 0x1c45(%rip), %rdx      # 0x96b5
callq 0x26d7
jmp 0x7a95
leaq 0x1(%rax), %rcx
movl %ecx, 0x212e3(%rip)     # 0x28d64
leaq 0x21438(%rip), %rcx     # 0x28ec0
movw %di, 0x2(%rcx,%rax,2)
movswl %di, %edi
callq 0x2f20
movl 0x212c9(%rip), %eax     # 0x28d64
decl %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/afi-lambda[P]a_little_smalltalk/src/parser.c
// Function: binaryContinuation
static boolean binaryContinuation(boolean superReceiver)
{
    boolean superTerm;
    object messagesym;

    superReceiver = unaryContinuation(superReceiver);
    while (parseok && (token == binary))
    {
        messagesym = newSymbol(tokenString);
        nextToken();
        superTerm = term();
        unaryContinuation(superTerm);
        genMessage(superReceiver, 1, messagesym);
        superReceiver = false;
    }
    return (superReceiver);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
callq 0x7f98
movl %eax, %ebx
cmpl $0x0, 0x20f67(%rip)     # 0x28d50
je 0x7e3a
leaq 0x2072e(%rip), %r15     # 0x28520
cmpl $0x9, (%r15)
jne 0x7e3a
leaq 0x206d1(%rip), %r14     # 0x284d0
movq %r14, %rdi
callq 0x37bd
movl %eax, %ebp
callq 0x6172
callq 0x80af
movl %eax, %edi
callq 0x7f98
movswl %bp, %edx
movl %ebx, %edi
movl $0x1, %esi
callq 0x73ac
xorl %ebx, %ebx
cmpl $0x0, 0x20f1e(%rip)     # 0x28d50
je 0x7e3a
cmpl $0x9, (%r15)
je 0x7dff
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/afi-lambda[P]a_little_smalltalk/src/parser.c
// Function: optimizeBlock
static int optimizeBlock(int instruction, boolean dopop)
{
    int location;
    enum blockstatus savebstat;

    savebstat = blockstat;
    genInstruction(DoSpecial, instruction);
    location = codeTop;
    genCode(0);
    if (dopop)
        genInstruction(DoSpecial, PopTop);
    nextToken();
    if (streq(tokenString, "["))
    {
        nextToken();
        if (blockstat == NotInBlock)
            blockstat = OptimizedBlock;
        body();
        if (!streq(tokenString, "]"))
            compilError(selector, "missing close", "after block");
        nextToken();
    }
    else
    {
        binaryContinuation(term());
        genMessage(false, 0, newSymbol("value"));
    }
    codeArray[location] = codeTop + 1;
    blockstat = savebstat;
    return (location);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movl %edi, %esi
movl 0x20efe(%rip), %r14d    # 0x28d54
movl $0xf, %edi
callq 0x70d3
movslq 0x20ef1(%rip), %rbx     # 0x28d58
cmpq $0x100, %rbx            # imm = 0x100
jl 0x7e8c
leaq 0x20ff9(%rip), %rdi     # 0x28e70
leaq 0x1c4d(%rip), %rsi      # 0x9acb
leaq 0x1830(%rip), %rdx      # 0x96b5
callq 0x26d7
jmp 0x7ea0
leal 0x1(%rbx), %eax
movl %eax, 0x20ec3(%rip)     # 0x28d58
leaq 0x20ed4(%rip), %rax     # 0x28d70
movb $0x0, (%rbx,%rax)
testl %ebp, %ebp
je 0x7ee3
movslq 0x20ead(%rip), %rax     # 0x28d58
cmpq $0x100, %rax            # imm = 0x100
jl 0x7ecf
leaq 0x20fb6(%rip), %rdi     # 0x28e70
leaq 0x1c0a(%rip), %rsi      # 0x9acb
leaq 0x17ed(%rip), %rdx      # 0x96b5
callq 0x26d7
jmp 0x7ee3
leal 0x1(%rax), %ecx
movl %ecx, 0x20e80(%rip)     # 0x28d58
leaq 0x20e91(%rip), %rcx     # 0x28d70
movb $-0xb, (%rax,%rcx)
callq 0x6172
leaq 0x205e1(%rip), %rdi     # 0x284d0
leaq 0x1bb9(%rip), %rsi      # 0x9aaf
callq 0x2160
testl %eax, %eax
je 0x7f25
callq 0x80af
movl %eax, %edi
callq 0x7dd4
leaq 0x1312(%rip), %rdi      # 0x9224
callq 0x37bd
movswl %ax, %edx
xorl %edi, %edi
xorl %esi, %esi
callq 0x73ac
jmp 0x7f78
callq 0x6172
cmpl $0x0, 0x20e23(%rip)     # 0x28d54
jne 0x7f3d
movl $0x2, 0x20e17(%rip)     # 0x28d54
callq 0x714d
leaq 0x20587(%rip), %rdi     # 0x284d0
leaq 0x1cce(%rip), %rsi      # 0x9c1e
callq 0x2160
testl %eax, %eax
je 0x7f73
leaq 0x20f10(%rip), %rdi     # 0x28e70
leaq 0x1b4a(%rip), %rsi      # 0x9ab1
leaq 0x1b51(%rip), %rdx      # 0x9abf
callq 0x26d7
callq 0x6172
movb 0x20dda(%rip), %al      # 0x28d58
incb %al
leaq 0x20de9(%rip), %rcx     # 0x28d70
movb %al, (%rbx,%rcx)
movl %r14d, 0x20dc3(%rip)    # 0x28d54
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/afi-lambda[P]a_little_smalltalk/src/parser.c
// Function: unaryContinuation
static boolean unaryContinuation(boolean superReceiver)
{
    int i;
    boolean sent;

    while (parseok && (token == nameconst))
    {
        /* first check to see if it could be a temp by mistake */
        for (i = 1; i < temporaryTop; i++)
            if (streq(tokenString, temporaryName[i]))
                compilWarn(selector, "message same as temporary:", tokenString);
        for (i = 1; i < argumentTop; i++)
            if (streq(tokenString, argumentName[i]))
                compilWarn(selector, "message same as argument:", tokenString);
        /* the next generates too many spurious messages */
        /* for (i=1; i < instanceTop; i++)
         if (streq(tokenString, instanceName[i]))
         compilWarn(selector,"message same as instance",
         tokenString); */

        sent = false;

        if (!sent)
        {
            genMessage(superReceiver, 0, newSymbol(tokenString));
        }
        /* once a message is sent to super, reciever is not super */
        superReceiver = false;
        nextToken();
    }
    return (superReceiver);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebp
cmpl $0x0, 0x20da4(%rip)     # 0x28d50
je 0x809a
leaq 0x20567(%rip), %rax     # 0x28520
cmpl $0x1, (%rax)
jne 0x809a
leaq 0x218f7(%rip), %r15     # 0x298c0
leaq 0x20500(%rip), %rbx     # 0x284d0
leaq 0x20e99(%rip), %r14     # 0x28e70
leaq 0x210e2(%rip), %r12     # 0x290c0
cmpl $0x2, 0x20d7b(%rip)     # 0x28d60
jl 0x801e
movl $0x1, %r13d
movq (%r15,%r13,8), %rsi
movq %rbx, %rdi
callq 0x2160
testl %eax, %eax
jne 0x800f
movq %r14, %rdi
leaq 0x1a73(%rip), %rsi      # 0x9a7a
movq %rbx, %rdx
callq 0x26b6
incq %r13
movslq 0x20d47(%rip), %rax     # 0x28d60
cmpq %rax, %r13
jl 0x7fed
cmpl $0x2, 0x20d37(%rip)     # 0x28d5c
jl 0x805e
movl $0x1, %r13d
movq (%r12,%r13,8), %rsi
movq %rbx, %rdi
callq 0x2160
testl %eax, %eax
jne 0x804f
movq %r14, %rdi
leaq 0x1a4e(%rip), %rsi      # 0x9a95
movq %rbx, %rdx
callq 0x26b6
incq %r13
movslq 0x20d03(%rip), %rax     # 0x28d5c
cmpq %rax, %r13
jl 0x802d
movq %rbx, %rdi
callq 0x37bd
movswl %ax, %edx
xorl %r13d, %r13d
movl %ebp, %edi
xorl %esi, %esi
callq 0x73ac
callq 0x6172
cmpl $0x0, 0x20ccf(%rip)     # 0x28d50
je 0x809d
leaq 0x20496(%rip), %rax     # 0x28520
cmpl $0x1, (%rax)
movl $0x0, %ebp
je 0x7fde
jmp 0x809d
movl %ebp, %r13d
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/afi-lambda[P]a_little_smalltalk/src/parser.c
// Function: genInteger
static void genInteger(int val)
{
    if (val == -1)
        genInstruction(PushConstant, minusOne);
    else if ((val >= 0) && (val <= 2))
        genInstruction(PushConstant, val);
    else
        genInstruction(PushLiteral, genLiteral(newInteger(val)));
}

// Assembly:
cmpl $-0x1, %edi
je 0x83ac
movl %edi, %esi
cmpl $0x2, %edi
ja 0x83d5
movl $0x5, %edi
jmp 0x70d3
movslq 0x209a5(%rip), %rax     # 0x28d58
cmpq $0x100, %rax            # imm = 0x100
jl 0x83f2
leaq 0x20aae(%rip), %rdi     # 0x28e70
leaq 0x1702(%rip), %rsi      # 0x9acb
leaq 0x12e5(%rip), %rdx      # 0x96b5
jmp 0x26d7
pushq %rax
movl %esi, %edi
callq 0x314c
movswl %ax, %edi
callq 0x7a4b
movl $0x4, %edi
movl %eax, %esi
popq %rax
jmp 0x70d3
leal 0x1(%rax), %ecx
movl %ecx, 0x2095d(%rip)     # 0x28d58
leaq 0x2096e(%rip), %rcx     # 0x28d70
movb $0x53, (%rax,%rcx)
retq