LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity.c
// Function: UnityEnd
int UnityEnd(void)
{
    UNITY_PRINT_EOL();
    UnityPrint(UnityStrBreaker);
    UNITY_PRINT_EOL();
    UnityPrintNumber((UNITY_INT)(Unity.NumberOfTests));
    UnityPrint(UnityStrResultsTests);
    UnityPrintNumber((UNITY_INT)(Unity.TestFailures));
    UnityPrint(UnityStrResultsFailures);
    UnityPrintNumber((UNITY_INT)(Unity.TestIgnores));
    UnityPrint(UnityStrResultsIgnored);
    UNITY_PRINT_EOL();
    if (Unity.TestFailures == 0U)
    {
        UnityPrint(UnityStrOk);
    }
    else
    {
        UnityPrint(UnityStrFail);
#ifdef UNITY_DIFFERENTIATE_FINAL_FAIL
        UNITY_OUTPUT_CHAR('E'); UNITY_OUTPUT_CHAR('D');
#endif
    }
    UNITY_PRINT_EOL();
    UNITY_FLUSH_CALL();
    UNITY_OUTPUT_COMPLETE();
    return (int)(Unity.TestFailures);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0xa, %edi
callq 0x2040
leaq 0x2fdb(%rip), %rdi      # 0xa4d0
callq 0x5020
movl $0xa, %edi
callq 0x2040
movq 0x698d(%rip), %rdi      # 0xde98
callq 0x5300
leaq 0x2fd1(%rip), %rdi      # 0xa4e8
callq 0x5020
movq 0x697d(%rip), %rdi      # 0xdea0
callq 0x5300
leaq 0x2fc1(%rip), %rdi      # 0xa4f0
callq 0x5020
movq 0x696d(%rip), %rdi      # 0xdea8
callq 0x5300
leaq 0x2fb4(%rip), %rdi      # 0xa4fb
callq 0x5020
movl $0xa, %edi
callq 0x2040
cmpq $0x0, 0x6942(%rip)      # 0xdea0
jne 0x756e
leaq 0x2f9e(%rip), %rdi      # 0xa505
callq 0x5020
jmp 0x757a
leaq 0x2f34(%rip), %rdi      # 0xa4a9
callq 0x5020
movl $0xa, %edi
callq 0x2040
movq 0x6915(%rip), %rax      # 0xdea0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity_fixture.c
// Function: UnityMain
int UnityMain(int argc, const char* argv[], void (*runAllTests)(void))
{
    int result = UnityGetCommandLineOptions(argc, argv);
    unsigned int r;
    if (result != 0)
        return result;

    for (r = 0; r < UnityFixture.RepeatCount; r++)
    {
        UnityBegin(argv[0]);
        announceTestRun(r);
        runAllTests();
        if (!UnityFixture.Verbose) UNITY_PRINT_EOL();
        UnityEnd();
    }

    return (int)Unity.TestFailures;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x7630
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x75c0
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x761a
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl 0x69c4(%rip), %eax      # 0xdf94
jae 0x760c
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x7460
movl -0x20(%rbp), %edi
callq 0x78b0
callq *-0x18(%rbp)
cmpl $0x0, 0x69a0(%rip)      # 0xdf90
jne 0x75fc
movl $0xa, %edi
callq 0x2040
callq 0x74e0
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x75c7
leaq 0x685d(%rip), %rax      # 0xde70
movq 0x30(%rax), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity_fixture.c
// Function: announceTestRun
static void announceTestRun(unsigned int runNumber)
{
    UnityPrint("Test run ");
    UnityPrintNumberUnsigned(runNumber+1);
    UnityPrint(" of ");
    UnityPrintNumberUnsigned(UnityFixture.RepeatCount);
    UNITY_PRINT_EOL();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x2d1e(%rip), %rdi      # 0xa5e0
callq 0x5020
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x5340
leaq 0x2d0d(%rip), %rdi      # 0xa5ea
callq 0x5020
movl 0x66ac(%rip), %eax      # 0xdf94
movl %eax, %edi
callq 0x5340
movl $0xa, %edi
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity_fixture.c
// Function: UnityTestRunner
void UnityTestRunner(unityfunction* setup,
                     unityfunction* testBody,
                     unityfunction* teardown,
                     const char* printableName,
                     const char* group,
                     const char* name,
                     const char* file,
                     unsigned int line)
{
    if (testSelected(name) && groupSelected(group))
    {
        Unity.TestFile = file;
        Unity.CurrentTestName = printableName;
        Unity.CurrentTestLineNumber = line;
        if (!UnityFixture.Verbose)
            UNITY_OUTPUT_CHAR('.');
        else
        {
            UnityPrint(printableName);
        #ifndef UNITY_REPEAT_TEST_NAME
            Unity.CurrentTestName = NULL;
        #endif
        }

        Unity.NumberOfTests++;
        UnityMalloc_StartTest();
        UnityPointer_Init();

        UNITY_EXEC_TIME_START();

        if (TEST_PROTECT())
        {
            setup();
            testBody();
        }
        if (TEST_PROTECT())
        {
            teardown();
        }
        if (TEST_PROTECT())
        {
            UnityPointer_UndoAllSets();
            if (!Unity.CurrentTestFailed)
                UnityMalloc_EndTest();
        }
        UnityConcludeFixtureTest();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x7a40
cmpl $0x0, %eax
je 0x7a30
movq -0x28(%rbp), %rdi
callq 0x7a70
cmpl $0x0, %eax
je 0x7a30
movq 0x10(%rbp), %rcx
leaq 0x651a(%rip), %rax      # 0xde70
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
leaq 0x650c(%rip), %rax      # 0xde70
movq %rcx, 0x8(%rax)
movl 0x18(%rbp), %eax
movl %eax, %ecx
leaq 0x64fc(%rip), %rax      # 0xde70
movq %rcx, 0x20(%rax)
cmpl $0x0, 0x6611(%rip)      # 0xdf90
jne 0x798d
movl $0x2e, %edi
callq 0x2040
jmp 0x79a5
movq -0x20(%rbp), %rdi
callq 0x5020
leaq 0x64d3(%rip), %rax      # 0xde70
movq $0x0, 0x8(%rax)
leaq 0x64c4(%rip), %rax      # 0xde70
movq 0x28(%rax), %rcx
addq $0x1, %rcx
leaq 0x64b5(%rip), %rax      # 0xde70
movq %rcx, 0x28(%rax)
callq 0x7aa0
callq 0x7ac0
leaq 0x64a0(%rip), %rdi      # 0xde70
addq $0x50, %rdi
callq 0x2150
cmpl $0x0, %eax
jne 0x79e4
callq *-0x8(%rbp)
callq *-0x10(%rbp)
leaq 0x6485(%rip), %rdi      # 0xde70
addq $0x50, %rdi
callq 0x2150
cmpl $0x0, %eax
jne 0x79fc
callq *-0x18(%rbp)
leaq 0x646d(%rip), %rdi      # 0xde70
addq $0x50, %rdi
callq 0x2150
cmpl $0x0, %eax
jne 0x7a2b
callq 0x7ad0
leaq 0x6453(%rip), %rax      # 0xde70
cmpq $0x0, 0x40(%rax)
jne 0x7a29
callq 0x7b30
jmp 0x7a2b
callq 0x7b60
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity_fixture.c
// Function: UnityPointer_UndoAllSets
void UnityPointer_UndoAllSets(void)
{
    while (pointer_index > 0)
    {
        pointer_index--;
        *(pointer_store[pointer_index].pointer) =
            pointer_store[pointer_index].old_value;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
jmp 0x7ad6
cmpl $0x0, 0x64cf(%rip)      # 0xdfac
jle 0x7b24
movl 0x64c7(%rip), %eax      # 0xdfac
addl $-0x1, %eax
movl %eax, 0x64be(%rip)      # 0xdfac
movslq 0x64b7(%rip), %rcx      # 0xdfac
leaq 0x64b4(%rip), %rax      # 0xdfb0
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rcx
movslq 0x649e(%rip), %rdx      # 0xdfac
leaq 0x649b(%rip), %rax      # 0xdfb0
shlq $0x4, %rdx
addq %rdx, %rax
movq (%rax), %rax
movq %rcx, (%rax)
jmp 0x7ad6
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity_fixture.c
// Function: UnityConcludeFixtureTest
void UnityConcludeFixtureTest(void)
{
    if (Unity.CurrentTestIgnored)
    {
        Unity.TestIgnores++;
        UNITY_PRINT_EOL();
    }
    else if (!Unity.CurrentTestFailed)
    {
        if (UnityFixture.Verbose)
        {
            UnityPrint(" PASS");
            UNITY_EXEC_TIME_STOP();
            UNITY_PRINT_EXEC_TIME();
            UNITY_PRINT_EOL();
        }
    }
    else /* Unity.CurrentTestFailed */
    {
        Unity.TestFailures++;
        UNITY_PRINT_EOL();
    }

    Unity.CurrentTestFailed = 0;
    Unity.CurrentTestIgnored = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x6305(%rip), %rax      # 0xde70
cmpq $0x0, 0x48(%rax)
je 0x7b98
leaq 0x62f7(%rip), %rax      # 0xde70
movq 0x38(%rax), %rcx
addq $0x1, %rcx
leaq 0x62e8(%rip), %rax      # 0xde70
movq %rcx, 0x38(%rax)
movl $0xa, %edi
callq 0x2040
jmp 0x7bed
leaq 0x62d1(%rip), %rax      # 0xde70
cmpq $0x0, 0x40(%rax)
jne 0x7bc7
cmpl $0x0, 0x63e3(%rip)      # 0xdf90
je 0x7bc5
leaq 0x2a24(%rip), %rdi      # 0xa5da
callq 0x5020
movl $0xa, %edi
callq 0x2040
jmp 0x7beb
leaq 0x62a2(%rip), %rax      # 0xde70
movq 0x30(%rax), %rcx
addq $0x1, %rcx
leaq 0x6293(%rip), %rax      # 0xde70
movq %rcx, 0x30(%rax)
movl $0xa, %edi
callq 0x2040
jmp 0x7bed
leaq 0x627c(%rip), %rax      # 0xde70
movq $0x0, 0x40(%rax)
leaq 0x626d(%rip), %rax      # 0xde70
movq $0x0, 0x48(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity_fixture.c
// Function: UnityIgnoreTest
void UnityIgnoreTest(const char* printableName, const char* group, const char* name)
{
    if (testSelected(name) && groupSelected(group))
    {
        Unity.NumberOfTests++;
        Unity.TestIgnores++;
        if (!UnityFixture.Verbose)
            UNITY_OUTPUT_CHAR('!');
        else
        {
            UnityPrint(printableName);
            UNITY_PRINT_EOL();
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7a40
cmpl $0x0, %eax
je 0x7c9e
movq -0x10(%rbp), %rdi
callq 0x7a70
cmpl $0x0, %eax
je 0x7c9e
leaq 0x6229(%rip), %rax      # 0xde70
movq 0x28(%rax), %rcx
addq $0x1, %rcx
leaq 0x621a(%rip), %rax      # 0xde70
movq %rcx, 0x28(%rax)
leaq 0x620f(%rip), %rax      # 0xde70
movq 0x38(%rax), %rcx
addq $0x1, %rcx
leaq 0x6200(%rip), %rax      # 0xde70
movq %rcx, 0x38(%rax)
cmpl $0x0, 0x6315(%rip)      # 0xdf90
jne 0x7c89
movl $0x21, %edi
callq 0x2040
jmp 0x7c9c
movq -0x8(%rbp), %rdi
callq 0x5020
movl $0xa, %edi
callq 0x2040
jmp 0x7c9e
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity_fixture.c
// Function: unity_malloc
void* unity_malloc(size_t size)
{
    char* mem;
    Guard* guard;
    size_t total_size = size + sizeof(Guard) + sizeof(end);

    if (malloc_fail_countdown != MALLOC_DONT_FAIL)
    {
        if (malloc_fail_countdown == 0)
            return NULL;
        malloc_fail_countdown--;
    }

    if (size == 0) return NULL;
#ifdef UNITY_EXCLUDE_STDLIB_MALLOC
    if (heap_index + total_size > UNITY_INTERNAL_HEAP_SIZE_BYTES)
    {
        guard = NULL;
    }
    else
    {
        guard = (Guard*)&unity_heap[heap_index];
        heap_index += total_size;
    }
#else
    guard = (Guard*)UNITY_FIXTURE_MALLOC(total_size);
#endif
    if (guard == NULL) return NULL;
    malloc_count++;
    guard->size = size;
    guard->guard_space = 0;
    mem = (char*)&(guard[1]);
    memcpy(&mem[size], end, sizeof(end));

    return (void*)mem;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
cmpl $-0x1, 0x5e39(%rip)     # 0xdb2c
je 0x7d1a
cmpl $0x0, 0x5e30(%rip)      # 0xdb2c
jne 0x7d0b
movq $0x0, -0x8(%rbp)
jmp 0x7d94
movl 0x5e1b(%rip), %eax      # 0xdb2c
addl $-0x1, %eax
movl %eax, 0x5e12(%rip)      # 0xdb2c
cmpq $0x0, -0x10(%rbp)
jne 0x7d2b
movq $0x0, -0x8(%rbp)
jmp 0x7d94
movq -0x28(%rbp), %rdi
callq 0x21b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x7d49
movq $0x0, -0x8(%rbp)
jmp 0x7d94
movl 0x6259(%rip), %eax      # 0xdfa8
addl $0x1, %eax
movl %eax, 0x6250(%rip)      # 0xdfa8
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x2866(%rip), %edx      # 0xa5ef
movl %edx, (%rax,%rcx)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity_fixture.c
// Function: unity_free
void unity_free(void* mem)
{
    int overrun;

    if (mem == NULL)
    {
        return;
    }

    overrun = isOverrun(mem);
    release_memory(mem);
    if (overrun)
    {
        UNITY_TEST_FAIL(Unity.CurrentTestLineNumber, "Buffer overrun detected during free()");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x7db5
jmp 0x7de7
movq -0x8(%rbp), %rdi
callq 0x7df0
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7e60
cmpl $0x0, -0xc(%rbp)
je 0x7de7
leaq 0x6099(%rip), %rax      # 0xde70
movq 0x20(%rax), %rsi
leaq 0x2787(%rip), %rdi      # 0xa569
callq 0x7240
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity_fixture.c
// Function: isOverrun
static int isOverrun(void* mem)
{
    Guard* guard = (Guard*)mem;
    char* memAsChar = (char*)mem;
    guard--;

    return guard->guard_space != 0 || strcmp(&memAsChar[guard->size], end) != 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $-0x10, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movb $0x1, %al
cmpq $0x0, 0x8(%rcx)
movb %al, -0x19(%rbp)
jne 0x7e48
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
addq (%rax), %rdi
leaq 0x27b5(%rip), %rsi      # 0xa5ef
callq 0x2160
cmpl $0x0, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity_fixture.c
// Function: release_memory
static void release_memory(void* mem)
{
    Guard* guard = (Guard*)mem;
    guard--;

    malloc_count--;
#ifdef UNITY_EXCLUDE_STDLIB_MALLOC
    if (mem == unity_heap + heap_index - guard->size - sizeof(end))
    {
        heap_index -= (guard->size + sizeof(Guard) + sizeof(end));
    }
#else
    UNITY_FIXTURE_FREE(guard);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $-0x10, %rax
movq %rax, -0x10(%rbp)
movl 0x6122(%rip), %eax      # 0xdfa8
addl $-0x1, %eax
movl %eax, 0x6119(%rip)      # 0xdfa8
movq -0x10(%rbp), %rdi
callq 0x2030
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity_fixture.c
// Function: unity_calloc
void* unity_calloc(size_t num, size_t size)
{
    void* mem = unity_malloc(num * size);
    if (mem == NULL) return NULL;
    memset(mem, 0, num * size);
    return mem;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
imulq -0x18(%rbp), %rdi
callq 0x7cd0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x7ed3
movq $0x0, -0x8(%rbp)
jmp 0x7eef
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rdx
imulq -0x18(%rbp), %rdx
xorl %esi, %esi
callq 0x2110
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity_fixture.c
// Function: unity_realloc
void* unity_realloc(void* oldMem, size_t size)
{
    Guard* guard = (Guard*)oldMem;
    void* newMem;

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

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7f31
movq -0x18(%rbp), %rdi
callq 0x7cd0
movq %rax, -0x8(%rbp)
jmp 0x7fdf
movq -0x20(%rbp), %rax
addq $-0x10, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7df0
cmpl $0x0, %eax
je 0x7f6b
movq -0x10(%rbp), %rdi
callq 0x7e60
leaq 0x5f15(%rip), %rax      # 0xde70
movq 0x20(%rax), %rsi
leaq 0x2629(%rip), %rdi      # 0xa58f
callq 0x7240
cmpq $0x0, -0x18(%rbp)
jne 0x7f85
movq -0x10(%rbp), %rdi
callq 0x7e60
movq $0x0, -0x8(%rbp)
jmp 0x7fdf
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jb 0x7f9c
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7fdf
movq -0x18(%rbp), %rdi
callq 0x7cd0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x7fba
movq $0x0, -0x8(%rbp)
jmp 0x7fdf
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
callq 0x21a0
movq -0x10(%rbp), %rdi
callq 0x7e60
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity_fixture.c
// Function: UnityPointer_Set
void UnityPointer_Set(void** pointer, void* newValue, UNITY_LINE_TYPE line)
{
    if (pointer_index >= UNITY_MAX_POINTERS)
    {
        UNITY_TEST_FAIL(line, "Too many pointers set");
    }
    else
    {
        pointer_store[pointer_index].pointer = pointer;
        pointer_store[pointer_index].old_value = *pointer;
        *pointer = newValue;
        pointer_index++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x5, 0x5fa1(%rip)      # 0xdfac
jl 0x801f
movq -0x18(%rbp), %rsi
leaq 0x25a0(%rip), %rdi      # 0xa5b8
callq 0x7240
jmp 0x8075
movq -0x8(%rbp), %rcx
movslq 0x5f82(%rip), %rdx      # 0xdfac
leaq 0x5f7f(%rip), %rax      # 0xdfb0
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movslq 0x5f63(%rip), %rdx      # 0xdfac
leaq 0x5f60(%rip), %rax      # 0xdfb0
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl 0x5f40(%rip), %eax      # 0xdfac
addl $0x1, %eax
movl %eax, 0x5f37(%rip)      # 0xdfac
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/tests.c
// Function: Tests_Run
void Tests_Run() {
  zf_log_set_output_level(ZF_LOG_DEBUG);
  RUN_TEST_GROUP(controls);
  RUN_TEST_GROUP(utility);
  RUN_TEST_GROUP(input);
  RUN_TEST_GROUP(errors);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x2, %edi
callq 0x3520
callq 0x8210
callq 0x8640
callq 0x8430
callq 0x82c0
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/afi-lambda[P]a_little_smalltalk/src/memory.c
// Function: initMemoryManager
void initMemoryManager()
{
    int i;

# ifdef obtalloc
    objectTable = obtalloc(ObjectTableMax, sizeof(struct objectStruct));
    if (! objectTable)
        sysError("cannot allocate","object table");
# endif

    /* set all the free list pointers to zero */
    for (i = 0; i < FREELISTMAX; i++)
        objectFreeList[i] = nilobj;

    /* set all the reference counts to zero */
    for (i = 0; i < ObjectTableMax; i++)
    {
        objectTable[i].referenceCount = 0;
        objectTable[i].size = 0;
    }

    /* make up the initial free lists */
    setFreeLists();

# ifndef mBlockAlloc
    /* force an allocation on first object assignment */
    currentMemoryPosition = MemoryBlockSize + 1;
# endif

    /* object at location 0 is the nil object, so give it nonzero ref */
    objectTable[0].referenceCount = 1;
    objectTable[0].size = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0x7d0, -0x4(%rbp)      # imm = 0x7D0
jge 0x2a24
movslq -0x4(%rbp), %rcx
leaq 0xc8ad(%rip), %rax      # 0xf2c0
movw $0x0, (%rax,%rcx,2)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x29ff
movl $0x0, -0x4(%rbp)
cmpl $0x1964, -0x4(%rbp)     # imm = 0x1964
jge 0x2a6f
movslq -0x4(%rbp), %rcx
leaq 0xd821(%rip), %rax      # 0x10260
shlq $0x4, %rcx
addq %rcx, %rax
movw $0x0, 0x2(%rax)
movslq -0x4(%rbp), %rcx
leaq 0xd809(%rip), %rax      # 0x10260
shlq $0x4, %rcx
addq %rcx, %rax
movw $0x0, 0x4(%rax)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x2a2b
callq 0x2aa0
movl $0x1771, 0x26e22(%rip)  # imm = 0x1771
movw $0x1, 0xd7db(%rip)      # 0x10262
movw $0x0, 0xd7d4(%rip)      # 0x10264
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/afi-lambda[P]a_little_smalltalk/src/memory.c
// Function: setFreeLists
void setFreeLists()
{
    int i, size;
    register int z;
    register struct objectStruct *p;

    objectFreeList[0] = nilobj;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw $0x0, 0xc813(%rip)      # 0xf2c0
movl $0x1963, -0xc(%rbp)     # imm = 0x1963
cmpl $0x0, -0xc(%rbp)
jle 0x2b7c
movslq -0xc(%rbp), %rcx
leaq 0xd797(%rip), %rax      # 0x10260
shlq $0x4, %rcx
addq %rcx, %rax
movswl 0x2(%rax), %eax
cmpl $0x0, %eax
jne 0x2b6c
movslq -0xc(%rbp), %rcx
leaq 0xd778(%rip), %rax      # 0x10260
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movswl 0x4(%rax), %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x2b17
xorl %eax, %eax
subl -0x8(%rbp), %eax
addl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x8(%rbp)
movslq -0x8(%rbp), %rcx
leaq 0xc79e(%rip), %rax      # 0xf2c0
movw (%rax,%rcx,2), %cx
movq -0x18(%rbp), %rax
movw %cx, (%rax)
movl -0xc(%rbp), %eax
movw %ax, %dx
movslq -0x8(%rbp), %rcx
leaq 0xc782(%rip), %rax      # 0xf2c0
movw %dx, (%rax,%rcx,2)
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jle 0x2b6a
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x4(%rbp), %ecx
addl $-0x1, %ecx
movl %ecx, -0x4(%rbp)
movslq %ecx, %rcx
movw $0x0, (%rax,%rcx,2)
jmp 0x2b48
jmp 0x2b6c
jmp 0x2b6e
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2ab4
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/afi-lambda[P]a_little_smalltalk/src/memory.c
// Function: mBlockAlloc
object *mBlockAlloc(int memorySize)
{
    object *objptr;

    if (currentMemoryPosition + memorySize >= MemoryBlockSize)
    {

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl 0x26d0f(%rip), %eax     # 0x298a0
addl -0x4(%rbp), %eax
cmpl $0x1770, %eax           # imm = 0x1770
jl 0x2bd8
movl $0x1770, %edi           # imm = 0x1770
movl $0x2, %esi
callq 0x2140
movq %rax, 0x26cf7(%rip)     # 0x298a8
cmpq $0x0, 0x26cef(%rip)     # 0x298a8
jne 0x2bce
leaq 0x9559(%rip), %rdi      # 0xc11b
leaq 0x9560(%rip), %rsi      # 0xc129
callq 0x63f0
movl $0x0, 0x26cc8(%rip)     # 0x298a0
movq 0x26cc9(%rip), %rax     # 0x298a8
movslq 0x26cba(%rip), %rcx     # 0x298a0
shlq %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %eax
addl 0x26ca7(%rip), %eax     # 0x298a0
movl %eax, 0x26ca1(%rip)     # 0x298a0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/afi-lambda[P]a_little_smalltalk/src/memory.c
// Function: allocStr
object allocStr(register const char *str)
{
    register object newSym;
    newSym = allocByte(1 + strlen(str));
    strcpy(charPtr(newSym), str);
    return (newSym);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2090
addq $0x1, %rax
movl %eax, %edi
callq 0x2eb0
movw %ax, -0xa(%rbp)
movw -0xa(%rbp), %ax
movw %ax, 0x26971(%rip)      # 0x298b0
movswl %ax, %edi
callq 0x2fb0
cmpl $0x0, %eax
je 0x2f70
movswl 0x2695d(%rip), %eax     # 0x298b0
sarl %eax
movslq %eax, %rcx
leaq 0xd301(%rip), %rax      # 0x10260
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2f92
movswl 0x26939(%rip), %eax     # 0x298b0
sarl %eax
movslq %eax, %rcx
leaq 0xd2dd(%rip), %rax      # 0x10260
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x2050
movw -0xa(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/afi-lambda[P]a_little_smalltalk/src/memory.c
// Function: sysDecr
void sysDecr(object z)
{
    register struct objectStruct *p;
    register int i;
    int size;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movswl -0x2(%rbp), %eax
sarl %eax
movslq %eax, %rcx
leaq 0xd1c1(%rip), %rax      # 0x10260
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movswl 0x2(%rax), %eax
cmpl $0x0, %eax
jge 0x30e6
movq 0xbf3a(%rip), %rax      # 0xeff8
movq (%rax), %rdi
movswl -0x2(%rbp), %edx
leaq 0x90ad(%rip), %rsi      # 0xc179
movb $0x0, %al
callq 0x2170
leaq 0x90aa(%rip), %rdi      # 0xc184
leaq 0x95d4(%rip), %rsi      # 0xc6b5
callq 0x63f0
movq -0x10(%rbp), %rax
movswl (%rax), %edi
callq 0x3020
movq -0x10(%rbp), %rax
movswl 0x4(%rax), %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x3116
xorl %eax, %eax
subl -0x18(%rbp), %eax
addl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x18(%rbp)
movslq -0x18(%rbp), %rcx
leaq 0xc19f(%rip), %rax      # 0xf2c0
movw (%rax,%rcx,2), %cx
movq -0x10(%rbp), %rax
movw %cx, (%rax)
movswl -0x2(%rbp), %eax
sarl %eax
movw %ax, %dx
movslq -0x18(%rbp), %rcx
leaq 0xc180(%rip), %rax      # 0xf2c0
movw %dx, (%rax,%rcx,2)
cmpl $0x0, -0x18(%rbp)
jle 0x31ae
movq -0x10(%rbp), %rax
movswl 0x4(%rax), %eax
cmpl $0x0, %eax
jle 0x3184
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x3182
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x14(%rbp), %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
movslq %ecx, %rcx
movswl (%rax,%rcx,2), %edi
callq 0x3020
jmp 0x315d
jmp 0x3184
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x31ac
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x14(%rbp), %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
movslq %ecx, %rcx
movw $0x0, (%rax,%rcx,2)
jmp 0x318a
jmp 0x31ae
movl -0x18(%rbp), %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x4(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/afi-lambda[P]a_little_smalltalk/src/memory.c
// Function: byteAtPut
void byteAtPut(object z, int i, int x)
{
    byte *bp;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movswl -0x2(%rbp), %edi
callq 0x2fb0
cmpl $0x0, %eax
je 0x320b
leaq 0x8fa3(%rip), %rdi      # 0xc19d
leaq 0x8fad(%rip), %rsi      # 0xc1ae
callq 0x63f0
jmp 0x3301
cmpl $0x0, -0x8(%rbp)
jle 0x3239
movl -0x8(%rbp), %eax
movswl -0x2(%rbp), %ecx
sarl %ecx
movslq %ecx, %rdx
leaq 0xd03c(%rip), %rcx      # 0x10260
shlq $0x4, %rdx
addq %rdx, %rcx
movswl 0x4(%rcx), %edx
xorl %ecx, %ecx
subl %edx, %ecx
shll %ecx
cmpl %ecx, %eax
jle 0x3284
movq 0xbdb8(%rip), %rax      # 0xeff8
movq (%rax), %rdi
movl -0x8(%rbp), %edx
movswl -0x2(%rbp), %eax
sarl %eax
movslq %eax, %rcx
leaq 0xd00a(%rip), %rax      # 0x10260
shlq $0x4, %rcx
addq %rcx, %rax
movswl 0x4(%rax), %ecx
leaq 0x8f50(%rip), %rsi      # 0xc1b8
movb $0x0, %al
callq 0x2170
leaq 0x995e(%rip), %rdi      # 0xcbd4
leaq 0x8f31(%rip), %rsi      # 0xc1ae
callq 0x63f0
jmp 0x32ff
movw -0x2(%rbp), %ax
movw %ax, 0x26621(%rip)      # 0x298b0
movswl %ax, %edi
callq 0x2fb0
cmpl $0x0, %eax
je 0x32c0
movswl 0x2660d(%rip), %eax     # 0x298b0
sarl %eax
movslq %eax, %rcx
leaq 0xcfb1(%rip), %rax      # 0x10260
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x32e2
movswl 0x265e9(%rip), %eax     # 0x298b0
sarl %eax
movslq %eax, %rcx
leaq 0xcf8d(%rip), %rax      # 0x10260
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movb %al, %dl
movq -0x18(%rbp), %rax
movl -0x8(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x3301
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/afi-lambda[P]a_little_smalltalk/src/memory.c
// Function: visit
void visit(register object x)
{
    int i, s;
    object *p;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movswl -0x2(%rbp), %eax
cmpl $0x0, %eax
je 0x3400
movswl -0x2(%rbp), %edi
callq 0x2fb0
cmpl $0x0, %eax
jne 0x3400
movswl -0x2(%rbp), %eax
sarl %eax
cltq
leaq 0xcf13(%rip), %rcx      # 0x10260
shlq $0x4, %rax
addq %rax, %rcx
movw 0x2(%rcx), %ax
addw $0x1, %ax
movw %ax, 0x2(%rcx)
cwtl
cmpl $0x1, %eax
jne 0x33fe
movswl -0x2(%rbp), %eax
sarl %eax
movslq %eax, %rcx
leaq 0xcee6(%rip), %rax      # 0x10260
shlq $0x4, %rcx
addq %rcx, %rax
movswl (%rax), %edi
callq 0x3310
movswl -0x2(%rbp), %eax
sarl %eax
movslq %eax, %rcx
leaq 0xcec7(%rip), %rax      # 0x10260
shlq $0x4, %rcx
addq %rcx, %rax
movswl 0x4(%rax), %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x33fc
movswl -0x2(%rbp), %eax
sarl %eax
movslq %eax, %rcx
leaq 0xcea3(%rip), %rax      # 0x10260
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x33fa
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x2, %rcx
movq %rcx, -0x18(%rbp)
movswl (%rax), %edi
callq 0x3310
movl -0x8(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x33d2
jmp 0x33fc
jmp 0x33fe
jmp 0x3400
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/afi-lambda[P]a_little_smalltalk/src/memory.c
// Function: objectCount
int objectCount()
{
    register int i, j;
    j = 0;
    for (i = 0; i < ObjectTableMax; i++)
        if (objectTable[i].referenceCount > 0)
            j++;
    return j;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x8(%rbp)
movl $0x0, -0x4(%rbp)
cmpl $0x1964, -0x4(%rbp)     # imm = 0x1964
jge 0x345c
movslq -0x4(%rbp), %rcx
leaq 0xce2a(%rip), %rax      # 0x10260
shlq $0x4, %rcx
addq %rcx, %rax
movswl 0x2(%rax), %eax
cmpl $0x0, %eax
jle 0x344f
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x3451
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x3422
movl -0x8(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/afi-lambda[P]a_little_smalltalk/src/names.c
// Function: strHash
int strHash(const char *str)
{
    register int hash;
    register const char *p;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x399b
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x3977
cmpl $0x0, -0xc(%rbp)
jge 0x39a9
xorl %eax, %eax
subl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
cmpl $0x4000, -0xc(%rbp)     # imm = 0x4000
jle 0x39bb
movl -0xc(%rbp), %eax
sarl $0x2, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/afi-lambda[P]a_little_smalltalk/src/names.c
// Function: globalKey
object globalKey(const char *str)
{
    objBuffer = nilobj;
    charBuffer = str;
    hashEachElement(symbols, strHash(str), strTest);
    return objBuffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movw $0x0, 0x25eeb(%rip)     # 0x298c0
movq -0x8(%rbp), %rax
movq %rax, 0x25ee8(%rip)     # 0x298c8
leaq 0x25ecd(%rip), %rax     # 0x298b4
movw (%rax), %ax
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3960
movl %eax, %esi
movw -0xa(%rbp), %ax
leaq 0x1c(%rip), %rdx        # 0x3a20
movswl %ax, %edi
callq 0x37a0
movw 0x25ead(%rip), %ax      # 0x298c0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/afi-lambda[P]a_little_smalltalk/src/names.c
// Function: strTest
static int strTest(object key)
{
    if (charPtr(key) && streq(charPtr(key), charBuffer))
    {
        objBuffer = key;
        return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %di, %ax
movw %ax, -0x6(%rbp)
movw -0x6(%rbp), %ax
leaq 0x25e76(%rip), %rcx     # 0x298b0
movw %ax, (%rcx)
movswl %ax, %edi
callq 0x2fb0
cmpl $0x0, %eax
je 0x3a71
leaq 0x25e5f(%rip), %rax     # 0x298b0
movswl (%rax), %eax
sarl %eax
movslq %eax, %rcx
leaq 0xc800(%rip), %rax      # 0x10260
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x3a96
leaq 0x25e38(%rip), %rax     # 0x298b0
movswl (%rax), %eax
sarl %eax
movslq %eax, %rcx
leaq 0xc7d9(%rip), %rax      # 0x10260
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, %rax
je 0x3b34
movw -0x6(%rbp), %ax
leaq 0x25e01(%rip), %rcx     # 0x298b0
movw %ax, (%rcx)
movswl %ax, %edi
callq 0x2fb0
cmpl $0x0, %eax
je 0x3ae6
leaq 0x25dea(%rip), %rax     # 0x298b0
movswl (%rax), %eax
sarl %eax
movslq %eax, %rcx
leaq 0xc78b(%rip), %rax      # 0x10260
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x3b0b
leaq 0x25dc3(%rip), %rax     # 0x298b0
movswl (%rax), %eax
sarl %eax
movslq %eax, %rcx
leaq 0xc764(%rip), %rax      # 0x10260
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq 0x25db2(%rip), %rsi     # 0x298c8
callq 0x2150
cmpl $0x0, %eax
jne 0x3b34
movw -0x6(%rbp), %ax
movw %ax, 0x25d95(%rip)      # 0x298c0
movl $0x1, -0x4(%rbp)
jmp 0x3b3b
movl $0x0, -0x4(%rbp)
movl -0x4(%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/names.c
// Function: initCommonSymbols
void initCommonSymbols()
{
    int i;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x8561(%rip), %rsi      # 0xc110
leaq 0x25cfe(%rip), %rax     # 0x298b4
movswl (%rax), %edi
callq 0x3b50
movw %ax, %cx
leaq 0x2642a(%rip), %rax     # 0x29ff2
movw %cx, (%rax)
leaq 0x8543(%rip), %rsi      # 0xc115
leaq 0x25cdb(%rip), %rax     # 0x298b4
movswl (%rax), %edi
callq 0x3b50
movw %ax, %cx
leaq 0x26409(%rip), %rax     # 0x29ff4
movw %cx, (%rax)
movl $0x0, -0x4(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0xb530(%rip), %rax      # 0xf130
cmpq $0x0, (%rax,%rcx,8)
je 0x3c38
movslq -0x4(%rbp), %rcx
leaq 0xb51e(%rip), %rax      # 0xf130
movq (%rax,%rcx,8), %rdi
callq 0x4000
movw %ax, %dx
movslq -0x4(%rbp), %rcx
leaq 0x25ca7(%rip), %rax     # 0x298d0
movw %dx, (%rax,%rcx,2)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x3bf5
movl $0x0, -0x4(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0xb536(%rip), %rax      # 0xf180
cmpq $0x0, (%rax,%rcx,8)
je 0x3c82
movslq -0x4(%rbp), %rcx
leaq 0xb524(%rip), %rax      # 0xf180
movq (%rax,%rcx,8), %rdi
callq 0x4000
movw %ax, %dx
movslq -0x4(%rbp), %rcx
leaq 0x25c7d(%rip), %rax     # 0x298f0
movw %dx, (%rax,%rcx,2)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x3c3f
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: getClass
object getClass(register object obj)
{
    if (isInteger(obj))
    {
        if (intClass == nilobj)
            intClass = globalSymbol("Integer");
        return (intClass);
    }
    return (classField(obj));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %di, %ax
movw %ax, -0x4(%rbp)
movswl -0x4(%rbp), %edi
callq 0x2fb0
cmpl $0x0, %eax
je 0x3d33
movswl 0x25c28(%rip), %eax     # 0x2992c
cmpl $0x0, %eax
jne 0x3d26
leaq 0x85d4(%rip), %rsi      # 0xc2e4
leaq 0x25b9d(%rip), %rax     # 0x298b4
movswl (%rax), %edi
callq 0x3b50
movw %ax, 0x25c06(%rip)      # 0x2992c
movw 0x25bff(%rip), %ax      # 0x2992c
movw %ax, -0x2(%rbp)
jmp 0x3d51
movswl -0x4(%rbp), %eax
sarl %eax
movslq %eax, %rcx
leaq 0xc51d(%rip), %rax      # 0x10260
shlq $0x4, %rcx
addq %rcx, %rax
movw (%rax), %ax
movw %ax, -0x2(%rbp)
movw -0x2(%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: newArray
object newArray(int size)
{
    object newObj;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
callq 0x2c10
movw %ax, -0x6(%rbp)
movswl 0x25bb0(%rip), %eax     # 0x2992e
cmpl $0x0, %eax
jne 0x3da0
leaq 0x835d(%rip), %rsi      # 0xc0e7
leaq 0x25b23(%rip), %rax     # 0x298b4
movswl (%rax), %edi
callq 0x3b50
movw %ax, 0x25b8e(%rip)      # 0x2992e
movw 0x25b87(%rip), %ax      # 0x2992e
movswl -0x6(%rbp), %ecx
sarl %ecx
movslq %ecx, %rdx
leaq 0xc4a9(%rip), %rcx      # 0x10260
shlq $0x4, %rdx
addq %rdx, %rcx
movw %ax, (%rcx)
movswl %ax, %edi
callq 0x2fd0
movw -0x6(%rbp), %ax
addq $0x10, %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: newChar
object newChar(int value)
{
    object newobj;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x1, %edi
callq 0x2c10
movw %ax, -0x6(%rbp)
movl -0x4(%rbp), %edi
callq 0x34a0
movswl -0x6(%rbp), %ecx
sarl %ecx
movslq %ecx, %rdx
leaq 0xc38f(%rip), %rcx      # 0x10260
shlq $0x4, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rcx
movw %ax, (%rcx)
movswl %ax, %edi
callq 0x2fd0
leaq 0x8404(%rip), %rsi      # 0xc2f2
leaq 0x259bf(%rip), %rax     # 0x298b4
movswl (%rax), %edi
callq 0x3b50
movswl -0x6(%rbp), %ecx
sarl %ecx
movslq %ecx, %rdx
leaq 0xc353(%rip), %rcx      # 0x10260
shlq $0x4, %rdx
addq %rdx, %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: newClass
object newClass(const char *name)
{
    object newObj, nameObj;

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

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

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

    return newObj;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x5, %edi
callq 0x2c10
movw %ax, -0xa(%rbp)
leaq 0x8187(%rip), %rsi      # 0xc0d8
leaq 0x2595c(%rip), %rax     # 0x298b4
movswl (%rax), %edi
callq 0x3b50
movswl -0xa(%rbp), %ecx
sarl %ecx
movslq %ecx, %rdx
leaq 0xc2f0(%rip), %rcx      # 0x10260
shlq $0x4, %rdx
addq %rdx, %rcx
movw %ax, (%rcx)
movswl %ax, %edi
callq 0x2fd0
movq -0x8(%rbp), %rdi
callq 0x4000
movw %ax, -0xc(%rbp)
movw -0xc(%rbp), %ax
movswl -0xa(%rbp), %ecx
sarl %ecx
movslq %ecx, %rdx
leaq 0xc2bd(%rip), %rcx      # 0x10260
shlq $0x4, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rcx
movw %ax, (%rcx)
movswl %ax, %edi
callq 0x2fd0
leaq 0x258f4(%rip), %rax     # 0x298b4
movw (%rax), %ax
movw %ax, -0xe(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3960
movw -0xe(%rbp), %cx
movl %eax, %esi
movw -0xc(%rbp), %ax
movswl %cx, %edi
movswl %ax, %edx
movswl -0xa(%rbp), %ecx
callq 0x34d0
movw -0xa(%rbp), %ax
addq $0x10, %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: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x39c0
movw %ax, -0x12(%rbp)
cmpw $0x0, -0x12(%rbp)
je 0x402d
movw -0x12(%rbp), %ax
movw %ax, -0x2(%rbp)
jmp 0x40bf
movq -0x10(%rbp), %rdi
callq 0x2f10
movw %ax, -0x12(%rbp)
movswl 0x258f1(%rip), %eax     # 0x29932
cmpl $0x0, %eax
jne 0x4063
leaq 0x8084(%rip), %rsi      # 0xc0d1
leaq 0x25860(%rip), %rax     # 0x298b4
movswl (%rax), %edi
callq 0x3b50
movw %ax, 0x258cf(%rip)      # 0x29932
movw 0x258c8(%rip), %ax      # 0x29932
movswl -0x12(%rbp), %ecx
sarl %ecx
movslq %ecx, %rdx
leaq 0xc1e6(%rip), %rcx      # 0x10260
shlq $0x4, %rdx
addq %rdx, %rcx
movw %ax, (%rcx)
movswl %ax, %edi
callq 0x2fd0
leaq 0x25821(%rip), %rax     # 0x298b4
movw (%rax), %ax
movw %ax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3960
movl %eax, %esi
movw -0x14(%rbp), %ax
xorl %ecx, %ecx
movswl %ax, %edi
movswl -0x12(%rbp), %edx
callq 0x34d0
movw -0x12(%rbp), %ax
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0x3d60
movw %ax, -0xe(%rbp)
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0x416c
movswl -0x2(%rbp), %eax
sarl %eax
movslq %eax, %rcx
leaq 0xc150(%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
movswl -0xe(%rbp), %ecx
sarl %ecx
movslq %ecx, %rdx
leaq 0xc128(%rip), %rcx      # 0x10260
shlq $0x4, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rcx
movl -0x14(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movw %ax, (%rcx,%rdx,2)
movswl %ax, %edi
callq 0x2fd0
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x40f8
movw -0xe(%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: 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
movq %rsp, %rbp
subq $0x10, %rsp
movw %cx, %ax
movw %dx, %cx
movw %si, %dx
movl %edi, -0x4(%rbp)
movw %dx, -0x6(%rbp)
movw %cx, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movl $0x6, %edi
callq 0x2c10
movw %ax, -0xc(%rbp)
leaq 0x8142(%rip), %rsi      # 0xc2f7
leaq 0x256f8(%rip), %rax     # 0x298b4
movswl (%rax), %edi
callq 0x3b50
movswl -0xc(%rbp), %ecx
sarl %ecx
movslq %ecx, %rdx
leaq 0xc08c(%rip), %rcx      # 0x10260
shlq $0x4, %rdx
addq %rdx, %rcx
movw %ax, (%rcx)
movswl %ax, %edi
callq 0x2fd0
movl -0x4(%rbp), %edi
callq 0x34a0
movswl -0xc(%rbp), %ecx
sarl %ecx
movslq %ecx, %rdx
leaq 0xc062(%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
movswl -0xc(%rbp), %ecx
sarl %ecx
movslq %ecx, %rdx
leaq 0xc038(%rip), %rcx      # 0x10260
shlq $0x4, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rcx
movw %ax, 0x2(%rcx)
movswl %ax, %edi
callq 0x2fd0
movw -0x8(%rbp), %ax
movswl -0xc(%rbp), %ecx
sarl %ecx
movslq %ecx, %rdx
leaq 0xc00d(%rip), %rcx      # 0x10260
shlq $0x4, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rcx
movw %ax, 0x4(%rcx)
movswl %ax, %edi
callq 0x2fd0
movw -0xa(%rbp), %ax
movswl -0xc(%rbp), %ecx
sarl %ecx
movslq %ecx, %rdx
leaq 0xbfe2(%rip), %rcx      # 0x10260
shlq $0x4, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rcx
movw %ax, 0x6(%rcx)
movswl %ax, %edi
callq 0x2fd0
movw -0xc(%rbp), %ax
addq $0x10, %rsp
popq %rbp
retq
nop