LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/log/zf_log.c
// Function: zf_log_write_mem_aux_d
void _zf_log_write_mem_aux_d(
        const char *const func, const char *const file, const unsigned line,
        const zf_log_spec *const log, 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(log, &src, &mem, lvl, tag, fmt, va);
    va_end(va);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
testb %al, %al
je 0x3aa4
movaps %xmm0, -0xf0(%rbp)
movaps %xmm1, -0xe0(%rbp)
movaps %xmm2, -0xd0(%rbp)
movaps %xmm3, -0xc0(%rbp)
movaps %xmm4, -0xb0(%rbp)
movaps %xmm5, -0xa0(%rbp)
movaps %xmm6, -0x90(%rbp)
movaps %xmm7, -0x80(%rbp)
movq 0x20(%rbp), %rax
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x38(%rbp)
movq 0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movl 0x18(%rbp), %eax
movl %eax, -0x50(%rbp)
leaq -0x120(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq 0x28(%rbp), %rax
movq %rax, -0x68(%rbp)
movl $0x30, -0x6c(%rbp)
movl $0x30, -0x70(%rbp)
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %ecx
movq -0x30(%rbp), %r8
movq 0x20(%rbp), %r9
movq %rsp, %rax
leaq -0x70(%rbp), %rdx
movq %rdx, (%rax)
leaq -0x48(%rbp), %rsi
leaq -0x58(%rbp), %rdx
callq 0x3630
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/log/zf_log.c
// Function: lvl_char
static char lvl_char(const int lvl)
{
    switch (lvl)
    {
    case ZF_LOG_VERBOSE:
        return 'V';
    case ZF_LOG_DEBUG:
        return 'D';
    case ZF_LOG_INFO:
        return 'I';
    case ZF_LOG_WARN:
        return 'W';
    case ZF_LOG_ERROR:
        return 'E';
    case ZF_LOG_FATAL:
        return 'F';
    default:
        ASSERT_UNREACHABLE("Bad log level");
        return '?';
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x5, %eax
ja 0x4913
movq -0x10(%rbp), %rax
leaq 0x593a(%rip), %rcx      # 0xa220
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x56, -0x1(%rbp)
jmp 0x4932
movb $0x44, -0x1(%rbp)
jmp 0x4932
movb $0x49, -0x1(%rbp)
jmp 0x4932
movb $0x57, -0x1(%rbp)
jmp 0x4932
movb $0x45, -0x1(%rbp)
jmp 0x4932
movb $0x46, -0x1(%rbp)
jmp 0x4932
leaq 0x593b(%rip), %rdi      # 0xa255
leaq 0x594d(%rip), %rsi      # 0xa26e
movl $0x2b9, %edx            # imm = 0x2B9
leaq 0x5952(%rip), %rcx      # 0xa27f
callq 0x20f0
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/log/zf_log.c
// Function: put_stringn
static INLINE char *put_stringn(const char *const s_p, const char *const s_e,
                                char *const p, char *const e)
{
    const ptrdiff_t m = e - p;
    ptrdiff_t n = s_e - s_p;
    if (n > m)
    {
        n = m;
    }
    memcpy(p, s_p, n);
    return p + n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jle 0x4a38
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x21a0
movq -0x18(%rbp), %rax
addq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/log/zf_log.c
// Function: tcache_get
static INLINE int tcache_get(const struct timeval *const tv, struct tm *const tm)
{
    unsigned mode;
    mode = __atomic_load_n(&g_tcache_mode, __ATOMIC_RELAXED);
    if (0 == (mode & TCACHE_FLUID))
    {
        mode = __atomic_fetch_add(&g_tcache_mode, 1, __ATOMIC_ACQUIRE);
        if (0 == (mode & TCACHE_FLUID))
        {
            if (g_tcache_tv.tv_sec == tv->tv_sec)
            {
                *tm = g_tcache_tm;
                __atomic_sub_fetch(&g_tcache_mode, 1, __ATOMIC_RELEASE);
                return !0;
            }
            __atomic_or_fetch(&g_tcache_mode, TCACHE_STALE, __ATOMIC_RELAXED);
        }
        __atomic_sub_fetch(&g_tcache_mode, 1, __ATOMIC_RELEASE);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl 0x90b6(%rip), %eax      # 0xdb28
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
andl $0xc0000000, %ecx       # imm = 0xC0000000
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x4b7d
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
lock
xaddl %eax, 0x9088(%rip)      # 0xdb28
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
andl $0xc0000000, %ecx       # imm = 0xC0000000
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x4b62
movq 0x9365(%rip), %rax      # 0xde28
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x4b1f
movq -0x18(%rbp), %rax
movq 0x9391(%rip), %rcx      # 0xde68
movq %rcx, 0x30(%rax)
movups 0x9376(%rip), %xmm0     # 0xde58
movups %xmm0, 0x20(%rax)
movups 0x935b(%rip), %xmm0     # 0xde48
movups %xmm0, 0x10(%rax)
movups 0x9340(%rip), %xmm0     # 0xde38
movups %xmm0, (%rax)
movl $0x1, -0x2c(%rbp)
movl -0x2c(%rbp), %ecx
movl %ecx, %eax
negl %eax
lock
xaddl %eax, 0x9017(%rip)      # 0xdb28
subl %ecx, %eax
movl %eax, -0x30(%rbp)
movl $0x1, -0x4(%rbp)
jmp 0x4b84
movl $0x40000000, -0x34(%rbp) # imm = 0x40000000
movl -0x34(%rbp), %eax
movl %eax, -0x48(%rbp)
movl 0x8ff6(%rip), %eax      # 0xdb28
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movl -0x48(%rbp), %edx
movl %eax, %ecx
orl %edx, %ecx
lock
cmpxchgl %ecx, 0x8fe1(%rip)      # 0xdb28
sete %cl
movl %eax, -0x4c(%rbp)
testb $0x1, %cl
movl %eax, -0x44(%rbp)
jne 0x4b57
jmp 0x4b35
movl -0x48(%rbp), %ecx
movl -0x4c(%rbp), %eax
orl %ecx, %eax
movl %eax, -0x38(%rbp)
movl $0x1, -0x3c(%rbp)
movl -0x3c(%rbp), %ecx
movl %ecx, %eax
negl %eax
lock
xaddl %eax, 0x8fb0(%rip)      # 0xdb28
subl %ecx, %eax
movl %eax, -0x40(%rbp)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/log/zf_log.c
// Function: tcache_set
static INLINE void tcache_set(const struct timeval *const tv, struct tm *const tm)
{
    unsigned stale = TCACHE_STALE;
    if (__atomic_compare_exchange_n(&g_tcache_mode, &stale, TCACHE_FLUID,
                                    0, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED))
    {
        g_tcache_tv = *tv;
        g_tcache_tm = *tm;
        __atomic_and_fetch(&g_tcache_mode, ~TCACHE_FLUID, __ATOMIC_RELEASE);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x40000000, -0x14(%rbp) # imm = 0x40000000
movl $0xc0000000, -0x18(%rbp) # imm = 0xC0000000
movl -0x14(%rbp), %eax
movl -0x18(%rbp), %ecx
lock
cmpxchgl %ecx, 0x8f6c(%rip)      # 0xdb28
movl %eax, %ecx
sete %al
movb %al, -0x29(%rbp)
movl %ecx, -0x28(%rbp)
testb $0x1, %al
jne 0x4bd1
movl -0x28(%rbp), %eax
movl %eax, -0x14(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
movb %al, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
je 0x4c50
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq %rcx, 0x923b(%rip)      # 0xde28
movq 0x8(%rax), %rax
movq %rax, 0x9238(%rip)      # 0xde30
movq -0x10(%rbp), %rsi
leaq 0x9235(%rip), %rdi      # 0xde38
movl $0x38, %edx
callq 0x21a0
movl $0x3fffffff, -0x20(%rbp) # imm = 0x3FFFFFFF
movl -0x20(%rbp), %eax
movl %eax, -0x34(%rbp)
movl 0x8f08(%rip), %eax      # 0xdb28
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl -0x34(%rbp), %edx
movl %eax, %ecx
andl %edx, %ecx
lock
cmpxchgl %ecx, 0x8ef3(%rip)      # 0xdb28
sete %cl
movl %eax, -0x38(%rbp)
testb $0x1, %cl
movl %eax, -0x30(%rbp)
jne 0x4c45
jmp 0x4c23
movl -0x34(%rbp), %ecx
movl -0x38(%rbp), %eax
andl %ecx, %eax
movl %eax, -0x24(%rbp)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb %al, -0x15(%rbp)
movq %r8, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %eax
movl $0xa, %ecx
xorl %edx, %edx
divl %ecx
addl $0x30, %edx
movb %dl, %cl
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x28(%rbp)
movb %cl, -0x1(%rax)
movl -0xc(%rbp), %eax
movl $0xa, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, %ecx
movl %ecx, -0xc(%rbp)
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x4c82
xorl %eax, %eax
cmpl -0x10(%rbp), %eax
jne 0x4ce2
movl -0x14(%rbp), %edi
movb -0x15(%rbp), %al
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
movsbl %al, %esi
callq 0x4d80
movq %rax, -0x8(%rbp)
jmp 0x4d73
movsbl -0x15(%rbp), %ecx
movl $0x30, %eax
cmpl %ecx, %eax
je 0x4d2c
movslq -0x10(%rbp), %rcx
leaq 0x553e(%rip), %rax      # 0xa238
movb 0x1(%rax,%rcx), %cl
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x28(%rbp)
movb %cl, -0x1(%rax)
movl -0x14(%rbp), %edi
movb -0x15(%rbp), %al
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
movsbl %al, %esi
callq 0x4d80
movq %rax, -0x8(%rbp)
jmp 0x4d73
movl -0x14(%rbp), %edi
movb -0x15(%rbp), %al
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
addq $0x1, %rcx
movsbl %al, %esi
callq 0x4d80
movq %rax, -0x28(%rbp)
movslq -0x10(%rbp), %rcx
leaq 0x54e3(%rip), %rax      # 0xa238
movb 0x1(%rax,%rcx), %cl
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x28(%rbp)
movb %cl, -0x1(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/log/zf_log.c
// Function: filename
static const char *filename(const char *file)
{
    const char *f = file;
    for (const char *p = file; 0 != *p; ++p)
    {
        if ('/' == *p || '\\' == *p)
        {
            f = p + 1;
        }
    }
    return f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x4ee1
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
movl $0x2f, %eax
cmpl %ecx, %eax
je 0x4ec5
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
movl $0x5c, %eax
cmpl %ecx, %eax
jne 0x4ed1
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x4ed3
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4e98
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x50f5
jmp 0x5041
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x50f3
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7e, %eax
jg 0x5074
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jl 0x5074
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x2040
jmp 0x50e2
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xd, %eax
jne 0x5096
movl $0x5c, %edi
callq 0x2040
movl $0x72, %edi
callq 0x2040
jmp 0x50e0
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x50b8
movl $0x5c, %edi
callq 0x2040
movl $0x6e, %edi
callq 0x2040
jmp 0x50de
movl $0x5c, %edi
callq 0x2040
movl $0x78, %edi
callq 0x2040
movq -0x10(%rbp), %rax
movsbq (%rax), %rdi
movl $0x2, %esi
callq 0x5100
jmp 0x50e0
jmp 0x50e2
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x5041
jmp 0x50f5
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
movb %al, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
movl %eax, %eax
cmpq $0x10, %rax
jbe 0x5128
movb $0x10, -0x11(%rbp)
jmp 0x512a
movsbl -0x11(%rbp), %eax
cmpl $0x0, %eax
jle 0x5177
movb -0x11(%rbp), %al
addb $-0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movsbl -0x11(%rbp), %ecx
shll $0x2, %ecx
movl %ecx, %ecx
shrq %cl, %rax
andl $0xf, %eax
movl %eax, -0x10(%rbp)
cmpl $0x9, -0x10(%rbp)
jg 0x5167
movl -0x10(%rbp), %eax
addl $0x30, %eax
movsbl %al, %edi
callq 0x2040
jmp 0x5175
movl -0x10(%rbp), %eax
addl $0x37, %eax
movsbl %al, %edi
callq 0x2040
jmp 0x512a
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity.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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x527c
jmp 0x51a4
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0x51c9
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
cmpl -0xc(%rbp), %eax
setb %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x51d5
jmp 0x527a
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7e, %eax
jg 0x51fb
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jl 0x51fb
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0x2040
jmp 0x5269
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xd, %eax
jne 0x521d
movl $0x5c, %edi
callq 0x2040
movl $0x72, %edi
callq 0x2040
jmp 0x5267
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x523f
movl $0x5c, %edi
callq 0x2040
movl $0x6e, %edi
callq 0x2040
jmp 0x5265
movl $0x5c, %edi
callq 0x2040
movl $0x78, %edi
callq 0x2040
movq -0x18(%rbp), %rax
movsbq (%rax), %rdi
movl $0x2, %esi
callq 0x5100
jmp 0x5267
jmp 0x5269
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x51a4
jmp 0x527c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity.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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
andl $0x10, %eax
cmpl $0x10, %eax
jne 0x52b5
movq -0x8(%rbp), %rdi
callq 0x5300
jmp 0x52f5
movl -0xc(%rbp), %eax
andl $0x20, %eax
cmpl $0x20, %eax
jne 0x52cb
movq -0x8(%rbp), %rdi
callq 0x5340
jmp 0x52f3
movl $0x30, %edi
callq 0x2040
movl $0x78, %edi
callq 0x2040
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
andl $0xf, %eax
shll %eax
movsbl %al, %esi
callq 0x5100
jmp 0x52f5
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jge 0x532f
movl $0x2d, %edi
callq 0x2040
xorl %eax, %eax
subq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5340
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity.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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x1, -0x10(%rbp)
movq -0x8(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x10(%rbp)
cmpq $0x9, %rax
jbe 0x5371
imulq $0xa, -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x5354
jmp 0x5373
movq -0x8(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x10(%rbp)
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
addq $0x30, %rdx
movb %dl, %al
movsbl %al, %edi
callq 0x2040
movq -0x10(%rbp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
ja 0x5373
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity.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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x80000000, %eax       # imm = 0x80000000
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x20, -0x1c(%rbp)
jge 0x543a
movq -0x18(%rbp), %rax
andq -0x8(%rbp), %rax
cmpq $0x0, %rax
je 0x541a
movq -0x18(%rbp), %rax
andq -0x10(%rbp), %rax
cmpq $0x0, %rax
je 0x540e
movl $0x31, %edi
callq 0x2040
jmp 0x5418
movl $0x30, %edi
callq 0x2040
jmp 0x5424
movl $0x58, %edi
callq 0x2040
movq -0x18(%rbp), %rax
shrq %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x53e0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity.c
// Function: UnityConcludeTest
void UnityConcludeTest(void)
{
    if (Unity.CurrentTestIgnored)
    {
        Unity.TestIgnores++;
    }
    else if (!Unity.CurrentTestFailed)
    {
        UnityTestResultsBegin(Unity.TestFile, Unity.CurrentTestLineNumber);
        UnityPrint(UnityStrPass);
    }
    else
    {
        Unity.TestFailures++;
    }

    Unity.CurrentTestFailed = 0;
    Unity.CurrentTestIgnored = 0;
    UNITY_EXEC_TIME_RESET();
    UNITY_PRINT_EOL();
    UNITY_FLUSH_CALL();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpq $0x0, 0x858c(%rip)      # 0xdeb8
je 0x5942
movq 0x8573(%rip), %rax      # 0xdea8
addq $0x1, %rax
movq %rax, 0x8568(%rip)      # 0xdea8
jmp 0x5981
cmpq $0x0, 0x8566(%rip)      # 0xdeb0
jne 0x596d
movq 0x851d(%rip), %rdi      # 0xde70
movq 0x8536(%rip), %rsi      # 0xde90
callq 0x59b0
leaq 0x4a06(%rip), %rdi      # 0xa36c
callq 0x5020
jmp 0x597f
movq 0x852c(%rip), %rax      # 0xdea0
addq $0x1, %rax
movq %rax, 0x8521(%rip)      # 0xdea0
jmp 0x5981
movq $0x0, 0x8524(%rip) # 0xdeb0
movq $0x0, 0x8521(%rip) # 0xdeb8
movl $0xa, %edi
callq 0x2040
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity.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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5020
movl $0x3a, %edi
callq 0x2040
movq -0x10(%rbp), %rdi
callq 0x5300
movl $0x3a, %edi
callq 0x2040
movq 0x848b(%rip), %rdi      # 0xde78
callq 0x5020
movl $0x3a, %edi
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity.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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpq $0x0, 0x847c(%rip)      # 0xdeb0
jne 0x5a40
cmpq $0x0, 0x847a(%rip)      # 0xdeb8
je 0x5a42
jmp 0x5abb
movq -0x8(%rbp), %rax
andq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
andq -0x18(%rbp), %rcx
cmpq %rcx, %rax
je 0x5abb
movq -0x28(%rbp), %rdi
callq 0x5ad0
leaq 0x490a(%rip), %rdi      # 0xa371
callq 0x5020
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x53c0
leaq 0x48fc(%rip), %rdi      # 0xa37c
callq 0x5020
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x53c0
movq -0x20(%rbp), %rdi
callq 0x5b10
movq $0x1, 0x840a(%rip) # 0xdeb0
leaq 0x83c3(%rip), %rdi      # 0xde70
addq $0x50, %rdi
movl $0x1, %esi
callq 0x21d0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity.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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5b88
leaq 0x4999(%rip), %rdi      # 0xa4c3
callq 0x5020
cmpq $0x0, 0x8349(%rip)      # 0xde80
je 0x5b7f
leaq 0x496e(%rip), %rdi      # 0xa4ae
callq 0x5020
movq 0x8334(%rip), %rdi      # 0xde80
callq 0x5020
cmpq $0x0, 0x832f(%rip)      # 0xde88
je 0x5b73
leaq 0x4956(%rip), %rdi      # 0xa4b8
callq 0x5020
movq 0x831a(%rip), %rdi      # 0xde88
callq 0x5020
leaq 0x4949(%rip), %rdi      # 0xa4c3
callq 0x5020
movq -0x8(%rbp), %rdi
callq 0x5020
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity.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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
cmpq $0x0, 0x82fc(%rip)      # 0xdeb0
jne 0x5bc0
cmpq $0x0, 0x82fa(%rip)      # 0xdeb8
je 0x5bc2
jmp 0x5c2e
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x5c2e
movq -0x20(%rbp), %rdi
callq 0x5ad0
leaq 0x4795(%rip), %rdi      # 0xa371
callq 0x5020
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x5290
leaq 0x4788(%rip), %rdi      # 0xa37c
callq 0x5020
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x5290
movq -0x18(%rbp), %rdi
callq 0x5b10
movq $0x1, 0x8297(%rip) # 0xdeb0
leaq 0x8250(%rip), %rdi      # 0xde70
addq $0x50, %rdi
movl $0x1, %esi
callq 0x21d0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity.c
// Function: UnityIsOneArrayNull
static int UnityIsOneArrayNull(UNITY_INTERNAL_PTR expected,
                               UNITY_INTERNAL_PTR actual,
                               const UNITY_LINE_TYPE lineNumber,
                               const char* msg)
{
    if (expected == actual) return 0; /* Both are NULL or same pointer */

    /* print and return true if just expected is NULL */
    if (expected == NULL)
    {
        UnityTestResultsFailBegin(lineNumber);
        UnityPrint(UnityStrNullPointerForExpected);
        UnityAddMsgIfSpecified(msg);
        return 1;
    }

    /* print and return true if just actual is NULL */
    if (actual == NULL)
    {
        UnityTestResultsFailBegin(lineNumber);
        UnityPrint(UnityStrNullPointerForActual);
        UnityAddMsgIfSpecified(msg);
        return 1;
    }

    return 0; /* return false if neither is NULL */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x60ab
movl $0x0, -0x4(%rbp)
jmp 0x610e
cmpq $0x0, -0x10(%rbp)
jne 0x60d9
movq -0x20(%rbp), %rdi
callq 0x5ad0
leaq 0x444e(%rip), %rdi      # 0xa510
callq 0x5020
movq -0x28(%rbp), %rdi
callq 0x5b10
movl $0x1, -0x4(%rbp)
jmp 0x610e
cmpq $0x0, -0x18(%rbp)
jne 0x6107
movq -0x20(%rbp), %rdi
callq 0x5ad0
leaq 0x4440(%rip), %rdi      # 0xa530
callq 0x5020
movq -0x28(%rbp), %rdi
callq 0x5b10
movl $0x1, -0x4(%rbp)
jmp 0x610e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movss %xmm0, -0x4(%rbp)
movss %xmm1, -0x8(%rbp)
movss %xmm2, -0xc(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
cmpq $0x0, 0x79c9(%rip)      # 0xdeb0
jne 0x64f3
cmpq $0x0, 0x79c7(%rip)      # 0xdeb8
je 0x64f5
jmp 0x656c
movss -0x4(%rbp), %xmm0
movss -0x8(%rbp), %xmm1
movss -0xc(%rbp), %xmm2
callq 0x62f0
cmpl $0x0, %eax
jne 0x656c
movq -0x20(%rbp), %rdi
callq 0x5ad0
leaq 0x3e53(%rip), %rdi      # 0xa371
callq 0x5020
movss -0x8(%rbp), %xmm0
callq 0x5440
leaq 0x3e48(%rip), %rdi      # 0xa37c
callq 0x5020
movss -0xc(%rbp), %xmm0
callq 0x5440
movq -0x18(%rbp), %rdi
callq 0x5b10
movq $0x1, 0x7959(%rip) # 0xdeb0
leaq 0x7912(%rip), %rdi      # 0xde70
addq $0x50, %rdi
movl $0x1, %esi
callq 0x21d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity.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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, 0x7500(%rip)      # 0xdeb0
jne 0x69bc
cmpq $0x0, 0x74fe(%rip)      # 0xdeb8
je 0x69c1
jmp 0x6a9e
cmpq $0x0, -0x8(%rbp)
je 0x6a3e
cmpq $0x0, -0x10(%rbp)
je 0x6a3e
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x25(%rbp)
jne 0x69ff
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0x6a08
jmp 0x6a3c
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
movsbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movl -0x24(%rbp), %edx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x6a2f
movq $0x1, 0x7483(%rip) # 0xdeb0
jmp 0x6a3c
jmp 0x6a31
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x69d6
jmp 0x6a55
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x6a53
movq $0x1, 0x745d(%rip) # 0xdeb0
jmp 0x6a55
cmpq $0x0, 0x7453(%rip)      # 0xdeb0
je 0x6a9e
movq -0x20(%rbp), %rdi
callq 0x5ad0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6ab0
movq -0x18(%rbp), %rdi
callq 0x5b10
movq $0x1, 0x7427(%rip) # 0xdeb0
leaq 0x73e0(%rip), %rdi      # 0xde70
addq $0x50, %rdi
movl $0x1, %esi
callq 0x21d0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity.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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x38aa(%rip), %rdi      # 0xa371
callq 0x5020
cmpq $0x0, -0x8(%rbp)
je 0x6af2
movl $0x27, %edi
callq 0x2040
movq -0x8(%rbp), %rdi
callq 0x5020
movl $0x27, %edi
callq 0x2040
jmp 0x6afe
leaq 0x3a50(%rip), %rdi      # 0xa549
callq 0x5020
leaq 0x3877(%rip), %rdi      # 0xa37c
callq 0x5020
cmpq $0x0, -0x10(%rbp)
je 0x6b30
movl $0x27, %edi
callq 0x2040
movq -0x10(%rbp), %rdi
callq 0x5020
movl $0x27, %edi
callq 0x2040
jmp 0x6b3c
leaq 0x3a12(%rip), %rdi      # 0xa549
callq 0x5020
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity.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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpq $0x0, 0x733d(%rip)      # 0xdeb0
jne 0x6b7f
cmpq $0x0, 0x733b(%rip)      # 0xdeb8
je 0x6b84
jmp 0x6c7f
cmpq $0x0, -0x8(%rbp)
je 0x6c1c
cmpq $0x0, -0x10(%rbp)
je 0x6c1c
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %ecx
xorl %eax, %eax
cmpl -0x14(%rbp), %ecx
movb %al, -0x2d(%rbp)
jae 0x6bdd
movq -0x8(%rbp), %rax
movl -0x2c(%rbp), %ecx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x2e(%rbp)
jne 0x6bd7
movq -0x10(%rbp), %rax
movl -0x2c(%rbp), %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x2e(%rbp)
movb -0x2e(%rbp), %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0x6be6
jmp 0x6c1a
movq -0x8(%rbp), %rax
movl -0x2c(%rbp), %ecx
movsbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movl -0x2c(%rbp), %edx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x6c0d
movq $0x1, 0x72a5(%rip) # 0xdeb0
jmp 0x6c1a
jmp 0x6c0f
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x6ba1
jmp 0x6c33
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x6c31
movq $0x1, 0x727f(%rip) # 0xdeb0
jmp 0x6c33
cmpq $0x0, 0x7275(%rip)      # 0xdeb0
je 0x6c7f
movq -0x28(%rbp), %rdi
callq 0x5ad0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x6c90
movq -0x20(%rbp), %rdi
callq 0x5b10
movq $0x1, 0x7246(%rip) # 0xdeb0
leaq 0x71ff(%rip), %rdi      # 0xde70
addq $0x50, %rdi
movl $0x1, %esi
callq 0x21d0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity.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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq 0x36c7(%rip), %rdi      # 0xa371
callq 0x5020
cmpq $0x0, -0x8(%rbp)
je 0x6cd8
movl $0x27, %edi
callq 0x2040
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x5180
movl $0x27, %edi
callq 0x2040
jmp 0x6ce4
leaq 0x386a(%rip), %rdi      # 0xa549
callq 0x5020
leaq 0x3691(%rip), %rdi      # 0xa37c
callq 0x5020
cmpq $0x0, -0x10(%rbp)
je 0x6d19
movl $0x27, %edi
callq 0x2040
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x5180
movl $0x27, %edi
callq 0x2040
jmp 0x6d25
leaq 0x3829(%rip), %rdi      # 0xa549
callq 0x5020
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity.c
// Function: UnityNumToPtr
UNITY_INTERNAL_PTR UnityNumToPtr(const UNITY_INT num, const UNITY_UINT8 size)
{
    switch(size)
    {
        case 1:
          UnityQuickCompare.i8 = (UNITY_INT8)num;
          return (UNITY_INTERNAL_PTR)(&UnityQuickCompare.i8);

        case 2:
          UnityQuickCompare.i16 = (UNITY_INT16)num;
          return (UNITY_INTERNAL_PTR)(&UnityQuickCompare.i16);

#ifdef UNITY_SUPPORT_64
        case 8:
          UnityQuickCompare.i64 = (UNITY_INT64)num;
          return (UNITY_INTERNAL_PTR)(&UnityQuickCompare.i64);
#endif
        default: /* 4 bytes */
          UnityQuickCompare.i32 = (UNITY_INT32)num;
          return (UNITY_INTERNAL_PTR)(&UnityQuickCompare.i32);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
movl %eax, -0x18(%rbp)
subl $0x1, %eax
je 0x71b0
jmp 0x719c
movl -0x18(%rbp), %eax
subl $0x2, %eax
je 0x71c7
jmp 0x71a6
movl -0x18(%rbp), %eax
subl $0x8, %eax
je 0x71df
jmp 0x71f7
movq -0x10(%rbp), %rax
movb %al, 0x6dce(%rip)       # 0xdf88
leaq 0x6dc7(%rip), %rax      # 0xdf88
movq %rax, -0x8(%rbp)
jmp 0x720c
movq -0x10(%rbp), %rax
movw %ax, 0x6db6(%rip)       # 0xdf88
leaq 0x6daf(%rip), %rax      # 0xdf88
movq %rax, -0x8(%rbp)
jmp 0x720c
movq -0x10(%rbp), %rax
movq %rax, 0x6d9e(%rip)      # 0xdf88
leaq 0x6d97(%rip), %rax      # 0xdf88
movq %rax, -0x8(%rbp)
jmp 0x720c
movq -0x10(%rbp), %rax
movl %eax, 0x6d87(%rip)      # 0xdf88
leaq 0x6d80(%rip), %rax      # 0xdf88
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity.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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, 0x6c58(%rip)      # 0xdeb0
jne 0x7264
cmpq $0x0, 0x6c56(%rip)      # 0xdeb8
je 0x726a
addq $0x10, %rsp
popq %rbp
retq
movq 0x6bff(%rip), %rdi      # 0xde70
movq -0x10(%rbp), %rsi
callq 0x59b0
leaq 0x3228(%rip), %rdi      # 0xa4a9
callq 0x5020
cmpq $0x0, -0x8(%rbp)
je 0x7306
movl $0x3a, %edi
callq 0x2040
cmpq $0x0, 0x6be1(%rip)      # 0xde80
je 0x72e7
leaq 0x3206(%rip), %rdi      # 0xa4ae
callq 0x5020
movq 0x6bcc(%rip), %rdi      # 0xde80
callq 0x5020
cmpq $0x0, 0x6bc7(%rip)      # 0xde88
je 0x72db
leaq 0x31ee(%rip), %rdi      # 0xa4b8
callq 0x5020
movq 0x6bb2(%rip), %rdi      # 0xde88
callq 0x5020
leaq 0x31e1(%rip), %rdi      # 0xa4c3
callq 0x5020
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0x72fd
movl $0x20, %edi
callq 0x2040
movq -0x8(%rbp), %rdi
callq 0x5020
movq $0x1, 0x6b9f(%rip) # 0xdeb0
leaq 0x6b58(%rip), %rdi      # 0xde70
addq $0x50, %rdi
movl $0x1, %esi
callq 0x21d0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, 0x6b68(%rip)      # 0xdeb0
jne 0x7354
cmpq $0x0, 0x6b66(%rip)      # 0xdeb8
je 0x735a
addq $0x10, %rsp
popq %rbp
retq
movq 0x6b0f(%rip), %rdi      # 0xde70
movq -0x10(%rbp), %rsi
callq 0x59b0
leaq 0x3155(%rip), %rdi      # 0xa4c6
callq 0x5020
cmpq $0x0, -0x8(%rbp)
je 0x739a
movl $0x3a, %edi
callq 0x2040
movl $0x20, %edi
callq 0x2040
movq -0x8(%rbp), %rdi
callq 0x5020
movq $0x1, 0x6b13(%rip) # 0xdeb8
leaq 0x6ac4(%rip), %rdi      # 0xde70
addq $0x50, %rdi
movl $0x1, %esi
callq 0x21d0
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, 0x6a9a(%rip)      # 0xde78
movslq -0x14(%rbp), %rax
movq %rax, 0x6aa7(%rip)      # 0xde90
movq 0x6aa8(%rip), %rax      # 0xde98
addq $0x1, %rax
movq %rax, 0x6a9d(%rip)      # 0xde98
movq $0x0, 0x6a7a(%rip) # 0xde80
movq $0x0, 0x6a77(%rip) # 0xde88
leaq 0x6a58(%rip), %rdi      # 0xde70
addq $0x50, %rdi
callq 0x2150
cmpl $0x0, %eax
jne 0x742e
callq 0x4fe0
callq *-0x8(%rbp)
leaq 0x6a3b(%rip), %rdi      # 0xde70
addq $0x50, %rdi
callq 0x2150
cmpl $0x0, %eax
jne 0x7448
callq 0x4ff0
callq 0x5920
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jeff-1amstudios[P]carmageddon-1-cheat-code-disassembly/src/test/framework/unity.c
// Function: UnityBegin
void UnityBegin(const char* filename)
{
    Unity.TestFile = filename;
    Unity.CurrentTestName = NULL;
    Unity.CurrentTestLineNumber = 0;
    Unity.NumberOfTests = 0;
    Unity.TestFailures = 0;
    Unity.TestIgnores = 0;
    Unity.CurrentTestFailed = 0;
    Unity.CurrentTestIgnored = 0;
    UNITY_EXEC_TIME_RESET();

    UNITY_CLR_DETAILS();
    UNITY_OUTPUT_START();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, 0x69fd(%rip)      # 0xde70
movq $0x0, 0x69fa(%rip) # 0xde78
movq $0x0, 0x6a07(%rip) # 0xde90
movq $0x0, 0x6a04(%rip) # 0xde98
movq $0x0, 0x6a01(%rip) # 0xdea0
movq $0x0, 0x69fe(%rip) # 0xdea8
movq $0x0, 0x69fb(%rip) # 0xdeb0
movq $0x0, 0x69f8(%rip) # 0xdeb8
movq $0x0, 0x69b5(%rip) # 0xde80
movq $0x0, 0x69b2(%rip) # 0xde88
popq %rbp
retq
nopl (%rax,%rax)