LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/utility.c
// Function: DecodeLine2
void DecodeLine2(char *pS)
{
  int len;
  int seed;
  int i;
  int count;
  unsigned char c;
  char *key;

  len = strlen(pS);
  count = 0;
  key = gLong_key;
  while ( len > 0 && (pS[len - 1] == 13 || pS[len - 1] == 10))
  {
    --len;
    pS[len] = 0;
  }
  seed = len % 16;
  for ( i = 0; i < len; i++)
  {
    c = pS[i];
    if (i >= 2) {
      if (pS[i - 1] == '/' && pS[i - 2] == '/') {
        key = gOther_long_key;
      }
    }
    if (gEncryption_method == 1) 
    { 
      if ( c == '\t' ) {
        c = 0x80;
      }
      c -= 0x20;
      if (!(c & 0x80)) {
        c = (c ^ key[seed]) & 0x7f;
        c += 0x20;
      }
      seed += 7;
      seed = seed % 16;
      
      if ( c == 0x80 ) {
        c = '\t';
      }
    }
    else {
      if (c == '\t') {
        c = 0x9f;
      }
      c -= 0x20;
      c = (c ^ key[seed]) & 0x7f;
      c += 0x20;

      seed += 7;
      seed = seed % 16;
      
      if ( c == 0x9f ) {
        c = '\t';
      }
    }
    pS[i] = c;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x20d0
movl %eax, %ecx
movl %eax, %edx
sarl $0x1f, %edx
andl %eax, %edx
testl %ecx, %ecx
jle 0x2b44
movzbl -0x1(%rbx,%rcx), %eax
cmpl $0xd, %eax
je 0x2b37
cmpl $0xa, %eax
jne 0x2b42
decq %rcx
movl %ecx, %eax
movb $0x0, (%rbx,%rax)
jmp 0x2b24
movl %ecx, %edx
xorl %ecx, %ecx
testl %edx, %edx
movl $0x0, %esi
cmovgl %edx, %esi
leaq 0x8f79(%rip), %rdi      # 0xbad0
pushq $0x10
popq %r8
leaq 0x8f7e(%rip), %r9       # 0xbae0
pushq $0x60
popq %r10
pushq $0x9
popq %r11
pushq $0x7f
popq %rbp
movl %edx, %eax
cltd
idivl %r8d
cmpq %rcx, %rsi
je 0x2c02
cmpq $0x2, %rcx
jb 0x2b92
cmpb $0x2f, -0x1(%rbx,%rcx)
jne 0x2b92
cmpb $0x2f, -0x2(%rbx,%rcx)
cmoveq %r9, %rdi
movb (%rbx,%rcx), %r15b
cmpl $0x1, 0x8f23(%rip)      # 0xbac0
movslq %edx, %rax
jne 0x2bcc
leal -0x20(%r15), %r14d
cmpb $0x9, %r15b
movzbl %r14b, %r15d
cmovel %r10d, %r15d
testb %r15b, %r15b
js 0x2bc6
movb (%rdi,%rax), %r14b
andb $0x7f, %r14b
xorb %r15b, %r14b
addb $0x20, %r14b
cmpb $-0x80, %r14b
jmp 0x2bec
leal 0x60(%r15), %r14d
cmpb $0x9, %r15b
movzbl %r14b, %r14d
cmovel %ebp, %r14d
xorb (%rdi,%rax), %r14b
andb $0x7f, %r14b
addb $0x20, %r14b
cmpb $-0x61, %r14b
movzbl %r14b, %eax
cmovel %r11d, %eax
addl $0x7, %edx
movb %al, (%rbx,%rcx)
incq %rcx
jmp 0x2b6d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/pc/sys.c
// Function: PDFatalError
void PDFatalError(char *pThe_str)
{
	if (been_here) {
		exit(1);
	}
	been_here = 1;

	fprintf(stderr, "FATAL ERROR: %s\n", pThe_str);
	// wait for keypress
	// DoSaveGame() -> exit
    if (TEST_really_exit) {
	   exit(1);
    }
}

// Assembly:
pushq %rax
cmpl $0x0, 0x9197(%rip)      # 0xbde0
jne 0x2c7b
movq %rdi, %rdx
movl $0x1, 0x9188(%rip)      # 0xbde0
movq 0x8399(%rip), %rax      # 0xaff8
movq (%rax), %rdi
leaq 0x45a2(%rip), %rsi      # 0x720b
xorl %eax, %eax
callq 0x2170
cmpl $0x0, 0x8e79(%rip)      # 0xbaf0
jne 0x2c7b
popq %rax
retq
pushq $0x1
popq %rdi
callq 0x2210
// File: /workspace/github_c_makefile_star2_O2/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/log/zf_log.c
// Function: zf_log_write_mem_d
void _zf_log_write_mem_d(
        const char *const func, const char *const file, const unsigned line,
        const int lvl, const char *const tag,
        const void *const d, const unsigned d_sz,
        const char *const fmt, ...)
{
    const src_location src = {func, file, line};
    const mem_block mem = {d, d_sz};
    va_list va;
    va_start(va, fmt);
    _zf_log_write_imp(&global_spec, &src, &mem, lvl, tag, fmt, va);
    va_end(va);
}

// Assembly:
subq $0x108, %rsp            # imm = 0x108
testb %al, %al
je 0x35ed
movaps %xmm0, 0x80(%rsp)
movaps %xmm1, 0x90(%rsp)
movaps %xmm2, 0xa0(%rsp)
movaps %xmm3, 0xb0(%rsp)
movaps %xmm4, 0xc0(%rsp)
movaps %xmm5, 0xd0(%rsp)
movaps %xmm6, 0xe0(%rsp)
movaps %xmm7, 0xf0(%rsp)
movq 0x118(%rsp), %rax
movl 0x110(%rsp), %r11d
leaq 0x38(%rsp), %r10
movq %rdi, (%r10)
movq %rsi, 0x8(%r10)
movl %edx, 0x10(%r10)
leaq 0x10(%rsp), %rdx
movq %r9, (%rdx)
movl %r11d, 0x8(%rdx)
leaq 0x50(%rsp), %rsi
leaq 0x20(%rsp), %rdi
movq %rsi, 0x10(%rdi)
leaq 0x120(%rsp), %rsi
movq %rsi, 0x8(%rdi)
movabsq $0x3000000030, %rsi     # imm = 0x3000000030
movq %rsi, (%rdi)
movq %rdi, (%rsp)
leaq 0x776d(%rip), %rdi      # 0xadb8
movq %r10, %rsi
movq %rax, %r9
callq 0x2d6b
addq $0x108, %rsp            # imm = 0x108
retq
// File: /workspace/github_c_makefile_star2_O2/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/log/zf_log.c
// Function: put_integer_r
static char *put_integer_r(unsigned v, const int sign,
                           const unsigned w, const char wc, char *const e)
{
    static const char _signs[] = {'-', '0', '+'};
    static const char *const signs = _signs + 1;
    char *p = e;
    do { *--p = '0' + v % 10; } while (0 != (v /= 10));
    if (0 == sign) return put_padding_r(w, wc, p, e);
    if ('0' != wc)
    {
        *--p = signs[sign];
        return put_padding_r(w, wc, p, e);
    }
    p = put_padding_r(w, wc, p, e + 1);
    *--p = signs[sign];
    return p;
}

// Assembly:
movl %edx, %r9d
movl %edi, %r10d
leaq -0x1(%r8), %rdi
pushq $0xa
popq %r11
movl %r10d, %eax
xorl %edx, %edx
divl %r11d
orb $0x30, %dl
movb %dl, (%rdi)
decq %rdi
cmpl $0x9, %r10d
movl %eax, %r10d
ja 0x38a0
testl %esi, %esi
je 0x38dc
cmpb $0x30, %cl
jne 0x38f2
movl %r9d, %eax
subq %rax, %r8
incq %r8
leaq 0x1(%rdi), %rax
cmpq %rax, %r8
jae 0x3908
movb $0x30, (%rdi)
decq %rdi
jmp 0x38cb
incq %rdi
movl %r9d, %eax
subq %rax, %r8
cmpq %rdi, %r8
jae 0x390b
movb %cl, -0x1(%rdi)
decq %rdi
jmp 0x38e5
movb $0x2d, (%rdi)
movl %r9d, %eax
subq %rax, %r8
cmpq %rdi, %r8
jae 0x390b
movb %cl, -0x1(%rdi)
decq %rdi
jmp 0x38fb
movb $0x2d, (%rdi)
movq %rdi, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity.c
// Function: UnityPrint
void UnityPrint(const char* string)
{
    const char* pch = string;

    if (pch != NULL)
    {
        while (*pch)
        {
            /* 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');
            }
#ifdef UNITY_OUTPUT_COLOR
            /* print ANSI escape code */
            else if (*pch == 27 && *(pch + 1) == '[')
            {
                while (*pch && *pch != 'm')
                {
                    UNITY_OUTPUT_CHAR(*pch);
                    pch++;
                }
                UNITY_OUTPUT_CHAR('m');
            }
#endif
            /* 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 0x39c3
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x5c
popq %rbp
pushq $0x72
popq %r15
pushq $0x78
popq %r12
pushq $0x2
popq %r13
movzbl (%rbx), %r14d
testl %r14d, %r14d
je 0x39b5
leal -0x20(%r14), %eax
cmpb $0x5e, %al
ja 0x397a
movl %r14d, %edi
jmp 0x3995
movl %ebp, %edi
callq 0x2040
cmpl $0xa, %r14d
je 0x3992
cmpl $0xd, %r14d
jne 0x399f
movl %r15d, %edi
jmp 0x3995
pushq $0x6e
popq %rdi
callq 0x2040
incq %rbx
jmp 0x3964
movl %r12d, %edi
callq 0x2040
movsbq (%rbx), %rdi
movl %r13d, %esi
callq 0x39c4
jmp 0x399a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x11, %esi
movzbl %sil, %eax
pushq $0x10
popq %r15
cmovbq %rax, %r15
leaq -0x4(,%r15,4), %r14
testb %r15b, %r15b
jle 0x3a0e
movq %rbx, %rax
movl %r14d, %ecx
shrq %cl, %rax
andl $0xf, %eax
leal 0x37(%rax), %ecx
leal 0x30(%rax), %edi
cmpl $0xa, %eax
cmovael %ecx, %edi
callq 0x2040
decb %r15b
addq $-0x4, %r14
jmp 0x39e3
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3aa0
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %r13d, %r13d
pushq $0x5c
popq %rbp
pushq $0x2
popq %r15
movsbl (%r14,%r13), %r12d
testl %r12d, %r12d
je 0x3a92
cmpl %ebx, %r13d
jae 0x3a92
leal -0x20(%r12), %eax
cmpb $0x5e, %al
ja 0x3a54
movl %r12d, %edi
jmp 0x3a71
movl %ebp, %edi
callq 0x2040
cmpb $0xa, %r12b
je 0x3a6e
movzbl %r12b, %eax
cmpl $0xd, %eax
jne 0x3a7b
pushq $0x72
jmp 0x3a70
pushq $0x6e
popq %rdi
callq 0x2040
incq %r13
jmp 0x3a37
pushq $0x78
popq %rdi
callq 0x2040
movsbq (%r14,%r13), %rdi
movl %r15d, %esi
callq 0x39c4
jmp 0x3a76
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3ade
testb $0x20, %bpl
jne 0x3aec
pushq $0x30
popq %rdi
callq 0x2040
pushq $0x78
popq %rdi
callq 0x2040
addb %bpl, %bpl
andb $0x1e, %bpl
movzbl %bpl, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x39c4
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3afa
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3b17
// File: /workspace/github_c_makefile_star2_O2/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity.c
// Function: UnityPrintNumber
void UnityPrintNumber(const UNITY_INT number_to_print)
{
    UNITY_UINT number = (UNITY_UINT)number_to_print;

    if (number_to_print < 0)
    {
        /* A negative number, including MIN negative */
        UNITY_OUTPUT_CHAR('-');
        number = -number;
    }
    UnityPrintNumberUnsigned(number);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
jns 0x3b0e
pushq $0x2d
popq %rdi
callq 0x2040
negq %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x3b17
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %r14
movq %rbx, %rax
xorl %edx, %edx
divq %r14
cmpq $0x9, %rax
jbe 0x3b37
imulq $0xa, %r14, %r14
jmp 0x3b23
pushq $0xa
popq %r15
movq %rbx, %rax
xorl %edx, %edx
divq %r14
xorl %edx, %edx
divq %r15
movq %rdx, %rdi
orl $0x30, %edi
callq 0x2040
movq %r14, %rax
xorl %edx, %edx
divq %r15
cmpq $0x9, %r14
movq %rax, %r14
ja 0x3b3b
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity.c
// Function: UnityPrintMask
void UnityPrintMask(const UNITY_UINT mask, const UNITY_UINT number)
{
    UNITY_UINT current_bit = (UNITY_UINT)1 << (UNITY_INT_WIDTH - 1);
    UNITY_INT32 i;

    for (i = 0; i < UNITY_INT_WIDTH; i++)
    {
        if (current_bit & mask)
        {
            if (current_bit & number)
            {
                UNITY_OUTPUT_CHAR('1');
            }
            else
            {
                UNITY_OUTPUT_CHAR('0');
            }
        }
        else
        {
            UNITY_OUTPUT_CHAR('X');
        }
        current_bit = current_bit >> 1;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x80000000, %r15d      # imm = 0x80000000
pushq $0x20
popq %rbp
pushq $0x31
popq %r12
pushq $0x58
popq %r13
subl $0x1, %ebp
jb 0x3bb2
movq %r15, %rax
andq %rbx, %rax
cmpq $0x1, %rax
movl %r12d, %edi
sbbl $0x0, %edi
testq %r14, %r15
cmovel %r13d, %edi
callq 0x2040
shrq %r15
jmp 0x3b8c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0x3942
pushq $0x3a
popq %rbp
movl %ebp, %edi
callq 0x2040
movq %rbx, %rdi
callq 0x3afa
movl %ebp, %edi
callq 0x2040
movq 0x7f40(%rip), %rdi      # 0xbe48
callq 0x3942
movl %ebp, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O2/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 0x7f5f(%rip), %rax      # 0xbe88
orq 0x7f50(%rip), %rax      # 0xbe80
jne 0x3f46
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movq %rdx, %rax
xorq %rsi, %rax
testq %rdi, %rax
jne 0x3f52
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rcx, %rbx
movq %r8, %rdi
callq 0x3fad
leaq 0x33cf(%rip), %rdi      # 0x7333
callq 0x3942
movq %r15, %rdi
movq %r12, %rsi
callq 0x3b6a
leaq 0x33c3(%rip), %rdi      # 0x733e
callq 0x3942
movq %r15, %rdi
movq %r14, %rsi
callq 0x3b6a
movq %rbx, %rdi
callq 0x3fd2
movq $0x1, 0x7ee2(%rip) # 0xbe80
leaq 0x7eeb(%rip), %rdi      # 0xbe90
pushq $0x1
popq %rsi
callq 0x21d0
// File: /workspace/github_c_makefile_star2_O2/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 0x4040
pushq %rbx
movq %rdi, %rbx
leaq 0x34a1(%rip), %rdi      # 0x7483
callq 0x3942
cmpq $0x0, 0x7e61(%rip)      # 0xbe50
je 0x4037
leaq 0x3476(%rip), %rdi      # 0x746e
callq 0x3942
movq 0x7e4c(%rip), %rdi      # 0xbe50
callq 0x3942
cmpq $0x0, 0x7e47(%rip)      # 0xbe58
je 0x402b
leaq 0x345e(%rip), %rdi      # 0x7478
callq 0x3942
movq 0x7e32(%rip), %rdi      # 0xbe58
callq 0x3942
leaq 0x3451(%rip), %rdi      # 0x7483
callq 0x3942
movq %rbx, %rdi
popq %rbx
jmp 0x3942
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x405a
cmpq $0x0, 0x7e32(%rip)      # 0xbe80
jne 0x405a
cmpq $0x0, 0x7e30(%rip)      # 0xbe88
je 0x405b
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 0x3fad
leaq 0x32b6(%rip), %rdi      # 0x7333
callq 0x3942
movq %r15, %rdi
movl %ebp, %esi
callq 0x3aa1
leaq 0x32ab(%rip), %rdi      # 0x733e
callq 0x3942
movq %r14, %rdi
movl %ebp, %esi
callq 0x3aa1
movq %rbx, %rdi
callq 0x3fd2
movq $0x1, 0x7dcb(%rip) # 0xbe80
leaq 0x7dd4(%rip), %rdi      # 0xbe90
pushq $0x1
popq %rsi
callq 0x21d0
// File: /workspace/github_c_makefile_star2_O2/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 0x7db5(%rip), %rax      # 0xbe88
orq 0x7da6(%rip), %rax      # 0xbe80
jne 0x4169
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %r14
cmpq %rsi, %rdi
sete %al
testb %r15b, %al
jne 0x4169
movl %r9d, %ebp
movq %rcx, %rbx
xorl %eax, %eax
cmpq %r12, %r14
sete %al
testb $0x10, %bpl
jne 0x4147
movl %r15d, %edx
andl $0x2, %edx
shrl %edx
testb $0x4, %r15b
pushq $0x1
popq %rcx
cmovel %eax, %ecx
cmpq %r14, %r12
cmovbel %eax, %ecx
setb %al
testb %dl, %al
je 0x4165
movq %r8, %rdi
callq 0x3fad
leaq 0x31fd(%rip), %rdi      # 0x7333
callq 0x3942
movq %r12, %rdi
movl %ebp, %esi
callq 0x3aa1
jmp 0x4196
testb $0x2, %r15b
sete %dl
testb $0x4, %r15b
pushq $0x1
popq %rcx
cmovel %eax, %ecx
cmpq %r14, %r12
cmovlel %eax, %ecx
setge %al
orb %dl, %al
je 0x4127
testl %ecx, %ecx
jne 0x4172
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r8, %rdi
callq 0x3fad
leaq 0x31b2(%rip), %rdi      # 0x7333
callq 0x3942
movq %r12, %rdi
movl %ebp, %esi
callq 0x3aa1
testb $0x2, %r15b
je 0x41a2
leaq 0x31b3(%rip), %rdi      # 0x7350
callq 0x3942
testb $0x4, %r15b
je 0x41b4
leaq 0x31c1(%rip), %rdi      # 0x7370
callq 0x3942
testb $0x1, %r15b
je 0x41c6
leaq 0x31c1(%rip), %rdi      # 0x7382
callq 0x3942
movq %r14, %rdi
movl %ebp, %esi
callq 0x3aa1
movq %rbx, %rdi
callq 0x3fd2
movq $0x1, 0x7c9d(%rip) # 0xbe80
leaq 0x7ca6(%rip), %rdi      # 0xbe90
pushq $0x1
popq %rsi
callq 0x21d0
// File: /workspace/github_c_makefile_star2_O2/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 0x7a88(%rip), %rax      # 0xbe88
orq 0x7a79(%rip), %rax      # 0xbe80
jne 0x447b
movq %r8, %r12
movl %edx, %ebp
testl %edx, %edx
je 0x44f6
movq %rsi, %r14
movq %rdi, %r15
cmpq %rsi, %rdi
je 0x447b
movl %r9d, %r13d
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq (%rsp), %rcx
callq 0x439f
testl %eax, %eax
jne 0x44dc
xorl %ebx, %ebx
cmpl $0x1, %r13d
sete %bl
shll $0x2, %ebx
movl %ebp, %ebp
xorl %r13d, %r13d
cmpl %r13d, %ebp
je 0x447b
movss (%r15), %xmm1
movaps %xmm1, %xmm0
mulss 0x2e30(%rip), %xmm0     # 0x7294
movss (%r14,%r13,4), %xmm2
callq 0x450c
testl %eax, %eax
je 0x448a
addq %rbx, %r15
incq %r13
jmp 0x444f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rdi
callq 0x3fad
leaq 0x2f2e(%rip), %rdi      # 0x73c7
callq 0x3942
movq %r13, %rdi
callq 0x3b17
leaq 0x2e86(%rip), %rdi      # 0x7333
callq 0x3942
movss (%r15), %xmm0
callq 0x3bc1
leaq 0x2e7b(%rip), %rdi      # 0x733e
callq 0x3942
movss (%r14,%r13,4), %xmm0
callq 0x3bc1
movq (%rsp), %rdi
callq 0x3fd2
movq $0x1, 0x7999(%rip) # 0xbe80
leaq 0x79a2(%rip), %rdi      # 0xbe90
pushq $0x1
popq %rsi
callq 0x21d0
movq %r12, %rdi
callq 0x3fad
leaq 0x2e8b(%rip), %rdi      # 0x7390
callq 0x3942
jmp 0x44d3
// File: /workspace/github_c_makefile_star2_O2/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 0x78e6(%rip), %rax      # 0xbe88
orq 0x78d7(%rip), %rax      # 0xbe80
jne 0x45d0
movq %rsi, %r14
movq %rdi, %rbx
movss %xmm1, (%rsp)
movss (%rsp), %xmm1
movss %xmm2, 0x4(%rsp)
movss 0x4(%rsp), %xmm2
callq 0x450c
testl %eax, %eax
je 0x45d8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
callq 0x3fad
leaq 0x2d4c(%rip), %rdi      # 0x7333
callq 0x3942
movss (%rsp), %xmm0
callq 0x3bc1
leaq 0x2d41(%rip), %rdi      # 0x733e
callq 0x3942
movss 0x4(%rsp), %xmm0
callq 0x3bc1
movq %rbx, %rdi
callq 0x3fd2
movq $0x1, 0x7860(%rip) # 0xbe80
leaq 0x7869(%rip), %rdi      # 0xbe90
pushq $0x1
popq %rsi
callq 0x21d0
// File: /workspace/github_c_makefile_star2_O2/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 0x772e(%rip), %rax      # 0xbe88
orq 0x771f(%rip), %rax      # 0xbe80
jne 0x4797
movl %r9d, %ebp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rdx, %rax
testb $0x10, %bpl
jne 0x47a0
subq %r15, %rax
ja 0x4786
movq %r15, %rax
subq %r14, %rax
xorl %ecx, %ecx
cmpq %r12, %rax
seta %cl
movq %rcx, 0x76eb(%rip)      # 0xbe80
ja 0x47a7
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
subq %r15, %rax
jle 0x4780
jmp 0x4786
movq %r8, %rdi
callq 0x3fad
leaq 0x2c7a(%rip), %rdi      # 0x7430
callq 0x3942
movq %r12, %rdi
movl %ebp, %esi
callq 0x3aa1
leaq 0x2b67(%rip), %rdi      # 0x7333
callq 0x3942
movq %r15, %rdi
movl %ebp, %esi
callq 0x3aa1
leaq 0x2b5c(%rip), %rdi      # 0x733e
callq 0x3942
movq %r14, %rdi
movl %ebp, %esi
callq 0x3aa1
movq %rbx, %rdi
callq 0x3fd2
movq $0x1, 0x767c(%rip) # 0xbe80
leaq 0x7685(%rip), %rdi      # 0xbe90
pushq $0x1
popq %rsi
callq 0x21d0
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq 0x7666(%rip), %rax      # 0xbe88
orq 0x7657(%rip), %rax      # 0xbe80
jne 0x489f
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %dl
orb %al, %dl
jne 0x489a
xorl %eax, %eax
movl %eax, %esi
movb (%r15,%rsi), %dl
movb (%r14,%rsi), %sil
movl %edx, %edi
orb %sil, %dil
je 0x489f
incl %eax
cmpb %sil, %dl
je 0x4846
pushq $0x1
popq %r12
movq %r12, 0x7617(%rip)      # 0xbe80
movq %rcx, %rdi
callq 0x3fad
movq %r15, %rdi
movq %r14, %rsi
callq 0x48ab
movq %rbx, %rdi
callq 0x3fd2
movq %r12, 0x75f5(%rip)      # 0xbe80
leaq 0x75fe(%rip), %rdi      # 0xbe90
pushq $0x1
popq %rsi
callq 0x21d0
cmpq %r14, %r15
jne 0x485e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2a77(%rip), %rdi      # 0x7333
callq 0x3942
testq %r14, %r14
je 0x48e1
pushq $0x27
popq %rbp
movl %ebp, %edi
callq 0x2040
movq %r14, %rdi
callq 0x3942
movl %ebp, %edi
callq 0x2040
jmp 0x48ed
leaq 0x2c21(%rip), %rdi      # 0x7509
callq 0x3942
leaq 0x2a4a(%rip), %rdi      # 0x733e
callq 0x3942
testq %rbx, %rbx
je 0x491b
pushq $0x27
popq %rbp
movl %ebp, %edi
callq 0x2040
movq %rbx, %rdi
callq 0x3942
movl %ebp, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x2040
leaq 0x2be7(%rip), %rdi      # 0x7509
popq %rbx
popq %r14
popq %rbp
jmp 0x3942
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
movq 0x754e(%rip), %rax      # 0xbe88
orq 0x753f(%rip), %rax      # 0xbe80
jne 0x49c1
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 0x49bc
movl %ebp, %eax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x49c1
movb (%r15,%rcx), %dl
movb (%r14,%rcx), %sil
movl %edx, %edi
orb %sil, %dil
je 0x49c1
incq %rcx
cmpb %sil, %dl
je 0x4962
pushq $0x1
popq %r12
movq %r12, 0x74f7(%rip)      # 0xbe80
movq %r8, %rdi
callq 0x3fad
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x49ca
movq %rbx, %rdi
callq 0x3fd2
movq %r12, 0x74d3(%rip)      # 0xbe80
leaq 0x74dc(%rip), %rdi      # 0xbe90
pushq $0x1
popq %rsi
callq 0x21d0
cmpq %r14, %r15
jne 0x497e
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x2953(%rip), %rdi      # 0x7333
callq 0x3942
testq %r15, %r15
je 0x4a07
pushq $0x27
popq %rbp
movl %ebp, %edi
callq 0x2040
movq %r15, %rdi
movl %ebx, %esi
callq 0x3a14
movl %ebp, %edi
callq 0x2040
jmp 0x4a13
leaq 0x2afb(%rip), %rdi      # 0x7509
callq 0x3942
leaq 0x2924(%rip), %rdi      # 0x733e
callq 0x3942
testq %r14, %r14
je 0x4a49
pushq $0x27
popq %rbp
movl %ebp, %edi
callq 0x2040
movq %r14, %rdi
movl %ebx, %esi
callq 0x3a14
movl %ebp, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2040
leaq 0x2ab9(%rip), %rdi      # 0x7509
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3942
// File: /workspace/github_c_makefile_star2_O2/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 0x7105(%rip), %rax      # 0xbe88
orq 0x70f6(%rip), %rax      # 0xbe80
je 0x4d8d
retq
pushq %rbx
movq %rdi, %rbx
movq 0x70a8(%rip), %rdi      # 0xbe40
callq 0x3edd
leaq 0x26c5(%rip), %rdi      # 0x7469
callq 0x3942
testq %rbx, %rbx
je 0x4e1b
pushq $0x3a
popq %rdi
callq 0x2040
cmpq $0x0, 0x7092(%rip)      # 0xbe50
je 0x4e06
leaq 0x26a7(%rip), %rdi      # 0x746e
callq 0x3942
movq 0x707d(%rip), %rdi      # 0xbe50
callq 0x3942
cmpq $0x0, 0x7078(%rip)      # 0xbe58
je 0x4dfa
leaq 0x268f(%rip), %rdi      # 0x7478
callq 0x3942
movq 0x7063(%rip), %rdi      # 0xbe58
callq 0x3942
leaq 0x2682(%rip), %rdi      # 0x7483
callq 0x3942
cmpb $0x20, (%rbx)
je 0x4e13
pushq $0x20
popq %rdi
callq 0x2040
movq %rbx, %rdi
callq 0x3942
movq $0x1, 0x705a(%rip) # 0xbe80
leaq 0x7063(%rip), %rdi      # 0xbe90
pushq $0x1
popq %rsi
callq 0x21d0
// File: /workspace/github_c_makefile_star2_O2/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 0x704c(%rip), %rax      # 0xbe88
orq 0x703d(%rip), %rax      # 0xbe80
je 0x4e46
retq
pushq %rbx
movq %rdi, %rbx
movq 0x6fef(%rip), %rdi      # 0xbe40
callq 0x3edd
leaq 0x2629(%rip), %rdi      # 0x7486
callq 0x3942
testq %rbx, %rbx
je 0x4e7f
pushq $0x3a
popq %rdi
callq 0x2040
pushq $0x20
popq %rdi
callq 0x2040
movq %rbx, %rdi
callq 0x3942
movq $0x1, 0x6ffe(%rip) # 0xbe88
leaq 0x6fff(%rip), %rdi      # 0xbe90
pushq $0x1
popq %rsi
callq 0x21d0
// File: /workspace/github_c_makefile_star2_O2/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, 0x6fa7(%rip)      # 0xbe48
movslq %edx, %rax
movq %rax, 0x6fb5(%rip)      # 0xbe60
incq 0x6fb6(%rip)            # 0xbe68
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x6f91(%rip)     # 0xbe50
leaq 0x6fca(%rip), %rdi      # 0xbe90
callq 0x2150
testl %eax, %eax
jne 0x4ed6
callq 0x393c
callq *%rbx
leaq 0x6fb3(%rip), %rdi      # 0xbe90
callq 0x2150
testl %eax, %eax
jne 0x4eeb
callq 0x393d
callq 0x3e81
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq $0xa
popq %rbx
movl %ebx, %edi
callq 0x2040
leaq 0x255d(%rip), %rdi      # 0x7490
callq 0x3942
movl %ebx, %edi
callq 0x2040
movq 0x6f22(%rip), %rdi      # 0xbe68
callq 0x3afa
leaq 0x2556(%rip), %rdi      # 0x74a8
callq 0x3942
movq 0x6f12(%rip), %rdi      # 0xbe70
callq 0x3afa
leaq 0x2546(%rip), %rdi      # 0x74b0
callq 0x3942
movq 0x6f02(%rip), %rdi      # 0xbe78
callq 0x3afa
leaq 0x2539(%rip), %rdi      # 0x74bb
callq 0x3942
movl %ebx, %edi
callq 0x2040
cmpq $0x0, 0x6eda(%rip)      # 0xbe70
leaq 0x2528(%rip), %rax      # 0x74c5
leaq 0x24c5(%rip), %rdi      # 0x7469
cmoveq %rax, %rdi
callq 0x3942
movl %ebx, %edi
callq 0x2040
movl 0x6eb6(%rip), %eax      # 0xbe70
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
callq 0x5061
testl %eax, %eax
je 0x4fdb
pushq $0x1
popq %rax
jmp 0x5052
xorl %r15d, %r15d
leaq 0x25af(%rip), %r12      # 0x7594
leaq 0x25b2(%rip), %r13      # 0x759e
pushq $0xa
popq %rbp
movl 0x6f6f(%rip), %eax      # 0xbf64
cmpq %rax, %r15
jae 0x5048
movq (%r14), %rdi
callq 0x4ef2
movq %r12, %rdi
callq 0x3942
incq %r15
movq %r15, %rdi
callq 0x3b17
movq %r13, %rdi
callq 0x3942
movl 0x6f41(%rip), %edi      # 0xbf64
callq 0x3b17
movl %ebp, %edi
callq 0x2040
callq *%rbx
cmpl $0x0, 0x6f28(%rip)      # 0xbf60
jne 0x5041
movl %ebp, %edi
callq 0x2040
callq 0x4f21
jmp 0x4fef
leaq 0x6df1(%rip), %rax      # 0xbe40
movl 0x30(%rax), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r9, %rdi
callq 0x527e
testl %eax, %eax
je 0x5274
movq %r13, %rdi
callq 0x528d
testl %eax, %eax
je 0x5274
movl 0x38(%rsp), %eax
movq 0x30(%rsp), %rcx
leaq 0x6c59(%rip), %r13      # 0xbe40
movq %rcx, (%r13)
movq %r12, 0x8(%r13)
movl %eax, %eax
movq %rax, 0x20(%r13)
cmpl $0x0, 0x6d64(%rip)      # 0xbf60
je 0x520d
movq %r12, %rdi
callq 0x3942
andq $0x0, 0x8(%r13)
jmp 0x5215
pushq $0x2e
popq %rdi
callq 0x2040
incq 0x28(%r13)
andl $0x0, 0x6d58(%rip)      # 0xbf78
orl $-0x1, 0x68f5(%rip)     # 0xbb1c
andl $0x0, 0x6d4e(%rip)      # 0xbf7c
leaq 0x50(%r13), %r12
movq %r12, %rdi
callq 0x2150
testl %eax, %eax
jne 0x5244
callq *%r15
callq *%r14
movq %r12, %rdi
callq 0x2150
testl %eax, %eax
jne 0x5252
callq *%rbx
movq %r12, %rdi
callq 0x2150
testl %eax, %eax
jne 0x526f
callq 0x52b3
cmpq $0x0, 0x40(%r13)
jne 0x526f
callq 0x52e2
callq 0x530a
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movl 0x6cc3(%rip), %eax      # 0xbf7c
leaq 0x6cc0(%rip), %rcx      # 0xbf80
testl %eax, %eax
jle 0x52e1
decl %eax
movl %eax, 0x6cb0(%rip)      # 0xbf7c
movq %rax, %rdx
shlq $0x4, %rdx
movq (%rdx,%rcx), %rsi
movq 0x8(%rdx,%rcx), %rdx
movq %rdx, (%rsi)
jmp 0x52c0
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rdx, %rdi
callq 0x527e
testl %eax, %eax
je 0x5398
movq %r14, %rdi
callq 0x528d
testl %eax, %eax
je 0x5398
leaq 0x6ac5(%rip), %rax      # 0xbe40
incq 0x28(%rax)
incq 0x38(%rax)
cmpl $0x0, 0x6bd6(%rip)      # 0xbf60
je 0x53a0
movq %rbx, %rdi
callq 0x3942
pushq $0xa
jmp 0x53a2
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x21
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O2/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 0x5442
movq %rdi, %rbx
callq 0x5449
movl %eax, %ebp
movq %rbx, %rdi
callq 0x5473
testl %ebp, %ebp
je 0x5442
leaq 0x6a14(%rip), %rax      # 0xbe40
movq 0x20(%rax), %rsi
leaq 0x20f2(%rip), %rdi      # 0x7529
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4d7c
addq $0x8, %rsp
popq %rbx
popq %rbp
retq