LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x3377
movl %eax, %ebx
testw %ax, %ax
jne 0x3827
movq %r14, %rdi
callq 0x2e75
movl %eax, %ebx
movzwl 0x24150(%rip), %eax     # 0x27912
testw %ax, %ax
jne 0x37e4
leaq 0x240c6(%rip), %rax     # 0x27894
movswl (%rax), %edi
leaq 0x58d0(%rip), %rsi      # 0x90a8
callq 0x345c
movw %ax, 0x2412e(%rip)      # 0x27912
movswl %bx, %ebp
movl %ebp, %ecx
shrl %ecx
movswq %cx, %rcx
shlq $0x4, %rcx
leaq 0xaa46(%rip), %rdx      # 0xe240
movw %ax, (%rdx,%rcx)
movswl %ax, %edi
callq 0x2eda
leaq 0x24087(%rip), %rax     # 0x27894
movswl (%rax), %r15d
movq %r14, %rdi
callq 0x3344
movl %r15d, %edi
movl %eax, %esi
movl %ebp, %edx
xorl %ecx, %ecx
callq 0x313c
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/afi-lambda[P]a_little_smalltalk/src/news.c
// Function: copyFrom
object copyFrom(object obj, int start, int size)
{
    object newObj;
    int i;

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r15d
movl %edi, 0x4(%rsp)
movl $0x6, %edi
callq 0x2d09
movswl %ax, %r14d
leaq 0x23fa3(%rip), %rax     # 0x27894
movswl (%rax), %edi
leaq 0x5a13(%rip), %rsi      # 0x930e
callq 0x345c
movl %r14d, %ecx
shrl %ecx
movswq %cx, %r13
shlq $0x4, %r13
leaq 0xa92c(%rip), %r12      # 0xe240
movw %ax, (%r12,%r13)
movswl %ax, %edi
callq 0x2eda
movl 0x4(%rsp), %edi
callq 0x3130
movq 0x8(%r12,%r13), %rcx
movw %ax, (%rcx)
movswl %ax, %edi
callq 0x2eda
movq 0x8(%r12,%r13), %rax
movw %r15w, 0x2(%rax)
movl %r15d, %edi
callq 0x2eda
movq 0x8(%r12,%r13), %rax
movw %bp, 0x4(%rax)
movl %ebp, %edi
callq 0x2eda
movq 0x8(%r12,%r13), %rax
movw %bx, 0x6(%rax)
movl %ebx, %edi
callq 0x2eda
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_O3/afi-lambda[P]a_little_smalltalk/src/news.c
// Function: newDictionary
object newDictionary(int size)
{
    object newObj;

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

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movl $0x8, %edi
callq 0x2e43
leaq 0x23e88(%rip), %r14     # 0x27890
movw %ax, (%r14)
movswl %ax, %ebx
movl %ebx, %edi
callq 0x2ed2
movswl (%r14), %eax
shrl %eax
movswq %ax, %rax
shlq $0x4, %rax
leaq 0xa815(%rip), %r14      # 0xe240
movq 0x8(%r14,%rax), %rax
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
leaq 0x23e54(%rip), %rax     # 0x27894
movswl (%rax), %edi
leaq 0x58cc(%rip), %rsi      # 0x9316
callq 0x345c
movl %ebx, %ecx
shrl %ecx
movswq %cx, %rcx
shlq $0x4, %rcx
movw %ax, (%r14,%rcx)
movswl %ax, %edi
callq 0x2eda
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/afi-lambda[P]a_little_smalltalk/src/news.c
// Function: newLink
object newLink(object key, object value)
{
    object newObj;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movl %edi, %r14d
movl $0x3, %edi
callq 0x2d09
movswl %ax, %ebp
leaq 0x23dd2(%rip), %rax     # 0x27894
movswl (%rax), %edi
leaq 0x55e9(%rip), %rsi      # 0x90b5
callq 0x345c
movl %ebp, %ecx
shrl %ecx
movswq %cx, %r15
shlq $0x4, %r15
leaq 0xa75c(%rip), %r12      # 0xe240
movw %ax, (%r12,%r15)
movswl %ax, %edi
callq 0x2eda
movq 0x8(%r12,%r15), %rax
movw %r14w, (%rax)
movl %r14d, %edi
callq 0x2eda
movq 0x8(%r12,%r15), %rax
movw %bx, 0x2(%rax)
movl %ebx, %edi
callq 0x2eda
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2e75
movl %eax, %ebx
movzwl 0x23d9d(%rip), %eax     # 0x27910
testw %ax, %ax
jne 0x3b95
leaq 0x23d15(%rip), %rax     # 0x27894
movswl (%rax), %edi
leaq 0x56db(%rip), %rsi      # 0x9264
callq 0x345c
movw %ax, 0x23d7b(%rip)      # 0x27910
movswl %bx, %ecx
shrl %ecx
movswq %cx, %rcx
shlq $0x4, %rcx
leaq 0xa697(%rip), %rdx      # 0xe240
movw %ax, (%rdx,%rcx)
movswl %ax, %edi
callq 0x2eda
movl %ebx, %eax
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movw $0x0, 0x2326d(%rip)     # 0x27fd0
movzwl (%rdi), %ebp
xorl %ebx, %ebx
testw %bp, %bp
je 0x4dce
movq %rdi, %r14
leaq 0x94c9(%rip), %r12      # 0xe240
leaq 0x61(%rip), %r15        # 0x4ddf
movswl %bp, %eax
shrl %eax
movswq %ax, %r13
shlq $0x4, %r13
movq 0x8(%r12,%r13), %rax
movswl 0x4(%rax), %edi
movswl 0x2323b(%rip), %esi     # 0x27fd6
movq %r15, %rdx
callq 0x3278
movw %ax, 0x23226(%rip)      # 0x27fd0
testw %ax, %ax
jne 0x4dc5
leaq (%r12,%r13), %rax
addq $0x8, %rax
movq (%rax), %rax
movzwl 0x6(%rax), %ebp
testw %bp, %bp
jne 0x4d7e
jmp 0x4dce
movw %bp, (%r14)
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4e52
movswl (%rsi), %edi
leaq 0x22a6c(%rip), %rbx     # 0x27890
movw %di, (%rbx)
callq 0x2ed2
movswl (%rbx), %eax
shrl %eax
movswq %ax, %rax
shlq $0x4, %rax
leaq 0x9400(%rip), %rcx      # 0xe240
movq 0x8(%rcx,%rax), %rdi
callq 0x20b0
movl %eax, %edi
popq %rbx
jmp 0x3130
callq 0x273d
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x21830(%rip), %rax     # 0x27894
movswl (%rax), %edi
leaq 0x22452(%rip), %rsi     # 0x284c0
callq 0x345c
movl %eax, %ebx
testw %ax, %ax
jne 0x6088
leaq 0x2243f(%rip), %rdi     # 0x284c0
callq 0x3708
movl %eax, %ebx
movswl %bx, %eax
shrl %eax
movswq %ax, %rax
shlq $0x4, %rax
leaq 0x81a4(%rip), %rcx      # 0xe240
movq 0x8(%rcx,%rax), %rdx
cmpw $0x0, 0x2(%rdx)
jne 0x60c6
leaq (%rcx,%rax), %r14
addq $0x8, %r14
xorl %edi, %edi
callq 0x3130
movq (%r14), %rcx
movw %ax, 0x2(%rcx)
movswl %ax, %edi
callq 0x2eda
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/afi-lambda[P]a_little_smalltalk/src/lex.c
// Function: peek
static char nextChar()
{
    if (pushindex > 0)
        cc = pushBuffer[--pushindex];
    else if (*cp)
        cc = *cp++;
    else
        cc = '\0';
    return (cc);
}

// Assembly:
movl 0x21c0a(%rip), %ecx     # 0x284b0
leaq 0x21c73(%rip), %rdx     # 0x28520
testl %ecx, %ecx
jle 0x68b8
decl %ecx
movb (%rcx,%rdx), %al
jmp 0x68d3
movq 0x21bf9(%rip), %rsi     # 0x284b8
movb (%rsi), %al
testb %al, %al
je 0x68d1
incq %rsi
movq %rsi, 0x21be9(%rip)     # 0x284b8
jmp 0x68d3
xorl %eax, %eax
leal 0x1(%rcx), %esi
movl %esi, 0x21bd4(%rip)     # 0x284b0
movslq %ecx, %rcx
movb %al, (%rcx,%rdx)
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x69a7
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 0x7934(%rip), %rbx      # 0xe240
movq 0x8(%rbx,%r14), %rax
movswl 0x6(%rax), %edi
callq 0x68e4
movq 0x8(%rbx,%r14), %rax
movzwl 0x8(%rax), %eax
testw %ax, %ax
je 0x6998
cwtl
shrl %eax
movswq %ax, %r14
shlq $0x4, %r14
movzwl 0x4(%rbx,%r14), %r15d
testw %r15w, %r15w
jle 0x6998
addq %rbx, %r14
xorl %r12d, %r12d
leaq 0x20f44(%rip), %r13     # 0x27890
leaq 0x21bed(%rip), %rbp     # 0x28540
movq 0x8(%r14), %rax
movswl (%rax,%r12,2), %edi
movw %di, (%r13)
callq 0x2ed2
movswl (%r13), %eax
shrl %eax
movswq %ax, %rax
shlq $0x4, %rax
movq 0x8(%rbx,%rax), %rax
movslq 0x21baf(%rip), %rcx     # 0x28530
leaq 0x1(%rcx), %rdx
movl %edx, 0x21ba5(%rip)     # 0x28530
movq %rax, 0x8(%rbp,%rcx,8)
incq %r12
cmpq %r12, %r15
jne 0x6953
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x0, 0x21b7f(%rip)     # 0x28530
retq
// File: /workspace/github_c_makefile_star2_O3/afi-lambda[P]a_little_smalltalk/src/parser.c
// Function: genInstruction
static void genInstruction(int high, int low)
{
    if (low >= 16)
    {
        genInstruction(Extended, high);
        genCode(low);
    }
    else
        genCode(high * 16 + low);
}

// Assembly:
pushq %rbx
movl %esi, %ebx
movl %edi, %esi
cmpl $0x10, %ebx
jl 0x6f56
xorl %edi, %edi
callq 0x6f21
movslq 0x21e0f(%rip), %rax     # 0x28d48
cmpq $0x100, %rax            # imm = 0x100
jge 0x6f65
leal 0x1(%rax), %ecx
movl %ecx, 0x21dfe(%rip)     # 0x28d48
leaq 0x21e0f(%rip), %rcx     # 0x28d60
movb %bl, (%rax,%rcx)
jmp 0x6f99
movslq 0x21deb(%rip), %rax     # 0x28d48
cmpq $0x100, %rax            # imm = 0x100
jl 0x6f80
leaq 0x21ef4(%rip), %rdi     # 0x28e60
leaq 0x2b5b(%rip), %rsi      # 0x9ace
leaq 0x2753(%rip), %rdx      # 0x96cd
popq %rbx
jmp 0x26d5
shll $0x4, %esi
addl %ebx, %esi
leal 0x1(%rax), %ecx
movl %ecx, 0x21dba(%rip)     # 0x28d48
leaq 0x21dcb(%rip), %rcx     # 0x28d60
movb %sil, (%rax,%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r14d
movl %edi, %ebp
movl %esi, %eax
orl %edi, %eax
je 0x721a
movl %r14d, %eax
xorl $0x1, %eax
orl %ebp, %eax
sete %cl
leaq 0x206e4(%rip), %rax     # 0x278d0
movzwl (%rax), %eax
testw %ax, %ax
setne %dl
testb %dl, %cl
je 0x728e
xorl %esi, %esi
leaq 0x206ca(%rip), %rcx     # 0x278d0
cmpw %bx, %ax
je 0x7247
movzwl 0x2(%rcx,%rsi,2), %eax
incq %rsi
testw %ax, %ax
jne 0x7206
jmp 0x728e
leaq 0x2068f(%rip), %rax     # 0x278b0
movzwl (%rax), %ecx
testw %cx, %cx
sete %r15b
je 0x725b
xorl %esi, %esi
cmpw %bx, %cx
je 0x7251
movzwl 0x2(%rax,%rsi,2), %ecx
incq %rsi
testw %cx, %cx
sete %r15b
jne 0x722f
jmp 0x725b
movl $0xb, %edi
jmp 0x72dc
movl $0xa, %edi
callq 0x6f21
movl %r14d, %eax
xorl $0x1, %eax
orl %ebp, %eax
jne 0x7284
testb $0x1, %r15b
je 0x734e
leaq 0x2065a(%rip), %rax     # 0x278d0
movzwl (%rax), %eax
testw %ax, %ax
jne 0x71fd
jmp 0x728e
testb $0x1, %r15b
je 0x734e
incl %r14d
movl $0x8, %edi
movl %r14d, %esi
callq 0x6f21
testl %ebp, %ebp
je 0x72cd
movslq 0x21a9f(%rip), %rax     # 0x28d48
cmpq $0x100, %rax            # imm = 0x100
jl 0x72eb
leaq 0x21ba8(%rip), %rdi     # 0x28e60
leaq 0x280f(%rip), %rsi      # 0x9ace
leaq 0x2407(%rip), %rdx      # 0x96cd
callq 0x26d5
jmp 0x72ff
movswl %bx, %edi
callq 0x77ff
movl $0x9, %edi
movl %eax, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6f21
leal 0x1(%rax), %ecx
movl %ecx, 0x21a54(%rip)     # 0x28d48
leaq 0x21a65(%rip), %rcx     # 0x28d60
movb $-0x5, (%rax,%rcx)
movswl %bx, %edi
callq 0x77ff
movslq 0x21a3a(%rip), %rcx     # 0x28d48
cmpq $0x100, %rcx            # imm = 0x100
jl 0x733b
leaq 0x21b42(%rip), %rdi     # 0x28e60
leaq 0x27a9(%rip), %rsi      # 0x9ace
leaq 0x23a1(%rip), %rdx      # 0x96cd
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x26d5
leal 0x1(%rcx), %edx
movl %edx, 0x21a04(%rip)     # 0x28d48
leaq 0x21a15(%rip), %rdx     # 0x28d60
movb %al, (%rcx,%rdx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
leaq 0x211a5(%rip), %r14     # 0x28510
cmpl $0x1, (%r14)
jne 0x73b3
leaq 0x21148(%rip), %rbx     # 0x284c0
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x2050
callq 0x60e6
cmpl $0x9, (%r14)
jne 0x739f
cmpb $0x3c, (%rbx)
jne 0x739f
cmpb $0x2d, 0x1(%rbx)
jne 0x739f
cmpb $0x0, 0x2(%rbx)
je 0x73d7
movq %rsp, %rdi
callq 0x7539
movl %eax, %edi
callq 0x770d
jmp 0x752d
callq 0x7e67
cmpl $0x0, 0x21981(%rip)     # 0x28d40
je 0x752d
movl %eax, %edi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x770d
callq 0x60e6
movslq 0x2196d(%rip), %rbx     # 0x28d50
testq %rbx, %rbx
jle 0x7418
leaq 0x224c1(%rip), %rax     # 0x298b0
leaq (%rax,%rbx,8), %r15
movq %rsp, %r14
movq (%r15), %rsi
movq %r14, %rdi
callq 0x2160
testl %eax, %eax
je 0x7478
je 0x7418
leaq -0x1(%rbx), %rax
addq $-0x8, %r15
cmpq $0x1, %rbx
movq %rax, %rbx
jg 0x73f6
movslq 0x21111(%rip), %r15     # 0x28530
testq %r15, %r15
jle 0x744d
xorl %ebx, %ebx
leaq 0x21113(%rip), %r12     # 0x28540
movq %rsp, %r14
movq 0x8(%r12,%rbx,8), %rsi
movq %r14, %rdi
callq 0x2160
testl %eax, %eax
je 0x751c
incq %rbx
cmpq %r15, %rbx
jb 0x7430
movslq 0x218f4(%rip), %rax     # 0x28d48
cmpq $0x100, %rax            # imm = 0x100
jl 0x7489
leaq 0x219fd(%rip), %rdi     # 0x28e60
leaq 0x2664(%rip), %rsi      # 0x9ace
leaq 0x225c(%rip), %rdx      # 0x96cd
callq 0x26d5
jmp 0x749d
callq 0x7359
decl %ebx
movl $0x7, %edi
jmp 0x7526
leal 0x1(%rax), %ecx
movl %ecx, 0x218b6(%rip)     # 0x28d48
leaq 0x218c7(%rip), %rcx     # 0x28d60
movb $0x20, (%rax,%rcx)
movq %rsp, %rdi
callq 0x379b
movswl %ax, %edi
callq 0x77ff
movl $0x4, %edi
movl %eax, %esi
callq 0x6f21
callq 0x7359
leaq 0x2558(%rip), %rdi      # 0x9a1d
callq 0x379b
movl %eax, %ebx
movslq 0x21875(%rip), %rax     # 0x28d48
cmpq $0x100, %rax            # imm = 0x100
jl 0x74f7
leaq 0x2197e(%rip), %rdi     # 0x28e60
leaq 0x25e5(%rip), %rsi      # 0x9ace
leaq 0x21dd(%rip), %rdx      # 0x96cd
callq 0x26d5
jmp 0x750b
leal 0x1(%rax), %ecx
movl %ecx, 0x21848(%rip)     # 0x28d48
leaq 0x21859(%rip), %rcx     # 0x28d60
movb $-0x7d, (%rax,%rcx)
movswl %bx, %edi
callq 0x77ff
movl $0x9, %edi
movl %eax, %esi
jmp 0x7528
callq 0x7359
movl $0x6, %edi
movl %ebx, %esi
callq 0x6f21
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/afi-lambda[P]a_little_smalltalk/src/parser.c
// Function: continuation
static void continuation(boolean superReceiver)
{
    superReceiver = keyContinuation(superReceiver);

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x7853
cmpl $0x0, 0x2161c(%rip)     # 0x28d40
je 0x77f0
leaq 0x20ddf(%rip), %r13     # 0x28510
cmpl $0xa, (%r13)
jne 0x77f0
movl %eax, %ebx
leaq 0x20d7b(%rip), %rbp     # 0x284c0
leaq 0x2382(%rip), %r15      # 0x9ace
leaq 0x1f7a(%rip), %r12      # 0x96cd
leaq 0x21606(%rip), %r14     # 0x28d60
cmpb $0x3b, (%rbp)
jne 0x77f0
cmpb $0x0, 0x1(%rbp)
jne 0x77f0
movslq 0x215d3(%rip), %rax     # 0x28d48
cmpq $0x100, %rax            # imm = 0x100
jl 0x7791
leaq 0x216dc(%rip), %rdi     # 0x28e60
movq %r15, %rsi
movq %r12, %rdx
callq 0x26d5
jmp 0x779f
leal 0x1(%rax), %ecx
movl %ecx, 0x215ae(%rip)     # 0x28d48
movb $-0xc, (%rax,%r14)
callq 0x60e6
movl %ebx, %edi
callq 0x7853
movslq 0x21596(%rip), %rax     # 0x28d48
cmpq $0x100, %rax            # imm = 0x100
jl 0x77ce
leaq 0x2169f(%rip), %rdi     # 0x28e60
movq %r15, %rsi
movq %r12, %rdx
callq 0x26d5
jmp 0x77dc
leal 0x1(%rax), %ecx
movl %ecx, 0x21571(%rip)     # 0x28d48
movb $-0xb, (%rax,%r14)
cmpl $0x0, 0x2155d(%rip)     # 0x28d40
je 0x77f0
cmpl $0xa, (%r13)
je 0x775a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2154d(%rip), %rax     # 0x28d54
cmpq $0x100, %rax            # imm = 0x100
jl 0x782b
leaq 0x2164a(%rip), %rdi     # 0x28e60
leaq 0x220e(%rip), %rsi      # 0x9a2b
leaq 0x1ea9(%rip), %rdx      # 0x96cd
callq 0x26d5
jmp 0x7849
leaq 0x1(%rax), %rcx
movl %ecx, 0x2151f(%rip)     # 0x28d54
leaq 0x21674(%rip), %rcx     # 0x28eb0
movw %di, 0x2(%rcx,%rax,2)
movswl %di, %edi
callq 0x2eda
movl 0x21505(%rip), %eax     # 0x28d54
decl %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/afi-lambda[P]a_little_smalltalk/src/parser.c
// Function: binaryContinuation
static boolean binaryContinuation(boolean superReceiver)
{
    boolean superTerm;
    object messagesym;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
callq 0x7d44
movl %eax, %ebx
cmpl $0x0, 0x211a7(%rip)     # 0x28d40
je 0x7bea
leaq 0x2096e(%rip), %r15     # 0x28510
cmpl $0x9, (%r15)
jne 0x7bea
leaq 0x20911(%rip), %r14     # 0x284c0
movq %r14, %rdi
callq 0x379b
movl %eax, %ebp
callq 0x60e6
callq 0x7e67
movl %eax, %edi
callq 0x7d44
movswl %bp, %edx
movl %ebx, %edi
movl $0x1, %esi
callq 0x71c6
xorl %ebx, %ebx
cmpl $0x0, 0x2115e(%rip)     # 0x28d40
je 0x7bea
cmpl $0x9, (%r15)
je 0x7baf
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/afi-lambda[P]a_little_smalltalk/src/parser.c
// Function: optimizeBlock
static int optimizeBlock(int instruction, boolean dopop)
{
    int location;
    enum blockstatus savebstat;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movl %edi, %esi
movl 0x2113b(%rip), %r14d    # 0x28d44
movl $0xf, %edi
callq 0x6f21
movslq 0x2112e(%rip), %rbx     # 0x28d48
cmpq $0x100, %rbx            # imm = 0x100
jl 0x7c3f
leaq 0x21236(%rip), %rdi     # 0x28e60
leaq 0x1e9d(%rip), %rsi      # 0x9ace
leaq 0x1a95(%rip), %rdx      # 0x96cd
callq 0x26d5
jmp 0x7c53
leal 0x1(%rbx), %eax
movl %eax, 0x21100(%rip)     # 0x28d48
leaq 0x21111(%rip), %rax     # 0x28d60
movb $0x0, (%rbx,%rax)
testl %ebp, %ebp
je 0x7c96
movslq 0x210ea(%rip), %rax     # 0x28d48
cmpq $0x100, %rax            # imm = 0x100
jl 0x7c82
leaq 0x211f3(%rip), %rdi     # 0x28e60
leaq 0x1e5a(%rip), %rsi      # 0x9ace
leaq 0x1a52(%rip), %rdx      # 0x96cd
callq 0x26d5
jmp 0x7c96
leal 0x1(%rax), %ecx
movl %ecx, 0x210bd(%rip)     # 0x28d48
leaq 0x210ce(%rip), %rcx     # 0x28d60
movb $-0xb, (%rax,%rcx)
callq 0x60e6
leaq 0x2081e(%rip), %r15     # 0x284c0
cmpb $0x5b, (%r15)
jne 0x7caf
cmpb $0x0, 0x1(%r15)
je 0x7cf9
callq 0x7e67
movl %eax, %edi
callq 0x7b84
leaq 0x1578(%rip), %rdi      # 0x923a
callq 0x379b
movswl %ax, %edx
xorl %edi, %edi
xorl %esi, %esi
callq 0x71c6
movb 0x2106f(%rip), %al      # 0x28d48
incb %al
leaq 0x2107e(%rip), %rcx     # 0x28d60
movb %al, (%rbx,%rcx)
movl %r14d, 0x21058(%rip)    # 0x28d44
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x60e6
cmpl $0x0, 0x2103f(%rip)     # 0x28d44
jne 0x7d11
movl $0x2, 0x21033(%rip)     # 0x28d44
callq 0x6f9b
cmpb $0x5d, (%r15)
jne 0x7d23
cmpb $0x0, 0x1(%r15)
je 0x7d3d
leaq 0x21136(%rip), %rdi     # 0x28e60
leaq 0x1d83(%rip), %rsi      # 0x9ab4
leaq 0x1d8a(%rip), %rdx      # 0x9ac2
callq 0x26d5
callq 0x60e6
jmp 0x7cd3
// File: /workspace/github_c_makefile_star2_O3/afi-lambda[P]a_little_smalltalk/src/parser.c
// Function: unaryContinuation
static boolean unaryContinuation(boolean superReceiver)
{
    int i;
    boolean sent;

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

        sent = false;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x0, 0x20fea(%rip)     # 0x28d40
je 0x7e52
leaq 0x207ad(%rip), %rax     # 0x28510
cmpl $0x1, (%rax)
jne 0x7e52
leaq 0x21b3d(%rip), %r15     # 0x298b0
leaq 0x20746(%rip), %rbx     # 0x284c0
leaq 0x210df(%rip), %r14     # 0x28e60
leaq 0x21328(%rip), %r12     # 0x290b0
movl %edi, 0x4(%rsp)
movl 0x20fbe(%rip), %ebp     # 0x28d50
cmpl $0x2, %ebp
jl 0x7dd0
movl $0x1, %r13d
movq (%r15,%r13,8), %rsi
movq %rbx, %rdi
callq 0x2160
testl %eax, %eax
jne 0x7dc5
movq %r14, %rdi
leaq 0x1cc8(%rip), %rsi      # 0x9a7f
movq %rbx, %rdx
callq 0x26b4
movl 0x20f8b(%rip), %ebp     # 0x28d50
incq %r13
movslq %ebp, %rax
cmpq %rax, %r13
jl 0x7d9d
movl 0x20f76(%rip), %ebp     # 0x28d4c
cmpl $0x2, %ebp
jl 0x7e14
movl $0x1, %r13d
movq (%r12,%r13,8), %rsi
movq %rbx, %rdi
callq 0x2160
testl %eax, %eax
jne 0x7e09
movq %r14, %rdi
leaq 0x1c9f(%rip), %rsi      # 0x9a9a
movq %rbx, %rdx
callq 0x26b4
movl 0x20f43(%rip), %ebp     # 0x28d4c
incq %r13
movslq %ebp, %rax
cmpq %rax, %r13
jl 0x7de1
movq %rbx, %rdi
callq 0x379b
movswl %ax, %edx
xorl %r13d, %r13d
movl 0x4(%rsp), %edi
xorl %esi, %esi
callq 0x71c6
callq 0x60e6
cmpl $0x0, 0x20f07(%rip)     # 0x28d40
je 0x7e55
leaq 0x206ce(%rip), %rax     # 0x28510
cmpl $0x1, (%rax)
movl $0x0, %edi
je 0x7d88
jmp 0x7e55
movl %edi, %r13d
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/afi-lambda[P]a_little_smalltalk/src/parser.c
// Function: genInteger
static void genInteger(int val)
{
    if (val == -1)
        genInstruction(PushConstant, minusOne);
    else if ((val >= 0) && (val <= 2))
        genInstruction(PushConstant, val);
    else
        genInstruction(PushLiteral, genLiteral(newInteger(val)));
}

// Assembly:
cmpl $-0x1, %edi
je 0x805c
movl %edi, %esi
cmpl $0x2, %edi
ja 0x8085
movl $0x5, %edi
jmp 0x6f21
movslq 0x20ce5(%rip), %rax     # 0x28d48
cmpq $0x100, %rax            # imm = 0x100
jl 0x80a2
leaq 0x20dee(%rip), %rdi     # 0x28e60
leaq 0x1a55(%rip), %rsi      # 0x9ace
leaq 0x164d(%rip), %rdx      # 0x96cd
jmp 0x26d5
pushq %rax
movl %esi, %edi
callq 0x3130
movswl %ax, %edi
callq 0x77ff
movl $0x4, %edi
movl %eax, %esi
popq %rax
jmp 0x6f21
leal 0x1(%rax), %ecx
movl %ecx, 0x20c9d(%rip)     # 0x28d48
leaq 0x20cae(%rip), %rcx     # 0x28d60
movb $0x53, (%rax,%rcx)
retq
// File: /workspace/github_c_makefile_star2_O3/afi-lambda[P]a_little_smalltalk/src/parser.c
// Function: parsePrimitive
static void parsePrimitive()
{
    int primitiveNumber, argumentCount;

    if (nextToken() != intconst)
        compilError(selector, "primitive number missing", "");
    primitiveNumber = tokenInteger;
    nextToken();
    argumentCount = 0;
    while (parseok && !((token == binary) && streq(tokenString, ">")))
    {
        term();
        argumentCount++;
    }
    genInstruction(DoPrimitive, argumentCount);
    genCode(primitiveNumber);
    nextToken();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
callq 0x60e6
cmpl $0x3, %eax
je 0x8359
leaq 0x20b1a(%rip), %rdi     # 0x28e60
leaq 0x1845(%rip), %rsi      # 0x9b92
leaq 0x1379(%rip), %rdx      # 0x96cd
callq 0x26d5
leaq 0x201b4(%rip), %rax     # 0x28514
movl (%rax), %ebp
callq 0x60e6
cmpl $0x0, 0x209d2(%rip)     # 0x28d40
je 0x83a5
xorl %ebx, %ebx
leaq 0x20197(%rip), %r14     # 0x28510
leaq 0x20140(%rip), %r15     # 0x284c0
cmpl $0x9, (%r14)
jne 0x8393
cmpb $0x3e, (%r15)
jne 0x8393
cmpb $0x0, 0x1(%r15)
je 0x83a7
callq 0x7e67
incl %ebx
cmpl $0x0, 0x2099f(%rip)     # 0x28d40
jne 0x8380
jmp 0x83a7
xorl %ebx, %ebx
movl $0xd, %edi
movl %ebx, %esi
callq 0x6f21
movslq 0x2098e(%rip), %rax     # 0x28d48
cmpq $0x100, %rax            # imm = 0x100
jl 0x83de
leaq 0x20a97(%rip), %rdi     # 0x28e60
leaq 0x16fe(%rip), %rsi      # 0x9ace
leaq 0x12f6(%rip), %rdx      # 0x96cd
callq 0x26d5
jmp 0x83f2
leal 0x1(%rax), %ecx
movl %ecx, 0x20961(%rip)     # 0x28d48
leaq 0x20972(%rip), %rcx     # 0x28d60
movb %bpl, (%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x60e6
// File: /workspace/github_c_makefile_star2_O3/afi-lambda[P]a_little_smalltalk/src/unixio.c
// Function: imageRead
void imageRead(FILE *fp)
{
    short i, size;
    //object *mBlockAlloc();

    fr(fp, (char *) &symbols, sizeof(object));
    i = 0;

    while (fr(fp, (char *) &dummyObject, sizeof(dummyObject)))
    {
        i = dummyObject.di;

        if ((i < 0) || (i > ObjectTableMax))
            sysError("reading index out of range", "");
        objectTable[i].STclass = dummyObject.cl;
        if ((objectTable[i].STclass < 0) || ((objectTable[i].STclass >> 1)
                                             > ObjectTableMax))
        {
            fprintf(stderr, "index %d\n", dummyObject.cl);
            sysError("class out of range", "imageRead");
        }
        objectTable[i].size = size = dummyObject.ds;
        if (size < 0)
            size = ((-size) + 1) / 2;
        if (size != 0)
        {
            objectTable[i].memory = mBlockAlloc((int) size);
            fr(fp, (char *) objectTable[i].memory, sizeof(object)
               * (int) size);
        }
        else
            objectTable[i].memory = (object *) 0;
    }

    /* now restore ref counts, getting rid of unneeded junk */
    visit(symbols);
    /* toss out the old free lists, build new ones */
    setFreeLists();

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1f08b(%rip), %rsi     # 0x27894
movl $0x2, %edx
callq 0x891a
leaq 0x21896(%rip), %rsi     # 0x2a0b0
movq %rbx, %rdi
movl $0x8, %edx
callq 0x891a
testl %eax, %eax
je 0x88f6
leaq 0xe97(%rip), %r12       # 0x96cd
leaq 0x5a03(%rip), %rbp      # 0xe240
leaq 0x2186c(%rip), %r13     # 0x2a0b0
movl 0x21865(%rip), %r14d    # 0x2a0b0
movzwl %r14w, %eax
cmpl $0x1965, %eax           # imm = 0x1965
jb 0x8865
leaq 0x13eb(%rip), %rdi      # 0x9c48
movq %r12, %rsi
callq 0x4dec
movzwl 0x21848(%rip), %edi     # 0x2a0b4
movswq %r14w, %r14
shlq $0x4, %r14
movw %di, (%rbp,%r14)
cmpl $0x32ca, %edi           # imm = 0x32CA
jae 0x88ef
addq %rbp, %r14
movzwl 0x2182a(%rip), %eax     # 0x2a0b6
movw %ax, 0x4(%r14)
movl $0x1, %ecx
subl %eax, %ecx
movzwl %cx, %r15d
shrl %r15d
testw %ax, %ax
cmovnsl %eax, %r15d
testw %r15w, %r15w
je 0x88cd
movzwl %r15w, %edi
callq 0x2ca2
movq %rax, 0x8(%r14)
leal (%r15,%r15), %ecx
movzwl %cx, %edx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x891a
jmp 0x88d5
movq $0x0, 0x8(%r14)
movq %rbx, %rdi
movq %r13, %rsi
movl $0x8, %edx
callq 0x891a
testl %eax, %eax
jne 0x8844
jmp 0x88f6
callq 0x287d
jmp 0x8882
leaq 0x1ef97(%rip), %rax     # 0x27894
movswl (%rax), %edi
callq 0x304a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2c2f
// File: /workspace/github_c_makefile_star2_O3/afi-lambda[P]a_little_smalltalk/src/unixio.c
// Function: fr
static int fr(FILE *fp, char *p, int s)
{
    int r;

    r = fread(p, s, 1, fp);
    if (r && (r != 1))
        sysError("imageRead count error", "");
    return r;
}

// Assembly:
pushq %rbx
movq %rsi, %rax
movq %rdi, %rcx
movslq %edx, %rsi
movl $0x1, %edx
movq %rax, %rdi
callq 0x2070
movq %rax, %rbx
cmpl $0x2, %ebx
jb 0x894c
leaq 0x138f(%rip), %rdi      # 0x9ccf
leaq 0xd86(%rip), %rsi       # 0x96cd
callq 0x4dec
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/afi-lambda[P]a_little_smalltalk/src/unixio.c
// Function: imageWrite
void imageWrite(FILE *fp)
{
    short i, size;

    fw(fp, (char *) &symbols, sizeof(object));

    for (i = 0; i < ObjectTableMax; i++)
    {
        if (objectTable[i].referenceCount > 0)
        {
            dummyObject.di = i;
            dummyObject.cl = objectTable[i].STclass;
            dummyObject.ds = size = objectTable[i].size;
            fw(fp, (char *) &dummyObject, sizeof(dummyObject));
            if (size < 0)
                size = ((-size) + 1) / 2;
            if (size != 0)
                fw(fp, (char *) objectTable[i].memory, sizeof(object) * size);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x1ef32(%rip), %rsi     # 0x27894
movl $0x2, %edx
callq 0x89f7
leaq 0x58cd(%rip), %r15      # 0xe240
addq $0x8, %r15
xorl %r12d, %r12d
leaq 0x2172f(%rip), %r14     # 0x2a0b0
cmpw $0x0, -0x6(%r15)
jle 0x89de
movl %r12d, 0x21720(%rip)    # 0x2a0b0
movzwl -0x8(%r15), %eax
movw %ax, 0x21718(%rip)      # 0x2a0b4
movl -0x4(%r15), %ebp
movw %bp, 0x2170f(%rip)      # 0x2a0b6
movq %rbx, %rdi
movq %r14, %rsi
movl $0x8, %edx
callq 0x89f7
movl $0x1, %eax
subl %ebp, %eax
movzwl %ax, %eax
shrl %eax
testw %bp, %bp
cmovnsl %ebp, %eax
testw %ax, %ax
je 0x89de
movq (%r15), %rsi
addl %eax, %eax
movzwl %ax, %edx
movq %rbx, %rdi
callq 0x89f7
incq %r12
addq $0x10, %r15
cmpq $0x1964, %r12           # imm = 0x1964
jne 0x8981
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ngkaho1234[P]ext4-extents-tree/mkdb.c
// Function: main
int main(int argc, char **argv)
{
	int index = -1;
	int opt;
	struct arg_table argtbl;

	while ((opt = getopt(argc, argv, "n:f:")) != -1) {
		switch (opt) {
		case 'n':
			argtbl.size = atoll(optarg);
			break;
		case 'f':
			/* FIXME: Beware of overflowing!!!. */
			strcpy(argtbl.path, optarg);
			break;
		default:
			usage(argc, argv);
			exit(EXIT_FAILURE);
		}
		index++;
	}
	if (index < 0) {
		usage(argc, argv);
		exit(EXIT_FAILURE);
	}
	if (mkdb(&argtbl))
		exit(EXIT_FAILURE);

	exit(EXIT_SUCCESS);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movq %rsi, %rbx
movl %edi, %r14d
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
leaq 0x39e7(%rip), %r15      # 0x608a
movq 0x692e(%rip), %r12      # 0x8fd8
movl %r14d, %edi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2240
cmpl $0x66, %eax
je 0x26d1
cmpl $0x6e, %eax
jne 0x26e6
movq (%r12), %rdi
callq 0x2150
movq %rax, -0x30(%rbp)
jmp 0x26e1
movq (%r12), %rsi
leaq -0x1030(%rbp), %rdi
callq 0x2050
incl %r13d
jmp 0x26aa
cmpl $-0x1, %eax
jne 0x26f0
testl %r13d, %r13d
jns 0x2702
movq %rbx, %rsi
callq 0x248c
movl $0x1, %edi
callq 0x2260
leaq -0x1030(%rbp), %rdi
callq 0x24a2
testl %eax, %eax
jne 0x26f8
xorl %edi, %edi
callq 0x2260
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/ngkaho1234[P]ext4-extents-tree/extents_bh.c
// Function: fs_bread
struct buffer_head *fs_bread(struct super_block *sb, ext4_fsblk_t block, int *ret)
{
	int err = 0;
	struct buffer_head *bh;
	bh = sb_getblk(sb, block);
	if (!bh)
		return NULL;

	err = bh_submit_read(bh);
	wait_on_buffer(bh);
	if (ret)
		*ret = err;

	fs_bh_alloc++;

	return bh;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl (%rdi), %edx
movq 0x10(%rdi), %rdi
callq 0x2fae
movq %rax, %r14
testq %rax, %rax
je 0x2769
movq %r14, %rdi
callq 0x2eec
movl %eax, %r15d
movq %r14, %rdi
callq 0x2ad9
testq %rbx, %rbx
je 0x2763
movl %r15d, (%rbx)
incl 0x6a2b(%rip)            # 0x9194
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ngkaho1234[P]ext4-extents-tree/extents_bh.c
// Function: fs_bwrite
struct buffer_head *fs_bwrite(struct super_block *sb, ext4_fsblk_t block, int *ret)
{
	int err = 0;
	struct buffer_head *bh;
	bh = sb_getblk(sb, block);
	if (ret)
		*ret = err;

	if (bh)
		fs_bh_alloc++;

	return bh;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl (%rdi), %edx
movq 0x10(%rdi), %rdi
callq 0x2fae
testq %rbx, %rbx
je 0x2796
movl $0x0, (%rbx)
testq %rax, %rax
je 0x27a1
incl 0x69f3(%rip)            # 0x9194
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ngkaho1234[P]ext4-extents-tree/buffer.c
// Function: bdev_alloc
struct block_device *bdev_alloc(int fd, int blocksize_bits)
{
	struct block_device *bdev;
	struct super_block *super;

	bdev = xmalloc(sizeof(struct block_device) + sizeof(struct super_block));
	memset(bdev, 0,
	       sizeof(struct block_device) + sizeof(struct super_block));
	super = (struct super_block *)(bdev + 1);

	bdev->bd_fd = fd;
	bdev->bd_flags = 0;
	bdev->bd_super = super;

	INIT_LIST_HEAD(&bdev->bd_bh_free);
	INIT_LIST_HEAD(&bdev->bd_bh_dirty);
#ifndef USE_AIO
	INIT_LIST_HEAD(&bdev->bd_bh_ioqueue);
#endif
	pthread_mutex_init(&bdev->bd_bh_free_lock, NULL);
	pthread_mutex_init(&bdev->bd_bh_dirty_lock, NULL);
#ifndef USE_AIO
	pthread_mutex_init(&bdev->bd_bh_ioqueue_lock, NULL);
#endif
	pthread_mutex_init(&bdev->bd_bh_root_lock, NULL);

	super->s_blocksize_bits = blocksize_bits;
	super->s_blocksize = 1 << super->s_blocksize_bits;
	super->s_bdev = bdev;

	pipe(bdev->bd_bh_writeback_wakeup_fd);
	pthread_create(&bdev->bd_bh_writeback_thread, NULL,
			buffer_writeback_thread, bdev);

#ifndef USE_AIO
	pipe(bdev->bd_bh_io_wakeup_fd);
	pthread_create(&bdev->bd_bh_io_thread, NULL,
			buffer_io_thread, bdev);
#endif

	return bdev;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movl %edi, %r15d
movl $0x1, %edi
movl $0x148, %esi            # imm = 0x148
callq 0x2140
movq %rax, %rbx
addq $0x128, %rax            # imm = 0x128
movl %r15d, (%rbx)
movq %rax, 0x10(%rbx)
leaq 0x48(%rbx), %rax
movq %rax, 0x50(%rbx)
movq %rax, 0x48(%rbx)
leaq 0x80(%rbx), %rax
movq %rax, 0x88(%rbx)
movq %rax, 0x80(%rbx)
leaq 0x20(%rbx), %rdi
xorl %esi, %esi
callq 0x22a0
leaq 0x58(%rbx), %rdi
xorl %esi, %esi
callq 0x22a0
leaq 0xc8(%rbx), %rdi
xorl %esi, %esi
callq 0x22a0
movl %r14d, 0x130(%rbx)
movl $0x1, %eax
movl %r14d, %ecx
shll %cl, %eax
cltq
movq %rax, 0x128(%rbx)
movq %rbx, 0x138(%rbx)
leaq 0x120(%rbx), %rdi
callq 0x20f0
leaq 0x110(%rbx), %rdi
leaq 0x18(%rip), %rdx        # 0x28f2
xorl %esi, %esi
movq %rbx, %rcx
callq 0x21f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ngkaho1234[P]ext4-extents-tree/buffer.c
// Function: buffer_writeback_thread
static void *buffer_writeback_thread(void *arg)
{
	struct epoll_event epev = {0};
	struct block_device *bdev = arg;
	int epfd = epoll_create(1);
	if (epfd < 0)
		return NULL;

	epev.events = EPOLLIN;
	epoll_ctl(epfd, EPOLL_CTL_ADD, bdev->bd_bh_writeback_wakeup_fd[0], &epev);

	while (1) {
		int ret;
		ret = epoll_wait(epfd, &epev, 1, buffer_writeback_ms);
		if (ret > 0) {
			/* We got an nofication. */
			signed char command;
			command = bdev_writeback_thread_read_notify(bdev);
			try_to_sync_buffers(bdev);
			if (bdev_is_notify_exiting(command))
				break;
			
			continue;
		}
		if (ret == 0) {
			/* just flush out the dirty data. */
			try_to_sync_buffers(bdev);
		}
		if (ret < 0 && errno != EINTR)
			break;

	}
	close(epfd);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq $0x0, -0x34(%rbp)
movl $0x1, %edi
callq 0x2250
testl %eax, %eax
js 0x29aa
movl %eax, %r14d
leaq -0x38(%rbp), %r15
movl $0x1, (%r15)
movl 0x120(%rbx), %edx
movl %eax, %edi
movl $0x1, %esi
movq %r15, %rcx
callq 0x2110
leaq -0x29(%rbp), %r12
movl %r14d, %edi
movq %r15, %rsi
movl $0x1, %edx
movl $0x2710, %ecx           # imm = 0x2710
callq 0x21e0
testl %eax, %eax
jle 0x298a
movl 0x120(%rbx), %edi
movb $0x0, -0x29(%rbp)
movl $0x1, %edx
movq %r12, %rsi
callq 0x2130
movb -0x29(%rbp), %r13b
movq %rbx, %rdi
callq 0x3324
testb %r13b, %r13b
jns 0x2947
jmp 0x29a2
je 0x2998
callq 0x2040
cmpl $0x4, (%rax)
je 0x2947
jmp 0x29a2
movq %rbx, %rdi
callq 0x3324
jmp 0x2947
movl %r14d, %edi
callq 0x20e0
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ngkaho1234[P]ext4-extents-tree/buffer.c
// Function: bdev_free
void bdev_free(struct block_device *bdev)
{
	struct rb_node *node;

	bdev_writeback_thread_notify_exit(bdev);
	pthread_join(bdev->bd_bh_writeback_thread, NULL);

#ifndef USE_AIO
	bdev_io_thread_notify_exit(bdev);
	pthread_join(bdev->bd_bh_io_thread, NULL);
#endif
	
	pthread_mutex_lock(&bdev->bd_bh_root_lock);
	while ((node = rb_first(&bdev->bd_bh_root))) {
		struct buffer_head *bh = rb_entry(
		    node, struct buffer_head, b_rb_node);
		wait_on_buffer(bh);
		detach_bh_from_freelist(bh);
		__buffer_remove(bdev, bh);
		buffer_free(bh);
	}
	pthread_mutex_unlock(&bdev->bd_bh_root_lock);

	if (bdev->bd_nr_free != 0)
		fprintf(stderr, "bdev->bd_nr_free == %d", bdev->bd_nr_free);

#ifndef USE_AIO
	close(bdev->bd_bh_io_wakeup_fd[0]);
	close(bdev->bd_bh_io_wakeup_fd[1]);
#endif

	close(bdev->bd_bh_writeback_wakeup_fd[0]);
	close(bdev->bd_bh_writeback_wakeup_fd[1]);

	pthread_mutex_destroy(&bdev->bd_bh_free_lock);
	pthread_mutex_destroy(&bdev->bd_bh_dirty_lock);
#ifndef USE_AIO
	pthread_mutex_destroy(&bdev->bd_bh_ioqueue_lock);
#endif
	pthread_mutex_destroy(&bdev->bd_bh_root_lock);

	xfree(bdev);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl 0x124(%rdi), %edi
leaq -0x29(%rbp), %rsi
movb $-0x1, (%rsi)
movl $0x1, %edx
callq 0x2080
movq 0x110(%rbx), %rdi
xorl %esi, %esi
callq 0x2290
leaq 0xc8(%rbx), %rdi
movq %rdi, -0x38(%rbp)
callq 0x22c0
leaq 0xf0(%rbx), %r15
movq %r15, %rdi
callq 0x3937
testq %rax, %rax
je 0x2a66
movq %rax, %r12
leaq -0x168(%r12), %r13
leaq -0x98(%r12), %r14
movq %r14, %rdi
callq 0x2060
movq %r14, %rdi
callq 0x2100
movq %r13, %rdi
callq 0x2aff
movq %r12, %rdi
movq %r15, %rsi
callq 0x3a09
movq %r13, %rdi
callq 0x2b79
movq %r15, %rdi
callq 0x3937
movq %rax, %r12
testq %rax, %rax
jne 0x2a1b
movq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x21b0
movl 0x18(%rbx), %edx
testl %edx, %edx
jne 0x2abf
movl 0x120(%rbx), %edi
callq 0x20e0
movl 0x124(%rbx), %edi
callq 0x20e0
leaq 0x20(%rbx), %rdi
callq 0x20b0
leaq 0x58(%rbx), %rdi
callq 0x20b0
movq %r14, %rdi
callq 0x20b0
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2030
movq 0x6532(%rip), %rax      # 0x8ff8
movq (%rax), %rdi
leaq 0x3613(%rip), %rsi      # 0x60e3
xorl %eax, %eax
callq 0x2170
jmp 0x2a79
// File: /workspace/github_c_makefile_star2_O3/ngkaho1234[P]ext4-extents-tree/buffer.c
// Function: buffer_free
static void buffer_free(struct buffer_head *bh)
{
	sem_destroy(&bh->b_event);
	pthread_mutex_destroy(&bh->b_lock);

	if (bh->b_count != 0)
		fprintf(stderr, "bh: %p b_count != 0, my pid: %d", bh, getpid());

	xfree(bh);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0xd0, %rdi
callq 0x22b0
leaq 0x110(%rbx), %rdi
callq 0x20b0
cmpl $0x0, 0x108(%rbx)
jne 0x2bb1
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2030
movq %rbx, %rdi
callq 0x2306
jmp 0x2ba3
// File: /workspace/github_c_makefile_star2_O3/ngkaho1234[P]ext4-extents-tree/buffer.c
// Function: buffer_alloc
struct buffer_head *buffer_alloc(struct block_device *bdev, uint64_t block,
				 int page_size)
{
	struct buffer_head *bh;
	bh = xmalloc(sizeof(struct buffer_head) + page_size);
	if (!bh)
		return NULL;

	memset(bh, 0, sizeof(struct buffer_head));
	bh->b_bdev = bdev;
	bh->b_data = bh + 1;
	bh->b_size = page_size;
	bh->b_blocknr = block;
	bh->b_count = 0;
	bh->b_page = NULL;

	sem_init(&bh->b_event, 0, 1);

	pthread_mutex_init(&bh->b_lock, NULL);
	INIT_LIST_HEAD(&bh->b_freelist);
	INIT_LIST_HEAD(&bh->b_dirty_list);

#ifndef USE_AIO
	INIT_LIST_HEAD(&bh->b_io_list);
#endif

	sync_writeback_buffers(bdev);

	return bh;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %r14
movslq %edx, %r12
leaq 0x180(%r12), %rdi
callq 0x21c0
movq %rax, %rbx
testq %rax, %rax
je 0x2c8b
movl $0x180, %edx            # imm = 0x180
movq %rbx, %rdi
xorl %esi, %esi
callq 0x20d0
movq %r14, 0xf0(%rbx)
leaq 0x180(%rbx), %rax
movq %rax, 0x18(%rbx)
movq %r12, 0x10(%rbx)
movq %r15, 0x8(%rbx)
movq $0x0, 0x20(%rbx)
leaq 0xd0(%rbx), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x21d0
leaq 0x110(%rbx), %rdi
xorl %esi, %esi
callq 0x22a0
leaq 0x158(%rbx), %rax
movq %rax, 0x160(%rbx)
movq %rax, 0x158(%rbx)
movq %rbx, %rax
addq $0x148, %rax            # imm = 0x148
movq %rax, 0x150(%rbx)
movq %rax, 0x148(%rbx)
cmpl $0xa, 0x652b(%rip)      # 0x919c
jl 0x2c8b
movl 0x124(%r14), %edi
leaq -0x21(%rbp), %rsi
movb $0x1, (%rsi)
movl $0x1, %edx
callq 0x2080
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq