LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/util/tweak_values.cpp
// Function: Util::show(char const*, unsigned int)
b8 show(const char *name, u32 value) {
    if (!debug_values_are_on()) return false;
    const char *buffer = Util::format_int(" %s: %u", name, value);
    debug_value_logic(name, buffer);
    return name == global_tweak.active && Input::mouse_pressed(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
callq 0xf630
cmpb $0x0, %al
jne 0xf01e
movb $0x0, -0x1(%rbp)
jmp 0xf071
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq 0x37863(%rip), %rdi     # 0x4688f
movb $0x0, %al
callq 0x102c0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x312c0
movq -0x10(%rbp), %rcx
xorl %eax, %eax
leaq 0x5add7(%rip), %rdx     # 0x69e28
cmpq 0x18(%rdx), %rcx
movb %al, -0x21(%rbp)
jne 0xf069
xorl %edi, %edi
callq 0x11c90
cmpb $0x0, %al
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/util/tweak_values.cpp
// Function: Util::show(char const*, float)
b8 show(const char *name, f32 value) {
    if (!debug_values_are_on()) return false;
    const char *buffer = Util::format_int(" %s: %.4f", name, value);
    debug_value_logic(name, buffer);
    return name == global_tweak.active && Input::mouse_pressed(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
callq 0xf630
cmpb $0x0, %al
jne 0xf0d0
movb $0x0, -0x1(%rbp)
jmp 0xf129
movq -0x10(%rbp), %rsi
movss -0x14(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x37799(%rip), %rdi     # 0x4687d
movb $0x1, %al
callq 0x102c0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x312c0
movq -0x10(%rbp), %rcx
xorl %eax, %eax
leaq 0x5ad1f(%rip), %rdx     # 0x69e28
cmpq 0x18(%rdx), %rcx
movb %al, -0x21(%rbp)
jne 0xf121
xorl %edi, %edi
callq 0x11c90
cmpb $0x0, %al
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/util/tweak_values.cpp
// Function: Util::show(char const*, Vec2)
b8 show(const char *name, Vec2 value) {
    if (!debug_values_are_on()) return false;
    const char *buffer = Util::format_int(" %s: %.4f, %.4f", name, value.x, value.y);
    debug_value_logic(name, buffer);
    return name == global_tweak.active && Input::mouse_pressed(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movlpd %xmm0, -0x9(%rbp)
movq %rdi, -0x18(%rbp)
callq 0xf630
cmpb $0x0, %al
jne 0xf190
movb $0x0, -0x1(%rbp)
jmp 0xf1f2
movq -0x18(%rbp), %rsi
movss -0x9(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movss -0x5(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
leaq 0x376ea(%rip), %rdi     # 0x46897
movb $0x2, %al
callq 0x102c0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x312c0
movq -0x18(%rbp), %rcx
xorl %eax, %eax
leaq 0x5ac56(%rip), %rdx     # 0x69e28
cmpq 0x18(%rdx), %rcx
movb %al, -0x21(%rbp)
jne 0xf1ea
xorl %edi, %edi
callq 0x11c90
cmpb $0x0, %al
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/util/tweak_values.cpp
// Function: Util::show(char const*, Span)
b8 show(const char *name, Span value) {
    if (!debug_values_are_on()) return false;
    const char *buffer = Util::format_int(" %s: %.4f, %.4f", name, value.min, value.max);
    debug_value_logic(name, buffer);
    return name == global_tweak.active && Input::mouse_pressed(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movlpd %xmm0, -0xc(%rbp)
movq %rdi, -0x18(%rbp)
callq 0xf630
cmpb $0x0, %al
jne 0xf250
movb $0x0, -0x1(%rbp)
jmp 0xf2b2
movq -0x18(%rbp), %rsi
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movss -0x8(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
leaq 0x3762a(%rip), %rdi     # 0x46897
movb $0x2, %al
callq 0x102c0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x312c0
movq -0x18(%rbp), %rcx
xorl %eax, %eax
leaq 0x5ab96(%rip), %rdx     # 0x69e28
cmpq 0x18(%rdx), %rcx
movb %al, -0x21(%rbp)
jne 0xf2aa
xorl %edi, %edi
callq 0x11c90
cmpb $0x0, %al
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/platform/input.h
// Function: Input::toID(Input::Player)
u32 toID(Player p) {
    switch (p) {
        case (Player::P1):
            return 0;
        case (Player::P2):
            return 1;
        case (Player::P3):
            return 2;
        case (Player::P4):
            return 3;
        default:
            UNREACHABLE;
    }
    // Safe guard return.
    return 0;
}

// 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 $0x7, %eax
ja 0xf413
movq -0x10(%rbp), %rax
leaq 0x3606a(%rip), %rcx     # 0x45450
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, -0x4(%rbp)
jmp 0xf454
movl $0x1, -0x4(%rbp)
jmp 0xf454
movl $0x2, -0x4(%rbp)
jmp 0xf454
movl $0x3, -0x4(%rbp)
jmp 0xf454
movq 0x59bc6(%rip), %rax     # 0x68fe0
movq (%rax), %rsi
leaq 0x3671d(%rip), %rdi     # 0x45b41
leaq 0x36722(%rip), %rdx     # 0x45b4d
movl $0x2d, %ecx
leaq 0x36732(%rip), %r8      # 0x45b69
leaq 0x36730(%rip), %r9      # 0x45b6e
movb $0x0, %al
callq 0xb100
callq 0xb1f0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2330
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/platform/input.cpp
// Function: Input::add_mod(unsigned int, unsigned int, Input::Player, float)
b8 add_mod(InputCode code, Name name, Player player, f32 modifier) {
    Binding binding = {code, player, name, 0};

    // Check if there is a free binding.
    ASSERT(is_valid_player(player), "");
    auto buttons = global_mapping.buttons[toID(player)];
    u32 index = binding.index();
    b8 valid = false;
    for (u32 i = 0; i < NUM_ALTERNATIVE_BINDINGS; i++) {
        if (buttons[index + i].is_used()) continue;
        binding.binding_id = i;
        buttons[index + i].reset(name, modifier);
        valid = true;
        break;
    }

    CHECK(valid, "Cannot add new mapping");
    if (!valid) return false;

    insert(binding);
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movb $0x0, -0x18(%rbp)
movl -0x10(%rbp), %edi
callq 0xf360
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
leaq 0x36969(%rip), %rdi     # 0x45e7f
movl $0x27, %esi
leaq 0x369cf(%rip), %rdx     # 0x45ef1
movzbl %al, %ecx
callq 0xb210
movl -0x10(%rbp), %edi
callq 0xf3c0
movl %eax, %eax
movl %eax, %ecx
leaq 0x59da3(%rip), %rax     # 0x692e0
movq 0x20(%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
leaq -0x24(%rbp), %rdi
callq 0x41560
movl %eax, -0x34(%rbp)
movb $0x0, -0x35(%rbp)
movl $0x0, -0x3c(%rbp)
cmpl $0x4, -0x3c(%rbp)
jae 0xf5b8
movq -0x30(%rbp), %rdi
movl -0x34(%rbp), %eax
addl -0x3c(%rbp), %eax
movl %eax, %eax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x415c0
cmpb $0x0, %al
je 0xf581
jmp 0xf5ad
movl -0x3c(%rbp), %eax
movb %al, -0x18(%rbp)
movq -0x30(%rbp), %rdi
movl -0x34(%rbp), %eax
addl -0x3c(%rbp), %eax
movl %eax, %eax
shlq $0x4, %rax
addq %rax, %rdi
movl -0xc(%rbp), %esi
movss -0x14(%rbp), %xmm0
callq 0x415e0
movb $0x1, -0x35(%rbp)
jmp 0xf5b8
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0xf55d
movzbl -0x35(%rbp), %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
leaq 0x368b4(%rip), %rdi     # 0x45e7f
movl $0x33, %esi
leaq 0x36934(%rip), %rdx     # 0x45f0b
movzbl %al, %ecx
callq 0xb270
cmpb $0x0, -0x35(%rbp)
jne 0xf5eb
movb $0x0, -0x1(%rbp)
jmp 0xf60c
movq -0x24(%rbp), %rax
movq %rax, -0x4c(%rbp)
movq -0x1c(%rbp), %rax
movq %rax, -0x44(%rbp)
movq -0x4c(%rbp), %rdi
movq -0x44(%rbp), %rsi
callq 0x10cd0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/util/font_settings.h
// Function: Util::init()
b8 init() {
        DEBUG_FONT = Asset::fetch_id("MONACO_FONT");
        if (DEBUG_FONT != Asset::ASSET_ID_NO_ASSET)
            return true;
        LOG("Failed to load the default font.");
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x36538(%rip), %rdi     # 0x45b87
callq 0xf6c0
movq %rax, %rcx
leaq 0x6f362(%rip), %rax     # 0x7e9c0
movq %rcx, (%rax)
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
leaq 0x6f353(%rip), %rax     # 0x7e9c0
cmpq %rcx, (%rax)
je 0xf678
movb $0x1, -0x1(%rbp)
jmp 0xf6ae
movq 0x59959(%rip), %rax     # 0x68fd8
movq (%rax), %rsi
leaq 0x3650a(%rip), %rdi     # 0x45b93
leaq 0x36507(%rip), %rdx     # 0x45b97
movl $0xe, %ecx
leaq 0x3651b(%rip), %r8      # 0x45bb7
leaq 0x36519(%rip), %r9      # 0x45bbc
movb $0x0, %al
callq 0xb100
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/asset/asset.cpp
// Function: Asset::fetch_id(char const*)
AssetID fetch_id(const char *str) {
    u64 hash = asset_hash(str);
    for (u64 i = 0; i < system.num_assets; i++) {
        Header *headers = system.headers;
        if (headers[i].hash == hash) return i;
    }
    LOG("Failed to load asset: '%s', check that the correct .fog file is loaded.", str);
    return ASSET_ID_NO_ASSET;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xe530
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
leaq 0x75be4(%rip), %rcx     # 0x852d0
cmpq 0x38(%rcx), %rax
jae 0xf731
leaq 0x75bd7(%rip), %rax     # 0x852d0
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
imulq $0x38, -0x20(%rbp), %rcx
addq %rcx, %rax
movq 0x28(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0xf721
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xf774
jmp 0xf723
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xf6e1
movq 0x598a0(%rip), %rax     # 0x68fd8
movq (%rax), %rsi
movq -0x10(%rbp), %rax
leaq 0x3644d(%rip), %rdi     # 0x45b93
leaq 0x36e59(%rip), %rdx     # 0x465a6
movl $0x40, %ecx
leaq 0x36ecc(%rip), %r8      # 0x46625
leaq 0x36ece(%rip), %r9      # 0x4662e
movq %rax, (%rsp)
movb $0x0, %al
callq 0xb100
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/renderer/text.cpp
// Function: Renderer::messure_text(char const*, float, unsigned long long)
Vec2 messure_text(const char *string, f32 size, AssetID font_id) {
    Asset::Font *font = Asset::fetch_font(font_id);
    ASSERT(font, "Cannot find font");
    f32 length = 0;
    if (!font->num_kernings) {
        while (*(string++)) length += font->glyphs[(u8) 'A'].advance;
    } else {
        u8 prev = '\0';
        while (*string) {
            u8 curr = *(string++);
            length += font->find_kerning(prev, curr);
            length += font->glyphs[curr].advance + font->glyphs[curr].x_offset;
        }
    }
    return V2(length * size, size * font->height);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2e570
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
setne %al
andb $0x1, %al
leaq 0x36b46(%rip), %rdi     # 0x46369
movl $0x5, %esi
leaq 0x36b57(%rip), %rdx     # 0x46386
movzbl %al, %ecx
callq 0xb210
xorps %xmm0, %xmm0
movss %xmm0, -0x2c(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0xf87e
jmp 0xf84c
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
cmpb $0x0, (%rax)
je 0xf87c
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movss 0x83c(%rax), %xmm0
addss -0x2c(%rbp), %xmm0
movss %xmm0, -0x2c(%rbp)
jmp 0xf84c
jmp 0xf8fa
movb $0x0, -0x2d(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0xf8f8
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb (%rax), %al
movb %al, -0x2e(%rbp)
movq -0x28(%rbp), %rdi
movb -0x2d(%rbp), %al
movsbl %al, %esi
movsbl -0x2e(%rbp), %edx
callq 0x42110
addss -0x2c(%rbp), %xmm0
movss %xmm0, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movzbl -0x2e(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movss 0x1c(%rax), %xmm0
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movzbl -0x2e(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
addss 0x14(%rax), %xmm0
addss -0x2c(%rbp), %xmm0
movss %xmm0, -0x2c(%rbp)
jmp 0xf882
jmp 0xf8fa
movss -0x2c(%rbp), %xmm0
movss -0x14(%rbp), %xmm1
mulss %xmm1, %xmm0
movq -0x28(%rbp), %rax
movss 0x8(%rax), %xmm2
mulss %xmm2, %xmm1
callq 0xbc10
movlpd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/util/io.cpp
// Function: Util::format(char const*, __va_list_tag*)
char *format(const char *fmt, va_list args) {
    // TODO(ed): Test this function.
    char c;
    int size = vsnprintf(&c, 1, fmt, args);
    ASSERT(size > 0, "Failed to print format string");
    char *buffer = request_temporary_memory<char>(++size);
    vsnprintf(buffer, size, fmt, args);
    va_end(args);
    return buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq -0x11(%rbp), %rdi
movl $0x1, %esi
callq 0x2340
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
setg %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
leaq 0x359bc(%rip), %rdi     # 0x45c30
movl $0x3c, %esi
leaq 0x359c7(%rip), %rdx     # 0x45c47
movzbl %al, %ecx
callq 0xb210
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movslq %eax, %rdi
callq 0x414a0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
callq 0x2340
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/util/io.cpp
// Function: Util::format_int(char const*, ...)
char *format_int(const char *fmt, ...) {
    va_list args;
    va_start(args, fmt);
    char c;
    int size = vsnprintf_(&c, 1, fmt, args);
    ASSERT(size > 0, "Failed to print format string");
    va_end(args);
    char *buffer = request_temporary_memory<char>(++size);
    va_start(args, fmt);
    vsnprintf_(buffer, size, fmt, args);
    va_end(args);
    return buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0x102f8
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rsi, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0xe0(%rbp), %rax
movq %rax, -0xf8(%rbp)
movq %rax, -0x10(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq %rax, -0x18(%rbp)
movl $0x30, -0x1c(%rbp)
movl $0x8, -0x20(%rbp)
movq -0x8(%rbp), %rdx
leaq -0x21(%rbp), %rdi
movl $0x1, %esi
leaq -0x20(%rbp), %rcx
movq %rcx, -0xf0(%rbp)
callq 0xafc0
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
testl %eax, %eax
setg %al
movzbl %al, %ecx
leaq 0x358b0(%rip), %rdi     # 0x45c30
leaq 0x358c0(%rip), %rdx     # 0x45c47
movl $0x4a, %esi
callq 0xb210
movl -0x28(%rbp), %eax
incl %eax
movl %eax, -0x28(%rbp)
movslq %eax, %rdi
callq 0x414a0
movq -0xf8(%rbp), %rdx
movq -0xf0(%rbp), %rcx
movq %rax, %rsi
movq -0xe8(%rbp), %rax
movq %rsi, -0x30(%rbp)
movq %rdx, -0x10(%rbp)
movq %rax, -0x18(%rbp)
movl $0x30, -0x1c(%rbp)
movl $0x8, -0x20(%rbp)
movq -0x30(%rbp), %rdi
movslq -0x28(%rbp), %rsi
movq -0x8(%rbp), %rdx
callq 0xafc0
movq -0x30(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/util/io.cpp
// Function: Util::format_inplace(char*, char const*, ...)
u32 format_inplace(char *out, const char *fmt, ...) {
    // TODO(ed): This needs some error checking..
    va_list args;
    va_start(args, fmt);
    u32 written = vsnprintf(out, 100, fmt, args);
    va_end(args);
    return written;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x1043b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0xf0(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x10, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x64, %esi
leaq -0x30(%rbp), %rcx
callq 0x2340
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/util/io.cpp
// Function: Util::utf8_size(char const*)
u8 utf8_size(const char *c) {
    if ((*c & 0b10000000) == 0) return 1;
    if ((*c & 0b11100000) == 0b11000000) return 2;
    if ((*c & 0b11110000) == 0b11100000) return 3;
    if ((*c & 0b11111000) == 0b11110000) return 4;
    ERR("Invalid codepoint");
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0x104d6
movb $0x1, -0x1(%rbp)
jmp 0x10557
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
andl $0xe0, %eax
cmpl $0xc0, %eax
jne 0x104ef
movb $0x2, -0x1(%rbp)
jmp 0x10557
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
andl $0xf0, %eax
cmpl $0xe0, %eax
jne 0x10508
movb $0x3, -0x1(%rbp)
jmp 0x10557
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
andl $0xf8, %eax
cmpl $0xf0, %eax
jne 0x10521
movb $0x4, -0x1(%rbp)
jmp 0x10557
movq 0x58ab8(%rip), %rax     # 0x68fe0
movq (%rax), %rsi
leaq 0x3573d(%rip), %rdi     # 0x45c6f
leaq 0x356f7(%rip), %rdx     # 0x45c30
movl $0x6e, %ecx
leaq 0x3572e(%rip), %r8      # 0x45c73
leaq 0x35731(%rip), %r9      # 0x45c7d
movb $0x0, %al
callq 0xb100
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/util/io.cpp
// Function: Util::utf8_insert_glyph(char*, char const*, unsigned int)
b8 utf8_insert_glyph(char *to, const char *from, u32 length) {
    const u32 glyph_size = utf8_size(from);
    if (glyph_size > length) return false;
    for (u32 i = 0; i < glyph_size; i++)
        to[i] = from[i];
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x104b0
movzbl %al, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jbe 0x105b0
movb $0x0, -0x1(%rbp)
jmp 0x105e2
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
jae 0x105de
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x105b7
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/util/io.cpp
// Function: Util::contains_substr(char const*, char const*)
b8 contains_substr(const char *str, const char *substr) {
    for (; *str; str++) {
        for (u32 i = 0; str[i] == substr[i]; i++) {
            if (substr[i+1] == '\0')
                return true;
        }
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x1069e
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movsbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movl -0x1c(%rbp), %edx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x1068e
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x10681
movb $0x1, -0x1(%rbp)
jmp 0x106a2
jmp 0x10683
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1064c
jmp 0x10690
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1063c
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/util/memory.cpp
// Function: Util::do_all_allocations()
void do_all_allocations() {
    static_assert(TOTAL_MEMORY_BUDGET % ARENA_SIZE_IN_BYTES == 0);

    // Setup regions.
    global_memory.free_regions = global_memory.all_regions + 0;
    global_memory.num_free_regions = NUM_ARENAS;
    for (u64 i = 0; i < NUM_ARENAS - 1; i++) {
        global_memory.all_regions[i].next = global_memory.all_regions + i + 1;
        global_memory.all_regions[i].memory = malloc(ARENA_SIZE_IN_BYTES);
    }
    global_memory.all_regions[NUM_ARENAS - 1].next = 0;

    // Frame memory
    for (u32 i = 0; i < FRAME_LAG_FOR_MEMORY; i++)
        FRAME_MEMORY[i] = request_arena();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x596a9(%rip), %rax     # 0x69e58
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, 0x8(%rax)
leaq 0x59697(%rip), %rax     # 0x69e58
movq $0x40, (%rax)
movq $0x0, -0x8(%rbp)
cmpq $0x3f, -0x8(%rbp)
jae 0x10840
movq -0x8(%rbp), %rax
leaq 0x59676(%rip), %rcx     # 0x69e58
addq $0x10, %rcx
shlq $0x5, %rax
addq %rax, %rcx
addq $0x20, %rcx
movq -0x8(%rbp), %rdx
leaq 0x5965c(%rip), %rax     # 0x69e58
addq $0x10, %rax
shlq $0x5, %rdx
addq %rdx, %rax
movq %rcx, 0x10(%rax)
movl $0x200000, %edi         # imm = 0x200000
callq 0x2440
movq %rax, %rcx
movq -0x8(%rbp), %rdx
leaq 0x59635(%rip), %rax     # 0x69e58
addq $0x10, %rax
shlq $0x5, %rdx
addq %rdx, %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x107d0
leaq 0x59611(%rip), %rax     # 0x69e58
movq $0x0, 0x800(%rax)
movl $0x0, -0xc(%rbp)
cmpl $0x2, -0xc(%rbp)
jae 0x10884
xorl %edi, %edi
callq 0x10890
movq %rax, %rdx
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x6e19b(%rip), %rax     # 0x7ea10
movq %rdx, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x10859
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/util/memory.cpp
// Function: Util::request_arena(unsigned char)
MemoryArena *request_arena(b8 only_one) {
    CHECK_ILLEGAL_ALLOC;
    ASSERT(global_memory.free_regions, "No more memory");
    ASSERT(global_memory.num_free_regions, "No more memory");
    MemoryArena *next = global_memory.free_regions;
    global_memory.free_regions = next->next;
    --global_memory.num_free_regions;
    next->only_one = only_one;
    next->next = 0;
    next->watermark = 0;
    return next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movl 0x58ad8(%rip), %eax     # 0x6937c
movl %eax, -0x14(%rbp)
testl %eax, %eax
je 0x108c8
jmp 0x108ad
movl -0x14(%rbp), %eax
subl $0x1, %eax
je 0x108c1
jmp 0x108b7
movl -0x14(%rbp), %eax
subl $0x2, %eax
je 0x108d2
jmp 0x108c6
callq 0x10700
jmp 0x108c8
movl $0x1, 0x58aaa(%rip)     # 0x6937c
jmp 0x108d4
jmp 0x108d6
leaq 0x5957b(%rip), %rax     # 0x69e58
cmpq $0x0, 0x8(%rax)
setne %al
andb $0x1, %al
leaq 0x353b1(%rip), %rdi     # 0x45c9f
movl $0x65, %esi
leaq 0x35503(%rip), %rdx     # 0x45dfd
movzbl %al, %ecx
callq 0xb210
leaq 0x5954f(%rip), %rax     # 0x69e58
cmpq $0x0, (%rax)
setne %al
andb $0x1, %al
leaq 0x35386(%rip), %rdi     # 0x45c9f
movl $0x66, %esi
leaq 0x35503(%rip), %rdx     # 0x45e28
movzbl %al, %ecx
callq 0xb210
leaq 0x59524(%rip), %rax     # 0x69e58
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
leaq 0x5950d(%rip), %rax     # 0x69e58
movq %rcx, 0x8(%rax)
leaq 0x59502(%rip), %rax     # 0x69e58
movq (%rax), %rcx
addq $-0x1, %rcx
leaq 0x594f4(%rip), %rax     # 0x69e58
movq %rcx, (%rax)
movb -0x1(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/util/memory.cpp
// Function: Util::MemoryArena::clear()
void MemoryArena::clear() {
    while (next) {
        MemoryArena *old = next;
        next = next->next;
        return_arean(old);
    }
    watermark = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x10a12
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0x10(%rbp)
movq 0x10(%rax), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0x10a50
jmp 0x109e4
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/util/memory.cpp
// Function: Util::return_arean(Util::MemoryArena*)
void return_arean(MemoryArena *arena) {
    ASSERT(arena, "nullptr is not a valid argument.");
    if (arena->next) return_arean(arena->next);
    ++global_memory.num_free_regions;
    arena->next = global_memory.free_regions;
    global_memory.free_regions = arena;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
setne %al
andb $0x1, %al
leaq 0x35232(%rip), %rdi     # 0x45c9f
movl $0x71, %esi
leaq 0x353de(%rip), %rdx     # 0x45e57
movzbl %al, %ecx
callq 0xb210
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x10a99
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x10a50
leaq 0x593b8(%rip), %rax     # 0x69e58
movq (%rax), %rcx
addq $0x1, %rcx
leaq 0x593aa(%rip), %rax     # 0x69e58
movq %rcx, (%rax)
leaq 0x593a0(%rip), %rax     # 0x69e58
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rcx
leaq 0x59389(%rip), %rax     # 0x69e58
movq %rcx, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/util/memory.cpp
// Function: Util::copy_bytes(void const*, void*, unsigned long long)
void copy_bytes(const void *from, void *to, u64 size) {
    // TODO(ed): memcpy might be like... A lot faster..
    u8 *_to = (u8 *) to;
    const u8 *_from = (const u8 *) from;
    while(size--) *(_to++) = *(_from++);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x18(%rbp)
cmpq $0x0, %rax
je 0x10b59
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movb (%rax), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
jmp 0x10b20
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/platform/input.cpp
// Function: Input::find_first_binding(unsigned int)
Binding *find_first_binding(InputCode code) {
    s64 low = 0;
    s64 high = global_mapping.used_bindings;
    while (low <= high) {
        s64 cur = (low + high) / 2;
        if (cur < 0 || global_mapping.used_bindings < cur)
            break;
        auto cur_code = global_mapping.bindings[cur].code;
        if (cur_code > code) {
            high = cur - 1;
        } else if (cur_code < code) {
            low = cur + 1;
        } else {
            while (global_mapping.bindings[(cur - 1)] == code) cur--;
            return global_mapping.bindings + cur;
        }
    }
    return nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
leaq 0x58716(%rip), %rax     # 0x692e0
movl 0x10(%rax), %eax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jg 0x10cb2
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jl 0x10c0c
leaq 0x586dd(%rip), %rax     # 0x692e0
movl 0x10(%rax), %eax
cmpq -0x28(%rbp), %rax
jge 0x10c11
jmp 0x10cb2
leaq 0x586c8(%rip), %rax     # 0x692e0
movq 0x18(%rax), %rax
movq -0x28(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jbe 0x10c42
movq -0x28(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x10cad
movl -0x2c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x10c58
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x10cab
jmp 0x10c5a
leaq 0x5867f(%rip), %rax     # 0x692e0
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rax
subq $0x1, %rax
shlq $0x4, %rax
addq %rax, %rdi
leaq -0xc(%rbp), %rsi
callq 0x41520
cmpb $0x0, %al
je 0x10c8f
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x10c5a
leaq 0x5864a(%rip), %rax     # 0x692e0
movq 0x18(%rax), %rax
movq -0x28(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x10cba
jmp 0x10cad
jmp 0x10bd1
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/platform/input.cpp
// Function: Input::insert(Input::Binding)
void insert(Binding binding) {
    ASSERT(global_mapping.used_bindings < global_mapping.num_total_bindings, "Too many bindings");

    Binding *it = global_mapping.bindings + global_mapping.used_bindings;
    while (global_mapping.bindings != it && binding.code < (it - 1)->code) {
        *it = *(it - 1);
        it--;
    }
    *it = binding;
    global_mapping.used_bindings += 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
leaq 0x585f9(%rip), %rax     # 0x692e0
movl 0x10(%rax), %eax
leaq 0x585ef(%rip), %rcx     # 0x692e0
cmpl 0xc(%rcx), %eax
setb %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
leaq 0x35174(%rip), %rdi     # 0x45e7f
movl $0x18, %esi
leaq 0x35186(%rip), %rdx     # 0x45e9d
movzbl %al, %ecx
callq 0xb210
leaq 0x585ba(%rip), %rax     # 0x692e0
movq 0x18(%rax), %rax
leaq 0x585af(%rip), %rcx     # 0x692e0
movl 0x10(%rcx), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
leaq 0x5859a(%rip), %rax     # 0x692e0
movq 0x18(%rax), %rcx
xorl %eax, %eax
cmpq -0x18(%rbp), %rcx
movb %al, -0x19(%rbp)
je 0x10d65
movl -0x10(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl -0x10(%rcx), %eax
setb %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x10d6e
jmp 0x10d93
movq -0x18(%rbp), %rcx
movq -0x18(%rbp), %rax
movq -0x10(%rcx), %rdx
movq %rdx, (%rax)
movq -0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $-0x10, %rax
movq %rax, -0x18(%rbp)
jmp 0x10d3f
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
movq %rcx, 0x8(%rax)
leaq 0x58533(%rip), %rax     # 0x692e0
movl 0x10(%rax), %ecx
addl $0x1, %ecx
leaq 0x58526(%rip), %rax     # 0x692e0
movl %ecx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/platform/input.cpp
// Function: Input::clear_input_for_frame()
void clear_input_for_frame() {
    for (u32 player = 0; player < (u32) Player::NUM; player++) {
        for (u32 button_id = 0; button_id < global_mapping.num_bindings_per_controller;
             button_id++) {
            auto *button = global_mapping.buttons[player] + button_id;
            button->state = clear_frame_flag(button->state);
        }
    }

    // Reset mouse frame
    global_mapping.mouse.depth = 0;
    global_mapping.mouse.move_x = 0;
    global_mapping.mouse.move_y = 0;
    global_mapping.mouse.wheel_x = 0;
    global_mapping.mouse.wheel_y = 0;
    global_mapping.mouse.state[0] = clear_frame_flag(global_mapping.mouse.state[0]);
    global_mapping.mouse.state[1] = clear_frame_flag(global_mapping.mouse.state[1]);
    global_mapping.mouse.state[2] = clear_frame_flag(global_mapping.mouse.state[2]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0x4, -0x4(%rbp)
jae 0x10e47
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
leaq 0x584ea(%rip), %rcx     # 0x692e0
cmpl 0x8(%rcx), %eax
jae 0x10e3a
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0x584d9(%rip), %rax     # 0x692e0
movq 0x20(%rax,%rcx,8), %rax
movl -0x8(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edi
callq 0xf460
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x10dec
jmp 0x10e3c
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x10ddf
leaq 0x58492(%rip), %rax     # 0x692e0
movl $0x0, 0x8c(%rax)
leaq 0x58481(%rip), %rax     # 0x692e0
movl $0x0, 0x7c(%rax)
leaq 0x58473(%rip), %rax     # 0x692e0
movl $0x0, 0x80(%rax)
leaq 0x58462(%rip), %rax     # 0x692e0
movl $0x0, 0x84(%rax)
leaq 0x58451(%rip), %rax     # 0x692e0
movl $0x0, 0x88(%rax)
leaq 0x58440(%rip), %rax     # 0x692e0
movl 0x68(%rax), %edi
callq 0xf460
movl %eax, %ecx
leaq 0x5842f(%rip), %rax     # 0x692e0
movl %ecx, 0x68(%rax)
leaq 0x58425(%rip), %rax     # 0x692e0
movl 0x6c(%rax), %edi
callq 0xf460
movl %eax, %ecx
leaq 0x58414(%rip), %rax     # 0x692e0
movl %ecx, 0x6c(%rax)
leaq 0x5840a(%rip), %rax     # 0x692e0
movl 0x70(%rax), %edi
callq 0xf460
movl %eax, %ecx
leaq 0x583f9(%rip), %rax     # 0x692e0
movl %ecx, 0x70(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/platform/input.cpp
// Function: Input::activate(unsigned int, float)
void activate(InputCode code, f32 value) {
    for (Binding *binding = find_first_binding(code);
         binding && (*binding) == code; binding++) {
        u32 index = binding->index();
        ASSERT(0 <= index && index < global_mapping.num_bindings_per_controller, "Invalid index");
        u32 player = binding->playerID();
        ASSERT(0 <= (u32) player && player < (u32) Player::NUM, "Invalid player");
        global_mapping.buttons[player][index].set(value);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movss %xmm0, -0x8(%rbp)
movl -0x4(%rbp), %edi
callq 0x10bb0
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x19(%rbp)
je 0x10f2d
movq -0x10(%rbp), %rdi
leaq -0x4(%rbp), %rsi
callq 0x41520
cmpb $0x0, %al
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x10f39
jmp 0x11012
movq -0x10(%rbp), %rdi
callq 0x41560
movl %eax, -0x14(%rbp)
xorl %eax, %eax
xorl %ecx, %ecx
cmpl -0x14(%rbp), %ecx
movb %al, -0x1a(%rbp)
ja 0x10f64
movl -0x14(%rbp), %eax
leaq 0x58385(%rip), %rcx     # 0x692e0
cmpl 0x8(%rcx), %eax
setb %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
leaq 0x34f04(%rip), %rdi     # 0x45e7f
movl $0x55, %esi
leaq 0x34fa4(%rip), %rdx     # 0x45f2b
movzbl %al, %ecx
callq 0xb210
movq -0x10(%rbp), %rdi
callq 0x41630
movl %eax, -0x18(%rbp)
xorl %eax, %eax
xorl %ecx, %ecx
cmpl -0x18(%rbp), %ecx
movb %al, -0x1b(%rbp)
ja 0x10fb1
cmpl $0x4, -0x18(%rbp)
setb %al
movb %al, -0x1b(%rbp)
movb -0x1b(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
leaq 0x34eb7(%rip), %rdi     # 0x45e7f
movl $0x57, %esi
leaq 0x34fa7(%rip), %rdx     # 0x45f7b
movzbl %al, %ecx
callq 0xb210
movl -0x18(%rbp), %eax
movl %eax, %ecx
leaq 0x582f8(%rip), %rax     # 0x692e0
movq 0x20(%rax,%rcx,8), %rdi
movl -0x14(%rbp), %eax
shlq $0x4, %rax
addq %rax, %rdi
movss -0x8(%rbp), %xmm0
callq 0x41690
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
jmp 0x10f0c
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/platform/input.cpp
// Function: Input::type_text(char const*)
void type_text(const char *string) {
    while (*string) {
        const u32 size_left = global_mapping.text_length - global_mapping.TEXT_LENGTH;
        if (Util::utf8_insert_glyph(global_mapping.text + global_mapping.text_length,
                              string, size_left)) {
            const u32 size = Util::utf8_size(string);
            global_mapping.text_length += size;
            string += size;
        } else {
            break;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x110a9
leaq 0x582a4(%rip), %rax     # 0x692e0
movl 0x44(%rax), %eax
subl $0x20, %eax
movl %eax, -0xc(%rbp)
leaq 0x58294(%rip), %rax     # 0x692e0
movl 0x44(%rax), %eax
leaq 0x5828a(%rip), %rdi     # 0x692e0
addq $0x48, %rdi
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
callq 0x10580
cmpb $0x0, %al
je 0x110a5
movq -0x8(%rbp), %rdi
callq 0x104b0
movzbl %al, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %ecx
leaq 0x5825a(%rip), %rax     # 0x692e0
addl 0x44(%rax), %ecx
leaq 0x58250(%rip), %rax     # 0x692e0
movl %ecx, 0x44(%rax)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x110a7
jmp 0x110a9
jmp 0x1102c
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/platform/input.cpp
// Function: Input::edit_string(char*, unsigned int)
b8 edit_string(char *text, u32 max_length) {
    if (!global_mapping.text_length) return false;
    s32 text_left = max_length;
    char *cursor = text;
    while (*cursor) { cursor++; text_left--; }
    char *edits = global_mapping.text;
    while (edits < global_mapping.text + global_mapping.text_length) {
        const u32 glyph_size = Util::utf8_size(edits);
        if (*edits == '\b') {
            if (cursor != text) {
                do {
                    cursor--;
                    text_left++;
                } while (!Util::utf8_is_first_char(cursor) && text < cursor);
            }
        } else {
            if (Util::utf8_insert_glyph(cursor, edits, text_left)) {
                cursor += glyph_size;
                text_left -= glyph_size;
            }
        }
        edits += glyph_size;
    }
    *cursor = '\0';
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
leaq 0x5821a(%rip), %rax     # 0x692e0
cmpl $0x0, 0x44(%rax)
jne 0x110d5
movb $0x0, -0x1(%rbp)
jmp 0x111f4
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
je 0x11103
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x110e3
leaq 0x581d6(%rip), %rax     # 0x692e0
addq $0x48, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
leaq 0x581c3(%rip), %rcx     # 0x692e0
movl 0x44(%rcx), %ecx
movl %ecx, %edx
leaq 0x581b7(%rip), %rcx     # 0x692e0
addq $0x48, %rcx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x111e9
movq -0x28(%rbp), %rdi
callq 0x104b0
movzbl %al, %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x8, %eax
jne 0x111a3
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x111a1
jmp 0x11160
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x20(%rbp), %rdi
callq 0x10560
movb %al, %cl
xorl %eax, %eax
cmpb $0x0, %cl
movb %al, -0x2d(%rbp)
jne 0x11198
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
setb %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0x11160
jmp 0x111a1
jmp 0x111d4
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x18(%rbp), %edx
callq 0x10580
cmpb $0x0, %al
je 0x111d2
movl -0x2c(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0x2c(%rbp), %ecx
movl -0x18(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x18(%rbp)
jmp 0x111d4
movl -0x2c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0x11112
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/platform/input.cpp
// Function: Input::super_pressed(unsigned int, Input::Player)
b8 super_pressed(Name name, Player player) {
    b8 remember = global_mapping.text_input;
    global_mapping.text_input = false;
    BEGIN_BINDINGS_BLOCK {
        if ((u32) button.state & (u32) ButtonState::TRIGGERED) {
            global_mapping.text_input = remember;
            return true;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x580ab(%rip), %rax     # 0x692e0
movb 0x40(%rax), %al
movb %al, -0xd(%rbp)
leaq 0x5809e(%rip), %rax     # 0x692e0
movb $0x0, 0x40(%rax)
leaq 0x58093(%rip), %rax     # 0x692e0
cmpb $0x0, 0x40(%rax)
je 0x1125c
movb $0x0, -0x1(%rbp)
jmp 0x1133f
movl $0x0, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jae 0x1132e
movl -0x14(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x18(%rbp)
movl -0xc(%rbp), %edi
movl -0x18(%rbp), %esi
callq 0xf3a0
cmpb $0x0, %al
jne 0x1128e
jmp 0x11320
movl $0x0, -0x28(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x20(%rbp)
movb $0x0, -0x1c(%rbp)
movl $0x0, -0x2c(%rbp)
cmpl $0x4, -0x2c(%rbp)
jae 0x1131e
movl -0x2c(%rbp), %eax
movb %al, -0x1c(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x4c(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x44(%rbp)
movq -0x4c(%rbp), %rsi
movq -0x44(%rbp), %rdx
leaq 0x58009(%rip), %rdi     # 0x692e0
callq 0x416e0
movq %rax, -0x3c(%rbp)
movq %rdx, -0x34(%rbp)
leaq -0x3c(%rbp), %rdi
callq 0x415c0
cmpb $0x0, %al
jne 0x112f3
jmp 0x11313
movl -0x34(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x11311
movb -0xd(%rbp), %cl
leaq 0x57fd8(%rip), %rax     # 0x692e0
movb %cl, 0x40(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x1133f
jmp 0x11313
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x112ac
jmp 0x11320
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x11263
movb -0xd(%rbp), %cl
leaq 0x57fa8(%rip), %rax     # 0x692e0
movb %cl, 0x40(%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/platform/input.cpp
// Function: Input::triggered(unsigned int, Input::Player)
b8 triggered(Name name, Player player) {
    BEGIN_BINDINGS_BLOCK {
        if ((u32) button.state & (u32) ButtonState::TRIGGERED) return true;
    }
    END_BINDINGS_BLOCK
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x57f7b(%rip), %rax     # 0x692e0
cmpb $0x0, 0x40(%rax)
je 0x11374
movb $0x0, -0x1(%rbp)
jmp 0x1143d
movl $0x0, -0x10(%rbp)
cmpl $0x4, -0x10(%rbp)
jae 0x11439
movl -0x10(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %edi
movl -0x14(%rbp), %esi
callq 0xf3a0
cmpb $0x0, %al
jne 0x113a6
jmp 0x1142b
movl $0x0, -0x24(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x1c(%rbp)
movb $0x0, -0x18(%rbp)
movl $0x0, -0x28(%rbp)
cmpl $0x4, -0x28(%rbp)
jae 0x11429
movl -0x28(%rbp), %eax
movb %al, -0x18(%rbp)
movq -0x24(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x1c(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
leaq 0x57ef1(%rip), %rdi     # 0x692e0
callq 0x416e0
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x415c0
cmpb $0x0, %al
jne 0x1140b
jmp 0x1141e
movl -0x30(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x1141c
movb $0x1, -0x1(%rbp)
jmp 0x1143d
jmp 0x1141e
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x113c4
jmp 0x1142b
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1137b
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/platform/input.cpp
// Function: Input::pressed(unsigned int, Input::Player)
b8 pressed(Name name, Player player) {
    BEGIN_BINDINGS_BLOCK {
        if (button.state == ButtonState::PRESSED) return true;
    }
    END_BINDINGS_BLOCK
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x57e7b(%rip), %rax     # 0x692e0
cmpb $0x0, 0x40(%rax)
je 0x11474
movb $0x0, -0x1(%rbp)
jmp 0x11538
movl $0x0, -0x10(%rbp)
cmpl $0x4, -0x10(%rbp)
jae 0x11534
movl -0x10(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %edi
movl -0x14(%rbp), %esi
callq 0xf3a0
cmpb $0x0, %al
jne 0x114a6
jmp 0x11526
movl $0x0, -0x24(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x1c(%rbp)
movb $0x0, -0x18(%rbp)
movl $0x0, -0x28(%rbp)
cmpl $0x4, -0x28(%rbp)
jae 0x11524
movl -0x28(%rbp), %eax
movb %al, -0x18(%rbp)
movq -0x24(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x1c(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
leaq 0x57df1(%rip), %rdi     # 0x692e0
callq 0x416e0
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x415c0
cmpb $0x0, %al
jne 0x1150b
jmp 0x11519
cmpl $0x3, -0x30(%rbp)
jne 0x11517
movb $0x1, -0x1(%rbp)
jmp 0x11538
jmp 0x11519
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x114c4
jmp 0x11526
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1147b
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/platform/input.cpp
// Function: Input::released(unsigned int, Input::Player)
b8 released(Name name, Player player) {
    BEGIN_BINDINGS_BLOCK {
        if (button.state == ButtonState::RELEASED) return true;
    }
    END_BINDINGS_BLOCK
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x57d7b(%rip), %rax     # 0x692e0
cmpb $0x0, 0x40(%rax)
je 0x11574
movb $0x0, -0x1(%rbp)
jmp 0x11638
movl $0x0, -0x10(%rbp)
cmpl $0x4, -0x10(%rbp)
jae 0x11634
movl -0x10(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %edi
movl -0x14(%rbp), %esi
callq 0xf3a0
cmpb $0x0, %al
jne 0x115a6
jmp 0x11626
movl $0x0, -0x24(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x1c(%rbp)
movb $0x0, -0x18(%rbp)
movl $0x0, -0x28(%rbp)
cmpl $0x4, -0x28(%rbp)
jae 0x11624
movl -0x28(%rbp), %eax
movb %al, -0x18(%rbp)
movq -0x24(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x1c(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
leaq 0x57cf1(%rip), %rdi     # 0x692e0
callq 0x416e0
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x415c0
cmpb $0x0, %al
jne 0x1160b
jmp 0x11619
cmpl $0x2, -0x30(%rbp)
jne 0x11617
movb $0x1, -0x1(%rbp)
jmp 0x11638
jmp 0x11619
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x115c4
jmp 0x11626
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1157b
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)