LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity_fixture.c
// Function: unity_realloc
void* unity_realloc(void* oldMem, size_t size)
{
    Guard* guard = (Guard*)oldMem;
    void* newMem;

    if (oldMem == NULL) return unity_malloc(size);

    guard--;
    if (isOverrun(oldMem))
    {
        release_memory(oldMem);
        UNITY_TEST_FAIL(Unity.CurrentTestLineNumber, "Buffer overrun detected during realloc()");
    }

    if (size == 0)
    {
        release_memory(oldMem);
        return NULL;
    }

    if (guard->size >= size) return oldMem;

#ifdef UNITY_EXCLUDE_STDLIB_MALLOC /* Optimization if memory is expandable */
    if (oldMem == unity_heap + heap_index - guard->size - sizeof(end) &&
        heap_index + size - guard->size <= UNITY_INTERNAL_HEAP_SIZE_BYTES)
    {
        release_memory(oldMem);    /* Not thread-safe, like unity_heap generally */
        return unity_malloc(size); /* No memcpy since data is in place */
    }
#endif
    newMem = unity_malloc(size);
    if (newMem == NULL) return NULL; /* Do not release old memory */
    memcpy(newMem, oldMem, guard->size);
    release_memory(oldMem);
    return newMem;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
testq %rdi, %rdi
je 0x5515
movq %rdi, %rbx
callq 0x5449
testl %eax, %eax
je 0x54de
movq %rbx, %rdi
callq 0x5473
leaq 0x6972(%rip), %rax      # 0xbe40
movq 0x20(%rax), %rsi
leaq 0x2076(%rip), %rdi      # 0x754f
callq 0x4d7c
testq %r14, %r14
je 0x5524
cmpq %r14, -0x10(%rbx)
jae 0x552e
movq %r14, %rdi
callq 0x53b6
testq %rax, %rax
je 0x552c
movq %rax, %r14
movq -0x10(%rbx), %rdx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x5473
movq %r14, %rbx
jmp 0x552e
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x53b6
movq %rbx, %rdi
callq 0x5473
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity_fixture.c
// Function: UnityPointer_Set
void UnityPointer_Set(void** pointer, void* newValue, UNITY_LINE_TYPE line)
{
    if (pointer_index >= UNITY_MAX_POINTERS)
    {
        UNITY_TEST_FAIL(line, "Too many pointers set");
    }
    else
    {
        pointer_store[pointer_index].pointer = pointer;
        pointer_store[pointer_index].old_value = *pointer;
        *pointer = newValue;
        pointer_index++;
    }
}

// Assembly:
movslq 0x6a3c(%rip), %rax      # 0xbf7c
cmpq $0x5, %rax
jl 0x5555
leaq 0x202b(%rip), %rdi      # 0x7578
movq %rdx, %rsi
jmp 0x4d7c
movq %rax, %rcx
shlq $0x4, %rcx
leaq 0x6a1d(%rip), %rdx      # 0xbf80
movq %rdi, (%rcx,%rdx)
movq (%rdi), %r8
movq %r8, 0x8(%rcx,%rdx)
movq %rsi, (%rdi)
incl %eax
movl %eax, 0x6a02(%rip)      # 0xbf7c
retq
// File: /workspace/github_c_makefile_star2_O2/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/tests.c
// Function: Tests_Run
void Tests_Run() {
  zf_log_set_output_level(ZF_LOG_DEBUG);
  RUN_TEST_GROUP(controls);
  RUN_TEST_GROUP(utility);
  RUN_TEST_GROUP(input);
  RUN_TEST_GROUP(errors);
}

// Assembly:
pushq %rax
pushq $0x2
popq %rdi
callq 0x2cb4
callq 0x5652
callq 0x58c2
callq 0x578b
popq %rax
jmp 0x56ba
nop
// File: /workspace/github_c_makefile_star2_O2/afi-lambda[P]a_little_smalltalk/src/st.c
// Function: goDoIt
static void goDoIt(const char *text)
{
    object process, stack, method;

    method = newMethod();
    incr(method);
    setInstanceVariables(nilobj);
    parse(method, text, false);

    process = allocObject(processSize);
    incr(process);
    stack = allocObject(50);
    incr(stack);

    /* make a process */
    basicAtPut(process, stackInProcess, stack);
    basicAtPut(process, stackTopInProcess, newInteger(10));
    basicAtPut(process, linkPtrInProcess, newInteger(2));

    /* put argument on stack */
    basicAtPut(stack, 1, nilobj); /* argument */
    /* now make a linkage area in stack */
    basicAtPut(stack, 2, nilobj); /* previous link */
    basicAtPut(stack, 3, nilobj); /* context object (nil = stack) */
    basicAtPut(stack, 4, newInteger(1)); /* return point */
    basicAtPut(stack, 5, method); /* method */
    basicAtPut(stack, 6, newInteger(1)); /* byte offset */

    /* now go execute it */
    while (execute(process, 15000))
        fprintf(stderr, "..");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %eax, %eax
callq 0x3707
movswl %ax, %ebp
movl %ebp, %edi
callq 0x2b30
xorl %edi, %edi
callq 0x63d4
movl %ebp, %edi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x649e
pushq $0x3
popq %rdi
callq 0x2964
movswl %ax, %ebx
movl %ebx, %edi
callq 0x2b30
pushq $0x32
popq %rdi
callq 0x2964
movswl %ax, %r14d
movl %r14d, %edi
callq 0x2b30
movl %ebx, %eax
shrl %eax
movswq %ax, %r12
shlq $0x4, %r12
leaq 0xbb0a(%rip), %r15      # 0xe230
movq 0x8(%r15,%r12), %rax
movw %r14w, (%rax)
movl %r14d, %edi
callq 0x2b30
pushq $0xa
popq %rdi
callq 0x2d9b
movq 0x8(%r15,%r12), %rcx
movw %ax, 0x2(%rcx)
movswl %ax, %edi
callq 0x2b30
pushq $0x2
popq %rdi
callq 0x2d9b
movq 0x8(%r15,%r12), %rcx
movw %ax, 0x4(%rcx)
movswl %ax, %edi
callq 0x2b30
shrl %r14d
movswq %r14w, %r12
shlq $0x4, %r12
movq 0x8(%r15,%r12), %rax
andw $0x0, (%rax)
xorl %edi, %edi
callq 0x2b30
movq 0x8(%r15,%r12), %rax
andw $0x0, 0x2(%rax)
xorl %edi, %edi
callq 0x2b30
movq 0x8(%r15,%r12), %rax
andw $0x0, 0x4(%rax)
xorl %edi, %edi
callq 0x2b30
pushq $0x1
popq %r14
movl %r14d, %edi
callq 0x2d9b
movq 0x8(%r15,%r12), %rcx
movw %ax, 0x6(%rcx)
movswl %ax, %edi
callq 0x2b30
movq 0x8(%r15,%r12), %rax
movw %bp, 0x8(%rax)
movl %ebp, %edi
callq 0x2b30
movl %r14d, %edi
callq 0x2d9b
movq 0x8(%r15,%r12), %rcx
movw %ax, 0xa(%rcx)
movswl %ax, %edi
callq 0x2b30
movq 0xa7fd(%rip), %r13      # 0xcff0
leaq 0x68ab(%rip), %r14      # 0x90a5
pushq $0x2
popq %r15
pushq $0x1
popq %r12
movl %ebx, %edi
movl $0x3a98, %esi           # imm = 0x3A98
callq 0x37be
testl %eax, %eax
je 0x2826
movq (%r13), %rcx
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x21f0
jmp 0x2802
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/afi-lambda[P]a_little_smalltalk/src/memory.c
// Function: setFreeLists
void setFreeLists()
{
    int i, size;
    register int z;
    register struct objectStruct *p;

    objectFreeList[0] = nilobj;

    for (z = ObjectTableMax - 1; z > 0; z--)
    {
        if (objectTable[z].referenceCount == 0)
        {
            /* Unreferenced, so do a sort of sysDecr: */
            p = &objectTable[z];
            size = p->size;
            if (size < 0)
                size = ((-size) + 1) / 2;
            p->STclass = objectFreeList[size];
            objectFreeList[size] = z;
            for (i = size; i > 0;)
                p->memory[--i] = nilobj;
        }
    }
}

// Assembly:
andw $0x0, 0xa9fb(%rip)      # 0xd290
movl $0x1963, %eax           # imm = 0x1963
leaq 0xb98f(%rip), %rcx      # 0xe230
pushq $0x1
popq %rdx
leaq 0xa9e5(%rip), %rsi      # 0xd290
movq %rax, %r8
subq $0x1, %rax
jb 0x28fe
movq %r8, %rdi
shlq $0x4, %rdi
cmpw $0x0, 0x2(%rdi,%rcx)
jne 0x28ab
addq %rcx, %rdi
movswl 0x4(%rdi), %r10d
movl %edx, %r9d
subl %r10d, %r9d
shrl %r9d
testl %r10d, %r10d
cmovnsl %r10d, %r9d
movzwl (%rsi,%r9,2), %r10d
movw %r10w, (%rdi)
movw %r8w, (%rsi,%r9,2)
testl %r9d, %r9d
jle 0x28ab
movq 0x8(%rdi), %r8
andw $0x0, -0x2(%r8,%r9,2)
decq %r9
jmp 0x28e9
retq
// File: /workspace/github_c_makefile_star2_O2/afi-lambda[P]a_little_smalltalk/src/memory.c
// Function: mBlockAlloc
object *mBlockAlloc(int memorySize)
{
    object *objptr;

    if (currentMemoryPosition + memorySize >= MemoryBlockSize)
    {

        /* we toss away space here.  Space-Frugal users may want to
         fix this by making a new object of size
         MemoryBlockSize - currentMemoryPositon - 1
         and putting it on the free list, but I think
         the savings is potentially small */

        memoryBlock = (object *) calloc((unsigned) MemoryBlockSize,
                                        sizeof(object));
        if (!memoryBlock)
            sysError("out of memory", "malloc failed");
        currentMemoryPosition = 0;
    }
    objptr = (object *) &memoryBlock[currentMemoryPosition];
    currentMemoryPosition += memorySize;
    return (objptr);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movl 0x24f64(%rip), %r14d    # 0x27870
leal (%r14,%rbx), %eax
cmpl $0x1770, %eax           # imm = 0x1770
jl 0x2946
pushq $0x2
popq %rsi
movl $0x1770, %edi           # imm = 0x1770
callq 0x2140
movq %rax, 0x24f4d(%rip)     # 0x27878
xorl %r14d, %r14d
testq %rax, %rax
jne 0x2946
leaq 0x67e0(%rip), %rdi      # 0x911a
leaq 0x67e7(%rip), %rsi      # 0x9128
callq 0x4938
movslq %r14d, %rcx
leaq (%rcx,%rcx), %rax
addq 0x24f24(%rip), %rax     # 0x27878
addl %ebx, %ecx
movl %ecx, 0x24f14(%rip)     # 0x27870
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb688(%rip), %rcx      # 0xe230
leaq (%rcx,%rax), %rbx
cmpw $0x0, 0x2(%rax,%rcx)
js 0x2c2d
movswl (%rbx), %edi
callq 0x2b55
movswl 0x4(%rbx), %eax
pushq $0x1
popq %r14
subl %eax, %r14d
shrl %r14d
testl %eax, %eax
cmovnsl %eax, %r14d
leaq 0xa6b9(%rip), %rcx      # 0xd290
movzwl (%rcx,%r14,2), %edx
movw %dx, (%rbx)
movw %bp, (%rcx,%r14,2)
testl %r14d, %r14d
jle 0x2c1d
testw %ax, %ax
jle 0x2c07
movq %r14, %r15
subq $0x1, %r15
jb 0x2c07
movq 0x8(%rbx), %rax
movswl (%rax,%r15,2), %edi
callq 0x2b55
jmp 0x2bf1
movq %r14, %rax
testl %eax, %eax
jle 0x2c1d
movq 0x8(%rbx), %rcx
andw $0x0, -0x2(%rcx,%rax,2)
decq %rax
jmp 0x2c0a
movw %r14w, 0x4(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %edi, %edx
movq 0xa3ba(%rip), %rax      # 0xcff0
movq (%rax), %rdi
leaq 0x6538(%rip), %rsi      # 0x9178
xorl %eax, %eax
callq 0x2170
leaq 0x6535(%rip), %rdi      # 0x9183
leaq 0x6a64(%rip), %rsi      # 0x96b9
callq 0x4938
jmp 0x2bb4
// File: /workspace/github_c_makefile_star2_O2/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:
testw $0x8001, %di            # imm = 0x8001
je 0x2c79
leaq 0x652f(%rip), %rdi      # 0x919c
leaq 0x6539(%rip), %rsi      # 0x91ad
jmp 0x4938
movl %esi, %eax
movzwl %di, %ecx
shrl %ecx
testl %esi, %esi
jle 0x2cb9
movl %ecx, %r8d
shll $0x4, %r8d
leaq 0xb59e(%rip), %rsi      # 0xe230
movswl 0x4(%r8,%rsi), %r8d
addl %r8d, %r8d
negl %r8d
cmpl %eax, %r8d
jl 0x2cb9
movw %di, 0x24bd6(%rip)      # 0x27880
shll $0x4, %ecx
movq 0x8(%rcx,%rsi), %rcx
movl %eax, %eax
movb %dl, -0x1(%rcx,%rax)
retq
pushq %rax
movq 0xa32f(%rip), %rdx      # 0xcff0
movq (%rdx), %rdi
shll $0x4, %ecx
leaq 0xb562(%rip), %rdx      # 0xe230
movswl 0x4(%rcx,%rdx), %ecx
leaq 0x64dd(%rip), %rsi      # 0x91b7
movl %eax, %edx
xorl %eax, %eax
callq 0x2170
leaq 0x6f46(%rip), %rdi      # 0x9c30
leaq 0x64bc(%rip), %rsi      # 0x91ad
popq %rax
jmp 0x4938
// File: /workspace/github_c_makefile_star2_O2/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
testw $0x8001, %di            # imm = 0x8001
setne %cl
orb %al, %cl
jne 0x2d29
andl $0xfffe, %edi           # imm = 0xFFFE
leaq 0xb51a(%rip), %rax      # 0xe230
movzwl 0x2(%rax,%rdi,8), %ecx
movl %ecx, %edx
incl %edx
movw %dx, 0x2(%rax,%rdi,8)
testw %cx, %cx
je 0x2d2a
retq
pushq %r15
pushq %r14
pushq %rbx
leaq (%rax,%rdi,8), %r14
movswl (%r14), %edi
callq 0x2cf7
movzwl 0x4(%r14), %ebx
testw %bx, %bx
jle 0x2d61
movq 0x8(%r14), %r14
xorl %r15d, %r15d
cmpl %r15d, %ebx
je 0x2d61
movswl (%r14,%r15,2), %edi
callq 0x2cf7
incq %r15
jmp 0x2d4d
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/afi-lambda[P]a_little_smalltalk/src/memory.c
// Function: objectCount
int objectCount()
{
    register int i, j;
    j = 0;
    for (i = 0; i < ObjectTableMax; i++)
        if (objectTable[i].referenceCount > 0)
            j++;
    return j;
}

// Assembly:
xorl %eax, %eax
pushq $0x2
popq %rcx
leaq 0xb4bd(%rip), %rdx      # 0xe230
cmpq $0x19642, %rcx          # imm = 0x19642
je 0x2d8f
xorl %esi, %esi
cmpw $0x0, (%rcx,%rdx)
setg %sil
addl %esi, %eax
addq $0x10, %rcx
jmp 0x2d73
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb46c(%rip), %r12      # 0xe230
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 0x2e03
leaq 0x63e0(%rip), %rdi      # 0x91c9
leaq 0x63f0(%rip), %rsi      # 0x91e0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4938
movl %ecx, %ebx
movl %edx, %ebp
addq %r12, %r13
movw $0x3, %cx
xorl %edx, %edx
divw %cx
movzwl %ax, %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 0x2e67
movw %bp, (%rax,%r14,2)
movswl %bp, %edi
callq 0x2b30
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 0x2b30
movswl %bp, %edi
movswl %bx, %esi
callq 0x368d
movl %eax, %r15d
movswl %ax, %edi
movl %edi, 0x4(%rsp)
callq 0x2b30
movq 0x8(%r13), %rcx
movzwl 0x4(%rcx,%r14,2), %eax
testw %ax, %ax
je 0x2eb5
cwtl
shrl %eax
movswq %ax, %rax
shlq $0x4, %rax
movq 0x8(%r12,%rax), %rcx
cmpw %bp, (%rcx)
je 0x2ebd
movzwl 0x4(%rcx), %eax
testw %ax, %ax
jne 0x2e90
movw %r15w, 0x4(%rcx)
jmp 0x2ec4
movw %r15w, 0x4(%rcx,%r14,2)
jmp 0x2ec4
movw %bx, 0x2(%rcx)
movl %ebx, %r15d
movswl %r15w, %edi
callq 0x2b30
movl 0x4(%rsp), %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2b55
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
shrl %edi
movswq %di, %rax
shlq $0x4, %rax
leaq 0xb334(%rip), %r14      # 0xe230
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 0x2f3c
leaq 0x62d4(%rip), %rdi      # 0x91f5
leaq 0x62da(%rip), %rsi      # 0x9202
callq 0x4938
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %rbx
addq %r14, %rcx
movw $0x3, %di
xorl %edx, %edx
divw %di
movzwl %ax, %edi
movl %esi, %eax
cltd
idivl %edi
leal (%rdx,%rdx,2), %eax
movq 0x8(%rcx), %rcx
cltq
leaq (%rcx,%rax,2), %r15
movzwl (%r15), %eax
testw %ax, %ax
je 0x2f77
movzwl 0x2(%r15), %ebp
movswl %ax, %edi
callq *%rbx
testl %eax, %eax
jne 0x2f2f
movzwl 0x4(%r15), %eax
testw %ax, %ax
je 0x2f2d
cwtl
shrl %eax
movswq %ax, %rax
shlq $0x4, %rax
movq 0x8(%r14,%rax), %r15
jmp 0x2f60
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
movsbl (%rdi), %ecx
testl %ecx, %ecx
je 0x2fa3
addl %ecx, %eax
incq %rdi
jmp 0x2f95
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_O2/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 %rbx
andw $0x0, 0x248ce(%rip)     # 0x27890
movq %rdi, 0x248cf(%rip)     # 0x27898
leaq 0x248b4(%rip), %rax     # 0x27884
movswl (%rax), %ebx
callq 0x2f93
leaq 0x12(%rip), %rdx        # 0x2ff1
movl %ebx, %edi
movl %eax, %esi
callq 0x2ee4
movzwl 0x248a1(%rip), %eax     # 0x27890
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
leaq 0x247e7(%rip), %rbx     # 0x27884
movswl (%rbx), %edi
leaq 0x6040(%rip), %rsi      # 0x90e7
callq 0x306f
leaq 0x24f0f(%rip), %rcx     # 0x27fc2
movw %ax, (%rcx)
movswl (%rbx), %edi
leaq 0x602c(%rip), %rsi      # 0x90ec
callq 0x306f
leaq 0x24ef8(%rip), %rcx     # 0x27fc4
movw %ax, (%rcx)
leaq 0x247ca(%rip), %rbx     # 0x278a0
leaq 0xa053(%rip), %r14      # 0xd130
movq (%r14), %rdi
testq %rdi, %rdi
je 0x30f7
callq 0x3368
movw %ax, (%rbx)
addq $0x2, %rbx
addq $0x8, %r14
jmp 0x30dd
leaq 0x247c2(%rip), %rbx     # 0x278c0
leaq 0xa07b(%rip), %r14      # 0xd180
movq (%r14), %rdi
testq %rdi, %rdi
je 0x311f
callq 0x3368
movw %ax, (%rbx)
addq $0x2, %rbx
addq $0x8, %r14
jmp 0x3105
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x2b28
testl %eax, %eax
je 0x3173
movzwl 0x247ad(%rip), %eax     # 0x278fc
testw %ax, %ax
jne 0x318b
leaq 0x24729(%rip), %rax     # 0x27884
movswl (%rax), %edi
leaq 0x6180(%rip), %rsi      # 0x92e5
callq 0x306f
movw %ax, 0x2478b(%rip)      # 0x278fc
jmp 0x318b
movswl %bx, %eax
shrl %eax
movswq %ax, %rax
shlq $0x4, %rax
leaq 0xb0a9(%rip), %rcx      # 0xe230
movzwl (%rcx,%rax), %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2964
movl %eax, %ebx
movzwl 0x24762(%rip), %eax     # 0x278fe
testw %ax, %ax
jne 0x31be
leaq 0x246dc(%rip), %rax     # 0x27884
movswl (%rax), %edi
leaq 0x5f0c(%rip), %rsi      # 0x90be
callq 0x306f
movw %ax, 0x24740(%rip)      # 0x278fe
movswl %bx, %ecx
shrl %ecx
movswq %cx, %rcx
shlq $0x4, %rcx
leaq 0xb05e(%rip), %rdx      # 0xe230
movw %ax, (%rdx,%rcx)
movswl %ax, %edi
callq 0x2b30
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rdi
callq 0x2964
movswl %ax, %ebx
movl %ebp, %edi
callq 0x2d9b
movl %ebx, %ecx
shrl %ecx
movswq %cx, %r14
shlq $0x4, %r14
leaq 0xaf99(%rip), %r15      # 0xe230
movq 0x8(%r15,%r14), %rcx
movw %ax, (%rcx)
movswl %ax, %edi
callq 0x2b30
leaq 0x245d6(%rip), %rax     # 0x27884
movswl (%rax), %edi
leaq 0x603b(%rip), %rsi      # 0x92f3
callq 0x306f
movw %ax, (%r15,%r14)
movswl %ax, %edi
callq 0x2b30
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x5
popq %rdi
callq 0x2964
movl %eax, %ebp
leaq 0x24591(%rip), %r15     # 0x27884
movswl (%r15), %edi
leaq 0x5db1(%rip), %rsi      # 0x90af
callq 0x306f
movswl %bp, %ebp
movl %ebp, %ecx
shrl %ecx
movswq %cx, %r14
shlq $0x4, %r14
leaq 0xaf17(%rip), %r12      # 0xe230
movw %ax, (%r12,%r14)
movswl %ax, %edi
callq 0x2b30
movq %rbx, %rdi
callq 0x3368
movq 0x8(%r12,%r14), %rcx
movw %ax, (%rcx)
movswl %ax, %r14d
movl %r14d, %edi
callq 0x2b30
movswl (%r15), %r15d
movq %rbx, %rdi
callq 0x2f93
movl %r15d, %edi
movl %eax, %esi
movl %r14d, %edx
movl %ebp, %ecx
callq 0x2da8
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2fb9
movl %eax, %ebx
testw %ax, %ax
jne 0x33f4
movq %r14, %rdi
callq 0x2ae2
movl %eax, %ebx
movzwl 0x24573(%rip), %eax     # 0x27902
testw %ax, %ax
jne 0x33b1
leaq 0x244e9(%rip), %rax     # 0x27884
movswl (%rax), %edi
leaq 0x5d03(%rip), %rsi      # 0x90a8
callq 0x306f
movw %ax, 0x24551(%rip)      # 0x27902
movswl %bx, %ebp
movl %ebp, %ecx
shrl %ecx
movswq %cx, %rcx
shlq $0x4, %rcx
leaq 0xae69(%rip), %rdx      # 0xe230
movw %ax, (%rdx,%rcx)
movswl %ax, %edi
callq 0x2b30
leaq 0x244aa(%rip), %rax     # 0x27884
movswl (%rax), %r15d
movq %r14, %rdi
callq 0x2f93
movl %r15d, %edi
movl %eax, %esi
movl %ebp, %edx
xorl %ecx, %ecx
callq 0x2da8
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %ebx
movl %esi, %r14d
movl %edi, %r15d
movl %edx, %edi
callq 0x318d
movswl %ax, %ebp
shrl %r15d
movswq %r15w, %rax
shlq $0x4, %rax
leaq 0xae00(%rip), %rcx      # 0xe230
leaq (%rcx,%rax), %r15
addq $0x8, %r15
movl %ebp, %eax
shrl %eax
movswq %ax, %rax
shlq $0x4, %rax
leaq (%rcx,%rax), %r12
addq $0x8, %r12
movslq %r14d, %rax
xorl %r14d, %r14d
testl %ebx, %ebx
cmovlel %r14d, %ebx
leaq -0x2(,%rax,2), %r13
cmpq %r14, %rbx
je 0x3483
movq (%r15), %rax
addq %r13, %rax
movswl (%rax,%r14,2), %edi
movq (%r12), %rax
movw %di, (%rax,%r14,2)
callq 0x2b30
incq %r14
jmp 0x3460
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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)
pushq $0x6
popq %rdi
callq 0x2964
movswl %ax, %r14d
leaq 0x243c7(%rip), %rax     # 0x27884
movswl (%rax), %edi
leaq 0x5e31(%rip), %rsi      # 0x92f8
callq 0x306f
movl %r14d, %ecx
shrl %ecx
movswq %cx, %r13
shlq $0x4, %r13
leaq 0xad50(%rip), %r12      # 0xe230
movw %ax, (%r12,%r13)
movswl %ax, %edi
callq 0x2b30
movl 0x4(%rsp), %edi
callq 0x2d9b
movq 0x8(%r12,%r13), %rcx
movw %ax, (%rcx)
movswl %ax, %edi
callq 0x2b30
movq 0x8(%r12,%r13), %rax
movw %r15w, 0x2(%rax)
movl %r15d, %edi
callq 0x2b30
movq 0x8(%r12,%r13), %rax
movw %bp, 0x4(%rax)
movl %ebp, %edi
callq 0x2b30
movq 0x8(%r12,%r13), %rax
movw %bx, 0x6(%rax)
movl %ebx, %edi
callq 0x2b30
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_O2/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
pushq $0x1
popq %rdi
callq 0x2964
movswl %ax, %ebx
leaq 0x2431f(%rip), %rax     # 0x27884
movswl (%rax), %edi
leaq 0x5b55(%rip), %rsi      # 0x90c4
callq 0x306f
movl %ebx, %ecx
shrl %ecx
movswq %cx, %r14
shlq $0x4, %r14
leaq 0xaca9(%rip), %r15      # 0xe230
movw %ax, (%r15,%r14)
movswl %ax, %edi
callq 0x2b30
movl %ebp, %edi
callq 0x318d
movq 0x8(%r15,%r14), %rcx
movw %ax, (%rcx)
movswl %ax, %edi
callq 0x2b30
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsp, %r14
movsd %xmm0, (%r14)
pushq $0x8
popq %rbp
movl %ebp, %edi
callq 0x2ab2
leaq 0x242a8(%rip), %r15     # 0x27880
movw %ax, (%r15)
movswl %ax, %ebx
movl %ebx, %edi
callq 0x2b28
movswl (%r15), %eax
shrl %eax
movswq %ax, %rax
shlq $0x4, %rax
leaq 0xac35(%rip), %r15      # 0xe230
movq 0x8(%r15,%rax), %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x3128
leaq 0x24273(%rip), %rax     # 0x27884
movswl (%rax), %edi
leaq 0x5ce5(%rip), %rsi      # 0x9300
callq 0x306f
movl %ebx, %ecx
shrl %ecx
movswq %cx, %rcx
shlq $0x4, %rcx
movw %ax, (%r15,%rcx)
movswl %ax, %edi
callq 0x2b30
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x3
popq %rdi
callq 0x2964
movswl %ax, %ebp
leaq 0x241d8(%rip), %rax     # 0x27884
movswl (%rax), %edi
leaq 0x59ff(%rip), %rsi      # 0x90b5
callq 0x306f
movl %ebp, %ecx
shrl %ecx
movswq %cx, %r15
shlq $0x4, %r15
leaq 0xab62(%rip), %r12      # 0xe230
movw %ax, (%r12,%r15)
movswl %ax, %edi
callq 0x2b30
movq 0x8(%r12,%r15), %rax
movw %r14w, (%rax)
movl %r14d, %edi
callq 0x2b30
movq 0x8(%r12,%r15), %rax
movw %bx, 0x2(%rax)
movl %ebx, %edi
callq 0x2b30
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2ae2
movl %eax, %ebx
movzwl 0x241a5(%rip), %eax     # 0x27900
testw %ax, %ax
jne 0x377d
leaq 0x2411d(%rip), %rax     # 0x27884
movswl (%rax), %edi
leaq 0x5add(%rip), %rsi      # 0x924e
callq 0x306f
movw %ax, 0x24183(%rip)      # 0x27900
movswl %bx, %ecx
shrl %ecx
movswq %cx, %rcx
shlq $0x4, %rcx
leaq 0xaa9f(%rip), %rdx      # 0xe230
movw %ax, (%rdx,%rcx)
movswl %ax, %edi
callq 0x2b30
movl %ebx, %eax
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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
andw $0x0, 0x23709(%rip)     # 0x27fc0
movq %rdi, %rbx
leaq 0x996f(%rip), %r15      # 0xe230
leaq 0x60(%rip), %r14        # 0x4928
movq %rdi, %rax
movzwl (%rax), %ebp
testw %bp, %bp
je 0x4915
movswl %bp, %eax
shrl %eax
movswq %ax, %r12
shlq $0x4, %r12
movq 0x8(%r15,%r12), %rax
movswl 0x4(%rax), %edi
movswl 0x236d6(%rip), %esi     # 0x27fc6
movq %r14, %rdx
callq 0x2ee4
movw %ax, 0x236c1(%rip)      # 0x27fc0
testw %ax, %ax
jne 0x4919
leaq (%r15,%r12), %rax
addq $0x8, %rax
movq (%rax), %rax
addq $0x6, %rax
jmp 0x48cb
xorl %eax, %eax
jmp 0x491f
movw %bp, (%rbx)
pushq $0x1
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4a45
movswl (%rsi), %edi
leaq 0x22e69(%rip), %rbx     # 0x27880
movw %di, (%rbx)
callq 0x2b28
movswl (%rbx), %eax
shrl %eax
movswq %ax, %rax
shlq $0x4, %rax
leaq 0x97fd(%rip), %rcx      # 0xe230
movq 0x8(%rcx,%rax), %rdi
callq 0x20b0
movl %eax, %edi
popq %rbx
jmp 0x2d9b
leaq 0x4a77(%rip), %rdi      # 0x94c3
leaq 0x4a82(%rip), %rsi      # 0x94d5
callq 0x4938
// File: /workspace/github_c_makefile_star2_O2/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 0x21b70(%rip), %rax     # 0x27884
movswl (%rax), %edi
leaq 0x227a2(%rip), %rsi     # 0x284c0
callq 0x306f
movl %eax, %ebx
testw %ax, %ax
jne 0x5d38
leaq 0x2278f(%rip), %rdi     # 0x284c0
callq 0x32d7
movl %eax, %ebx
movswl %bx, %eax
shrl %eax
movswq %ax, %rax
shlq $0x4, %rax
leaq 0x84e4(%rip), %rcx      # 0xe230
movq 0x8(%rcx,%rax), %rdx
cmpw $0x0, 0x2(%rdx)
jne 0x5d76
leaq (%rcx,%rax), %r14
addq $0x8, %r14
xorl %edi, %edi
callq 0x2d9b
movq (%r14), %rcx
movw %ax, 0x2(%rcx)
movswl %ax, %edi
callq 0x2b30
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x22108(%rip), %eax     # 0x284a0
testl %eax, %eax
jle 0x63b0
decl %eax
movl %eax, 0x220fc(%rip)     # 0x284a0
leaq 0x22175(%rip), %rcx     # 0x28520
movb (%rax,%rcx), %al
jmp 0x63cb
movq 0x220f1(%rip), %rcx     # 0x284a8
movb (%rcx), %al
testb %al, %al
je 0x63c9
incq %rcx
movq %rcx, 0x220e1(%rip)     # 0x284a8
jmp 0x63cb
xorl %eax, %eax
movb %al, 0x220df(%rip)      # 0x284b0
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x6496
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 0x7e34(%rip), %rbx      # 0xe230
movq 0x8(%rbx,%r14), %rax
movswl 0x6(%rax), %edi
callq 0x63d4
movq 0x8(%rbx,%r14), %rax
movzwl 0x8(%rax), %eax
testw %ax, %ax
je 0x6487
cwtl
shrl %eax
movswq %ax, %rax
shlq $0x4, %rax
leaq (%rbx,%rax), %r14
movswq 0x4(%rbx,%rax), %r15
pushq $0x1
popq %r12
leaq 0x21448(%rip), %r13     # 0x27880
leaq 0x22101(%rip), %rbp     # 0x28540
cmpq %r15, %r12
jg 0x6487
movq 0x8(%r14), %rax
movswl -0x2(%rax,%r12,2), %edi
movw %di, (%r13)
callq 0x2b28
movswl (%r13), %eax
shrl %eax
movswq %ax, %rax
shlq $0x4, %rax
movq 0x8(%rbx,%rax), %rax
movslq 0x220bd(%rip), %rcx     # 0x28530
leaq 0x1(%rcx), %rdx
movl %edx, 0x220b3(%rip)     # 0x28530
movq %rax, 0x8(%rbp,%rcx,8)
incq %r12
jmp 0x643f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
andl $0x0, 0x22093(%rip)     # 0x28530
retq
// File: /workspace/github_c_makefile_star2_O2/afi-lambda[P]a_little_smalltalk/src/parser.c
// Function: body
static void body()
{
    /* empty blocks are same as nil */
    if ((blockstat == InBlock) || (blockstat == OptimizedBlock))
        if ((token == closing) && streq(tokenString, "]"))
        {
            genInstruction(PushConstant, nilConst);
            return;
        }

    while (parseok)
    {
        statement();
        if (token == closing)
            if (streq(tokenString,"."))
            {
                nextToken();
                if (token == inputend)
                    break;
                else
                    /* pop result, go to next statement */
                    genInstruction(DoSpecial, PopTop);
            }
            else
                break; /* leaving result on stack */
        else if (token == inputend)
            break; /* leaving result on stack */
        else
        {
            compilError(selector, "invalid statement ending; token is ",
                             tokenString);
        }
    }
}

// Assembly:
pushq %rbx
movl 0x22383(%rip), %eax     # 0x28d44
decl %eax
leaq 0x21b46(%rip), %rbx     # 0x28510
cmpl $0x1, %eax
ja 0x69ea
cmpl $0xa, (%rbx)
jne 0x69ea
leaq 0x21ae5(%rip), %rax     # 0x284c0
cmpb $0x5d, (%rax)
jne 0x69ea
cmpb $0x0, 0x1(%rax)
je 0x6ab5
cmpl $0x0, 0x2234f(%rip)     # 0x28d40
je 0x6ab3
cmpl $0x9, (%rbx)
jne 0x6a0e
leaq 0x21abd(%rip), %rax     # 0x284c0
cmpb $0x5e, (%rax)
jne 0x6a0e
cmpb $0x0, 0x1(%rax)
je 0x6a67
callq 0x6be4
movl (%rbx), %eax
cmpl $0xa, %eax
je 0x6a3f
cmpl $0xb, %eax
je 0x6ab3
leaq 0x22436(%rip), %rdi     # 0x28e60
leaq 0x2f9c(%rip), %rsi      # 0x99cd
leaq 0x21a88(%rip), %rdx     # 0x284c0
callq 0x499b
jmp 0x69ea
leaq 0x21a7a(%rip), %rax     # 0x284c0
cmpb $0x2e, (%rax)
jne 0x6ab3
cmpb $0x0, 0x1(%rax)
jne 0x6ab3
callq 0x5d93
cmpl $0xb, (%rbx)
je 0x6ab3
movl $0xf5, %edi
callq 0x7361
jmp 0x69ea
callq 0x5d93
callq 0x6be4
cmpl $0x1, 0x222cc(%rip)     # 0x28d44
jne 0x6aa4
pushq $0x54
popq %rdi
callq 0x7361
leaq 0x2f68(%rip), %rdi      # 0x99f1
callq 0x3368
movswl %ax, %edx
xorl %edi, %edi
xorl %esi, %esi
callq 0x6abe
movl $0xf5, %edi
callq 0x7361
movl $0xf2, %edi
callq 0x7361
jmp 0x6a13
popq %rbx
retq
pushq $0x55
popq %rdi
popq %rbx
jmp 0x7361
// File: /workspace/github_c_makefile_star2_O2/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, %ebp
movl %esi, %eax
orl %edi, %eax
movl %edi, 0x4(%rsp)
movl %esi, (%rsp)
je 0x6b25
movl %esi, %eax
xorl $0x1, %eax
xorl %r13d, %r13d
orl %ebp, %eax
je 0x6b8e
movl (%rsp), %esi
incl %esi
pushq $0x8
popq %rdi
callq 0x699a
cmpl $0x0, 0x4(%rsp)
je 0x6b61
movl $0xfb, %edi
callq 0x7361
movswl %bx, %edi
callq 0x6fb3
movl %eax, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7361
xorl %r15d, %r15d
pushq $0x1
popq %r13
leaq 0x20d6d(%rip), %r14     # 0x278a0
pushq $0xa
popq %r12
xorl %eax, %eax
testl %eax, %eax
jne 0x6b84
movzwl (%r14,%r15,2), %ecx
testw %cx, %cx
je 0x6b81
xorl %eax, %eax
cmpw %bx, %cx
jne 0x6b5c
movl %r12d, %edi
movl %r15d, %esi
callq 0x699a
movl %r13d, %eax
incq %r15
jmp 0x6b39
movswl %bx, %edi
callq 0x6fb3
pushq $0x9
popq %rdi
movl %eax, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x699a
xorl %r13d, %r13d
movl (%rsp), %ecx
xorl $0x1, %ecx
orl %ebp, %ecx
jne 0x6bcd
pushq $0x1
popq %rbp
xorl %r15d, %r15d
leaq 0x20d25(%rip), %r14     # 0x278c0
pushq $0xb
popq %r12
testl %r13d, %r13d
jne 0x6bd5
movzwl (%r14,%r15,2), %eax
testw %ax, %ax
je 0x6aea
xorl %r13d, %r13d
cmpw %bx, %ax
jne 0x6bc8
movl %r12d, %edi
movl %r15d, %esi
callq 0x699a
movl %ebp, %r13d
incq %r15
jmp 0x6b9f
testl %eax, %eax
je 0x6aea
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
leaq 0x21917(%rip), %r14     # 0x28510
cmpl $0x1, (%r14)
jne 0x6c41
leaq 0x218ba(%rip), %rbx     # 0x284c0
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x2050
callq 0x5d93
cmpl $0x9, (%r14)
jne 0x6c2d
cmpb $0x3c, (%rbx)
jne 0x6c2d
cmpb $0x2d, 0x1(%rbx)
jne 0x6c2d
cmpb $0x0, 0x2(%rbx)
je 0x6c68
movq %rsp, %rdi
callq 0x6d6d
movl %eax, %edi
callq 0x6f55
jmp 0x6d5e
callq 0x749e
cmpl $0x0, 0x220f3(%rip)     # 0x28d40
je 0x6d5e
movl %eax, %edi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6f55
callq 0x5d93
movl 0x220dc(%rip), %r14d    # 0x28d50
leaq 0x22c35(%rip), %rax     # 0x298b0
leaq (%rax,%r14,8), %r15
xorl %ecx, %ecx
movq %rsp, %rbx
pushq $0x7
popq %rbp
pushq $0x1
popq %r12
testl %ecx, %ecx
jne 0x6cc1
testl %r14d, %r14d
jle 0x6cc1
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x2150
xorl %ecx, %ecx
testl %eax, %eax
jne 0x6cb8
callq 0x6be4
leal -0x1(%r14), %esi
movl %ebp, %edi
callq 0x699a
movl %r12d, %ecx
addq $-0x8, %r15
decl %r14d
jmp 0x6c8b
pushq $0x1
popq %r14
movl 0x21864(%rip), %r13d    # 0x28530
leaq 0x2186d(%rip), %r15     # 0x28540
movq %rsp, %rbx
pushq $0x6
popq %rbp
pushq $0x1
popq %r12
testl %ecx, %ecx
jne 0x6d1a
movslq %r13d, %rax
cmpq %rax, %r14
jg 0x6d1a
movq (%r15,%r14,8), %rsi
movq %rbx, %rdi
callq 0x2150
xorl %ecx, %ecx
testl %eax, %eax
jne 0x6d15
callq 0x6be4
leal -0x1(%r14), %esi
movl %ebp, %edi
callq 0x699a
movl 0x2181e(%rip), %r13d    # 0x28530
movl %r12d, %ecx
incq %r14
jmp 0x6cdd
testl %ecx, %ecx
jne 0x6d5e
pushq $0x20
popq %rdi
callq 0x7361
movq %rsp, %rdi
callq 0x3368
movswl %ax, %edi
callq 0x6fb3
pushq $0x4
popq %rdi
movl %eax, %esi
callq 0x699a
callq 0x6be4
leaq 0x2cb1(%rip), %rdi      # 0x99fd
callq 0x3368
movswl %ax, %edx
pushq $0x2
popq %rsi
xorl %edi, %edi
callq 0x6abe
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
callq 0x7007
movl %eax, %ebx
leaq 0x215a8(%rip), %r14     # 0x28510
leaq 0x21551(%rip), %r15     # 0x284c0
cmpl $0x0, 0x21dca(%rip)     # 0x28d40
je 0x6fad
cmpl $0xa, (%r14)
jne 0x6fad
cmpb $0x3b, (%r15)
jne 0x6fad
cmpb $0x0, 0x1(%r15)
jne 0x6fad
movl $0xf4, %edi
callq 0x7361
callq 0x5d93
movl %ebx, %edi
callq 0x7007
movl $0xf5, %edi
callq 0x7361
jmp 0x6f6f
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x21d99(%rip), %rax     # 0x28d54
cmpq $0x100, %rax            # imm = 0x100
jl 0x6fdf
leaq 0x21e96(%rip), %rdi     # 0x28e60
leaq 0x2a3a(%rip), %rsi      # 0x9a0b
leaq 0x26e1(%rip), %rdx      # 0x96b9
callq 0x499b
jmp 0x6ffd
leaq 0x1(%rax), %rcx
movl %ecx, 0x21d6b(%rip)     # 0x28d54
leaq 0x21ec0(%rip), %rcx     # 0x28eb0
movw %di, 0x2(%rcx,%rax,2)
movswl %di, %edi
callq 0x2b30
movl 0x21d51(%rip), %eax     # 0x28d54
decl %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
callq 0x739f
movl %eax, %ebp
leaq 0x212e7(%rip), %r12     # 0x28510
leaq 0x21290(%rip), %rbx     # 0x284c0
pushq $0x1
popq %r14
cmpl $0x0, 0x21b05(%rip)     # 0x28d40
je 0x7272
cmpl $0x9, (%r12)
jne 0x7272
movq %rbx, %rdi
callq 0x3368
movl %eax, %r15d
callq 0x5d93
callq 0x749e
movl %eax, %edi
callq 0x739f
movswl %r15w, %edx
movl %ebp, %edi
movl %r14d, %esi
callq 0x6abe
xorl %ebp, %ebp
jmp 0x7234
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq