LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity.c
// Function: UnityPrintNumberHex
void UnityPrintNumberHex(const UNITY_UINT number, const char nibbles_to_print)
{
    int nibble;
    char nibbles = nibbles_to_print;
    if ((unsigned)nibbles > (2 * sizeof(number)))
    {
        nibbles = 2 * sizeof(number);
    }

    while (nibbles > 0)
    {
        nibbles--;
        nibble = (int)(number >> (nibbles * 4)) & 0x0F;
        if (nibble <= 9)
        {
            UNITY_OUTPUT_CHAR((char)('0' + nibble));
        }
        else
        {
            UNITY_OUTPUT_CHAR((char)('A' - 10 + nibble));
        }
    }
}

// Assembly:
cmpl $0x11, %esi
movl $0x10, %eax
cmovbl %esi, %eax
testb %al, %al
jle 0x3fcc
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movzbl %al, %r14d
leaq -0x4(,%r14,4), %r15
incq %r14
movl %r15d, %ecx
andb $-0x4, %cl
movq %rbx, %rax
shrq %cl, %rax
andl $0xf, %eax
leal 0x37(%rax), %ecx
leal 0x30(%rax), %edi
cmpl $0xa, %eax
cmovael %ecx, %edi
callq 0x2040
decq %r14
addq $-0x4, %r15
cmpq $0x1, %r14
jg 0x3f9a
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity.c
// Function: UnityPrintLen
void UnityPrintLen(const char* string, const UNITY_UINT32 length)
{
    const char* pch = string;

    if (pch != NULL)
    {
        while (*pch && (UNITY_UINT32)(pch - string) < length)
        {
            /* printable characters plus CR & LF are printed */
            if ((*pch <= 126) && (*pch >= 32))
            {
                UNITY_OUTPUT_CHAR(*pch);
            }
            /* write escaped carriage returns */
            else if (*pch == 13)
            {
                UNITY_OUTPUT_CHAR('\\');
                UNITY_OUTPUT_CHAR('r');
            }
            /* write escaped line feeds */
            else if (*pch == 10)
            {
                UNITY_OUTPUT_CHAR('\\');
                UNITY_OUTPUT_CHAR('n');
            }
            /* unprintable characters are shown as codes */
            else
            {
                UNITY_OUTPUT_CHAR('\\');
                UNITY_OUTPUT_CHAR('x');
                UnityPrintNumberHex((UNITY_UINT)*pch, 2);
            }
            pch++;
        }
    }
}

// Assembly:
testq %rdi, %rdi
je 0x406d
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movb (%rdi), %r12b
testb %r12b, %r12b
sete %al
testl %esi, %esi
sete %cl
orb %al, %cl
jne 0x4065
movl $0x1, %r15d
leal -0x20(%r12), %eax
movzbl %r12b, %ebp
cmpb $0x5e, %al
ja 0x400c
movl %ebp, %edi
jmp 0x402d
movl $0x5c, %edi
callq 0x2040
cmpb $0xa, %r12b
je 0x4028
cmpl $0xd, %ebp
jne 0x4049
movl $0x72, %edi
jmp 0x402d
movl $0x6e, %edi
callq 0x2040
movb (%r14,%r15), %r12b
testb %r12b, %r12b
je 0x4065
leaq 0x1(%r15), %rax
cmpl %ebx, %r15d
movq %rax, %r15
jb 0x3ffb
jmp 0x4065
movl $0x78, %edi
callq 0x2040
movsbq -0x1(%r14,%r15), %rdi
movl $0x2, %esi
callq 0x3f74
jmp 0x4032
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity.c
// Function: UnityPrintNumberByStyle
void UnityPrintNumberByStyle(const UNITY_INT number, const UNITY_DISPLAY_STYLE_T style)
{
    if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT)
    {
        UnityPrintNumber(number);
    }
    else if ((style & UNITY_DISPLAY_RANGE_UINT) == UNITY_DISPLAY_RANGE_UINT)
    {
        UnityPrintNumberUnsigned((UNITY_UINT)number);
    }
    else
    {
        UNITY_OUTPUT_CHAR('0');
        UNITY_OUTPUT_CHAR('x');
        UnityPrintNumberHex((UNITY_UINT)number, (char)((style & 0xF) * 2));
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
testb $0x10, %bpl
jne 0x40af
testb $0x20, %bpl
jne 0x40bd
movl $0x30, %edi
callq 0x2040
movl $0x78, %edi
callq 0x2040
addb %bpl, %bpl
andb $0x1e, %bpl
movzbl %bpl, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3f74
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x40cb
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x40ea
// File: /workspace/github_c_makefile_star2_O1/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity.c
// Function: UnityPrintNumberUnsigned
void UnityPrintNumberUnsigned(const UNITY_UINT number)
{
    UNITY_UINT divisor = 1;

    /* figure out initial divisor */
    while (number / divisor > 9)
    {
        divisor *= 10;
    }

    /* now mod and print, then divide divisor */
    do
    {
        UNITY_OUTPUT_CHAR((char)('0' + (number / divisor % 10)));
        divisor /= 10;
    } while (divisor > 0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x1, %r14d
cmpq $0xa, %rdi
jb 0x4113
addq %r14, %r14
leaq (%r14,%r14,4), %r14
movq %rbx, %rax
xorl %edx, %edx
divq %r14
cmpq $0x9, %rax
ja 0x40fe
movabsq $-0x3333333333333333, %r15 # imm = 0xCCCCCCCCCCCCCCCD
movq %rbx, %rax
xorl %edx, %edx
divq %r14
movq %rax, %rdi
mulq %r15
shrq $0x3, %rdx
addl %edx, %edx
leal (%rdx,%rdx,4), %eax
subl %eax, %edi
orl $0x30, %edi
callq 0x2040
movq %r14, %rax
mulq %r15
shrq $0x3, %rdx
cmpq $0x9, %r14
movq %rdx, %r14
ja 0x411d
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity.c
// Function: UnityTestResultsBegin
static void UnityTestResultsBegin(const char* file, const UNITY_LINE_TYPE line)
{
    UnityPrint(file);
    UNITY_OUTPUT_CHAR(':');
    UnityPrintNumber((UNITY_INT)line);
    UNITY_OUTPUT_CHAR(':');
    UnityPrint(Unity.CurrentTestName);
    UNITY_OUTPUT_CHAR(':');
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
callq 0x3efa
movl $0x3a, %edi
callq 0x2040
movq %rbx, %rdi
callq 0x40cb
movl $0x3a, %edi
callq 0x2040
movq 0x7880(%rip), %rdi      # 0xbe48
callq 0x3efa
movl $0x3a, %edi
popq %rbx
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O1/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity.c
// Function: UnityAssertBits
void UnityAssertBits(const UNITY_INT mask,
                     const UNITY_INT expected,
                     const UNITY_INT actual,
                     const char* msg,
                     const UNITY_LINE_TYPE lineNumber)
{
    RETURN_IF_FAIL_OR_IGNORE;

    if ((mask & expected) != (mask & actual))
    {
        UnityTestResultsFailBegin(lineNumber);
        UnityPrint(UnityStrExpected);
        UnityPrintMask((UNITY_UINT)mask, (UNITY_UINT)expected);
        UnityPrint(UnityStrWas);
        UnityPrintMask((UNITY_UINT)mask, (UNITY_UINT)actual);
        UnityAddMsgIfSpecified(msg);
        UNITY_FAIL_AND_BAIL;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x78a1(%rip), %rax      # 0xbe88
orq 0x7892(%rip), %rax      # 0xbe80
jne 0x4604
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movq %rdx, %rax
xorq %rsi, %rax
testq %rdi, %rax
jne 0x4610
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rcx, %rbx
movq %r8, %rdi
callq 0x466d
leaq 0x3d11(%rip), %rdi      # 0x8333
callq 0x3efa
movq %r15, %rdi
movq %r12, %rsi
callq 0x4157
leaq 0x3d05(%rip), %rdi      # 0x833e
callq 0x3efa
movq %r15, %rdi
movq %r14, %rsi
callq 0x4157
movq %rbx, %rdi
callq 0x4694
movq $0x1, 0x7824(%rip) # 0xbe80
leaq 0x782d(%rip), %rdi      # 0xbe90
movl $0x1, %esi
callq 0x21d0
// File: /workspace/github_c_makefile_star2_O1/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity.c
// Function: UnityAddMsgIfSpecified
static void UnityAddMsgIfSpecified(const char* msg)
{
    if (msg)
    {
        UnityPrint(UnityStrSpacer);
#ifndef UNITY_EXCLUDE_DETAILS
        if (Unity.CurrentDetail1)
        {
            UnityPrint(UnityStrDetail1Name);
            UnityPrint(Unity.CurrentDetail1);
            if (Unity.CurrentDetail2)
            {
                UnityPrint(UnityStrDetail2Name);
                UnityPrint(Unity.CurrentDetail2);
            }
            UnityPrint(UnityStrSpacer);
        }
#endif
        UnityPrint(msg);
    }
}

// Assembly:
testq %rdi, %rdi
je 0x4702
pushq %rbx
movq %rdi, %rbx
leaq 0x3ddf(%rip), %rdi      # 0x8483
callq 0x3efa
cmpq $0x0, 0x779f(%rip)      # 0xbe50
je 0x46f9
leaq 0x3db4(%rip), %rdi      # 0x846e
callq 0x3efa
movq 0x778a(%rip), %rdi      # 0xbe50
callq 0x3efa
cmpq $0x0, 0x7785(%rip)      # 0xbe58
je 0x46ed
leaq 0x3d9c(%rip), %rdi      # 0x8478
callq 0x3efa
movq 0x7770(%rip), %rdi      # 0xbe58
callq 0x3efa
leaq 0x3d8f(%rip), %rdi      # 0x8483
callq 0x3efa
movq %rbx, %rdi
popq %rbx
jmp 0x3efa
retq
// File: /workspace/github_c_makefile_star2_O1/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity.c
// Function: UnityAssertEqualNumber
void UnityAssertEqualNumber(const UNITY_INT expected,
                            const UNITY_INT actual,
                            const char* msg,
                            const UNITY_LINE_TYPE lineNumber,
                            const UNITY_DISPLAY_STYLE_T style)
{
    RETURN_IF_FAIL_OR_IGNORE;

    if (expected != actual)
    {
        UnityTestResultsFailBegin(lineNumber);
        UnityPrint(UnityStrExpected);
        UnityPrintNumberByStyle(expected, style);
        UnityPrint(UnityStrWas);
        UnityPrintNumberByStyle(actual, style);
        UnityAddMsgIfSpecified(msg);
        UNITY_FAIL_AND_BAIL;
    }
}

// Assembly:
cmpq %rsi, %rdi
je 0x471c
cmpq $0x0, 0x7770(%rip)      # 0xbe80
jne 0x471c
cmpq $0x0, 0x776e(%rip)      # 0xbe88
je 0x471d
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rcx, %rdi
callq 0x466d
leaq 0x3bf4(%rip), %rdi      # 0x8333
callq 0x3efa
movq %r15, %rdi
movl %ebp, %esi
callq 0x406e
leaq 0x3be9(%rip), %rdi      # 0x833e
callq 0x3efa
movq %r14, %rdi
movl %ebp, %esi
callq 0x406e
movq %rbx, %rdi
callq 0x4694
movq $0x1, 0x7709(%rip) # 0xbe80
leaq 0x7712(%rip), %rdi      # 0xbe90
movl $0x1, %esi
callq 0x21d0
// File: /workspace/github_c_makefile_star2_O1/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity.c
// Function: UnityAssertGreaterOrLessOrEqualNumber
void UnityAssertGreaterOrLessOrEqualNumber(const UNITY_INT threshold,
                                           const UNITY_INT actual,
                                           const UNITY_COMPARISON_T compare,
                                           const char *msg,
                                           const UNITY_LINE_TYPE lineNumber,
                                           const UNITY_DISPLAY_STYLE_T style)
{
    int failed = 0;
    RETURN_IF_FAIL_OR_IGNORE;

    if (threshold == actual && compare & UNITY_EQUAL_TO) return;
    if (threshold == actual) failed = 1;

    if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT)
    {
        if (actual > threshold && compare & UNITY_SMALLER_THAN) failed = 1;
        if (actual < threshold && compare & UNITY_GREATER_THAN) failed = 1;
    }
    else /* UINT or HEX */
    {
        if ((UNITY_UINT)actual > (UNITY_UINT)threshold && compare & UNITY_SMALLER_THAN) failed = 1;
        if ((UNITY_UINT)actual < (UNITY_UINT)threshold && compare & UNITY_GREATER_THAN) failed = 1;
    }

    if (failed)
    {
        UnityTestResultsFailBegin(lineNumber);
        UnityPrint(UnityStrExpected);
        UnityPrintNumberByStyle(actual, style);
        if (compare & UNITY_GREATER_THAN) UnityPrint(UnityStrGt);
        if (compare & UNITY_SMALLER_THAN) UnityPrint(UnityStrLt);
        if (compare & UNITY_EQUAL_TO)     UnityPrint(UnityStrOrEqual);
        UnityPrintNumberByStyle(threshold, style);
        UnityAddMsgIfSpecified(msg);
        UNITY_FAIL_AND_BAIL;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x76f1(%rip), %rax      # 0xbe88
orq 0x76e2(%rip), %rax      # 0xbe80
jne 0x4800
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %r14
cmpq %rsi, %rdi
sete %al
testb %r15b, %al
jne 0x4800
movl %r9d, %ebp
movq %rcx, %rbx
testb $0x4, %r15b
sete %al
movl %r15d, %edx
andl $0x2, %edx
shrl %edx
xorl %esi, %esi
xorl %edi, %edi
xorl %ecx, %ecx
xorl %r9d, %r9d
cmpq %r14, %r12
setbe %sil
setae %dil
setle %cl
setge %r9b
testb $0x10, %bpl
cmovel %edi, %r9d
notb %r9b
cmovel %esi, %ecx
testb %dl, %r9b
jne 0x4809
orb %al, %cl
je 0x4809
cmpq %r12, %r14
je 0x4809
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r8, %rdi
callq 0x466d
leaq 0x3b1b(%rip), %rdi      # 0x8333
callq 0x3efa
movq %r12, %rdi
movl %ebp, %esi
callq 0x406e
testb $0x2, %r15b
je 0x4839
leaq 0x3b1c(%rip), %rdi      # 0x8350
callq 0x3efa
testb $0x4, %r15b
je 0x484b
leaq 0x3b2a(%rip), %rdi      # 0x8370
callq 0x3efa
testb $0x1, %r15b
je 0x485d
leaq 0x3b2a(%rip), %rdi      # 0x8382
callq 0x3efa
movq %r14, %rdi
movl %ebp, %esi
callq 0x406e
movq %rbx, %rdi
callq 0x4694
movq $0x1, 0x7606(%rip) # 0xbe80
leaq 0x760f(%rip), %rdi      # 0xbe90
movl $0x1, %esi
callq 0x21d0
// File: /workspace/github_c_makefile_star2_O1/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity.c
// Function: UnityAssertEqualFloatArray
void UnityAssertEqualFloatArray(UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* expected,
                                UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* actual,
                                const UNITY_UINT32 num_elements,
                                const char* msg,
                                const UNITY_LINE_TYPE lineNumber,
                                const UNITY_FLAGS_T flags)
{
    UNITY_UINT32 elements = num_elements;
    UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* ptr_expected = expected;
    UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* ptr_actual = actual;

    RETURN_IF_FAIL_OR_IGNORE;

    if (elements == 0)
    {
        UnityPrintPointlessAndBail();
    }

    if (expected == actual)
    {
        return; /* Both are NULL or same pointer */
    }

    if (UnityIsOneArrayNull((UNITY_INTERNAL_PTR)expected, (UNITY_INTERNAL_PTR)actual, lineNumber, msg))
    {
        UNITY_FAIL_AND_BAIL;
    }

    while (elements--)
    {
        if (!UnityFloatsWithin(*ptr_expected * UNITY_FLOAT_PRECISION, *ptr_expected, *ptr_actual))
        {
            UnityTestResultsFailBegin(lineNumber);
            UnityPrint(UnityStrElement);
            UnityPrintNumberUnsigned(num_elements - elements - 1);
            UNITY_PRINT_EXPECTED_AND_ACTUAL_FLOAT((UNITY_DOUBLE)*ptr_expected, (UNITY_DOUBLE)*ptr_actual);
            UnityAddMsgIfSpecified(msg);
            UNITY_FAIL_AND_BAIL;
        }
        if (flags == UNITY_ARRAY_TO_ARRAY)
        {
            ptr_expected++;
        }
        ptr_actual++;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, (%rsp)
movq 0x73f2(%rip), %rax      # 0xbe88
orq 0x73e3(%rip), %rax      # 0xbe80
jne 0x4b0f
movq %r8, %r12
movl %edx, %ebp
testl %edx, %edx
je 0x4b8c
movq %rsi, %r14
movq %rdi, %r15
cmpq %rsi, %rdi
je 0x4b0f
movl %r9d, %r13d
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq (%rsp), %rcx
callq 0x4a33
testl %eax, %eax
jne 0x4b70
xorl %ebx, %ebx
cmpl $0x1, %r13d
sete %bl
shll $0x2, %ebx
movl %ebp, %ebp
xorl %r13d, %r13d
movss (%r15), %xmm1
movaps %xmm1, %xmm0
mulss 0x379f(%rip), %xmm0     # 0x8294
movss (%r14,%r13,4), %xmm2
callq 0x4ba2
testl %eax, %eax
je 0x4b1e
addq %rbx, %r15
incq %r13
cmpl %r13d, %ebp
jne 0x4ae5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rdi
callq 0x466d
leaq 0x389a(%rip), %rdi      # 0x83c7
callq 0x3efa
movq %r13, %rdi
callq 0x40ea
leaq 0x37f2(%rip), %rdi      # 0x8333
callq 0x3efa
movss (%r15), %xmm0
callq 0x41a4
leaq 0x37e7(%rip), %rdi      # 0x833e
callq 0x3efa
movss (%r14,%r13,4), %xmm0
callq 0x41a4
movq (%rsp), %rdi
callq 0x4694
movq $0x1, 0x7305(%rip) # 0xbe80
leaq 0x730e(%rip), %rdi      # 0xbe90
movl $0x1, %esi
callq 0x21d0
movq %r12, %rdi
callq 0x466d
leaq 0x37f5(%rip), %rdi      # 0x8390
callq 0x3efa
jmp 0x4b67
// File: /workspace/github_c_makefile_star2_O1/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity.c
// Function: UnityAssertFloatsWithin
void UnityAssertFloatsWithin(const UNITY_FLOAT delta,
                             const UNITY_FLOAT expected,
                             const UNITY_FLOAT actual,
                             const char* msg,
                             const UNITY_LINE_TYPE lineNumber)
{
    RETURN_IF_FAIL_OR_IGNORE;


    if (!UnityFloatsWithin(delta, expected, actual))
    {
        UnityTestResultsFailBegin(lineNumber);
        UNITY_PRINT_EXPECTED_AND_ACTUAL_FLOAT((UNITY_DOUBLE)expected, (UNITY_DOUBLE)actual);
        UnityAddMsgIfSpecified(msg);
        UNITY_FAIL_AND_BAIL;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x7248(%rip), %rax      # 0xbe88
orq 0x7239(%rip), %rax      # 0xbe80
jne 0x4c6e
movq %rsi, %r14
movq %rdi, %rbx
movss %xmm1, (%rsp)
movss (%rsp), %xmm1
movss %xmm2, 0x4(%rsp)
movss 0x4(%rsp), %xmm2
callq 0x4ba2
testl %eax, %eax
je 0x4c76
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
callq 0x466d
leaq 0x36ae(%rip), %rdi      # 0x8333
callq 0x3efa
movss (%rsp), %xmm0
callq 0x41a4
leaq 0x36a3(%rip), %rdi      # 0x833e
callq 0x3efa
movss 0x4(%rsp), %xmm0
callq 0x41a4
movq %rbx, %rdi
callq 0x4694
movq $0x1, 0x71c2(%rip) # 0xbe80
leaq 0x71cb(%rip), %rdi      # 0xbe90
movl $0x1, %esi
callq 0x21d0
// File: /workspace/github_c_makefile_star2_O1/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity.c
// Function: UnityAssertNumbersWithin
void UnityAssertNumbersWithin(const UNITY_UINT delta,
                              const UNITY_INT expected,
                              const UNITY_INT actual,
                              const char* msg,
                              const UNITY_LINE_TYPE lineNumber,
                              const UNITY_DISPLAY_STYLE_T style)
{
    RETURN_IF_FAIL_OR_IGNORE;

    if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT)
    {
        if (actual > expected)
        {
            Unity.CurrentTestFailed = (((UNITY_UINT)actual - (UNITY_UINT)expected) > delta);
        }
        else
        {
            Unity.CurrentTestFailed = (((UNITY_UINT)expected - (UNITY_UINT)actual) > delta);
        }
    }
    else
    {
        if ((UNITY_UINT)actual > (UNITY_UINT)expected)
        {
            Unity.CurrentTestFailed = (((UNITY_UINT)actual - (UNITY_UINT)expected) > delta);
        }
        else
        {
            Unity.CurrentTestFailed = (((UNITY_UINT)expected - (UNITY_UINT)actual) > delta);
        }
    }

    if (Unity.CurrentTestFailed)
    {
        UnityTestResultsFailBegin(lineNumber);
        UnityPrint(UnityStrDelta);
        UnityPrintNumberByStyle((UNITY_INT)delta, style);
        UnityPrint(UnityStrExpected);
        UnityPrintNumberByStyle(expected, style);
        UnityPrint(UnityStrWas);
        UnityPrintNumberByStyle(actual, style);
        UnityAddMsgIfSpecified(msg);
        UNITY_FAIL_AND_BAIL;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x7083(%rip), %rax      # 0xbe88
orq 0x7074(%rip), %rax      # 0xbe80
jne 0x4e42
movl %r9d, %ebp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rdx, %rax
testb $0x10, %bpl
jne 0x4e4b
subq %r15, %rax
ja 0x4e31
movq %r15, %rax
subq %r14, %rax
xorl %ecx, %ecx
cmpq %r12, %rax
seta %cl
movq %rcx, 0x7040(%rip)      # 0xbe80
ja 0x4e52
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
subq %r15, %rax
jle 0x4e2b
jmp 0x4e31
movq %r8, %rdi
callq 0x466d
leaq 0x35cf(%rip), %rdi      # 0x8430
callq 0x3efa
movq %r12, %rdi
movl %ebp, %esi
callq 0x406e
leaq 0x34bc(%rip), %rdi      # 0x8333
callq 0x3efa
movq %r15, %rdi
movl %ebp, %esi
callq 0x406e
leaq 0x34b1(%rip), %rdi      # 0x833e
callq 0x3efa
movq %r14, %rdi
movl %ebp, %esi
callq 0x406e
movq %rbx, %rdi
callq 0x4694
movq $0x1, 0x6fd1(%rip) # 0xbe80
leaq 0x6fda(%rip), %rdi      # 0xbe90
movl $0x1, %esi
callq 0x21d0
// File: /workspace/github_c_makefile_star2_O1/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity.c
// Function: UnityAssertEqualString
void UnityAssertEqualString(const char* expected,
                            const char* actual,
                            const char* msg,
                            const UNITY_LINE_TYPE lineNumber)
{
    UNITY_UINT32 i;

    RETURN_IF_FAIL_OR_IGNORE;

    /* if both pointers not null compare the strings */
    if (expected && actual)
    {
        for (i = 0; expected[i] || actual[i]; i++)
        {
            if (expected[i] != actual[i])
            {
                Unity.CurrentTestFailed = 1;
                break;
            }
        }
    }
    else
    { /* handle case of one pointers being null (if both null, test should pass) */
        if (expected != actual)
        {
            Unity.CurrentTestFailed = 1;
        }
    }

    if (Unity.CurrentTestFailed)
    {
        UnityTestResultsFailBegin(lineNumber);
        UnityPrintExpectedAndActualStrings(expected, actual);
        UnityAddMsgIfSpecified(msg);
        UNITY_FAIL_AND_BAIL;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x6fbc(%rip), %rax      # 0xbe88
orq 0x6fad(%rip), %rax      # 0xbe80
jne 0x4f26
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %dl
orb %al, %dl
jne 0x4f0c
xorl %esi, %esi
movl %esi, %eax
movb (%r15,%rax), %dl
testb %dl, %dl
jne 0x4f01
cmpb $0x0, (%r14,%rax)
je 0x4f1c
leal 0x1(%rax), %esi
cmpb (%r14,%rax), %dl
je 0x4ef0
jmp 0x4f11
cmpq %r14, %r15
je 0x4f1c
movq $0x1, 0x6f64(%rip) # 0xbe80
cmpq $0x0, 0x6f5c(%rip)      # 0xbe80
jne 0x4f2c
popq %rbx
popq %r14
popq %r15
retq
movq %rcx, %rdi
callq 0x466d
movq %r15, %rdi
movq %r14, %rsi
callq 0x4f63
movq %rbx, %rdi
callq 0x4694
movq $0x1, 0x6f2e(%rip) # 0xbe80
leaq 0x6f37(%rip), %rdi      # 0xbe90
movl $0x1, %esi
callq 0x21d0
// File: /workspace/github_c_makefile_star2_O1/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity.c
// Function: UnityPrintExpectedAndActualStrings
static void UnityPrintExpectedAndActualStrings(const char* expected, const char* actual)
{
    UnityPrint(UnityStrExpected);
    if (expected != NULL)
    {
        UNITY_OUTPUT_CHAR('\'');
        UnityPrint(expected);
        UNITY_OUTPUT_CHAR('\'');
    }
    else
    {
        UnityPrint(UnityStrNull);
    }
    UnityPrint(UnityStrWas);
    if (actual != NULL)
    {
        UNITY_OUTPUT_CHAR('\'');
        UnityPrint(actual);
        UNITY_OUTPUT_CHAR('\'');
    }
    else
    {
        UnityPrint(UnityStrNull);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x33bf(%rip), %rdi      # 0x8333
callq 0x3efa
testq %r14, %r14
je 0x4f9c
movl $0x27, %edi
callq 0x2040
movq %r14, %rdi
callq 0x3efa
movl $0x27, %edi
callq 0x2040
jmp 0x4fa8
leaq 0x3566(%rip), %rdi      # 0x8509
callq 0x3efa
leaq 0x338f(%rip), %rdi      # 0x833e
callq 0x3efa
testq %rbx, %rbx
je 0x4fdc
movl $0x27, %edi
callq 0x2040
movq %rbx, %rdi
callq 0x3efa
movl $0x27, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2040
leaq 0x3526(%rip), %rdi      # 0x8509
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3efa
// File: /workspace/github_c_makefile_star2_O1/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity.c
// Function: UnityAssertEqualStringLen
void UnityAssertEqualStringLen(const char* expected,
                               const char* actual,
                               const UNITY_UINT32 length,
                               const char* msg,
                               const UNITY_LINE_TYPE lineNumber)
{
    UNITY_UINT32 i;

    RETURN_IF_FAIL_OR_IGNORE;

    /* if both pointers not null compare the strings */
    if (expected && actual)
    {
        for (i = 0; (i < length) && (expected[i] || actual[i]); i++)
        {
            if (expected[i] != actual[i])
            {
                Unity.CurrentTestFailed = 1;
                break;
            }
        }
    }
    else
    { /* handle case of one pointers being null (if both null, test should pass) */
        if (expected != actual)
        {
            Unity.CurrentTestFailed = 1;
        }
    }

    if (Unity.CurrentTestFailed)
    {
        UnityTestResultsFailBegin(lineNumber);
        UnityPrintExpectedAndActualStringsLen(expected, actual, length);
        UnityAddMsgIfSpecified(msg);
        UNITY_FAIL_AND_BAIL;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x6e8b(%rip), %rax      # 0xbe88
orq 0x6e7c(%rip), %rax      # 0xbe80
jne 0x5061
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x5047
testl %ebp, %ebp
je 0x5057
movl %ebp, %eax
xorl %ecx, %ecx
movb (%r15,%rcx), %dl
testb %dl, %dl
jne 0x5038
cmpb $0x0, (%r14,%rcx)
je 0x5057
cmpb (%r14,%rcx), %dl
jne 0x504c
incq %rcx
cmpl %ecx, %eax
jne 0x5029
jmp 0x5057
cmpq %r14, %r15
je 0x5057
movq $0x1, 0x6e29(%rip) # 0xbe80
cmpq $0x0, 0x6e21(%rip)      # 0xbe80
jne 0x506c
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r8, %rdi
callq 0x466d
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x50a5
movq %rbx, %rdi
callq 0x4694
movq $0x1, 0x6dec(%rip) # 0xbe80
leaq 0x6df5(%rip), %rdi      # 0xbe90
movl $0x1, %esi
callq 0x21d0
// File: /workspace/github_c_makefile_star2_O1/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity.c
// Function: UnityPrintExpectedAndActualStringsLen
static void UnityPrintExpectedAndActualStringsLen(const char* expected,
                                                  const char* actual,
                                                  const UNITY_UINT32 length)
{
    UnityPrint(UnityStrExpected);
    if (expected != NULL)
    {
        UNITY_OUTPUT_CHAR('\'');
        UnityPrintLen(expected, length);
        UNITY_OUTPUT_CHAR('\'');
    }
    else
    {
        UnityPrint(UnityStrNull);
    }
    UnityPrint(UnityStrWas);
    if (actual != NULL)
    {
        UNITY_OUTPUT_CHAR('\'');
        UnityPrintLen(actual, length);
        UNITY_OUTPUT_CHAR('\'');
    }
    else
    {
        UnityPrint(UnityStrNull);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x327a(%rip), %rdi      # 0x8333
callq 0x3efa
testq %r15, %r15
je 0x50e3
movl $0x27, %edi
callq 0x2040
movq %r15, %rdi
movl %ebx, %esi
callq 0x3fcd
movl $0x27, %edi
callq 0x2040
jmp 0x50ef
leaq 0x341f(%rip), %rdi      # 0x8509
callq 0x3efa
leaq 0x3248(%rip), %rdi      # 0x833e
callq 0x3efa
testq %r14, %r14
je 0x5123
movl $0x27, %edi
callq 0x2040
movq %r14, %rdi
movl %ebx, %esi
callq 0x3fcd
movl $0x27, %edi
popq %rbx
popq %r14
popq %r15
jmp 0x2040
leaq 0x33df(%rip), %rdi      # 0x8509
popq %rbx
popq %r14
popq %r15
jmp 0x3efa
// File: /workspace/github_c_makefile_star2_O1/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity.c
// Function: UnityFail
void UnityFail(const char* msg, const UNITY_LINE_TYPE line)
{
    RETURN_IF_FAIL_OR_IGNORE;

    UnityTestResultsBegin(Unity.TestFile, line);
    UnityPrint(UnityStrFail);
    if (msg != NULL)
    {
        UNITY_OUTPUT_CHAR(':');

#ifndef UNITY_EXCLUDE_DETAILS
        if (Unity.CurrentDetail1)
        {
            UnityPrint(UnityStrDetail1Name);
            UnityPrint(Unity.CurrentDetail1);
            if (Unity.CurrentDetail2)
            {
                UnityPrint(UnityStrDetail2Name);
                UnityPrint(Unity.CurrentDetail2);
            }
            UnityPrint(UnityStrSpacer);
        }
#endif
        if (msg[0] != ' ')
        {
            UNITY_OUTPUT_CHAR(' ');
        }
        UnityPrint(msg);
    }

    UNITY_FAIL_AND_BAIL;
}

// Assembly:
movq 0x6a22(%rip), %rax      # 0xbe88
orq 0x6a13(%rip), %rax      # 0xbe80
je 0x5470
retq
pushq %rbx
movq %rdi, %rbx
movq 0x69c5(%rip), %rdi      # 0xbe40
callq 0x459c
leaq 0x2fe2(%rip), %rdi      # 0x8469
callq 0x3efa
testq %rbx, %rbx
je 0x5502
movl $0x3a, %edi
callq 0x2040
cmpq $0x0, 0x69ad(%rip)      # 0xbe50
je 0x54eb
leaq 0x2fc2(%rip), %rdi      # 0x846e
callq 0x3efa
movq 0x6998(%rip), %rdi      # 0xbe50
callq 0x3efa
cmpq $0x0, 0x6993(%rip)      # 0xbe58
je 0x54df
leaq 0x2faa(%rip), %rdi      # 0x8478
callq 0x3efa
movq 0x697e(%rip), %rdi      # 0xbe58
callq 0x3efa
leaq 0x2f9d(%rip), %rdi      # 0x8483
callq 0x3efa
cmpb $0x20, (%rbx)
je 0x54fa
movl $0x20, %edi
callq 0x2040
movq %rbx, %rdi
callq 0x3efa
movq $0x1, 0x6973(%rip) # 0xbe80
leaq 0x697c(%rip), %rdi      # 0xbe90
movl $0x1, %esi
callq 0x21d0
// File: /workspace/github_c_makefile_star2_O1/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity.c
// Function: UnityIgnore
void UnityIgnore(const char* msg, const UNITY_LINE_TYPE line)
{
    RETURN_IF_FAIL_OR_IGNORE;

    UnityTestResultsBegin(Unity.TestFile, line);
    UnityPrint(UnityStrIgnore);
    if (msg != NULL)
    {
        UNITY_OUTPUT_CHAR(':');
        UNITY_OUTPUT_CHAR(' ');
        UnityPrint(msg);
    }
    UNITY_IGNORE_AND_BAIL;
}

// Assembly:
movq 0x6963(%rip), %rax      # 0xbe88
orq 0x6954(%rip), %rax      # 0xbe80
je 0x552f
retq
pushq %rbx
movq %rdi, %rbx
movq 0x6906(%rip), %rdi      # 0xbe40
callq 0x459c
leaq 0x2f40(%rip), %rdi      # 0x8486
callq 0x3efa
testq %rbx, %rbx
je 0x556c
movl $0x3a, %edi
callq 0x2040
movl $0x20, %edi
callq 0x2040
movq %rbx, %rdi
callq 0x3efa
movq $0x1, 0x6911(%rip) # 0xbe88
leaq 0x6912(%rip), %rdi      # 0xbe90
movl $0x1, %esi
callq 0x21d0
// File: /workspace/github_c_makefile_star2_O1/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity.c
// Function: UnityDefaultTestRun
void UnityDefaultTestRun(UnityTestFunction Func, const char* FuncName, const int FuncLineNum)
{
    Unity.CurrentTestName = FuncName;
    Unity.CurrentTestLineNumber = (UNITY_LINE_TYPE)FuncLineNum;
    Unity.NumberOfTests++;
    UNITY_CLR_DETAILS();
    if (TEST_PROTECT())
    {
        setUp();
        Func();
    }
    if (TEST_PROTECT())
    {
        tearDown();
    }
    UnityConcludeTest();
}

// Assembly:
pushq %rbx
movq %rsi, 0x68b8(%rip)      # 0xbe48
movslq %edx, %rax
movq %rax, 0x68c6(%rip)      # 0xbe60
incq 0x68c7(%rip)            # 0xbe68
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x68a2(%rip)     # 0xbe50
leaq 0x68db(%rip), %rdi      # 0xbe90
callq 0x2150
testl %eax, %eax
jne 0x55c5
callq 0x3ef4
callq *%rbx
leaq 0x68c4(%rip), %rdi      # 0xbe90
callq 0x2150
testl %eax, %eax
jne 0x55da
callq 0x3ef5
callq 0x453e
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rax
movl $0xa, %edi
callq 0x2040
leaq 0x2e6b(%rip), %rdi      # 0x8490
callq 0x3efa
movl $0xa, %edi
callq 0x2040
movq 0x682d(%rip), %rdi      # 0xbe68
callq 0x40cb
leaq 0x2e61(%rip), %rdi      # 0x84a8
callq 0x3efa
movq 0x681d(%rip), %rdi      # 0xbe70
callq 0x40cb
leaq 0x2e51(%rip), %rdi      # 0x84b0
callq 0x3efa
movq 0x680d(%rip), %rdi      # 0xbe78
callq 0x40cb
leaq 0x2e44(%rip), %rdi      # 0x84bb
callq 0x3efa
movl $0xa, %edi
callq 0x2040
cmpq $0x0, 0x67e2(%rip)      # 0xbe70
leaq 0x2e30(%rip), %rax      # 0x84c5
leaq 0x2dcd(%rip), %rdi      # 0x8469
cmoveq %rax, %rdi
callq 0x3efa
movl $0xa, %edi
callq 0x2040
movl 0x67bb(%rip), %eax      # 0xbe70
popq %rcx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
callq 0x5766
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x575c
cmpl $0x0, 0x6882(%rip)      # 0xbf64
je 0x5752
xorl %r15d, %r15d
leaq 0x2eb2(%rip), %r12      # 0x85a0
leaq 0x2eb5(%rip), %r13      # 0x85aa
movq (%r14), %rdi
callq 0x55e1
movq %r12, %rdi
callq 0x3efa
incq %r15
movq %r15, %rdi
callq 0x40ea
movq %r13, %rdi
callq 0x3efa
movl 0x6846(%rip), %edi      # 0xbf64
callq 0x40ea
movl $0xa, %edi
callq 0x2040
callq *%rbx
cmpl $0x0, 0x682a(%rip)      # 0xbf60
jne 0x5742
movl $0xa, %edi
callq 0x2040
callq 0x5613
movl 0x6817(%rip), %eax      # 0xbf64
cmpq %rax, %r15
jb 0x56f5
leaq 0x66e7(%rip), %rax      # 0xbe40
movl 0x30(%rax), %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r13
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x665f(%rip), %rsi      # 0xbf68
testq %rsi, %rsi
je 0x591f
movq %r9, %rdi
callq 0x2240
testq %rax, %rax
je 0x5a43
movq 0x664a(%rip), %rsi      # 0xbf70
testq %rsi, %rsi
je 0x593c
movq %r13, %rdi
callq 0x2240
testq %rax, %rax
je 0x5a43
movl 0x38(%rsp), %eax
movq 0x30(%rsp), %rcx
leaq 0x64f4(%rip), %r13      # 0xbe40
movq %rcx, (%r13)
movq %r12, 0x8(%r13)
movl %eax, %eax
movq %rax, 0x20(%r13)
cmpl $0x0, 0x65ff(%rip)      # 0xbf60
je 0x5975
movq %r12, %rdi
callq 0x3efa
movq $0x0, 0x8(%r13)
jmp 0x597f
movl $0x2e, %edi
callq 0x2040
incq 0x28(%r13)
xorl %eax, %eax
movl %eax, 0x65ed(%rip)      # 0xbf78
movl $0xffffffff, 0x6187(%rip) # imm = 0xFFFFFFFF
movl %eax, 0x65e1(%rip)      # 0xbf7c
leaq 0x50(%r13), %r12
movq %r12, %rdi
callq 0x2150
testl %eax, %eax
jne 0x59b1
callq *%r15
callq *%r14
movq %r12, %rdi
callq 0x2150
testl %eax, %eax
jne 0x59bf
callq *%rbx
movq %r12, %rdi
callq 0x2150
testl %eax, %eax
jne 0x5a3e
movslq 0x65aa(%rip), %rax      # 0xbf7c
testq %rax, %rax
jle 0x5a14
leaq 0x1(%rax), %rcx
shlq $0x4, %rax
leaq 0x659a(%rip), %rdx      # 0xbf80
addq %rdx, %rax
addq $-0x8, %rax
movq -0x8(%rax), %rdx
movq (%rax), %rsi
movq %rsi, (%rdx)
movq %rcx, %rdx
decq %rdx
addq $-0x10, %rax
movq %rdx, %rcx
cmpq $0x1, %rdx
jg 0x59ed
movl $0x0, 0x6568(%rip)      # 0xbf7c
cmpq $0x0, 0x40(%r13)
jne 0x5a3e
movl $0xffffffff, 0x60f7(%rip) # imm = 0xFFFFFFFF
cmpl $0x0, 0x654c(%rip)      # 0xbf78
je 0x5a3e
movq 0x20(%r13), %rsi
leaq 0x2adf(%rip), %rdi      # 0x8518
callq 0x545f
callq 0x5add
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movslq 0x6508(%rip), %rax      # 0xbf7c
testq %rax, %rax
jle 0x5ab1
leaq 0x1(%rax), %rcx
movq %rax, %rdx
shlq $0x4, %rdx
leaq 0x64f5(%rip), %rsi      # 0xbf80
addq %rsi, %rdx
addq $-0x8, %rdx
movq -0x8(%rdx), %rsi
movq (%rdx), %rdi
movq %rdi, (%rsi)
decq %rcx
decl %eax
addq $-0x10, %rdx
cmpq $0x1, %rcx
jg 0x5a92
movl %eax, 0x64cb(%rip)      # 0xbf7c
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x6430(%rip), %rsi      # 0xbf68
testq %rsi, %rsi
je 0x5b4a
movq %rdx, %rdi
callq 0x2240
testq %rax, %rax
je 0x5b8a
movq 0x641f(%rip), %rsi      # 0xbf70
testq %rsi, %rsi
je 0x5b63
movq %r14, %rdi
callq 0x2240
testq %rax, %rax
je 0x5b8a
leaq 0x62d6(%rip), %rax      # 0xbe40
incq 0x28(%rax)
incq 0x38(%rax)
cmpl $0x0, 0x63e7(%rip)      # 0xbf60
je 0x5b92
movq %rbx, %rdi
callq 0x3efa
movl $0xa, %edi
jmp 0x5b97
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x21, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x5c62
leaq -0x10(%rdi), %rbx
cmpq $0x0, -0x8(%rdi)
je 0x5c21
decl 0x6361(%rip)            # 0xbf78
movq %rbx, %rdi
callq 0x2030
jmp 0x5c45
addq -0x10(%rdi), %rdi
leaq 0x2983(%rip), %rsi      # 0x85af
callq 0x2160
movl %eax, %ebp
decl 0x633f(%rip)            # 0xbf78
movq %rbx, %rdi
callq 0x2030
testl %ebp, %ebp
je 0x5c62
leaq 0x61f4(%rip), %rax      # 0xbe40
movq 0x20(%rax), %rsi
leaq 0x28d2(%rip), %rdi      # 0x8529
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x545f
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
testq %rdi, %rdi
je 0x5d27
movq %rdi, %rbx
leaq -0x10(%rdi), %r14
cmpq $0x0, -0x8(%rdi)
jne 0x5cc6
movq -0x10(%rbx), %rdi
addq %rbx, %rdi
leaq 0x28f2(%rip), %rsi      # 0x85af
callq 0x2160
testl %eax, %eax
je 0x5ceb
decl 0x62ac(%rip)            # 0xbf78
movq %r14, %rdi
callq 0x2030
leaq 0x6165(%rip), %rax      # 0xbe40
movq 0x20(%rax), %rsi
leaq 0x2869(%rip), %rdi      # 0x854f
callq 0x545f
testq %r15, %r15
je 0x5d34
cmpq %r15, (%r14)
jae 0x5d44
movq %r15, %rdi
callq 0x5baa
testq %rax, %rax
je 0x5d42
movq %rax, %r15
movq -0x10(%rbx), %rdx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21a0
decl 0x625e(%rip)            # 0xbf78
movq %r14, %rdi
callq 0x2030
movq %r15, %rbx
jmp 0x5d44
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x5baa
decl 0x623e(%rip)            # 0xbf78
movq %r14, %rdi
callq 0x2030
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity_fixture.c
// Function: UnityPointer_Set
void UnityPointer_Set(void** pointer, void* newValue, UNITY_LINE_TYPE line)
{
    if (pointer_index >= UNITY_MAX_POINTERS)
    {
        UNITY_TEST_FAIL(line, "Too many pointers set");
    }
    else
    {
        pointer_store[pointer_index].pointer = pointer;
        pointer_store[pointer_index].old_value = *pointer;
        *pointer = newValue;
        pointer_index++;
    }
}

// Assembly:
movslq 0x6228(%rip), %rax      # 0xbf7c
cmpq $0x5, %rax
jl 0x5d69
leaq 0x2817(%rip), %rdi      # 0x8578
movq %rdx, %rsi
jmp 0x545f
movq %rax, %rcx
shlq $0x4, %rcx
leaq 0x6209(%rip), %rdx      # 0xbf80
movq %rdi, (%rcx,%rdx)
movq (%rdi), %r8
movq %r8, 0x8(%rcx,%rdx)
movq %rsi, (%rdi)
incl %eax
movl %eax, 0x61ee(%rip)      # 0xbf7c
retq
nop
// File: /workspace/github_c_makefile_star2_O1/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/tests.c
// Function: Tests_Run
void Tests_Run() {
  zf_log_set_output_level(ZF_LOG_DEBUG);
  RUN_TEST_GROUP(controls);
  RUN_TEST_GROUP(utility);
  RUN_TEST_GROUP(input);
  RUN_TEST_GROUP(errors);
}

// Assembly:
pushq %rax
movl $0x2, %edi
callq 0x2d56
callq 0x5e4c
callq 0x6186
callq 0x600b
popq %rax
jmp 0x5ef5
// File: /workspace/github_c_makefile_star2_O1/afi-lambda[P]a_little_smalltalk/src/st.c
// Function: goDoIt
static void goDoIt(const char *text)
{
    object process, stack, method;

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

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r12d, %r12d
xorl %eax, %eax
callq 0x3b41
movswl %ax, %ebp
movl %ebp, %edi
callq 0x2f20
xorl %edi, %edi
callq 0x6a9c
movl %ebp, %edi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x6b6a
movl $0x3, %edi
callq 0x2d15
movl %eax, 0x4(%rsp)
movswl %ax, %r14d
movl %r14d, %edi
callq 0x2f20
movl $0x32, %edi
callq 0x2d15
movswl %ax, %r15d
movl %r15d, %edi
callq 0x2f20
movl %r14d, %eax
shrl %eax
movswq %ax, %rbx
shlq $0x4, %rbx
leaq 0xb745(%rip), %r13      # 0xe240
movq 0x8(%r13,%rbx), %rax
movw %r15w, (%rax)
movl %r15d, %edi
callq 0x2f20
movl $0xa, %edi
callq 0x314c
movq 0x8(%r13,%rbx), %rcx
movw %ax, 0x2(%rcx)
movswl %ax, %edi
callq 0x2f20
movl $0x2, %edi
callq 0x314c
movq 0x8(%r13,%rbx), %rcx
movw %ax, 0x4(%rcx)
movswl %ax, %edi
callq 0x2f20
shrl %r15d
movswq %r15w, %r15
shlq $0x4, %r15
movq 0x8(%r13,%r15), %rax
movw %r12w, (%rax)
xorl %edi, %edi
callq 0x2f20
movq 0x8(%r13,%r15), %rax
movw %r12w, 0x2(%rax)
xorl %edi, %edi
callq 0x2f20
movq 0x8(%r13,%r15), %rax
movw %r12w, 0x4(%rax)
xorl %edi, %edi
callq 0x2f20
movl $0x1, %edi
callq 0x314c
movq 0x8(%r13,%r15), %rcx
movw %ax, 0x6(%rcx)
movswl %ax, %edi
callq 0x2f20
movq 0x8(%r13,%r15), %rax
movw %bp, 0x8(%rax)
movl %ebp, %edi
callq 0x2f20
movl $0x1, %edi
callq 0x314c
movq 0x8(%r13,%r15), %rcx
movw %ax, 0xa(%rcx)
movswl %ax, %edi
callq 0x2f20
movl %r14d, %edi
movl $0x3a98, %esi           # imm = 0x3A98
callq 0x3c09
testl %eax, %eax
jne 0x2be5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x4(%rsp), %edi
callq 0x250a
jmp 0x2bd6
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movw $0x0, 0xa653(%rip)      # 0xd2a0
movl $0x1964, %ebx           # imm = 0x1964
leaq 0x24c1f(%rip), %r14     # 0x27878
leaq 0xa640(%rip), %r15      # 0xd2a0
cmpw $0x0, -0x6(%r14)
jne 0x2c9d
movswl -0x4(%r14), %eax
movl $0x1, %edx
subl %eax, %edx
shrl %edx
testl %eax, %eax
cmovnsl %eax, %edx
movzwl (%r15,%rdx,2), %eax
movw %ax, -0x8(%r14)
leal -0x1(%rbx), %eax
movw %ax, (%r15,%rdx,2)
testl %edx, %edx
jle 0x2c9d
movq (%r14), %rdi
addl %edx, %edx
xorl %esi, %esi
callq 0x20d0
decq %rbx
addq $-0x10, %r14
cmpq $0x1, %rbx
ja 0x2c60
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movl %edi, %ebx
movl 0x24bc7(%rip), %eax     # 0x27880
addl %edi, %eax
cmpl $0x1770, %eax           # imm = 0x1770
jl 0x2cfa
movl $0x1770, %edi           # imm = 0x1770
movl $0x2, %esi
callq 0x2150
movq %rax, 0x24bb0(%rip)     # 0x27888
testq %rax, %rax
jne 0x2cf0
leaq 0x6436(%rip), %rdi      # 0x911a
leaq 0x643d(%rip), %rsi      # 0x9128
callq 0x4dfc
movl $0x0, 0x24b86(%rip)     # 0x27880
movslq 0x24b7f(%rip), %rax     # 0x27880
addl %eax, %ebx
addq %rax, %rax
addq 0x24b7b(%rip), %rax     # 0x27888
movl %ebx, 0x24b6d(%rip)     # 0x27880
popq %rbx
retq