LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x1, %edi
callq 0x2c10
movw %ax, -0x6(%rbp)
leaq 0x7e2d(%rip), %rsi      # 0xc0ed
leaq 0x255ed(%rip), %rax     # 0x298b4
movswl (%rax), %edi
callq 0x3b50
movswl -0x6(%rbp), %ecx
sarl %ecx
movslq %ecx, %rdx
leaq 0xbf81(%rip), %rcx      # 0x10260
shlq $0x4, %rdx
addq %rdx, %rcx
movw %ax, (%rcx)
movswl %ax, %edi
callq 0x2fd0
movl -0x4(%rbp), %edi
callq 0x3d60
movswl -0x6(%rbp), %ecx
sarl %ecx
movslq %ecx, %rdx
leaq 0xbf57(%rip), %rcx      # 0x10260
shlq $0x4, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rcx
movw %ax, (%rcx)
movswl %ax, %edi
callq 0x2fd0
movw -0x6(%rbp), %ax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x8(%rbp)
movl $0x8, %edi
callq 0x2eb0
movw %ax, -0xa(%rbp)
movw -0xa(%rbp), %ax
leaq 0x2555a(%rip), %rcx     # 0x298b0
movw %ax, (%rcx)
movswl %ax, %edi
callq 0x2fb0
cmpl $0x0, %eax
je 0x438d
leaq 0x25543(%rip), %rax     # 0x298b0
movswl (%rax), %eax
sarl %eax
movslq %eax, %rcx
leaq 0xbee4(%rip), %rax      # 0x10260
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x43b2
leaq 0x2551c(%rip), %rax     # 0x298b0
movswl (%rax), %eax
sarl %eax
movslq %eax, %rcx
leaq 0xbebd(%rip), %rax      # 0x10260
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x8(%rbp), %rsi
movl $0x8, %edx
callq 0x3c90
leaq 0x7f34(%rip), %rsi      # 0xc2ff
leaq 0x254e2(%rip), %rax     # 0x298b4
movswl (%rax), %edi
callq 0x3b50
movswl -0xa(%rbp), %ecx
sarl %ecx
movslq %ecx, %rdx
leaq 0xbe76(%rip), %rcx      # 0x10260
shlq $0x4, %rdx
addq %rdx, %rcx
movw %ax, (%rcx)
movswl %ax, %edi
callq 0x2fd0
movw -0xa(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movw %si, %ax
movw %di, %cx
movw %cx, -0x2(%rbp)
movw %ax, -0x4(%rbp)
movl $0x3, %edi
callq 0x2c10
movw %ax, -0x6(%rbp)
leaq 0x7c03(%rip), %rsi      # 0xc0de
leaq 0x253d2(%rip), %rax     # 0x298b4
movswl (%rax), %edi
callq 0x3b50
movswl -0x6(%rbp), %ecx
sarl %ecx
movslq %ecx, %rdx
leaq 0xbd66(%rip), %rcx      # 0x10260
shlq $0x4, %rdx
addq %rdx, %rcx
movw %ax, (%rcx)
movswl %ax, %edi
callq 0x2fd0
movw -0x2(%rbp), %ax
movswl -0x6(%rbp), %ecx
sarl %ecx
movslq %ecx, %rdx
leaq 0xbd40(%rip), %rcx      # 0x10260
shlq $0x4, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rcx
movw %ax, (%rcx)
movswl %ax, %edi
callq 0x2fd0
movw -0x4(%rbp), %ax
movswl -0x6(%rbp), %ecx
sarl %ecx
movslq %ecx, %rdx
leaq 0xbd16(%rip), %rcx      # 0x10260
shlq $0x4, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rcx
movw %ax, 0x2(%rcx)
movswl %ax, %edi
callq 0x2fd0
movw -0x6(%rbp), %ax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2f10
movw %ax, -0xa(%rbp)
movswl 0x25340(%rip), %eax     # 0x29930
cmpl $0x0, %eax
jne 0x4612
leaq 0x7c53(%rip), %rsi      # 0xc24f
leaq 0x252b1(%rip), %rax     # 0x298b4
movswl (%rax), %edi
callq 0x3b50
movw %ax, 0x2531e(%rip)      # 0x29930
movw 0x25317(%rip), %ax      # 0x29930
movswl -0xa(%rbp), %ecx
sarl %ecx
movslq %ecx, %rdx
leaq 0xbc37(%rip), %rcx      # 0x10260
shlq $0x4, %rdx
addq %rdx, %rcx
movw %ax, (%rcx)
movswl %ax, %edi
callq 0x2fd0
movw -0xa(%rbp), %ax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movw $0x0, 0x23dcb(%rip)     # 0x29ff0
movq -0x10(%rbp), %rax
movw (%rax), %ax
movw %ax, -0x14(%rbp)
movswl -0x14(%rbp), %eax
cmpl $0x0, %eax
je 0x62b5
movswl -0x14(%rbp), %eax
sarl %eax
movslq %eax, %rcx
leaq 0xa017(%rip), %rax      # 0x10260
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movw 0x4(%rax), %ax
movw %ax, -0x12(%rbp)
movw -0x12(%rbp), %ax
movswl 0x23d8f(%rip), %esi     # 0x29ff6
leaq 0x152(%rip), %rdx       # 0x63c0
movswl %ax, %edi
callq 0x37a0
movw %ax, 0x23d73(%rip)      # 0x29ff0
movswl 0x23d6c(%rip), %eax     # 0x29ff0
cmpl $0x0, %eax
je 0x628b
jmp 0x62b5
jmp 0x628d
movswl -0x14(%rbp), %eax
sarl %eax
movslq %eax, %rcx
leaq 0x9fc3(%rip), %rax      # 0x10260
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movw 0x6(%rax), %ax
movw %ax, -0x14(%rbp)
jmp 0x6230
movswl 0x23d34(%rip), %eax     # 0x29ff0
cmpl $0x0, %eax
jne 0x62d5
movq -0x10(%rbp), %rax
movw (%rax), %ax
movw %ax, -0x14(%rbp)
movl $0x0, -0x4(%rbp)
jmp 0x62e7
movw -0x14(%rbp), %cx
movq -0x10(%rbp), %rax
movw %cx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/afi-lambda[P]a_little_smalltalk/src/interp.c
// Function: growProcessStack
static object growProcessStack(int top, int toadd)
{
    int size, i;
    object newStack;

    if (toadd < 100)
        toadd = 100;
    size = sizeField(processStack) + toadd;
    newStack = newArray(size);
    for (i = 1; i <= top; i++)
    {
        basicAtPut(newStack, i, basicAt(processStack, i));
    }
    return newStack;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x64, -0x8(%rbp)
jge 0x630b
movl $0x64, -0x8(%rbp)
movswl 0x23cd6(%rip), %eax     # 0x29fe8
sarl %eax
movslq %eax, %rcx
leaq 0x9f42(%rip), %rax      # 0x10260
shlq $0x4, %rcx
addq %rcx, %rax
movswl 0x4(%rax), %eax
addl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0x3d60
movw %ax, -0x12(%rbp)
movl $0x1, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x4(%rbp), %eax
jg 0x63b0
movswl 0x23c97(%rip), %eax     # 0x29fe8
sarl %eax
movslq %eax, %rcx
leaq 0x9f03(%rip), %rax      # 0x10260
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movswl -0x12(%rbp), %ecx
sarl %ecx
movslq %ecx, %rdx
leaq 0x9edb(%rip), %rcx      # 0x10260
shlq $0x4, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rcx
movl -0x10(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movw %ax, (%rcx,%rdx,2)
movswl %ax, %edi
callq 0x2fd0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x6342
movw -0x12(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %eax
subl $0x96, %eax
jne 0x65ef
jmp 0x656f
movq -0x10(%rbp), %rax
movw (%rax), %ax
leaq 0x23333(%rip), %rcx     # 0x298b0
movw %ax, (%rcx)
movswl %ax, %edi
callq 0x2fb0
cmpl $0x0, %eax
je 0x65b4
leaq 0x2331c(%rip), %rax     # 0x298b0
movswl (%rax), %eax
sarl %eax
movslq %eax, %rcx
leaq 0x9cbd(%rip), %rax      # 0x10260
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x65d9
leaq 0x232f5(%rip), %rax     # 0x298b0
movswl (%rax), %eax
sarl %eax
movslq %eax, %rcx
leaq 0x9c96(%rip), %rax      # 0x10260
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x20a0
movl %eax, %edi
callq 0x34a0
movw %ax, -0x12(%rbp)
jmp 0x6602
leaq 0x5ec9(%rip), %rdi      # 0xc4bf
leaq 0x5ed4(%rip), %rsi      # 0xc4d1
callq 0x63f0
movw -0x12(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/afi-lambda[P]a_little_smalltalk/src/primitive.c
// Function: zeroaryPrims
static object zeroaryPrims(int number)
{
    short i;
    object returnedObject;
    int objectCount();

    returnedObject = nilobj;
    switch (number)
    {

    case 1:
        fprintf(stderr, "did primitive 1\n");
        break;

    case 2:
        fprintf(stderr, "object count %d\n", objectCount());
        break;

    case 3: /* return a random number */
        /* this is hacked because of the representation */
        /* of integers as shorts */
        i = rand() >> 8; /* strip off lower bits */
        if (i < 0)
            i = -i;
        returnedObject = newInteger(i>>1);
        break;

    case 4: /* return time in seconds */
        i = (short) time((long *) 0);
        returnedObject = newInteger(i);
        break;

    case 5: /* flip watch - done in interp */
        break;

    case 9:
        exit(0);

    default: /* unknown primitive */
        sysError("unknown primitive", "zeroargPrims");
        break;
    }
    return (returnedObject);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movw $0x0, -0x8(%rbp)
movl -0x4(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x8, %eax
ja 0x69da
movq -0x10(%rbp), %rax
leaq 0x5be8(%rip), %rcx      # 0xc518
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x86b8(%rip), %rax      # 0xeff8
movq (%rax), %rdi
leaq 0x5d5b(%rip), %rsi      # 0xc6a5
movb $0x0, %al
callq 0x2170
jmp 0x69ed
movq 0x869b(%rip), %rax      # 0xeff8
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movb $0x0, %al
callq 0x3410
movq -0x18(%rbp), %rdi
movl %eax, %edx
leaq 0x5d3e(%rip), %rsi      # 0xc6b6
movb $0x0, %al
callq 0x2170
jmp 0x69ed
callq 0x2210
sarl $0x8, %eax
movw %ax, -0x6(%rbp)
movswl -0x6(%rbp), %eax
cmpl $0x0, %eax
jge 0x69a2
movswl -0x6(%rbp), %ecx
xorl %eax, %eax
subl %ecx, %eax
movw %ax, -0x6(%rbp)
movswl -0x6(%rbp), %edi
sarl %edi
callq 0x34a0
movw %ax, -0x8(%rbp)
jmp 0x69ed
xorl %eax, %eax
movl %eax, %edi
movb $0x0, %al
callq 0x2180
movw %ax, -0x6(%rbp)
movswl -0x6(%rbp), %edi
callq 0x34a0
movw %ax, -0x8(%rbp)
jmp 0x69ed
jmp 0x69ed
xorl %edi, %edi
callq 0x21e0
leaq 0x5ade(%rip), %rdi      # 0xc4bf
leaq 0x5cdf(%rip), %rsi      # 0xc6c7
callq 0x63f0
movw -0x8(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/afi-lambda[P]a_little_smalltalk/src/primitive.c
// Function: intUnary
static int intUnary(int number, int firstarg)
{
    object returnedObject;

    switch (number)
    {
    case 1: /* float equiv of integer */
        returnedObject = newFloat((double) firstarg);
        break;

    case 2: /* print - for debugging purposes */
        fprintf(stderr, "debugging print %d\n", firstarg);
        break;

    case 3: /* set time slice - done in interpreter */
        break;

    case 5: /* set random number */
        srand((unsigned) firstarg);
        returnedObject = nilobj;
        break;

    case 8:
        returnedObject = allocObject(firstarg);
        break;

    case 9:
        returnedObject = allocByte(firstarg);
        break;

    default:
        sysError("intUnary primitive", "not implemented yet");
    }
    return (returnedObject);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x8, %eax
ja 0x79cd
movq -0x18(%rbp), %rax
leaq 0x4c3f(%rip), %rcx      # 0xc5a8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cvtsi2sdl -0x8(%rbp), %xmm0
callq 0x4330
movw %ax, -0xa(%rbp)
jmp 0x79e0
movq 0x766f(%rip), %rax      # 0xeff8
movq (%rax), %rdi
movl -0x8(%rbp), %edx
leaq 0x4de9(%rip), %rsi      # 0xc77f
movb $0x0, %al
callq 0x2170
jmp 0x79e0
jmp 0x79e0
movl -0x8(%rbp), %edi
callq 0x2100
movw $0x0, -0xa(%rbp)
jmp 0x79e0
movl -0x8(%rbp), %edi
callq 0x2c10
movw %ax, -0xa(%rbp)
jmp 0x79e0
movl -0x8(%rbp), %edi
callq 0x2eb0
movw %ax, -0xa(%rbp)
jmp 0x79e0
leaq 0x4dbf(%rip), %rdi      # 0xc793
leaq 0x5256(%rip), %rsi      # 0xcc31
callq 0x63f0
movswl -0xa(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/afi-lambda[P]a_little_smalltalk/src/primitive.c
// Function: strUnary
static int strUnary(int number, char *firstargument)
{
    object returnedObject;

    switch (number)
    {
    case 1: /* length of string */
        returnedObject = newInteger(strlen(firstargument));
        break;

    case 2: /* hash value of symbol */
        returnedObject = newInteger(strHash(firstargument));
        break;

    case 3: /* string as symbol */
        returnedObject = newSymbol(firstargument);
        break;

    case 7: /* value of symbol */
        returnedObject = globalSymbol(firstargument);
        break;

    case 8:
# ifndef NOSYSTEM
        returnedObject = newInteger(system(firstargument));
# endif
        break;

    case 9:
        sysError("fatal error", firstargument);
        break;

    default:
        sysError("unknown primitive", "strUnary");
        break;
    }

    return (returnedObject);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x8, %eax
ja 0x7ce6
movq -0x20(%rbp), %rax
leaq 0x49be(%rip), %rcx      # 0xc61c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
callq 0x2090
movl %eax, %edi
callq 0x34a0
movw %ax, -0x12(%rbp)
jmp 0x7cf9
movq -0x10(%rbp), %rdi
callq 0x3960
movl %eax, %edi
callq 0x34a0
movw %ax, -0x12(%rbp)
jmp 0x7cf9
movq -0x10(%rbp), %rdi
callq 0x4000
movw %ax, -0x12(%rbp)
jmp 0x7cf9
leaq 0x21c0b(%rip), %rax     # 0x298b4
movw (%rax), %ax
movq -0x10(%rbp), %rsi
movswl %ax, %edi
callq 0x3b50
movw %ax, -0x12(%rbp)
jmp 0x7cf9
movq -0x10(%rbp), %rdi
callq 0x20a0
movl %eax, %edi
callq 0x34a0
movw %ax, -0x12(%rbp)
jmp 0x7cf9
movq -0x10(%rbp), %rsi
leaq 0x4ac7(%rip), %rdi      # 0xc7a6
callq 0x63f0
jmp 0x7cf9
leaq 0x47d2(%rip), %rdi      # 0xc4bf
leaq 0x4abe(%rip), %rsi      # 0xc7b2
callq 0x63f0
movswl -0x12(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/afi-lambda[P]a_little_smalltalk/src/filein.c
// Function: fileIn
void fileIn(FILE *fd, boolean printit)
{
    while (fgets(textBuffer, TextBufferSize, fd) != NULL)
    {
        lexinit(textBuffer);
        if (token == inputend)
            ; /* do nothing, get next line */
        else if ((token == binary) && streq(tokenString, "\""))
            ; /* do nothing, its a comment */
        /* Syntax for Class and Methods definitions
         
         Number extend [
           radiusToArea [
             ^self squared * Float pi
           ]
           radiusToCircumference [
             ^self * 2 * Float pi
           ]
         ]
        */
        else if ((token == nameconst) && streq(tokenString,"Class"))
            readClassDeclaration();
        else if ((token == nameconst) && streq(tokenString,"Methods"))
            readMethods(fd, printit);
        else
            sysError("unrecognized line", textBuffer);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdx
leaq 0x22096(%rip), %rdi     # 0x2a0d0
movl $0x400, %esi            # imm = 0x400
callq 0x2110
cmpq $0x0, %rax
je 0x810c
leaq 0x2207b(%rip), %rdi     # 0x2a0d0
callq 0x86e0
leaq 0x224df(%rip), %rax     # 0x2a540
cmpl $0xb, (%rax)
jne 0x806b
jmp 0x8107
leaq 0x224ce(%rip), %rax     # 0x2a540
cmpl $0x9, (%rax)
jne 0x8091
leaq 0x22472(%rip), %rdi     # 0x2a4f0
leaq 0x4750(%rip), %rsi      # 0xc7d5
callq 0x2150
cmpl $0x0, %eax
jne 0x8091
jmp 0x8105
leaq 0x224a8(%rip), %rax     # 0x2a540
cmpl $0x1, (%rax)
jne 0x80bc
leaq 0x2244c(%rip), %rdi     # 0x2a4f0
leaq 0x402d(%rip), %rsi      # 0xc0d8
callq 0x2150
cmpl $0x0, %eax
jne 0x80bc
callq 0x8470
jmp 0x8103
leaq 0x2247d(%rip), %rax     # 0x2a540
cmpl $0x1, (%rax)
jne 0x80ee
leaq 0x22421(%rip), %rdi     # 0x2a4f0
leaq 0x4701(%rip), %rsi      # 0xc7d7
callq 0x2150
cmpl $0x0, %eax
jne 0x80ee
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x8120
jmp 0x8101
leaq 0x46ea(%rip), %rdi      # 0xc7df
leaq 0x21fd4(%rip), %rsi     # 0x2a0d0
callq 0x63f0
jmp 0x8103
jmp 0x8105
jmp 0x8107
jmp 0x802f
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x21261(%rip), %rax     # 0x298b4
movw (%rax), %ax
movq -0x8(%rbp), %rsi
movswl %ax, %edi
callq 0x3b50
movw %ax, -0xa(%rbp)
movswl -0xa(%rbp), %eax
cmpl $0x0, %eax
jne 0x867c
movq -0x8(%rbp), %rdi
callq 0x3f30
movw %ax, -0xa(%rbp)
movswl -0xa(%rbp), %eax
sarl %eax
movslq %eax, %rcx
leaq 0x7bd4(%rip), %rax      # 0x10260
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movswl 0x2(%rax), %eax
cmpl $0x0, %eax
jne 0x86ce
xorl %edi, %edi
callq 0x34a0
movswl -0xa(%rbp), %ecx
sarl %ecx
movslq %ecx, %rdx
leaq 0x7ba9(%rip), %rcx      # 0x10260
shlq $0x4, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rcx
movw %ax, 0x2(%rcx)
movswl %ax, %edi
callq 0x2fd0
movw -0xa(%rbp), %ax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/afi-lambda[P]a_little_smalltalk/src/lex.c
// Function: isSymbolChar
static boolean isSymbolChar(char c)
{
    if (isdigit(c) || isalpha(c))
        return (true);
    if (isspace(c) || isClosing(c))
        return (false);
    return (true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x5(%rbp)
callq 0x2220
movq (%rax), %rax
movsbl -0x5(%rbp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0x8f38
callq 0x2220
movq (%rax), %rax
movsbl -0x5(%rbp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
je 0x8f41
movl $0x1, -0x4(%rbp)
jmp 0x8f7c
callq 0x2220
movq (%rax), %rax
movsbl -0x5(%rbp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
jne 0x8f6c
movsbl -0x5(%rbp), %edi
callq 0x8f90
cmpl $0x0, %eax
je 0x8f75
movl $0x0, -0x4(%rbp)
jmp 0x8f7c
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/afi-lambda[P]a_little_smalltalk/src/lex.c
// Function: isClosing
static boolean isClosing(char c)
{
    switch (c)
    {
    case '.':
    case ']':
    case ')':
    case ';':
    case '\"':
    case '\'':
        return (true);
    }
    return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0x22, %eax
je 0x8fda
jmp 0x8fa8
movl -0xc(%rbp), %eax
subl $0x27, %eax
je 0x8fda
jmp 0x8fb2
movl -0xc(%rbp), %eax
subl $0x29, %eax
je 0x8fda
jmp 0x8fbc
movl -0xc(%rbp), %eax
subl $0x2e, %eax
je 0x8fda
jmp 0x8fc6
movl -0xc(%rbp), %eax
subl $0x3b, %eax
je 0x8fda
jmp 0x8fd0
movl -0xc(%rbp), %eax
subl $0x5d, %eax
jne 0x8fe3
jmp 0x8fda
movl $0x1, -0x4(%rbp)
jmp 0x8fea
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
cmpl $0x0, 0x213e5(%rip)     # 0x2a4d0
jle 0x9111
movl 0x213dd(%rip), %eax     # 0x2a4d0
addl $-0x1, %eax
movl %eax, 0x213d4(%rip)     # 0x2a4d0
movslq %eax, %rcx
leaq 0x2145a(%rip), %rax     # 0x2a560
movb (%rax,%rcx), %al
movb %al, 0x213d1(%rip)      # 0x2a4e0
jmp 0x9145
movq 0x213c0(%rip), %rax     # 0x2a4d8
cmpb $0x0, (%rax)
je 0x913c
movq 0x213b4(%rip), %rax     # 0x2a4d8
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x213a6(%rip)     # 0x2a4d8
movb (%rax), %al
movb %al, 0x213a6(%rip)      # 0x2a4e0
jmp 0x9143
movb $0x0, 0x2139d(%rip)     # 0x2a4e0
jmp 0x9145
movb 0x21395(%rip), %al      # 0x2a4e0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movswl -0x2(%rbp), %eax
cmpl $0x0, %eax
jne 0x9177
movl $0x0, 0x213fe(%rip)     # 0x2a570
jmp 0x92ba
movswl -0x2(%rbp), %eax
sarl %eax
movslq %eax, %rcx
leaq 0x70d9(%rip), %rax      # 0x10260
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movswl 0x6(%rax), %edi
callq 0x9150
movswl -0x2(%rbp), %eax
sarl %eax
movslq %eax, %rcx
leaq 0x70b5(%rip), %rax      # 0x10260
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movw 0x8(%rax), %ax
movw %ax, -0xe(%rbp)
movswl -0xe(%rbp), %eax
cmpl $0x0, %eax
je 0x92b8
movswl -0xe(%rbp), %eax
sarl %eax
movslq %eax, %rcx
leaq 0x7085(%rip), %rax      # 0x10260
shlq $0x4, %rcx
addq %rcx, %rax
movswl 0x4(%rax), %eax
movl %eax, -0xc(%rbp)
movl $0x1, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0x92b6
movswl -0xe(%rbp), %eax
sarl %eax
movslq %eax, %rcx
leaq 0x7054(%rip), %rax      # 0x10260
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movl -0x8(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
leaq 0x20685(%rip), %rcx     # 0x298b0
movw %ax, (%rcx)
movswl %ax, %edi
callq 0x2fb0
cmpl $0x0, %eax
je 0x9262
leaq 0x2066e(%rip), %rax     # 0x298b0
movswl (%rax), %eax
sarl %eax
movslq %eax, %rcx
leaq 0x700f(%rip), %rax      # 0x10260
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x9287
leaq 0x20647(%rip), %rax     # 0x298b0
movswl (%rax), %eax
sarl %eax
movslq %eax, %rcx
leaq 0x6fe8(%rip), %rax      # 0x10260
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdx
movl 0x212df(%rip), %eax     # 0x2a570
addl $0x1, %eax
movl %eax, 0x212d6(%rip)     # 0x2a570
movslq %eax, %rcx
leaq 0x212dc(%rip), %rax     # 0x2a580
movq %rdx, (%rax,%rcx,8)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x91f0
jmp 0x92b8
jmp 0x92ba
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x10, -0x8(%rbp)
jl 0x9678
movl -0x4(%rbp), %esi
xorl %edi, %edi
callq 0x9650
movl -0x8(%rbp), %edi
callq 0xa750
jmp 0x9686
movl -0x4(%rbp), %edi
shll $0x4, %edi
addl -0x8(%rbp), %edi
callq 0xa750
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/afi-lambda[P]a_little_smalltalk/src/parser.c
// Function: temporaries
static void temporaries()
{
    object tempsym;

    temporaryTop = 0;
    if ((token == binary) && streq(tokenString, "|"))
    {
        nextToken();
        while (token == nameconst)
        {
            if (++temporaryTop > maxTemporary)
                maxTemporary = temporaryTop;
            if (temporaryTop > temporaryLimit)
                compilError(selector, "too many temporaries in method", "");
            else
            {
                tempsym = newSymbol(tokenString);
                temporaryName[temporaryTop] = charPtr(tempsym);
            }
            nextToken();
        }
        if ((token != binary) || !streq(tokenString, "|"))
            compilError(selector, "temporary list not terminated by bar", "");
        else
            nextToken();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, 0x2146e(%rip)     # 0x2ad90
leaq 0x20c17(%rip), %rax     # 0x2a540
cmpl $0x9, (%rax)
jne 0x9a8f
leaq 0x20bb7(%rip), %rdi     # 0x2a4f0
leaq 0x3248(%rip), %rsi      # 0xcb88
callq 0x2150
cmpl $0x0, %eax
jne 0x9a8f
callq 0x8710
leaq 0x20be6(%rip), %rax     # 0x2a540
cmpl $0x1, (%rax)
jne 0x9a48
movl 0x21427(%rip), %eax     # 0x2ad90
addl $0x1, %eax
movl %eax, 0x2141e(%rip)     # 0x2ad90
cmpl 0x21420(%rip), %eax     # 0x2ad98
jle 0x9986
movl 0x21410(%rip), %eax     # 0x2ad90
movl %eax, 0x21412(%rip)     # 0x2ad98
cmpl $0x100, 0x21400(%rip)   # imm = 0x100
jle 0x99b1
leaq 0x21507(%rip), %rdi     # 0x2aea0
leaq 0x2f81(%rip), %rsi      # 0xc921
leaq 0x2d0e(%rip), %rdx      # 0xc6b5
callq 0x64b0
jmp 0x9a3e
leaq 0x20b38(%rip), %rdi     # 0x2a4f0
callq 0x4000
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
leaq 0x1fee4(%rip), %rcx     # 0x298b0
movw %ax, (%rcx)
movswl %ax, %edi
callq 0x2fb0
cmpl $0x0, %eax
je 0x9a03
leaq 0x1fecd(%rip), %rax     # 0x298b0
movswl (%rax), %eax
sarl %eax
movslq %eax, %rcx
leaq 0x686e(%rip), %rax      # 0x10260
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x9a28
leaq 0x1fea6(%rip), %rax     # 0x298b0
movswl (%rax), %eax
sarl %eax
movslq %eax, %rcx
leaq 0x6847(%rip), %rax      # 0x10260
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdx
movslq 0x2135d(%rip), %rcx     # 0x2ad90
leaq 0x21eb6(%rip), %rax     # 0x2b8f0
movq %rdx, (%rax,%rcx,8)
callq 0x8710
jmp 0x9953
leaq 0x20af1(%rip), %rax     # 0x2a540
cmpl $0x9, (%rax)
jne 0x9a6c
leaq 0x20a95(%rip), %rdi     # 0x2a4f0
leaq 0x3126(%rip), %rsi      # 0xcb88
callq 0x2150
cmpl $0x0, %eax
je 0x9a88
leaq 0x2142d(%rip), %rdi     # 0x2aea0
leaq 0x2ec6(%rip), %rsi      # 0xc940
leaq 0x2c34(%rip), %rdx      # 0xc6b5
callq 0x64b0
jmp 0x9a8d
callq 0x8710
jmp 0x9a8f
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
cmpl $0x1, 0x212d9(%rip)     # 0x2ad84
je 0x9ab6
cmpl $0x2, 0x212d0(%rip)     # 0x2ad84
jne 0x9aed
leaq 0x20a83(%rip), %rax     # 0x2a540
cmpl $0xa, (%rax)
jne 0x9aeb
leaq 0x20a27(%rip), %rdi     # 0x2a4f0
leaq 0x30d2(%rip), %rsi      # 0xcba2
callq 0x2150
cmpl $0x0, %eax
jne 0x9aeb
movl $0x5, %esi
movl %esi, %edi
callq 0x9650
jmp 0x9b7c
jmp 0x9aed
jmp 0x9aef
cmpl $0x0, 0x2128a(%rip)     # 0x2ad80
je 0x9b7c
callq 0x9b80
leaq 0x20a38(%rip), %rax     # 0x2a540
cmpl $0xa, (%rax)
jne 0x9b4d
leaq 0x209dc(%rip), %rdi     # 0x2a4f0
leaq 0x25b4(%rip), %rsi      # 0xc0cf
callq 0x2150
cmpl $0x0, %eax
jne 0x9b49
callq 0x8710
leaq 0x20a0f(%rip), %rax     # 0x2a540
cmpl $0xb, (%rax)
jne 0x9b38
jmp 0x9b7c
movl $0xf, %edi
movl $0x5, %esi
callq 0x9650
jmp 0x9b4b
jmp 0x9b7c
jmp 0x9b77
leaq 0x209ec(%rip), %rax     # 0x2a540
cmpl $0xb, (%rax)
jne 0x9b5b
jmp 0x9b7c
leaq 0x2133e(%rip), %rdi     # 0x2aea0
leaq 0x2dfc(%rip), %rsi      # 0xc965
leaq 0x20980(%rip), %rdx     # 0x2a4f0
callq 0x64b0
jmp 0x9b77
jmp 0x9aef
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/afi-lambda[P]a_little_smalltalk/src/parser.c
// Function: statement
static void statement()
{

    if ((token == binary) && streq(tokenString, "^"))
    {
        nextToken();
        expression();
        if (blockstat == InBlock)
        {
            /* change return point before returning */
            genInstruction(PushConstant, contextConst);
            genMessage(false, 0, newSymbol("blockReturn"));
            genInstruction(DoSpecial, PopTop);
        }
        genInstruction(DoSpecial, StackReturn);
    }
    else
    {
        expression();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x209b5(%rip), %rax     # 0x2a540
cmpl $0x9, (%rax)
jne 0x9c02
leaq 0x20959(%rip), %rdi     # 0x2a4f0
leaq 0x2deb(%rip), %rsi      # 0xc989
callq 0x2150
cmpl $0x0, %eax
jne 0x9c02
callq 0x8710
callq 0x9d80
cmpl $0x1, 0x211cb(%rip)     # 0x2ad84
jne 0x9bf1
movl $0x5, %edi
movl $0x4, %esi
callq 0x9650
leaq 0x2dba(%rip), %rdi      # 0xc98b
callq 0x4000
xorl %esi, %esi
movl %esi, %edi
movswl %ax, %edx
callq 0x9c10
movl $0xf, %edi
movl $0x5, %esi
callq 0x9650
movl $0xf, %edi
movl $0x2, %esi
callq 0x9650
jmp 0x9c07
callq 0x9d80
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movw %dx, %ax
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x9ca5
cmpl $0x0, -0x8(%rbp)
jne 0x9ca5
movl $0x0, -0x14(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x10(%rbp)
movb %al, -0x15(%rbp)
jne 0x9c62
movslq -0x14(%rbp), %rcx
leaq 0x1fc7b(%rip), %rax     # 0x298d0
movswl (%rax,%rcx,2), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x9c6b
jmp 0x9ca3
movswl -0xa(%rbp), %eax
movslq -0x14(%rbp), %rdx
leaq 0x1fc56(%rip), %rcx     # 0x298d0
movswl (%rcx,%rdx,2), %ecx
cmpl %ecx, %eax
jne 0x9c96
movl -0x14(%rbp), %esi
movl $0xa, %edi
callq 0x9650
movl $0x1, -0x10(%rbp)
jmp 0x9c98
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x9c3f
jmp 0x9ca5
cmpl $0x0, -0x4(%rbp)
jne 0x9d1e
cmpl $0x1, -0x8(%rbp)
jne 0x9d1e
movl $0x0, -0x14(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x10(%rbp)
movb %al, -0x16(%rbp)
jne 0x9cdb
movslq -0x14(%rbp), %rcx
leaq 0x1fc22(%rip), %rax     # 0x298f0
movswl (%rax,%rcx,2), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x16(%rbp)
movb -0x16(%rbp), %al
testb $0x1, %al
jne 0x9ce4
jmp 0x9d1c
movswl -0xa(%rbp), %eax
movslq -0x14(%rbp), %rdx
leaq 0x1fbfd(%rip), %rcx     # 0x298f0
movswl (%rcx,%rdx,2), %ecx
cmpl %ecx, %eax
jne 0x9d0f
movl -0x14(%rbp), %esi
movl $0xb, %edi
callq 0x9650
movl $0x1, -0x10(%rbp)
jmp 0x9d11
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x9cb8
jmp 0x9d1e
cmpl $0x0, -0x10(%rbp)
jne 0x9d72
movl -0x8(%rbp), %esi
addl $0x1, %esi
movl $0x8, %edi
callq 0x9650
cmpl $0x0, -0x4(%rbp)
je 0x9d5b
movl $0xf, %edi
movl $0xb, %esi
callq 0x9650
movswl -0xa(%rbp), %edi
callq 0xa290
movl %eax, %edi
callq 0xa750
jmp 0x9d70
movswl -0xa(%rbp), %edi
callq 0xa290
movl %eax, %esi
movl $0x9, %edi
callq 0x9650
jmp 0x9d72
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x207b1(%rip), %rax     # 0x2a540
cmpl $0x1, (%rax)
jne 0x9df3
leaq -0x40(%rbp), %rdi
leaq 0x20751(%rip), %rsi     # 0x2a4f0
callq 0x2050
callq 0x8710
leaq 0x20790(%rip), %rax     # 0x2a540
cmpl $0x9, (%rax)
jne 0x9ddd
leaq 0x20734(%rip), %rdi     # 0x2a4f0
leaq 0x2bd4(%rip), %rsi      # 0xc997
callq 0x2150
cmpl $0x0, %eax
jne 0x9ddd
callq 0x8710
leaq -0x40(%rbp), %rdi
callq 0x9e20
jmp 0x9df1
leaq -0x40(%rbp), %rdi
callq 0x9f70
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %edi
callq 0xa200
jmp 0x9e0e
callq 0xa8e0
movl %eax, -0x4(%rbp)
cmpl $0x0, 0x20f7e(%rip)     # 0x2ad80
je 0x9e0c
movl -0x4(%rbp), %edi
callq 0xa200
jmp 0x9e0e
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/afi-lambda[P]a_little_smalltalk/src/parser.c
// Function: assignment
static void assignment(char *name)
{
    int i;
    boolean done;

    done = false;

    /* it might be a temporary */
    for (i = temporaryTop; (!done) && (i > 0); i--)
        if (streq(name, temporaryName[i]))
        {
            expression();
            genInstruction(AssignTemporary, i - 1);
            done = true;
        }

    /* or it might be an instance variable */
    for (i = 1; (!done) && (i <= instanceTop); i++)
        if (streq(name, instanceName[i]))
        {
            expression();
            genInstruction(AssignInstance, i - 1);
            done = true;
        }

    if (!done)   /* not known, handle at run time */
    {
        genInstruction(PushArgument, 0);
        genInstruction(PushLiteral, genLiteral(newSymbol(name)));
        expression();
        genMessage(false, 2, newSymbol("assign:value:"));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x10(%rbp)
movl 0x20f57(%rip), %eax     # 0x2ad90
movl %eax, -0xc(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x10(%rbp)
movb %al, -0x11(%rbp)
jne 0x9e51
cmpl $0x0, -0xc(%rbp)
setg %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x9e5a
jmp 0x9ea0
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rcx
leaq 0x21a87(%rip), %rax     # 0x2b8f0
movq (%rax,%rcx,8), %rsi
callq 0x2150
cmpl $0x0, %eax
jne 0x9e93
callq 0x9d80
movl -0xc(%rbp), %esi
subl $0x1, %esi
movl $0x7, %edi
callq 0x9650
movl $0x1, -0x10(%rbp)
jmp 0x9e95
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x9e3c
movl $0x1, -0xc(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x10(%rbp)
movb %al, -0x12(%rbp)
jne 0x9ec1
movl -0xc(%rbp), %eax
cmpl 0x206b5(%rip), %eax     # 0x2a570
setle %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
testb $0x1, %al
jne 0x9eca
jmp 0x9f10
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rcx
leaq 0x206a7(%rip), %rax     # 0x2a580
movq (%rax,%rcx,8), %rsi
callq 0x2150
cmpl $0x0, %eax
jne 0x9f03
callq 0x9d80
movl -0xc(%rbp), %esi
subl $0x1, %esi
movl $0x6, %edi
callq 0x9650
movl $0x1, -0x10(%rbp)
jmp 0x9f05
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x9ea7
cmpl $0x0, -0x10(%rbp)
jne 0x9f5f
movl $0x2, %edi
xorl %esi, %esi
callq 0x9650
movq -0x8(%rbp), %rdi
callq 0x4000
movswl %ax, %edi
callq 0xa290
movl %eax, %esi
movl $0x4, %edi
callq 0x9650
callq 0x9d80
leaq 0x2a4f(%rip), %rdi      # 0xc99a
callq 0x4000
xorl %edi, %edi
movl $0x2, %esi
movswl %ax, %edx
callq 0x9c10
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
callq 0xa300
movl %eax, -0x4(%rbp)
xorl %eax, %eax
cmpl $0x0, 0x20b61(%rip)     # 0x2ad80
movb %al, -0x5(%rbp)
je 0xa251
xorl %eax, %eax
leaq 0x20313(%rip), %rcx     # 0x2a540
cmpl $0xa, (%rcx)
movb %al, -0x5(%rbp)
jne 0xa251
leaq 0x202b4(%rip), %rdi     # 0x2a4f0
leaq 0x27a3(%rip), %rsi      # 0xc9e6
callq 0x2150
cmpl $0x0, %eax
sete %al
movb %al, -0x5(%rbp)
movb -0x5(%rbp), %al
testb $0x1, %al
jne 0xa25a
jmp 0xa287
movl $0xf, %edi
movl $0x4, %esi
callq 0x9650
callq 0x8710
movl -0x4(%rbp), %edi
callq 0xa300
movl $0xf, %edi
movl $0x5, %esi
callq 0x9650
jmp 0xa216
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
cmpl $0x100, 0x20aeb(%rip)   # imm = 0x100
jl 0xa2c7
leaq 0x20bee(%rip), %rdi     # 0x2aea0
leaq 0x26ef(%rip), %rsi      # 0xc9a8
leaq 0x23f5(%rip), %rdx      # 0xc6b5
callq 0x64b0
jmp 0xa2f1
movw -0x2(%rbp), %dx
movl 0x20ac3(%rip), %eax     # 0x2ad94
addl $0x1, %eax
movl %eax, 0x20aba(%rip)     # 0x2ad94
movslq %eax, %rcx
leaq 0x20c0c(%rip), %rax     # 0x2aef0
movw %dx, (%rax,%rcx,2)
movswl -0x2(%rbp), %edi
callq 0x2fd0
movl 0x20a9d(%rip), %eax     # 0x2ad94
subl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
callq 0xa7b0
movl %eax, -0x4(%rbp)
xorl %eax, %eax
cmpl $0x0, 0x207b1(%rip)     # 0x2ad80
movb %al, -0xb(%rbp)
je 0xa5e4
leaq 0x1ff65(%rip), %rax     # 0x2a540
cmpl $0x9, (%rax)
sete %al
movb %al, -0xb(%rbp)
movb -0xb(%rbp), %al
testb $0x1, %al
jne 0xa5ed
jmp 0xa62c
leaq 0x1fefc(%rip), %rdi     # 0x2a4f0
callq 0x4000
movw %ax, -0xa(%rbp)
callq 0x8710
callq 0xa8e0
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %edi
callq 0xa7b0
movl -0x4(%rbp), %edi
movl $0x1, %esi
movswl -0xa(%rbp), %edx
callq 0x9c10
movl $0x0, -0x4(%rbp)
jmp 0xa5c6
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl 0x20730(%rip), %eax     # 0x2ad84
movl %eax, -0x10(%rbp)
movl -0x4(%rbp), %esi
movl $0xf, %edi
callq 0x9650
movl 0x2071e(%rip), %eax     # 0x2ad88
movl %eax, -0xc(%rbp)
xorl %edi, %edi
callq 0xa750
cmpl $0x0, -0x8(%rbp)
je 0xa689
movl $0xf, %edi
movl $0x5, %esi
callq 0x9650
callq 0x8710
leaq 0x1fe5b(%rip), %rdi     # 0x2a4f0
leaq 0x2397(%rip), %rsi      # 0xca33
callq 0x2150
cmpl $0x0, %eax
jne 0xa6fc
callq 0x8710
cmpl $0x0, 0x206d2(%rip)     # 0x2ad84
jne 0xa6be
movl $0x2, 0x206c6(%rip)     # 0x2ad84
callq 0x9aa0
leaq 0x1fe26(%rip), %rdi     # 0x2a4f0
leaq 0x24d1(%rip), %rsi      # 0xcba2
callq 0x2150
cmpl $0x0, %eax
je 0xa6f5
leaq 0x207be(%rip), %rdi     # 0x2aea0
leaq 0x234c(%rip), %rsi      # 0xca35
leaq 0x2353(%rip), %rdx      # 0xca43
callq 0x64b0
callq 0x8710
jmp 0xa720
callq 0xa8e0
movl %eax, %edi
callq 0xa5b0
leaq 0x1b16(%rip), %rdi      # 0xc225
callq 0x4000
xorl %esi, %esi
movl %esi, %edi
movswl %ax, %edx
callq 0x9c10
movl 0x20662(%rip), %eax     # 0x2ad88
addl $0x1, %eax
movb %al, %dl
movslq -0xc(%rbp), %rcx
leaq 0x2066a(%rip), %rax     # 0x2ada0
movb %dl, (%rax,%rcx)
movl -0x10(%rbp), %eax
movl %eax, 0x20642(%rip)     # 0x2ad84
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
xorl %eax, %eax
cmpl $0x0, 0x205bc(%rip)     # 0x2ad80
movb %al, -0xd(%rbp)
je 0xa7d9
leaq 0x1fd70(%rip), %rax     # 0x2a540
cmpl $0x1, (%rax)
sete %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
testb $0x1, %al
jne 0xa7e5
jmp 0xa8d4
movl $0x1, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x2059b(%rip), %eax     # 0x2ad90
jge 0xa83e
movslq -0x8(%rbp), %rcx
leaq 0x210ee(%rip), %rax     # 0x2b8f0
movq (%rax,%rcx,8), %rsi
leaq 0x1fce3(%rip), %rdi     # 0x2a4f0
callq 0x2150
cmpl $0x0, %eax
jne 0xa831
leaq 0x20682(%rip), %rdi     # 0x2aea0
leaq 0x21d9(%rip), %rsi      # 0xc9fe
leaq 0x1fcc4(%rip), %rdx     # 0x2a4f0
callq 0x6470
jmp 0xa833
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xa7ec
movl $0x1, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x2053e(%rip), %eax     # 0x2ad8c
jge 0xa897
movslq -0x8(%rbp), %rcx
leaq 0x20895(%rip), %rax     # 0x2b0f0
movq (%rax,%rcx,8), %rsi
leaq 0x1fc8a(%rip), %rdi     # 0x2a4f0
callq 0x2150
cmpl $0x0, %eax
jne 0xa88a
leaq 0x20629(%rip), %rdi     # 0x2aea0
leaq 0x219b(%rip), %rsi      # 0xca19
leaq 0x1fc6b(%rip), %rdx     # 0x2a4f0
callq 0x6470
jmp 0xa88c
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xa845
movl $0x0, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0xa8c3
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
leaq 0x1fc3f(%rip), %rdi     # 0x2a4f0
callq 0x4000
movl -0x14(%rbp), %edi
xorl %esi, %esi
movswl %ax, %edx
callq 0x9c10
movl $0x0, -0x4(%rbp)
callq 0x8710
jmp 0xa7bb
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $-0x1, -0x4(%rbp)
jne 0xac32
movl $0x5, %edi
movl $0x3, %esi
callq 0x9650
jmp 0xac6b
cmpl $0x0, -0x4(%rbp)
jl 0xac4d
cmpl $0x2, -0x4(%rbp)
jg 0xac4d
movl -0x4(%rbp), %esi
movl $0x5, %edi
callq 0x9650
jmp 0xac69
movl -0x4(%rbp), %edi
callq 0x34a0
movswl %ax, %edi
callq 0xa290
movl %eax, %esi
movl $0x4, %edi
callq 0x9650
jmp 0xac6b
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)