LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/FredTheDino[P]Fog/src/engine/logic/block_physics.cpp
// Function: Physics::create_body(unsigned int, float, float, float)
Body create_body(ShapeID shape_id, f32 mass, f32 bounce, f32 damping) {
    ASSERT(shape_id >= 0, "Invalid shape ID");
    ASSERT(shape_id < global_shape_list.length, "Invalid shape ID");

    Body body = {};
    body.scale = V2(1, 1);
    body.layer = 0xFFFFFFFF;
    body.damping = damping;
    body.shape = shape_id;
    body.bounce = bounce;
    if (mass == 0.0)
        body.inverse_mass = 0.0f;
    else
        body.inverse_mass = 1.0f / mass;

    return body;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movss %xmm2, -0x14(%rbp)
movss %xmm1, -0x18(%rbp)
movss %xmm0, -0x1c(%rbp)
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x3fc68(%rip), %rax     # 0x64940
xorl %ecx, %ecx
cmpl %esi, 0x4(%rax)
seta %cl
leaq 0xcd24(%rip), %rdi      # 0x31a0b
leaq 0xce66(%rip), %rdx      # 0x31b54
movl $0x8e, %esi
callq 0x729c
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
movups %xmm0, 0x28(%rbx)
movups %xmm0, 0x8(%rbx)
movl $0x0, 0x38(%rbx)
movsd 0xb58a(%rip), %xmm0     # 0x302a0
movsd %xmm0, 0x1c(%rbx)
movl $0xffffffff, 0x4(%rbx)  # imm = 0xFFFFFFFF
movss -0x14(%rbp), %xmm0
movss %xmm0, 0x40(%rbx)
movl %r14d, (%rbx)
movss -0x18(%rbp), %xmm0
movss %xmm0, 0x44(%rbx)
movss 0xb2c3(%rip), %xmm0     # 0x30004
movss -0x1c(%rbp), %xmm2
divss %xmm2, %xmm0
xorps %xmm1, %xmm1
cmpeqss %xmm2, %xmm1
andnps %xmm0, %xmm1
movss %xmm1, 0x3c(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/FredTheDino[P]Fog/src/engine/logic/block_physics.cpp
// Function: Physics::point_in_box(Vec2, Vec2, Vec2, float)
b8 point_in_box(Vec2 p, Vec2 center, Vec2 dim, f32 rotation) {
    p = rotate(p, -rotation);
    center = rotate(center, -rotation);
    Vec2 delta = p - center;
    return ABS(delta.x) < ABS(dim.x * 0.5) && ABS(delta.y) < ABS(dim.y * 0.5);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movaps %xmm2, -0x70(%rbp)
movaps %xmm1, -0x60(%rbp)
movaps %xmm0, -0x30(%rbp)
movaps %xmm3, %xmm0
xorps 0xae6f(%rip), %xmm0     # 0x30040
movaps %xmm0, -0x20(%rbp)
callq 0x2050
movss %xmm0, -0x4(%rbp)
movaps -0x20(%rbp), %xmm0
callq 0x2350
movaps -0x30(%rbp), %xmm3
movaps %xmm3, %xmm1
shufps $0x55, %xmm3, %xmm1     # xmm1 = xmm1[1,1],xmm3[1,1]
movss -0x4(%rbp), %xmm2
movaps %xmm1, -0x40(%rbp)
mulss %xmm1, %xmm2
movaps %xmm3, %xmm1
movss %xmm0, -0x8(%rbp)
mulss %xmm0, %xmm1
subss %xmm2, %xmm1
movaps %xmm1, -0x50(%rbp)
movaps -0x20(%rbp), %xmm0
callq 0x2050
movss %xmm0, -0xc(%rbp)
movaps -0x20(%rbp), %xmm0
callq 0x2350
movss -0xc(%rbp), %xmm7
movaps -0x60(%rbp), %xmm6
movaps -0x70(%rbp), %xmm5
movaps %xmm6, %xmm1
shufps $0x55, %xmm6, %xmm1     # xmm1 = xmm1[1,1],xmm6[1,1]
movaps %xmm7, %xmm2
mulss %xmm1, %xmm2
movaps %xmm6, %xmm3
mulss %xmm0, %xmm3
subss %xmm2, %xmm3
movaps -0x50(%rbp), %xmm4
subss %xmm3, %xmm4
movaps 0xade0(%rip), %xmm2     # 0x30040
xorps %xmm4, %xmm2
maxss %xmm4, %xmm2
cvtss2sd %xmm2, %xmm2
xorps %xmm3, %xmm3
cvtss2sd %xmm5, %xmm3
mulsd 0xb7de(%rip), %xmm3     # 0x30a58
movapd 0xb0de(%rip), %xmm4     # 0x30360
xorpd %xmm3, %xmm4
maxsd %xmm3, %xmm4
ucomisd %xmm2, %xmm4
jbe 0x252f4
movaps -0x40(%rbp), %xmm3
mulss -0x8(%rbp), %xmm3
movaps -0x30(%rbp), %xmm2
mulss -0x4(%rbp), %xmm2
addss %xmm3, %xmm2
mulss %xmm0, %xmm1
mulss %xmm7, %xmm6
addss %xmm1, %xmm6
subss %xmm6, %xmm2
movaps 0xad83(%rip), %xmm0     # 0x30040
xorps %xmm2, %xmm0
maxss %xmm2, %xmm0
shufps $0x55, %xmm5, %xmm5     # xmm5 = xmm5[1,1,1,1]
xorps %xmm1, %xmm1
cvtss2sd %xmm5, %xmm1
mulsd 0xb781(%rip), %xmm1     # 0x30a58
cvtss2sd %xmm0, %xmm0
movapd 0xb07d(%rip), %xmm2     # 0x30360
xorpd %xmm1, %xmm2
maxsd %xmm1, %xmm2
ucomisd %xmm0, %xmm2
seta %al
jmp 0x252f6
xorl %eax, %eax
addq $0x70, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/FredTheDino[P]Fog/src/engine/logic/block_physics.cpp
// Function: Physics::integrate(Physics::Body*, float)
void integrate(Body *body, f32 delta) {
    body->acceleration += body->force * body->inverse_mass;
    body->velocity += body->acceleration * delta;
    body->position += body->velocity * delta;

#if 1
    f32 damping = CLAMP(0.0f, 1.0f, 1 - body->damping);
    if (damping != 0.0f)
        body->velocity = body->velocity * pow(damping, delta);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movaps %xmm0, %xmm1
movss 0x3c(%rdi), %xmm0
movss 0x34(%rdi), %xmm2
mulss %xmm0, %xmm2
mulss 0x38(%rdi), %xmm0
addss 0x2c(%rdi), %xmm2
movss %xmm2, 0x2c(%rdi)
addss 0x30(%rdi), %xmm0
movss %xmm0, 0x30(%rdi)
mulss %xmm1, %xmm2
mulss %xmm1, %xmm0
addss 0x24(%rdi), %xmm2
movss %xmm2, 0x24(%rdi)
addss 0x28(%rdi), %xmm0
movss %xmm0, 0x28(%rdi)
mulss %xmm1, %xmm2
mulss %xmm1, %xmm0
addss 0x14(%rdi), %xmm2
movss %xmm2, 0x14(%rdi)
addss 0x18(%rdi), %xmm0
movss %xmm0, 0x18(%rdi)
movss 0xac98(%rip), %xmm0     # 0x30004
movaps %xmm0, %xmm2
subss 0x40(%rdi), %xmm2
xorps %xmm3, %xmm3
ucomiss %xmm2, %xmm3
ja 0x253ab
movq %rdi, %rbx
ucomiss %xmm0, %xmm2
ja 0x25391
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm2
movaps %xmm2, %xmm0
jne 0x25391
jnp 0x253ab
callq 0x23f0
movss 0x24(%rbx), %xmm1
mulss %xmm0, %xmm1
mulss 0x28(%rbx), %xmm0
unpcklps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movlps %xmm1, 0x24(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/FredTheDino[P]Fog/src/engine/platform/mixer.cpp
// Function: Mixer::add(float*, float, float)
void add(f32 *value, f32 target, f32 delta) {
    if (delta > 0 && *value < target) {
        *value = MIN(*value + delta, target);
    } else if (delta < 0 && *value > target) {
        *value = MAX(*value + delta, target);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorps %xmm3, %xmm3
ucomiss %xmm3, %xmm1
jbe 0x25e42
movss (%rdi), %xmm2
ucomiss %xmm2, %xmm0
jbe 0x25e42
addss %xmm1, %xmm2
minss %xmm0, %xmm2
jmp 0x25e58
ucomiss %xmm1, %xmm3
jbe 0x25e5c
movss (%rdi), %xmm2
ucomiss %xmm0, %xmm2
jbe 0x25e5c
addss %xmm1, %xmm2
maxss %xmm0, %xmm2
movss %xmm2, (%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/FredTheDino[P]Fog/src/engine/platform/mixer.cpp
// Function: Mixer::Channel::set_delay(float, float, float)
void Channel::set_delay(f32 feedback, f32 len_seconds, f32 in_seconds) {
    if (feedback >= 0) delay.feedback_target = feedback;
    if (len_seconds >= 0) delay.len_seconds_target = len_seconds;
    delay.feedback_delta = (delay.feedback_target - delay.feedback) / (in_seconds * AUDIO_SAMPLE_RATE / (AUDIO_SAMPLES_WANT * 2));
    delay.len_seconds_delta = (delay.len_seconds_target - delay.len_seconds) / (in_seconds * AUDIO_SAMPLE_RATE / (AUDIO_SAMPLES_WANT * 2));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorps %xmm3, %xmm3
ucomiss %xmm3, %xmm0
jb 0x26299
movss %xmm0, 0xc(%rdi)
ucomiss %xmm3, %xmm1
jae 0x262a5
movss 0x1c(%rdi), %xmm1
jmp 0x262aa
movss %xmm1, 0x1c(%rdi)
movss 0xc(%rdi), %xmm0
subss 0x8(%rdi), %xmm0
mulss 0x9fa8(%rip), %xmm2     # 0x30264
mulss 0x9fa4(%rip), %xmm2     # 0x30268
divss %xmm2, %xmm0
movss %xmm0, 0x10(%rdi)
subss 0x18(%rdi), %xmm1
divss %xmm2, %xmm1
movss %xmm1, 0x20(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/FredTheDino[P]Fog/src/engine/platform/mixer.cpp
// Function: Mixer::push_sound(Mixer::SoundSource)
AudioID push_sound(SoundSource source) {
    lock_audio();
    if (audio_struct.num_free_sources) {
        u16 source_id =
            audio_struct.free_sources[--audio_struct.num_free_sources];
        source.gen = audio_struct.sources[source_id].gen + 1;
        audio_struct.sources[source_id] = source;
        unlock_audio();
        return {source.gen, source_id};
    } else {
        ERR("Not enough free sources, skipping playing of sound");
    }
    unlock_audio();
    return {0, NUM_SOURCES};
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x28bab(%rip), %rbx     # 0x4f378
movl 0x9cc(%rbx), %edi
callq 0x2230
movzwl 0x600(%rbx), %eax
testw %ax, %ax
je 0x26841
leaq 0x10(%rbp), %rcx
decl %eax
movw %ax, 0x600(%rbx)
movzwl %ax, %eax
movzwl 0x602(%rbx,%rax,2), %r14d
leaq (%r14,%r14,2), %rax
shll $0x4, %eax
movb 0x26(%rbx,%rax), %r15b
incb %r15b
movb %r15b, 0x26(%rcx)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rbx,%rax)
movups %xmm0, (%rbx,%rax)
movups 0x20(%rcx), %xmm0
movups %xmm0, 0x20(%rbx,%rax)
movl 0x9cc(%rbx), %edi
callq 0x2070
shll $0x10, %r14d
movzbl %r15b, %eax
orl %r14d, %eax
jmp 0x26883
movq 0x28788(%rip), %rax     # 0x4efd0
movq (%rax), %rsi
leaq 0xa44d(%rip), %rdi      # 0x30c9f
leaq 0xb331(%rip), %rdx      # 0x31b8a
leaq 0xb3b3(%rip), %r8       # 0x31c13
leaq 0xb3b7(%rip), %r9       # 0x31c1e
movl $0x7e, %ecx
xorl %eax, %eax
callq 0x718c
movl 0x9cc(%rbx), %edi
callq 0x2070
movl $0x200000, %eax         # imm = 0x200000
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/FredTheDino[P]Fog/src/engine/platform/mixer.cpp
// Function: Mixer::play_sound_at(unsigned int, unsigned long long, Vec2, float, float, float, float, unsigned char)
AudioID play_sound_at(u32 channel_id, AssetID asset_id, Vec2 position, f32 pitch, f32 gain,
                      f32 pitch_variance, f32 gain_variance, b8 loop) {
    ASSERT(channel_id < NUM_CHANNELS, "Invalid channel");
    return push_sound({0, asset_id, channel_id, pitch + random_real(-1, 1) * pitch_variance,
                       gain + random_real(-1, 1) * gain_variance, loop, true,
                       position});
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movl %edx, %ebx
movss %xmm4, -0x24(%rbp)
movss %xmm3, -0x1c(%rbp)
movss %xmm2, -0x28(%rbp)
movss %xmm1, -0x20(%rbp)
movaps %xmm0, -0x70(%rbp)
movq %rsi, %r14
movl %edi, %r15d
xorl %ecx, %ecx
cmpl $0xa, %edi
setb %cl
leaq 0xb0e1(%rip), %rdi      # 0x31b8a
leaq 0xb138(%rip), %rdx      # 0x31be8
movl $0x93, %esi
callq 0x729c
movl $0x0, -0x58(%rbp)
movq %r14, -0x50(%rbp)
movl %r15d, -0x48(%rbp)
leaq 0x29304(%rip), %rax     # 0x4fdd4
movl 0xc(%rax), %edx
movl (%rax), %esi
movl %edx, %ecx
shrl $0x2, %ecx
xorl %edx, %ecx
movl %esi, %edx
shll $0x4, %edx
xorl %esi, %edx
xorl %ecx, %edx
addl %ecx, %ecx
xorl %edx, %ecx
movl 0x10(%rax), %edx
leal (%rdx,%rcx), %edi
addl $0x587c5, %edi          # imm = 0x587C5
xorps %xmm2, %xmm2
cvtsi2ss %rdi, %xmm2
movl 0x8(%rax), %edi
movl 0x4(%rax), %r8d
movss 0x9718(%rip), %xmm0     # 0x30224
mulss %xmm0, %xmm2
addss %xmm2, %xmm2
movss 0x970c(%rip), %xmm1     # 0x30228
addss %xmm1, %xmm2
mulss -0x1c(%rbp), %xmm2
addss -0x20(%rbp), %xmm2
movss %xmm2, -0x44(%rbp)
movl %r8d, 0xc(%rax)
movl %esi, 0x8(%rax)
movl %ecx, 0x4(%rax)
movl %edi, %esi
shrl $0x2, %esi
xorl %edi, %esi
leal (%rsi,%rsi), %edi
xorl %esi, %edi
xorl %ecx, %edi
shll $0x4, %ecx
xorl %edi, %ecx
movl %ecx, (%rax)
addl %edx, %ecx
addl $0xb0f8a, %ecx          # imm = 0xB0F8A
addl $0xb0f8a, %edx          # imm = 0xB0F8A
xorps %xmm2, %xmm2
cvtsi2ss %rcx, %xmm2
movl %edx, 0x10(%rax)
mulss %xmm0, %xmm2
addss %xmm2, %xmm2
addss %xmm1, %xmm2
mulss -0x24(%rbp), %xmm2
addss -0x28(%rbp), %xmm2
movss %xmm2, -0x40(%rbp)
movb %bl, -0x3c(%rbp)
movb $0x1, -0x3b(%rbp)
movaps -0x70(%rbp), %xmm0
movlps %xmm0, -0x3a(%rbp)
movb $0x0, -0x32(%rbp)
movq $0x0, -0x30(%rbp)
movups -0x58(%rbp), %xmm0
movups -0x48(%rbp), %xmm1
movups -0x38(%rbp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x267bc
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/FredTheDino[P]Fog/src/engine/platform/mixer.cpp
// Function: Mixer::stop_sound(Mixer::AudioID)
void stop_sound(AudioID id) {
    ASSERT(id.slot < NUM_SOURCES, "Invalid index in ID");
    lock_audio();
    SoundSource *source = fetch_source(id);
    if (source->gen == id.gen) {
        audio_struct.free_sources[audio_struct.num_free_sources++] = id.slot;
        source->gain = 0.0;
    } else {
        ERR("Invalid removal of AudioID that does not exist");
    }
    unlock_audio();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
xorl %ecx, %ecx
cmpl $0x200000, %edi         # imm = 0x200000
setb %cl
leaq 0xafa5(%rip), %rdi      # 0x31b8a
leaq 0xb0a6(%rip), %rdx      # 0x31c92
movl $0x9a, %esi
callq 0x729c
leaq 0x2877b(%rip), %r14     # 0x4f378
movl 0x9cc(%r14), %edi
callq 0x2230
movl %ebx, %edi
callq 0x268bc
cmpb %bl, 0x26(%rax)
jne 0x26c3d
shrl $0x10, %ebx
movzwl 0x600(%r14), %ecx
leal 0x1(%rcx), %edx
movw %dx, 0x600(%r14)
movw %bx, 0x602(%r14,%rcx,2)
movl $0x0, 0x18(%rax)
jmp 0x26c6f
movq 0x2838c(%rip), %rax     # 0x4efd0
movq (%rax), %rsi
leaq 0xa051(%rip), %rdi      # 0x30c9f
leaq 0xaf35(%rip), %rdx      # 0x31b8a
leaq 0xb061(%rip), %r8       # 0x31cbd
leaq 0xb065(%rip), %r9       # 0x31cc8
movl $0xa1, %ecx
xorl %eax, %eax
callq 0x718c
movl 0x9cc(%r14), %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x2070
// File: /workspace/github_c_makefile_star2_O3/FredTheDino[P]Fog/src/engine/platform/mixer.cpp
// Function: Mixer::post_sound_hook(Mixer::AudioID, void (*)())
void post_sound_hook(AudioID id, FogCallback post_hook) {
    ASSERT(id.slot < NUM_SOURCES, "Invalid index in ID");
    lock_audio();
    SoundSource *source = fetch_source(id);
    if (source->gen == id.gen) {
        source->post_hook = post_hook;
    } else {
        ERR("Tried to attach a post hook to an AudioID that does not exist");
    }
    unlock_audio();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
xorl %ecx, %ecx
cmpl $0x200000, %edi         # imm = 0x200000
setb %cl
leaq 0xaee9(%rip), %rdi      # 0x31b8a
leaq 0xafea(%rip), %rdx      # 0x31c92
movl $0xa7, %esi
callq 0x729c
leaq 0x286bf(%rip), %r15     # 0x4f378
movl 0x9cc(%r15), %edi
callq 0x2230
movl %r14d, %edi
callq 0x268bc
cmpb %r14b, 0x26(%rax)
jne 0x26cd9
movq %rbx, 0x28(%rax)
jmp 0x26d0b
movq 0x282f0(%rip), %rax     # 0x4efd0
movq (%rax), %rsi
leaq 0x9fb5(%rip), %rdi      # 0x30c9f
leaq 0xae99(%rip), %rdx      # 0x31b8a
leaq 0xafff(%rip), %r8       # 0x31cf7
leaq 0xb008(%rip), %r9       # 0x31d07
movl $0xad, %ecx
xorl %eax, %eax
callq 0x718c
movl 0x9cc(%r15), %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2070
// File: /workspace/github_c_makefile_star2_O3/FredTheDino[P]Fog/src/engine/platform/mixer.cpp
// Function: Mixer::init()
b8 init() {
    OTHER_THREAD(AUDIO);
    OTHER_THREAD(AUDIO_SOURCES);
    OTHER_THREAD(AUDIO_EFFECTS);

    audio_mixer.arena = Util::request_arena();

    audio_struct.num_free_sources = NUM_SOURCES;
    for (u32 i = 0; i < NUM_SOURCES; i++)
        audio_struct.free_sources[i] = i;

    for (u32 i = 0; i < NUM_CHANNELS; i++)
        audio_struct.channels[i].buffer = audio_mixer.arena->push<f32>(CHANNEL_BUFFER_LENGTH);

    SDL_AudioSpec want = {};
    want.freq = AUDIO_SAMPLE_RATE;
    want.format = AUDIO_F32;
    want.samples = AUDIO_SAMPLES_WANT;
    want.channels = 2;
    want.callback = audio_callback;
    audio_struct.time_step = 1.0 / (f32) AUDIO_SAMPLE_RATE;
    want.userdata = (void *) &audio_struct;

    // Let SDL handle the translation for us.
    SDL_AudioSpec have;
    audio_struct.dev = SDL_OpenAudioDevice(NULL, 0, &want, &have, 0);
    if (audio_struct.dev <= 0) {
        ERR("%s", SDL_GetError());
        return false;
    }

    SDL_PauseAudioDevice(audio_struct.dev, 0);
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
leaq 0x29397(%rip), %rax     # 0x50630
movb $0x1, %cl
movb %cl, 0x201(%rax)
movb %cl, 0x249(%rax)
movb %cl, 0x291(%rax)
xorl %r15d, %r15d
xorl %edi, %edi
callq 0xacd1
leaq 0x44022(%rip), %r14     # 0x6b2e0
movq %rax, 0x10(%r14)
leaq 0x280af(%rip), %rbx     # 0x4f378
movw $0x20, 0x600(%rbx)
movw %r15w, 0x602(%rbx,%r15,2)
incq %r15
cmpq $0x20, %r15
jne 0x272d2
xorl %r15d, %r15d
movq 0x10(%r14), %rdi
movl $0x46500, %esi          # imm = 0x46500
callq 0x2ece4
movq %rax, 0x648(%rbx,%r15)
addq $0x58, %r15
cmpq $0x370, %r15            # imm = 0x370
jne 0x272e7
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %rdx
movaps %xmm0, (%rdx)
movl $0xbb80, (%rdx)         # imm = 0xBB80
movw $0x8120, 0x4(%rdx)      # imm = 0x8120
movw $0x800, 0x8(%rdx)       # imm = 0x800
movb $0x2, 0x6(%rdx)
leaq -0x610(%rip), %rax      # 0x26d21
movq %rax, 0x10(%rdx)
movl $0x37aec33e, 0x9c8(%rbx) # imm = 0x37AEC33E
movq %rbx, 0x18(%rdx)
leaq -0x60(%rbp), %rcx
xorl %edi, %edi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x2420
movl %eax, 0x9cc(%rbx)
testl %eax, %eax
je 0x2736a
movl %eax, %edi
xorl %esi, %esi
callq 0x21a0
movb $0x1, %bl
jmp 0x273aa
movq 0x27c5f(%rip), %rax     # 0x4efd0
movq (%rax), %r14
callq 0x24a0
movq %rax, (%rsp)
leaq 0x991b(%rip), %rdi      # 0x30c9f
leaq 0xa7ff(%rip), %rdx      # 0x31b8a
leaq 0x9855(%rip), %r8       # 0x30be7
leaq 0x9f12(%rip), %r9       # 0x312ab
xorl %ebx, %ebx
movq %r14, %rsi
movl $0x147, %ecx            # imm = 0x147
xorl %eax, %eax
callq 0x718c
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/FredTheDino[P]Fog/src/engine/unix_main.cpp
// Function: Fog::register_debug_keybinds()
void register_debug_keybinds() {
    using namespace Input;

    QUIT = request_name();
    TWEAK_SMOOTH = request_name();
    TWEAK_STEP = request_name();
    DEBUG_PERF = request_name();
    DEBUG_VIEW = request_name();
    DEBUG_VALUES = request_name();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x1, %edi
callq 0xbce7
leaq 0x3d4cf(%rip), %rcx     # 0x64968
movl %eax, (%rcx)
movl $0x1, %edi
callq 0xbce7
leaq 0x3d4c0(%rip), %rcx     # 0x6496c
movl %eax, (%rcx)
movl $0x1, %edi
callq 0xbce7
leaq 0x3d4b1(%rip), %rcx     # 0x64970
movl %eax, (%rcx)
movl $0x1, %edi
callq 0xbce7
leaq 0x3d4a2(%rip), %rcx     # 0x64974
movl %eax, (%rcx)
movl $0x1, %edi
callq 0xbce7
leaq 0x3d493(%rip), %rcx     # 0x64978
movl %eax, (%rcx)
movl $0x1, %edi
callq 0xbce7
leaq 0x3d484(%rip), %rcx     # 0x6497c
movl %eax, (%rcx)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/FredTheDino[P]Fog/src/engine/unix_main.cpp
// Function: Fog::update()
void update() {
    Logic::frame(SDL_GetTicks() / 1000.0f);

    if (show_perf)
        Perf::report();
    Util::clear_tweak_values();
    Perf::clear();
    START_PERF(MAIN);
    START_PERF(INPUT);
    Input::clear_input_for_frame();
    STOP_PERF(INPUT);
    SDL::poll_events();

    Logic::call(Logic::At::PRE_UPDATE);
    Logic::call(Logic::At::POST_UPDATE);

    Mixer::audio_struct.position = Renderer::fetch_camera()->position;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
callq 0x24f0
movl %eax, %eax
cvtsi2ss %rax, %xmm0
divss 0x88ca(%rip), %xmm0     # 0x30020
leaq 0x291b3(%rip), %rbx     # 0x50910
movss 0x14028(%rbx), %xmm1
movaps %xmm0, %xmm2
subss %xmm1, %xmm2
xorps %xmm3, %xmm3
cmpneqss %xmm1, %xmm3
andps %xmm2, %xmm3
movss %xmm3, 0x1402c(%rbx)
movss %xmm0, 0x14028(%rbx)
cmpb $0x0, 0x43b6b(%rip)     # 0x6b2f9
je 0x27795
callq 0x23806
callq 0x23b9d
callq 0x236a8
leaq 0xa765(%rip), %rsi      # 0x31f0b
xorl %edi, %edi
callq 0x21db9
leaq 0xa75c(%rip), %rsi      # 0x31f10
movl $0x1, %edi
callq 0x21db9
callq 0xaff5
movl $0x1, %edi
callq 0x21e89
callq 0x27826
movss 0x14028(%rbx), %xmm0
movss 0x1402c(%rbx), %xmm1
leaq 0x8(%rbx), %rdi
callq 0x2415c
movss 0x14028(%rbx), %xmm0
movss 0x1402c(%rbx), %xmm1
addq $0x5010, %rbx           # imm = 0x5010
movq %rbx, %rdi
callq 0x2415c
movq 0x43a2f(%rip), %rax     # 0x6b240
leaq 0x27b60(%rip), %rcx     # 0x4f378
movq %rax, 0x9bc(%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/FredTheDino[P]Fog/src/engine/unix_main.cpp
// Function: Fog::draw()
void draw() {
    START_PERF(RENDER);
    Renderer::clear();

    Logic::call(Logic::At::PRE_DRAW);
    // User defined
    Logic::call(Logic::At::POST_DRAW);

    Renderer::blit();
    STOP_PERF(RENDER);

    STOP_PERF(MAIN);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0xa17f(%rip), %rsi      # 0x31f16
movl $0x2, %edi
callq 0x21db9
leaq 0x3cd70(%rip), %rax     # 0x64b18
movl $0x4100, %edi           # imm = 0x4100
callq *(%rax)
leaq 0x28b5a(%rip), %rbx     # 0x50910
movss 0x14028(%rbx), %xmm0
movss 0x1402c(%rbx), %xmm1
leaq 0xa018(%rbx), %rdi
callq 0x2415c
movss 0x14028(%rbx), %xmm0
movss 0x1402c(%rbx), %xmm1
addq $0xf020, %rbx           # imm = 0xF020
movq %rbx, %rdi
callq 0x2415c
callq 0x211b2
movl $0x2, %edi
callq 0x21e89
xorl %edi, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x21e89
// File: /workspace/github_c_makefile_star2_O3/FredTheDino[P]Fog/src/engine/unix_main.cpp
// Function: Fog::post_init()
void post_init() {
#ifdef DEBUG
    setup_debug_keybinds();
#endif
    Util::strict_allocation_check();
    Logic::frame(SDL_GetTicks() / 1000.0f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x274fc
movl $0x1, 0x27418(%rip)     # 0x4f374
callq 0x24f0
movl %eax, %eax
cvtsi2ss %rax, %xmm0
divss 0x80b0(%rip), %xmm0     # 0x30020
leaq 0x28999(%rip), %rax     # 0x50910
movss 0x14028(%rax), %xmm1
movaps %xmm0, %xmm2
subss %xmm1, %xmm2
xorps %xmm3, %xmm3
cmpneqss %xmm1, %xmm3
andps %xmm2, %xmm3
movss %xmm3, 0x1402c(%rax)
movss %xmm0, 0x14028(%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/FredTheDino[P]Fog/src/engine/unix_main.cpp
// Function: Fog::run(void (*)(), void (*)())
void run(FogCallback user_update, FogCallback user_draw) {
    post_init();
    while (SDL::running) {
        Logic::frame(SDL_GetTicks() / 1000.0f);

        if (show_perf)
            Perf::report();
        Util::clear_tweak_values();
        Perf::clear();
        START_PERF(MAIN);
        START_PERF(INPUT);
        Input::clear_input_for_frame();
        STOP_PERF(INPUT);
        SDL::poll_events();

#if DEBUG
        if (value(QUIT, Input::ANY))
            SDL::running = false;
#endif

        Logic::call(Logic::At::PRE_UPDATE);
        // User defined
        user_update();
        Logic::call(Logic::At::POST_UPDATE);

        Mixer::audio_struct.position = Renderer::fetch_camera()->position;

        Renderer::clear();
        START_PERF(RENDER);

        Logic::call(Logic::At::PRE_DRAW);
        // User defined
        user_draw();
        Logic::call(Logic::At::POST_DRAW);

        STOP_PERF(RENDER);
        Renderer::blit();

        STOP_PERF(MAIN);
    }

    _fog_close_app_responsibly();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, -0x30(%rbp)
callq 0x27f49
cmpb $0x0, 0x43330(%rip)     # 0x6b2f8
jne 0x28168
leaq 0x2893b(%rip), %r14     # 0x50910
leaq 0x8(%r14), %r13
leaq 0x5010(%r14), %r15
leaq 0xa018(%r14), %r12
leaq 0xf020(%r14), %rbx
callq 0x24f0
movl %eax, %eax
xorps %xmm0, %xmm0
cvtsi2ss %rax, %xmm0
divss 0x801b(%rip), %xmm0     # 0x30020
movss 0x14028(%r14), %xmm1
movaps %xmm0, %xmm2
subss %xmm1, %xmm2
cmpneqss 0x821a(%rip), %xmm1     # 0x30238
andps %xmm2, %xmm1
movss %xmm1, 0x1402c(%r14)
movss %xmm0, 0x14028(%r14)
cmpb $0x0, 0x432bf(%rip)     # 0x6b2f9
je 0x28041
callq 0x23806
callq 0x23b9d
callq 0x236a8
xorl %edi, %edi
leaq 0x9eb7(%rip), %rsi      # 0x31f0b
callq 0x21db9
movl $0x1, %edi
leaq 0x9eab(%rip), %rsi      # 0x31f10
callq 0x21db9
callq 0xaff5
movl $0x1, %edi
callq 0x21e89
callq 0x27826
leaq 0x3c8e3(%rip), %rax     # 0x64968
movl (%rax), %edi
movl $0xf, %esi
callq 0xb85b
ucomiss 0x81a0(%rip), %xmm0     # 0x30238
jne 0x2809c
jnp 0x280a3
movb $0x1, 0x43255(%rip)     # 0x6b2f8
movss 0x14028(%r14), %xmm0
movss 0x1402c(%r14), %xmm1
movq %r13, %rdi
callq 0x2415c
callq *-0x30(%rbp)
movss 0x14028(%r14), %xmm0
movss 0x1402c(%r14), %xmm1
movq %r15, %rdi
callq 0x2415c
movq 0x4315f(%rip), %rax     # 0x6b240
leaq 0x27290(%rip), %rcx     # 0x4f378
movq %rax, 0x9bc(%rcx)
movl $0x4100, %edi           # imm = 0x4100
leaq 0x3ca1d(%rip), %rax     # 0x64b18
callq *(%rax)
movl $0x2, %edi
leaq 0x9e0d(%rip), %rsi      # 0x31f16
callq 0x21db9
movss 0x14028(%r14), %xmm0
movss 0x1402c(%r14), %xmm1
movq %r12, %rdi
callq 0x2415c
callq *-0x38(%rbp)
movss 0x14028(%r14), %xmm0
movss 0x1402c(%r14), %xmm1
movq %rbx, %rdi
callq 0x2415c
movl $0x2, %edi
callq 0x21e89
callq 0x211b2
xorl %edi, %edi
callq 0x21e89
cmpb $0x1, 0x43196(%rip)     # 0x6b2f8
jne 0x27fee
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7243
// File: /workspace/github_c_makefile_star2_O3/FredTheDino[P]Fog/src/engine/util/printf.c
// Function: out_rev(void (*)(char, void*, unsigned long, unsigned long), char*, unsigned long, unsigned long, char const*, unsigned long, unsigned int, unsigned int)
static size_t _out_rev(out_fct_type out, char* buffer, size_t idx, size_t maxlen, const char* buf, size_t len, unsigned int width, unsigned int flags)
{
  const size_t start_idx = idx;

  // pad spaces up to given width
  if (!(flags & FLAGS_LEFT) && !(flags & FLAGS_ZEROPAD)) {
    for (size_t i = len; i < width; i++) {
      out(' ', buffer, idx++, maxlen);
    }
  }

  // reverse string
  while (len) {
    out(buf[--len], buffer, idx++, maxlen);
  }

  // append pad spaces up to given width
  if (flags & FLAGS_LEFT) {
    while (idx - start_idx < width) {
      out(' ', buffer, idx++, maxlen);
    }
  }

  return idx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r13
movq %r8, -0x48(%rbp)
movq %rcx, -0x40(%rbp)
movq %rdx, %r14
movq %rsi, -0x38(%rbp)
movq %rdi, %r15
movl 0x18(%rbp), %eax
movq %rdx, -0x30(%rbp)
testb $0x3, %al
jne 0x2d37e
movl 0x10(%rbp), %ebx
movq -0x30(%rbp), %r14
subq %r13, %rbx
jbe 0x2d37e
movq -0x30(%rbp), %rdx
leaq 0x1(%rdx), %r14
movl $0x20, %edi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rcx
callq *%r15
movq %r14, %rdx
decq %rbx
jne 0x2d362
testq %r13, %r13
je 0x2d3a9
movq -0x48(%rbp), %r12
movsbl -0x1(%r12,%r13), %edi
leaq 0x1(%r14), %rbx
movq -0x38(%rbp), %rsi
movq %r14, %rdx
movq -0x40(%rbp), %rcx
callq *%r15
movq %rbx, %r14
decq %r13
jne 0x2d387
jmp 0x2d3ac
movq %r14, %rbx
movl 0x18(%rbp), %eax
testb $0x2, %al
je 0x2d3f1
movl 0x10(%rbp), %r12d
movq %rbx, %rax
movq -0x30(%rbp), %r13
subq %r13, %rax
cmpq %r12, %rax
jae 0x2d3f1
negq %r13
leaq 0x1(%rbx), %r14
movl $0x20, %edi
movq -0x38(%rbp), %rsi
movq %rbx, %rdx
movq -0x40(%rbp), %rcx
callq *%r15
leaq (%rbx,%r13), %rax
incq %rax
movq %r14, %rbx
cmpq %r12, %rax
jb 0x2d3c9
jmp 0x2d3f4
movq %rbx, %r14
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/FredTheDino[P]Fog/inc/glad/glad.c
// Function: has_ext(char const*)
static int has_ext(const char *ext) {
#ifdef _GLAD_IS_SOME_NEW_VERSION
    if(max_loaded_major < 3) {
#endif
        const char *extensions;
        const char *loc;
        const char *terminator;
        extensions = exts;
        if(extensions == NULL || ext == NULL) {
            return 0;
        }

        while(1) {
            loc = strstr(extensions, ext);
            if(loc == NULL) {
                return 0;
            }

            terminator = loc + strlen(ext);
            if((loc == extensions || *(loc - 1) == ' ') &&
                (*terminator == ' ' || *terminator == '\0')) {
                return 1;
            }
            extensions = terminator;
        }
#ifdef _GLAD_IS_SOME_NEW_VERSION
    } else {
        int index;
        if(exts_i == NULL) return 0;
        for(index = 0; index < num_exts_i; index++) {
            const char *e = exts_i[index];

            if(exts_i[index] != NULL && strcmp(e, ext) == 0) {
                return 1;
            }
        }
    }
#endif

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x2, 0x3def2(%rip)     # 0x6b310
jg 0x2d490
movq 0x3def1(%rip), %r15     # 0x6b318
testq %r15, %r15
sete %al
testq %rbx, %rbx
sete %cl
xorl %r14d, %r14d
orb %al, %cl
jne 0x2d4d6
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2290
testq %rax, %rax
je 0x2d4d6
movq %rax, %r13
movq %rbx, %rdi
callq 0x2250
movq %rax, %r12
movq %r15, %rax
leaq (%r12,%r13), %r15
cmpq %rax, %r13
je 0x2d473
cmpb $0x20, -0x1(%r13)
jne 0x2d47b
movzbl (%r15), %eax
testb $-0x21, %al
je 0x2d4d0
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2290
movq %rax, %r13
testq %rax, %rax
jne 0x2d460
jmp 0x2d4d6
movq 0x3de91(%rip), %r15     # 0x6b328
xorl %r14d, %r14d
testq %r15, %r15
je 0x2d4d6
movslq 0x3de7a(%rip), %r12     # 0x6b320
testq %r12, %r12
jle 0x2d4d6
xorl %r14d, %r14d
movq (%r15,%r14,8), %rdi
testq %rdi, %rdi
je 0x2d4c3
movq %rbx, %rsi
callq 0x23d0
testl %eax, %eax
je 0x2d4d0
incq %r14
cmpq %r14, %r12
jne 0x2d4ae
xorl %r14d, %r14d
jmp 0x2d4d6
movl $0x1, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/FredTheDino[P]Fog/src/engine/util/memory.cpp
// Function: Input::Mapping::VirtualButton* Util::MemoryArena::push<Input::Mapping::VirtualButton>(unsigned long long)
T *MemoryArena::push(u64 count) {
    CHECK_ILLEGAL_ALLOC;
    u64 allocation_size = sizeof(T) * count;
    ASSERT(allocation_size <= ARENA_SIZE_IN_BYTES, "Too large allocation");
    if (watermark + allocation_size > ARENA_SIZE_IN_BYTES) {
        if (!next) {
            if (only_one) HALT_AND_CATCH_FIRE;
            // Only complain once.
            allow_allocation();
            next = request_arena();
        }
        return next->push<T>(count);
    }
    void *region = (void *) (((u8 *) memory) + watermark);
    watermark += allocation_size;
    return (T *) region;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %rax
shlq $0x4, %rbx
xorl %r14d, %r14d
cmpq $0x200001, %rbx         # imm = 0x200001
setb %r14b
leaq 0x36b0(%rip), %r15      # 0x30ccf
leaq 0x181ce(%rip), %r12     # 0x457f4
movq %rax, %r13
movl 0x21d45(%rip), %eax     # 0x4f374
cmpl $0x2, %eax
je 0x2d682
cmpl $0x1, %eax
jne 0x2d678
movl 0x37381(%rip), %eax     # 0x649c0
incl %eax
movl %eax, 0x37379(%rip)     # 0x649c0
movq 0x21982(%rip), %rcx     # 0x4efd0
movq (%rcx), %rsi
movl %eax, (%rsp)
leaq 0x3644(%rip), %rdi      # 0x30c9f
movq %r15, %rdx
movl $0x2a, %ecx
leaq 0x3680(%rip), %r8       # 0x30cea
leaq 0x3691(%rip), %r9       # 0x30d02
xorl %eax, %eax
callq 0x718c
movl $0x1, 0x21cf2(%rip)     # 0x4f374
movq %r15, %rdi
movl $0x7c, %esi
movq %r12, %rdx
movl %r14d, %ecx
callq 0x729c
movq 0x8(%r13), %rax
leaq (%rax,%rbx), %rcx
cmpq $0x200001, %rcx         # imm = 0x200001
jb 0x2d6dd
movq 0x10(%r13), %rax
testq %rax, %rax
jne 0x2d626
cmpb $0x0, (%r13)
jne 0x2d6f4
cmpl $0x1, 0x21cb3(%rip)     # 0x4f374
jne 0x2d6cd
movl $0x0, 0x21ca7(%rip)     # 0x4f374
xorl %edi, %edi
callq 0xacd1
movq %rax, 0x10(%r13)
jmp 0x2d626
addq 0x18(%r13), %rax
movq %rcx, 0x8(%r13)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x7243
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2330
nop
// File: /workspace/github_c_makefile_star2_O3/FredTheDino[P]Fog/src/engine/renderer/opengl_renderer.cpp
// Function: Renderer::Impl::RenderQueue<Renderer::Impl::Vertex>::create(unsigned int)
void RenderQueue<T>::create(u32 triangles_per_buffer) {
    ASSERT(gl_draw_hint == 0,
           "Cannot create same RenderQueue twice without deleting.");
    buffer_size = triangles_per_buffer * 3;
    arena = Util::request_arena(true);
    vertex_buffers = arena->push<GLBuffer>(num_buffers);

    gl_draw_hint = GL_TRIANGLES;

    next_free = 0;
    num_buffers = 0;
    expand();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
xorl %ecx, %ecx
cmpl $0x0, 0x4(%rdi)
sete %cl
leaq 0x3842(%rip), %rdi      # 0x31075
leaq 0x17ff7(%rip), %rdx     # 0x45831
movl $0x5e, %esi
callq 0x729c
leal (%r14,%r14,2), %eax
movl %eax, (%rbx)
movl $0x1, %edi
callq 0xacd1
movq %rax, 0x18(%rbx)
movl 0xc(%rbx), %esi
movq %rax, %rdi
callq 0x2edf6
movq %rax, 0x10(%rbx)
movq $0x4, 0x4(%rbx)
movl $0x0, 0xc(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2ef0a
// File: /workspace/github_c_makefile_star2_O3/FredTheDino[P]Fog/src/engine/renderer/opengl_renderer.cpp
// Function: Renderer::Impl::RenderQueue<Renderer::Impl::Vertex>::push(unsigned int, Renderer::Impl::Vertex*)
void RenderQueue<T>::push(u32 num_new_verticies, T *new_verticies) {
    ASSERT(gl_draw_hint, "Trying to use uninitalized render queue.");
    ASSERT(gl_draw_hint == GL_TRIANGLES, "Push code assumes triangles.");

    while (num_new_verticies) {
        for (u32 i = next_free; num_new_verticies; i++) {
            next_free = i;
            if (next_free == num_buffers) expand();
            GLBuffer *buffer = vertex_buffers + next_free;
            u32 free = buffer_size - buffer->draw_length;
            if (free == 0) continue;
            u32 to_push = MIN(num_new_verticies, (u32) free);

            buffer->bind();
            glBufferSubData(GL_ARRAY_BUFFER,
                            buffer->draw_length * sizeof(T),
                            to_push * sizeof(T), new_verticies);

            buffer->draw_length += to_push;
            num_new_verticies -= to_push;
            new_verticies += to_push;
        }
    }
    glBindVertexArray(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, -0x38(%rbp)
movl %esi, %r14d
movq %rdi, %r15
xorl %ecx, %ecx
cmpl $0x0, 0x4(%rdi)
setne %cl
leaq 0x375c(%rip), %r12      # 0x31075
leaq 0x17f91(%rip), %rdx     # 0x458b1
movq %r12, %rdi
movl $0x6c, %esi
callq 0x729c
xorl %ecx, %ecx
cmpl $0x4, 0x4(%r15)
sete %cl
leaq 0x17faa(%rip), %rdx     # 0x458e8
movq %r12, %rdi
movl $0x6d, %esi
callq 0x729c
testl %r14d, %r14d
je 0x2da05
movl 0x8(%r15), %r13d
movq %r15, -0x40(%rbp)
movl %r13d, 0x8(%r15)
movl %r13d, %ecx
cmpl 0xc(%r15), %r13d
jne 0x2d975
movq %r15, %rdi
callq 0x2ef0a
movl 0x8(%r15), %ecx
movq 0x10(%r15), %rax
movl %ecx, %ecx
leaq (%rcx,%rcx,2), %rcx
movl (%r15), %ebx
subl (%rax,%rcx,4), %ebx
je 0x2d9f9
movl %r14d, -0x2c(%rbp)
leaq (%rax,%rcx,4), %r14
cmpl %ebx, -0x2c(%rbp)
cmovbl -0x2c(%rbp), %ebx
movl 0x8(%r14), %edi
leaq 0x37107(%rip), %rax     # 0x64aa8
callq *(%rax)
movl 0x4(%r14), %esi
movl $0x8892, %edi           # imm = 0x8892
leaq 0x370bd(%rip), %rax     # 0x64a70
callq *(%rax)
movl (%r14), %eax
shlq $0x2, %rax
leaq (%rax,%rax,8), %rsi
leaq (,%rbx,4), %rax
leaq (%rax,%rax,8), %r12
movl $0x8892, %edi           # imm = 0x8892
movq %r12, %rdx
movq -0x38(%rbp), %r15
movq %r15, %rcx
leaq 0x3710e(%rip), %rax     # 0x64af0
callq *(%rax)
addl %ebx, (%r14)
movl -0x2c(%rbp), %r14d
subl %ebx, %r14d
addq %r12, %r15
movq %r15, -0x38(%rbp)
movq -0x40(%rbp), %r15
incl %r13d
testl %r14d, %r14d
jne 0x2d95c
leaq 0x3709c(%rip), %rax     # 0x64aa8
xorl %edi, %edi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *(%rax)
// File: /workspace/github_c_makefile_star2_O3/FredTheDino[P]Fog/src/engine/renderer/opengl_renderer.cpp
// Function: Renderer::Impl::RenderQueue<Renderer::Impl::Vertex>::draw() const
void RenderQueue<T>::draw() const {
    ASSERT(gl_draw_hint, "Trying to use uninitalized render queue");
    for (u32 i = 0; i < num_buffers; i++) {
        GLBuffer buffer = vertex_buffers[i];
        if (buffer.draw_length == 0) break;
        buffer.bind();
        glBindBuffer(GL_ARRAY_BUFFER, buffer.gl_buffer);
        glDrawArrays(gl_draw_hint, 0, buffer.draw_length);
    }
    glBindVertexArray(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %ecx, %ecx
cmpl $0x0, 0x4(%rdi)
setne %cl
leaq 0x3506(%rip), %rdi      # 0x31075
leaq 0x17d05(%rip), %rdx     # 0x4587b
movl $0xcf, %esi
callq 0x729c
cmpl $0x0, 0xc(%rbx)
je 0x2dbf1
movl $0x8, %r12d
xorl %r13d, %r13d
movq 0x10(%rbx), %rax
movl -0x8(%rax,%r12), %r14d
testl %r14d, %r14d
je 0x2dbf1
movl -0x4(%rax,%r12), %r15d
movl (%rax,%r12), %edi
leaq 0x36efb(%rip), %rax     # 0x64aa8
callq *(%rax)
movl $0x8892, %edi           # imm = 0x8892
movl %r15d, %esi
leaq 0x36eb2(%rip), %rax     # 0x64a70
callq *(%rax)
movl $0x8892, %edi           # imm = 0x8892
movl %r15d, %esi
leaq 0x36ea1(%rip), %rax     # 0x64a70
callq *(%rax)
movl 0x4(%rbx), %edi
xorl %esi, %esi
movl %r14d, %edx
leaq 0x371d8(%rip), %rax     # 0x64db8
callq *(%rax)
incq %r13
movl 0xc(%rbx), %eax
addq $0xc, %r12
cmpq %rax, %r13
jb 0x2db8f
leaq 0x36eb0(%rip), %rax     # 0x64aa8
xorl %edi, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *(%rax)
// File: /workspace/github_c_makefile_star2_O3/FredTheDino[P]Fog/src/engine/asset/asset.h
// Function: Asset::Font::find_kerning(char, char)
f32 find_kerning(char a, char b) {
        u16 key = (a << 8) | b;
        s64 low = 0;
        s64 high = num_kernings;
        s64 last_guess = -1;
        while (low <= high) {
            s64 cur = (low + high) / 2;
            if (cur < 0 || num_kernings < cur || cur == last_guess)
                break;
            last_guess = cur;
            u16 cur_key = kernings[cur].key;
            if (cur_key > key)
                high = cur + 1;
            else if (cur_key < key)
                low = cur + 1;
            else
                return kernings[cur].ammount;
        }
        return 0;
    }

// Assembly:
movq 0x18(%rdi), %rax
xorps %xmm0, %xmm0
testq %rax, %rax
js 0x2dd2e
pushq %rbp
movq %rsp, %rbp
movsbl %dl, %edx
movzbl %sil, %esi
shll $0x8, %esi
movq 0x28(%rdi), %rcx
movzwl %dx, %edx
orl %esi, %edx
movq $-0x1, %r9
xorl %esi, %esi
movq %rax, %rdi
leaq (%rsi,%rdi), %r8
shrq %r8
cmpq %r8, %rax
jb 0x2dd2d
cmpq %r9, %r8
je 0x2dd2d
movzwl (%rcx,%r8,8), %r9d
cmpl %r9d, %edx
jae 0x2dd16
leaq 0x1(%r8), %rdi
jmp 0x2dd1c
jbe 0x2dd26
leaq 0x1(%r8), %rsi
movq %r8, %r9
cmpq %rdi, %rsi
jle 0x2dcf5
jmp 0x2dd2d
movss 0x4(%rcx,%r8,8), %xmm0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/FredTheDino[P]Fog/src/engine/asset/asset.cpp
// Function: unsigned long Asset::read_from_file<Asset::FileHeader>(_IO_FILE*, void*, unsigned long)
size_t read_from_file(FILE *stream, void *ptr, size_t num = 1) {
    if (!num) {
        ERR("Has to read something from file, invalid read");
        return 0;
    }
    size_t read = 0;
    do {
        size_t last_read = fread(ptr, sizeof(T), num - read, stream);
        ASSERT(last_read, "Failed to read anything from asset file.");
        read += last_read;
        ptr = (void *) ((u8 *) ptr + last_read * sizeof(T));
    } while (read < num);
    return read;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x2deaf
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %ebx, %ebx
movq %r14, %rdx
subq %rbx, %rdx
movl $0x20, %esi
movq %r15, %rdi
movq %r12, %rcx
callq 0x22c0
movq %rax, %r13
xorl %ecx, %ecx
testq %rax, %rax
setne %cl
leaq 0x3749(%rip), %rdi      # 0x315d6
movl $0x4d, %esi
leaq 0x17ac1(%rip), %rdx     # 0x4595a
callq 0x729c
addq %r13, %rbx
shlq $0x5, %r13
addq %r13, %r15
cmpq %r14, %rbx
jb 0x2de65
jmp 0x2dee3
movq 0x2111a(%rip), %rax     # 0x4efd0
movq (%rax), %rsi
leaq 0x2ddf(%rip), %rdi      # 0x30c9f
leaq 0x370f(%rip), %rdx      # 0x315d6
leaq 0x17a4f(%rip), %r8      # 0x4591d
leaq 0x17a57(%rip), %r9      # 0x4592c
xorl %ebx, %ebx
movl $0x47, %ecx
xorl %eax, %eax
callq 0x718c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/FredTheDino[P]Fog/src/engine/logic/logic.h
// Function: Logic::Timer::call(float, float)
void call(f32 time, f32 delta) {
        if (next <= time && next != -1) {
            if (end == FOREVER) {
                callback(delta, time, 0, aux);
            } else if (end == ONCE) {
                callback(delta, time, 1, aux);
            } else {
                f32 percent = CLAMP(0, 1, (time - start) / (end - start));
                callback(delta, time, percent, aux);
            }
            next += spacing;
        }
    }

// Assembly:
movaps %xmm0, %xmm3
movss 0x8(%rdi), %xmm0
ucomiss %xmm0, %xmm3
jb 0x2ebfc
ucomiss 0x16a8(%rip), %xmm0     # 0x30228
jne 0x2eb84
jnp 0x2ebfc
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movss 0xc(%rdi), %xmm0
xorps %xmm2, %xmm2
ucomiss 0x168c(%rip), %xmm0     # 0x30228
jne 0x2eba0
jnp 0x2ebda
ucomiss %xmm2, %xmm0
jne 0x2ebb1
jp 0x2ebb1
movss 0x1455(%rip), %xmm2     # 0x30004
jmp 0x2ebda
movss 0x4(%rbx), %xmm5
movaps %xmm3, %xmm4
subss %xmm5, %xmm4
subss %xmm5, %xmm0
divss %xmm0, %xmm4
ucomiss %xmm4, %xmm2
ja 0x2ebda
movss 0x1432(%rip), %xmm2     # 0x30004
ucomiss %xmm2, %xmm4
ja 0x2ebda
movaps %xmm4, %xmm2
movq 0x20(%rbx), %rdi
movaps %xmm1, %xmm0
movaps %xmm3, %xmm1
callq *0x18(%rbx)
movss 0x10(%rbx), %xmm0
addss 0x8(%rbx), %xmm0
movss %xmm0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/FredTheDino[P]Fog/src/engine/util/block_list.h
// Function: Util::List<Vec2>::append(Vec2)
void append(T element)
    {
        ASSERT(initalized, "Trying to use uninitalized list");
        length++;
        if (length >= capacity)
            resize(capacity * 2);

        data[length - 1] = element;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movaps %xmm0, -0x20(%rbp)
movq %rdi, %rbx
xorl %ecx, %ecx
cmpb $0x0, 0x10(%rdi)
setne %cl
leaq 0x16d70(%rip), %rdi     # 0x4598e
leaq 0x16d86(%rip), %rdx     # 0x459ab
movl $0x38, %esi
callq 0x729c
movl (%rbx), %esi
movl 0x4(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x4(%rbx)
cmpl %esi, %ecx
jb 0x2ec4d
addl %esi, %esi
movq %rbx, %rdi
callq 0x2f3da
movl 0x4(%rbx), %eax
decl %eax
movq 0x8(%rbx), %rcx
movl %eax, %eax
movaps -0x20(%rbp), %xmm0
movlps %xmm0, (%rcx,%rax,8)
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/FredTheDino[P]Fog/src/engine/renderer/opengl_renderer.cpp
// Function: Renderer::Impl::RenderQueue<Renderer::Impl::Vertex>::expand()
void RenderQueue<T>::expand() {
    ASSERT(gl_draw_hint, "Trying to use uninitalized render queue");
    arena->clear();
    u32 to_copy = num_buffers;
    num_buffers += GROW_BY;
    GLBuffer *new_buffers = arena->push<GLBuffer>(num_buffers);
    if (new_buffers != vertex_buffers) {
        for (u32 i = 0; i < to_copy; i++) {
            new_buffers[i] = vertex_buffers[i];
        }
        vertex_buffers = new_buffers;
    }

    u32 vaos[GROW_BY];
    glGenVertexArrays(GROW_BY, vaos);
    u32 buffers[GROW_BY];
    glGenBuffers(GROW_BY, buffers);
    for (u32 i = 0; i < GROW_BY; i++) {
        vertex_buffers[to_copy + i] = {0, buffers[i], vaos[i]};
        vertex_buffers[to_copy + i].bind();
        glBufferData(GL_ARRAY_BUFFER, buffer_size * sizeof(T), NULL,
                     GL_STREAM_DRAW);
        enable_attrib_pointer();
    }
    glBindVertexArray(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorl %ecx, %ecx
cmpl $0x0, 0x4(%rdi)
setne %cl
leaq 0x2147(%rip), %rdi      # 0x31075
leaq 0x16946(%rip), %rdx     # 0x4587b
movl $0x88, %esi
callq 0x729c
movq 0x18(%rbx), %r14
movq 0x10(%r14), %rdi
movq %r14, %rax
testq %rdi, %rdi
je 0x2ef69
movq 0x10(%rdi), %rax
movq %rax, 0x10(%r14)
callq 0xae55
movq 0x10(%r14), %rdi
testq %rdi, %rdi
jne 0x2ef4f
movq 0x18(%rbx), %rax
movq $0x0, 0x8(%r14)
movl 0xc(%rbx), %r14d
leal 0x3(%r14), %esi
movl %esi, 0xc(%rbx)
movq %rax, %rdi
callq 0x2edf6
cmpq 0x10(%rbx), %rax
je 0x2efbe
testq %r14, %r14
je 0x2efba
leaq (,%r14,4), %rcx
leaq (%rcx,%rcx,2), %rcx
xorl %edx, %edx
movq 0x10(%rbx), %rsi
movl 0x8(%rsi,%rdx), %edi
movl %edi, 0x8(%rax,%rdx)
movq (%rsi,%rdx), %rsi
movq %rsi, (%rax,%rdx)
addq $0xc, %rdx
cmpq %rdx, %rcx
jne 0x2ef9d
movq %rax, 0x10(%rbx)
leaq 0x35feb(%rip), %rax     # 0x64fb0
leaq -0x40(%rbp), %rsi
movl $0x3, %edi
callq *(%rax)
leaq 0x35fa9(%rip), %rax     # 0x64f80
leaq -0x34(%rbp), %rsi
movl $0x3, %edi
callq *(%rax)
xorl %r12d, %r12d
movl -0x34(%rbp,%r12,4), %eax
movl -0x40(%rbp,%r12,4), %edi
movq 0x10(%rbx), %r13
leal (%r14,%r12), %ecx
leaq (%rcx,%rcx,2), %r15
movl $0x0, (%r13,%r15,4)
movl %eax, 0x4(%r13,%r15,4)
movl %edi, 0x8(%r13,%r15,4)
leaq 0x35a93(%rip), %rax     # 0x64aa8
callq *(%rax)
movl 0x4(%r13,%r15,4), %esi
movl $0x8892, %edi           # imm = 0x8892
leaq 0x35a48(%rip), %rax     # 0x64a70
callq *(%rax)
movl (%rbx), %eax
shlq $0x2, %rax
leaq (%rax,%rax,8), %rsi
movl $0x8892, %edi           # imm = 0x8892
xorl %edx, %edx
movl $0x88e0, %ecx           # imm = 0x88E0
leaq 0x35aa1(%rip), %rax     # 0x64ae8
callq *(%rax)
callq 0x1fc0a
incq %r12
cmpq $0x3, %r12
jne 0x2efe5
xorl %edi, %edi
leaq 0x35a48(%rip), %rax     # 0x64aa8
callq *(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/FredTheDino[P]Fog/src/engine/util/block_list.h
// Function: Util::List<Vec2>::resize(unsigned int)
void resize(u32 new_size)
    {
        ASSERT(initalized, "Trying to use uninitalized list");
        // Only expand it. No need to free memory.
        if (capacity < new_size)
        {
            data = resize_memory<T>(data, sizeof(T) * new_size);
            capacity = new_size;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
xorl %ecx, %ecx
cmpb $0x0, 0x10(%rdi)
setne %cl
leaq 0x16598(%rip), %rdi     # 0x4598e
leaq 0x165ae(%rip), %rdx     # 0x459ab
movl $0x2d, %esi
callq 0x729c
cmpl %ebx, (%r14)
jae 0x2f423
movq 0x8(%r14), %rdi
leal (,%rbx,8), %esi
callq 0x2f428
movq %rax, 0x8(%r14)
movl %ebx, (%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/motet-a[P]libforks/examples/basic.c
// Function: main
int main() {
  libforks_ServerConn conn;
  assert(libforks_start(&conn) == libforks_OK);

  assert(libforks_fork(
    conn,
    NULL, // pid_ptr
    NULL, // socket_fd_ptr
    NULL, // exit_fd_ptr
    child_main
  ) == libforks_OK);

  // `libforks_stop` waits until the child process exits
  assert(libforks_stop(conn) == libforks_OK);

  puts("main process exited");

  return 0;
}

// Assembly:
pushq %rax
movq %rsp, %rdi
callq 0x179f
testl %eax, %eax
jne 0x1360
movq (%rsp), %rdi
leaq 0x89(%rip), %r8         # 0x13bd
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x212c
testl %eax, %eax
jne 0x137f
movq (%rsp), %rdi
callq 0x22e7
testl %eax, %eax
jne 0x139e
leaq 0x1d54(%rip), %rdi      # 0x30ab
callq 0x1070
xorl %eax, %eax
popq %rcx
retq
leaq 0x1c9d(%rip), %rdi      # 0x3004
leaq 0x1cbb(%rip), %rsi      # 0x3029
leaq 0x1cc5(%rip), %rcx      # 0x303a
movl $0x15, %edx
callq 0x10c0
leaq 0x1cbf(%rip), %rdi      # 0x3045
leaq 0x1c9c(%rip), %rsi      # 0x3029
leaq 0x1ca6(%rip), %rcx      # 0x303a
movl $0x1d, %edx
callq 0x10c0
leaq 0x1ce3(%rip), %rdi      # 0x3088
leaq 0x1c7d(%rip), %rsi      # 0x3029
leaq 0x1c87(%rip), %rcx      # 0x303a
movl $0x20, %edx
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O3/ammarfaizi2[P]riyuu/src/main.c
// Function: main
int main(int argc, char *argv[], char *envp[])
{
	uint8_t exit_code = 0;
	riyuu_run run;

	if (argc == 1) {
		show_help(argv[0]);
		goto out;
	}

	if (!argv_parser(argc, argv, envp, &run, &exit_code)) {
		goto out;
	}

	exit_code = riyuu_exec_run(&run);

out:
	exit(exit_code);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb $0x0, -0x1(%rbp)
cmpl $0x1, %edi
jne 0x2559
movq (%rsi), %rdi
callq 0x6fd4
xorl %eax, %eax
jmp 0x257b
leaq -0x18(%rbp), %rcx
leaq -0x1(%rbp), %r8
callq 0x7004
testb %al, %al
je 0x2578
leaq -0x18(%rbp), %rdi
callq 0x7134
movb %al, -0x1(%rbp)
jmp 0x257b
movb -0x1(%rbp), %al
movzbl %al, %edi
callq 0x21a0
nop
// File: /workspace/github_c_makefile_star2_O3/ammarfaizi2[P]riyuu/src/third_party/cjson/cJSON_Utils.c
// Function: cJSONUtils_strdup(unsigned char const*)
static unsigned char* cJSONUtils_strdup(const unsigned char* const string)
{
    size_t length = 0;
    unsigned char *copy = NULL;

    length = strlen((const char*)string) + sizeof("");
    copy = (unsigned char*) cJSON_malloc(length);
    if (copy == NULL)
    {
        return NULL;
    }
    memcpy(copy, string, length);

    return copy;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x2140
movq %rax, %r14
incq %r14
movq %r14, %rdi
callq 0x5094
testq %rax, %rax
je 0x59cd
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x2040
popq %rbx
popq %r14
popq %rbp
retq