LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/renderer/opengl_renderer.cpp
// Function: Renderer::Impl::RenderQueue<Renderer::Impl::Vertex>::enable_attrib_pointer()
void RenderQueue<Vertex>::enable_attrib_pointer() {
    glEnableVertexAttribArray(0);
    glEnableVertexAttribArray(1);
    glEnableVertexAttribArray(2);
    glEnableVertexAttribArray(3);

    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex),
                          (void *) offsetof(Vertex, position));
    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex),
                          (void *) offsetof(Vertex, texture));
    glVertexAttribPointer(2, 1, GL_FLOAT, GL_FALSE, sizeof(Vertex),
                          (void *) offsetof(Vertex, sprite));
    glVertexAttribPointer(3, 4, GL_FLOAT, GL_FALSE, sizeof(Vertex),
                          (void *) offsetof(Vertex, color));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
xorl %edi, %edi
leaq 0x53a23(%rip), %rax     # 0x7ee78
callq *(%rax)
movl $0x1, %edi
leaq 0x53a15(%rip), %rax     # 0x7ee78
callq *(%rax)
movl $0x2, %edi
leaq 0x53a07(%rip), %rax     # 0x7ee78
callq *(%rax)
movl $0x3, %edi
leaq 0x539f9(%rip), %rax     # 0x7ee78
callq *(%rax)
xorl %ecx, %ecx
movl $0x2, %esi
movl $0x1406, %edx           # imm = 0x1406
movl $0x24, %r8d
xorl %eax, %eax
movl %eax, %r9d
leaq 0x549e9(%rip), %rax     # 0x7fe88
movl %ecx, %edi
callq *(%rax)
movl $0x1, %edi
movl $0x2, %esi
movl $0x1406, %edx           # imm = 0x1406
xorl %ecx, %ecx
movl $0x24, %r8d
movl $0x8, %r9d
leaq 0x549c1(%rip), %rax     # 0x7fe88
callq *(%rax)
movl $0x2, %edi
movl $0x1, %esi
movl $0x1406, %edx           # imm = 0x1406
xorl %ecx, %ecx
movl $0x24, %r8d
movl $0x10, %r9d
leaq 0x5499b(%rip), %rax     # 0x7fe88
callq *(%rax)
movl $0x3, %edi
movl $0x4, %esi
movl $0x1406, %edx           # imm = 0x1406
xorl %ecx, %ecx
movl $0x24, %r8d
movl $0x14, %r9d
leaq 0x54975(%rip), %rax     # 0x7fe88
callq *(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/renderer/opengl_renderer.cpp
// Function: Renderer::Impl::resize_window(int, int)
void resize_window(int width, int height) {
    recalculate_global_aspect_ratio(width, height);
    glViewport(0, 0, width, height);

    for (u32 cam = 0; cam < OPENGL_NUM_CAMERAS; cam++) {
        GLuint rbo = screen_rbos[cam];
        GLuint texture = screen_textures[cam];
        glBindTexture(GL_TEXTURE_2D, texture);
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB,
                GL_UNSIGNED_BYTE, NULL);

        glBindRenderbuffer(GL_RENDERBUFFER, rbo);
        glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8,
                width, height);
    }
    glBindRenderbuffer(GL_RENDERBUFFER, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x2b7b0
leaq 0x547d8(%rip), %rax     # 0x7fe98
movq (%rax), %rax
movl -0x4(%rbp), %edx
movl -0x8(%rbp), %ecx
xorl %esi, %esi
movl %esi, %edi
callq *%rax
movl $0x0, -0xc(%rbp)
cmpl $0x2, -0xc(%rbp)
jae 0x2b793
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x59b50(%rip), %rax     # 0x8523c
movl (%rax,%rcx,4), %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x59b46(%rip), %rax     # 0x85244
movl (%rax,%rcx,4), %eax
movl %eax, -0x14(%rbp)
leaq 0x533d5(%rip), %rax     # 0x7eae0
movq (%rax), %rax
movl -0x14(%rbp), %esi
movl $0xde1, %edi            # imm = 0xDE1
callq *%rax
leaq 0x54339(%rip), %rax     # 0x7fa58
movq (%rax), %rax
movl -0x4(%rbp), %ecx
movl -0x8(%rbp), %r8d
movl $0xde1, %edi            # imm = 0xDE1
xorl %r9d, %r9d
movl $0x1907, %edx           # imm = 0x1907
xorl %esi, %esi
movl %r9d, %esi
movl $0x1907, (%rsp)         # imm = 0x1907
movl $0x1401, 0x8(%rsp)      # imm = 0x1401
movq $0x0, 0x10(%rsp)
callq *%rax
leaq 0x5337c(%rip), %rax     # 0x7ead8
movq (%rax), %rax
movl -0x10(%rbp), %esi
movl $0x8d41, %edi           # imm = 0x8D41
callq *%rax
leaq 0x54068(%rip), %rax     # 0x7f7d8
movq (%rax), %rax
movl -0x4(%rbp), %edx
movl -0x8(%rbp), %ecx
movl $0x8d41, %edi           # imm = 0x8D41
movl $0x88f0, %esi           # imm = 0x88F0
callq *%rax
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2b6d6
movl $0x8d41, %edi           # imm = 0x8D41
xorl %esi, %esi
leaq 0x53337(%rip), %rax     # 0x7ead8
callq *(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/renderer/camera.cpp
// Function: Renderer::recalculate_global_aspect_ratio(int, int)
void recalculate_global_aspect_ratio(int width, int height) {
    get_window()->width = width;
    get_window()->height = height;
    get_window()->aspect_ratio = (f32) height / (f32) width;

#if OPENGL_AUTO_APPLY_ASPECTRATIO_CHANGE
    for (u32 i = 0; i < OPENGL_NUM_CAMERAS; i++) {
        fetch_camera(i)->aspect_ratio = get_window()->aspect_ratio;
    }
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cvtsi2ssl -0x4(%rbp), %xmm0
movss %xmm0, -0x18(%rbp)
callq 0x2fc90
movss -0x18(%rbp), %xmm0
movss %xmm0, (%rax)
cvtsi2ssl -0x8(%rbp), %xmm0
movss %xmm0, -0x14(%rbp)
callq 0x2fc90
movss -0x14(%rbp), %xmm0
movss %xmm0, 0x4(%rax)
cvtsi2ssl -0x8(%rbp), %xmm0
cvtsi2ssl -0x4(%rbp), %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0x10(%rbp)
callq 0x2fc90
movss -0x10(%rbp), %xmm0
movss %xmm0, 0x8(%rax)
movl $0x0, -0xc(%rbp)
cmpl $0x2, -0xc(%rbp)
jae 0x2b84a
callq 0x2fc90
movss 0x8(%rax), %xmm0
movss %xmm0, -0x1c(%rbp)
movl -0xc(%rbp), %edi
callq 0xf980
movss -0x1c(%rbp), %xmm0
movss %xmm0, 0x14(%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2b818
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/renderer/opengl_renderer.cpp
// Function: Renderer::Impl::render_post_processing()
void render_post_processing() {
    post_process_shader_program.bind();

    // This needs to run every frame
    {
        for (u32 i = 0; i < OPENGL_NUM_CAMERAS; i++) {
            glBindTexture(GL_TEXTURE_2D, screen_textures[i]);
            glActiveTexture(GL_TEXTURE1 + i);
        }

        glUniform1iv(screen_texture_location, OPENGL_NUM_CAMERAS, &_fog_texture_indicies[0]);
        glUniform1i(num_screen_textures_location, _fog_num_active_cameras);
    }

    glBindVertexArray(screen_quad_vao);
    glDrawArrays(GL_TRIANGLES, 0, 6);
    glBindVertexArray(0);

    glBindTexture(GL_TEXTURE_2D, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x59395(%rip), %rdi     # 0x85004
callq 0x41a10
movl $0x0, -0x4(%rbp)
cmpl $0x2, -0x4(%rbp)
jae 0x2bcc1
leaq 0x52e58(%rip), %rax     # 0x7eae0
movq (%rax), %rax
movl -0x4(%rbp), %ecx
movl %ecx, %edx
leaq 0x595ad(%rip), %rcx     # 0x85244
movl (%rcx,%rdx,4), %esi
movl $0xde1, %edi            # imm = 0xDE1
callq *%rax
leaq 0x52db8(%rip), %rax     # 0x7ea60
movq (%rax), %rax
movl -0x4(%rbp), %edi
addl $0x84c1, %edi           # imm = 0x84C1
callq *%rax
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x2bc7b
leaq 0x53e28(%rip), %rax     # 0x7faf0
movq (%rax), %rax
leaq 0x59582(%rip), %rcx     # 0x85254
movl (%rcx), %edi
movl $0x2, %esi
leaq 0x59594(%rip), %rdx     # 0x85274
callq *%rax
leaq 0x53dff(%rip), %rax     # 0x7fae8
movq (%rax), %rax
leaq 0x59565(%rip), %rcx     # 0x85258
movl (%rcx), %edi
leaq 0x3ec50(%rip), %rcx     # 0x6a94c
movl (%rcx), %esi
callq *%rax
leaq 0x52de1(%rip), %rax     # 0x7eae8
movq (%rax), %rax
leaq 0x5953b(%rip), %rcx     # 0x8524c
movl (%rcx), %edi
callq *%rax
movl $0x4, %edi
xorl %esi, %esi
movl $0x6, %edx
leaq 0x530d0(%rip), %rax     # 0x7edf8
callq *(%rax)
xorl %edi, %edi
leaq 0x52db5(%rip), %rax     # 0x7eae8
callq *(%rax)
movl $0xde1, %edi            # imm = 0xDE1
xorl %esi, %esi
leaq 0x52d9d(%rip), %rax     # 0x7eae0
callq *(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/renderer/opengl_renderer.cpp
// Function: Renderer::Impl::push_triangle(unsigned int, Vec2, Vec2, Vec2, Vec2, Vec2, Vec2, Vec4, Vec4, Vec4, float)
void push_triangle(u32 layer, Vec2 p1, Vec2 p2, Vec2 p3,
                          Vec2 uv1, Vec2 uv2, Vec2 uv3,
                          Vec4 color1, Vec4 color2, Vec4 color3,
                          f32 sprite) {
    LAYER_CHECK(layer);
    Vertex verticies[] = {
        {p1, uv1, sprite, color1},
        {p2, uv2, sprite, color2},
        {p3, uv3, sprite, color3},
    };
    sprite_render_queues[layer].push(LEN(verticies), verticies);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movss 0x30(%rbp), %xmm8
leaq 0x20(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0xc0(%rbp)
movlpd %xmm0, -0x8(%rbp)
movlpd %xmm1, -0x10(%rbp)
movlpd %xmm2, -0x18(%rbp)
movlpd %xmm3, -0x20(%rbp)
movlpd %xmm4, -0x28(%rbp)
movlpd %xmm5, -0x30(%rbp)
movlpd %xmm6, -0x40(%rbp)
movlpd %xmm7, -0x38(%rbp)
movl %edi, -0x44(%rbp)
xorl %eax, %eax
xorl %ecx, %ecx
cmpl -0x44(%rbp), %ecx
movb %al, -0xb1(%rbp)
ja 0x2c7ae
cmpl $0x10, -0x44(%rbp)
setb %al
movb %al, -0xb1(%rbp)
movb -0xb1(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
leaq 0x1987d(%rip), %rdi     # 0x46045
movl $0x1cc, %esi            # imm = 0x1CC
leaq 0x198f3(%rip), %rdx     # 0x460c7
movzbl %al, %ecx
callq 0xb210
movq -0xc0(%rbp), %rcx
movq -0xc8(%rbp), %rax
movq -0x8(%rbp), %rdx
movq %rdx, -0xb0(%rbp)
movq -0x20(%rbp), %rdx
movq %rdx, -0xa8(%rbp)
movss 0x30(%rbp), %xmm0
movss %xmm0, -0xa0(%rbp)
movq -0x40(%rbp), %rdx
movq %rdx, -0x9c(%rbp)
movq -0x38(%rbp), %rdx
movq %rdx, -0x94(%rbp)
movq -0x10(%rbp), %rdx
movq %rdx, -0x8c(%rbp)
movq -0x28(%rbp), %rdx
movq %rdx, -0x84(%rbp)
movss 0x30(%rbp), %xmm0
movss %xmm0, -0x7c(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x78(%rbp)
movq 0x8(%rcx), %rcx
movq %rcx, -0x70(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, -0x68(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movss 0x30(%rbp), %xmm0
movss %xmm0, -0x58(%rbp)
movq (%rax), %rcx
movq %rcx, -0x54(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x4c(%rbp)
movl -0x44(%rbp), %eax
leaq 0x5878b(%rip), %rdi     # 0x85010
shlq $0x5, %rax
addq %rax, %rdi
leaq -0xb0(%rbp), %rdx
movl $0x3, %esi
callq 0x41b80
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/util/performance.cpp
// Function: Perf::_start_perf_clock(Perf::MarkerID, char const*)
void _start_perf_clock(MarkerID id, const char *name) {
    ASSERT(0 <= id && id < NUMBER_OF_MARKERS, "Invalid perf ID");
    volatile Clock *clock = clocks + id;
    clock->name = name;
    CHECK(!clock->active, "Starting allready started clock");
    clock->count++;
    if (!clock->active) {
        clock->active = true;
        clock->start = highp_now();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
xorl %ecx, %ecx
cmpl -0x4(%rbp), %ecx
movb %al, -0x19(%rbp)
jg 0x2e5b5
cmpl $0xa, -0x4(%rbp)
setl %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
leaq 0x180e2(%rip), %rdi     # 0x466ae
movl $0x15, %esi
leaq 0x18117(%rip), %rdx     # 0x466ef
movzbl %al, %ecx
callq 0xb210
movslq -0x4(%rbp), %rcx
leaq 0x3c085(%rip), %rax     # 0x6a670
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movb 0x8(%rax), %al
cmpb $0x0, %al
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
leaq 0x1808b(%rip), %rdi     # 0x466ae
movl $0x18, %esi
leaq 0x180f3(%rip), %rdx     # 0x46722
movzbl %al, %ecx
callq 0xb270
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movb 0x8(%rax), %al
cmpb $0x0, %al
jne 0x2e66a
movq -0x18(%rbp), %rax
movb $0x1, 0x8(%rax)
callq 0x30da0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/renderer/particle_system.cpp
// Function: Renderer::ParticleSystemInt::spawn(unsigned int)
void ParticleSystemInt::spawn(u32 num_particles) {
    ASSERT(particles, "Trying to use uninitalized/destroyed particle system");
    for (u32 i = 0; i < num_particles; i++) {
        if (head == tail) {
            if (!drop_oldest)
                return;
            head = (head + 1) % max_num_particles;
        }
        Particle new_particle = generate();
        particles[tail] = new_particle;
        tail = (tail + 1) % max_num_particles;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
cmpq $0x0, 0x118(%rax)
setne %al
andb $0x1, %al
leaq 0x17b32(%rip), %rdi     # 0x463e3
movl $0x76, %esi
leaq 0x17b4e(%rip), %rdx     # 0x4640b
movzbl %al, %ecx
callq 0xb210
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x2e99c
movq -0xa0(%rbp), %rcx
movl 0x108(%rcx), %eax
cmpl 0x10c(%rcx), %eax
jne 0x2e927
movq -0xa0(%rbp), %rax
cmpb $0x0, 0x12d(%rax)
jne 0x2e902
jmp 0x2e99c
movq -0xa0(%rbp), %rcx
movl 0x108(%rcx), %eax
addl $0x1, %eax
xorl %edx, %edx
divl 0x110(%rcx)
movq -0xa0(%rbp), %rax
movl %edx, 0x108(%rax)
movq -0xa0(%rbp), %rsi
leaq -0x98(%rbp), %rdi
callq 0x2f220
movq -0xa0(%rbp), %rax
movq 0x118(%rax), %rdi
movl 0x10c(%rax), %eax
imulq $0x88, %rax, %rax
addq %rax, %rdi
leaq -0x98(%rbp), %rsi
movl $0x88, %edx
callq 0x2090
movq -0xa0(%rbp), %rcx
movl 0x10c(%rcx), %eax
addl $0x1, %eax
xorl %edx, %edx
divl 0x110(%rcx)
movq -0xa0(%rbp), %rax
movl %edx, 0x10c(%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2e8cc
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/renderer/particle_system.cpp
// Function: Renderer::ParticleSystemInt::update(float)
void ParticleSystemInt::update(f32 delta) {
    ASSERT(particles, "Trying to use uninitalized/destroyed particle system");
    u32 i = head;
    b8 move = true;
    do {
        particles[i].update(delta);
        if (move && !particles[i].alive) {
            u32 new_head = (head + 1) % max_num_particles;
            if (new_head != tail) {
                head = new_head;
            }
        } else {
            move = false;
        }
    } while ((i = (i + 1) % max_num_particles) != tail);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x118(%rax)
setne %al
andb $0x1, %al
leaq 0x179d6(%rip), %rdi     # 0x463e3
movl $0x84, %esi
leaq 0x179f2(%rip), %rdx     # 0x4640b
movzbl %al, %ecx
callq 0xb210
movq -0x20(%rbp), %rax
movl 0x108(%rax), %eax
movl %eax, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
movq -0x20(%rbp), %rax
movq 0x118(%rax), %rdi
movl -0x10(%rbp), %eax
imulq $0x88, %rax, %rax
addq %rax, %rdi
movss -0xc(%rbp), %xmm0
callq 0x2edf0
cmpb $0x0, -0x11(%rbp)
je 0x2eaaa
movq -0x20(%rbp), %rax
movq 0x118(%rax), %rax
movl -0x10(%rbp), %ecx
imulq $0x88, %rcx, %rcx
addq %rcx, %rax
cmpb $0x0, 0x9(%rax)
jne 0x2eaaa
movq -0x20(%rbp), %rcx
movl 0x108(%rcx), %eax
addl $0x1, %eax
xorl %edx, %edx
divl 0x110(%rcx)
movl %edx, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl 0x10c(%rcx), %eax
je 0x2eaa8
movq -0x20(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, 0x108(%rax)
jmp 0x2eaae
movb $0x0, -0x11(%rbp)
jmp 0x2eab0
movq -0x20(%rbp), %rcx
movl -0x10(%rbp), %eax
addl $0x1, %eax
xorl %edx, %edx
divl 0x110(%rcx)
movq -0x20(%rbp), %rax
movl %edx, -0x10(%rbp)
cmpl 0x10c(%rax), %edx
jne 0x2ea32
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/renderer/particle_system.cpp
// Function: Renderer::ParticleSystemInt::draw()
void ParticleSystemInt::draw() {
    ASSERT(particles, "Trying to use uninitalized/destroyed particle system");
    u32 i = head;
    Vec2 p = relative ? position : V2(0, 0);
    do {
        i %= max_num_particles;
        if (num_sprites) {
            AssetID sprite = sprites[particles[i].sprite];
            particles[i].render(layer, p, sprite);
        } else {
            particles[i].render(layer, p, Asset::ASSET_ID_NO_ASSET);
        }
    } while ((i = (i + 1) % max_num_particles) != tail);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, 0x118(%rax)
setne %al
andb $0x1, %al
leaq 0x178bb(%rip), %rdi     # 0x463e3
movl $0x95, %esi
leaq 0x178d7(%rip), %rdx     # 0x4640b
movzbl %al, %ecx
callq 0xb210
movq -0x38(%rbp), %rax
movl 0x108(%rax), %ecx
movl %ecx, -0xc(%rbp)
cmpb $0x0, 0x128(%rax)
je 0x2eb63
movq -0x38(%rbp), %rax
movq 0x130(%rax), %rax
movq %rax, -0x14(%rbp)
jmp 0x2eb73
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0xbc10
movlpd %xmm0, -0x14(%rbp)
jmp 0x2eb75
movq -0x38(%rbp), %rax
movl 0x110(%rax), %ecx
movl -0xc(%rbp), %eax
xorl %edx, %edx
divl %ecx
movq -0x38(%rbp), %rax
movl %edx, -0xc(%rbp)
cmpl $0x0, (%rax)
je 0x2ebf4
movq -0x38(%rbp), %rax
movq 0x118(%rax), %rcx
movl -0xc(%rbp), %edx
movl %edx, %esi
movq %rsi, %rdx
shlq $0x7, %rdx
leaq (%rdx,%rsi,8), %rdx
movswq 0x80(%rcx,%rdx), %rcx
movq 0x8(%rax,%rcx,8), %rcx
movq %rcx, -0x20(%rbp)
movq 0x118(%rax), %rdi
movl -0xc(%rbp), %ecx
movl %ecx, %edx
movq %rdx, %rcx
shlq $0x7, %rcx
leaq (%rcx,%rdx,8), %rcx
addq %rcx, %rdi
movl 0x4(%rax), %esi
movq -0x14(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdx
movsd -0x28(%rbp), %xmm0
callq 0x2ef20
jmp 0x2ec2c
movq -0x38(%rbp), %rax
movq 0x118(%rax), %rdi
movl -0xc(%rbp), %ecx
movl %ecx, %edx
movq %rdx, %rcx
shlq $0x7, %rcx
leaq (%rcx,%rdx,8), %rcx
addq %rcx, %rdi
movl 0x4(%rax), %esi
movq -0x14(%rbp), %rax
movq %rax, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2ef20
jmp 0x2ec2e
movq -0x38(%rbp), %rcx
movl -0xc(%rbp), %eax
addl $0x1, %eax
xorl %edx, %edx
divl 0x110(%rcx)
movq -0x38(%rbp), %rax
movl %edx, -0xc(%rbp)
cmpl 0x10c(%rax), %edx
jne 0x2eb75
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/renderer/particle_system.cpp
// Function: Renderer::ParticleSystemInt::clear()
void ParticleSystemInt::clear() {
    for (u32 i = 0; i < max_num_particles; i++) {
        particles[i].alive = false;
    }
    tail = 0;
    head = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x110(%rcx), %eax
jae 0x2eccd
movq -0x18(%rbp), %rax
movq 0x118(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x88, %rcx, %rcx
addq %rcx, %rax
movb $0x0, 0x9(%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2ec97
movq -0x18(%rbp), %rax
movl $0x0, 0x10c(%rax)
movl $0x1, 0x108(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/renderer/particle_system.cpp
// Function: Renderer::ParticleSystemInt::add_sprite(unsigned long long)
void ParticleSystemInt::add_sprite(AssetID sprite){
    ASSERT(particles, "Trying to use uninitalized/destroyed particle system");
    ASSERT(Asset::is(sprite, Asset::Type::SPRITE), "Invalid sprite given to particle system.");
    ASSERT(num_sprites != MAX_NUM_SUB_SPRITES,
            "Too manu subsprites in particle system");
    sprites[num_sprites++] = sprite;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x118(%rax)
setne %al
andb $0x1, %al
leaq 0x17697(%rip), %rdi     # 0x463e3
movl $0xac, %esi
leaq 0x176b3(%rip), %rdx     # 0x4640b
movzbl %al, %ecx
callq 0xb210
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0x2f750
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
leaq 0x17663(%rip), %rdi     # 0x463e3
movl $0xad, %esi
leaq 0x176bf(%rip), %rdx     # 0x4644b
movzbl %al, %ecx
callq 0xb210
movq -0x18(%rbp), %rax
cmpl $0x20, (%rax)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
leaq 0x17631(%rip), %rdi     # 0x463e3
movl $0xaf, %esi
leaq 0x176de(%rip), %rdx     # 0x4649c
movzbl %al, %ecx
callq 0xb210
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdx
movl (%rax), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, (%rax)
movl %ecx, %ecx
movq %rdx, 0x8(%rax,%rcx,8)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/renderer/particle_system.cpp
// Function: Renderer::Particle::update(float)
void Particle::update(f32 delta) {
    alive = alive && (keep_alive || progress < 1.0);
    if (!alive) return;
    progress += inv_alive_time * delta;
    velocity += acceleration * delta;
    position += velocity * delta;
    velocity *= pow(damping, delta);
    rotation += angular_velocity * delta;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x28(%rbp)
xorl %eax, %eax
cmpb $0x0, 0x9(%rcx)
movb %al, -0x1d(%rbp)
je 0x2ee47
movq -0x28(%rbp), %rcx
movb $0x1, %al
cmpb $0x0, 0x8(%rcx)
movb %al, -0x29(%rbp)
jne 0x2ee41
movq -0x28(%rbp), %rax
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x16229(%rip), %xmm0    # 0x45060
ucomisd %xmm1, %xmm0
seta %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
movb %al, -0x1d(%rbp)
movq -0x28(%rbp), %rax
movb -0x1d(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x9(%rax)
cmpb $0x0, 0x9(%rax)
jne 0x2ee5f
jmp 0x2ef0b
movq -0x28(%rbp), %rdi
movss (%rdi), %xmm1
movss 0x4(%rdi), %xmm0
movss -0xc(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, (%rdi)
addq $0x24, %rdi
movss -0xc(%rbp), %xmm0
callq 0x5810
movq -0x28(%rbp), %rdi
movlpd %xmm0, -0x14(%rbp)
addq $0x1c, %rdi
movq %rdi, -0x38(%rbp)
movsd -0x14(%rbp), %xmm0
callq 0x5410
movq -0x38(%rbp), %rdi
movss -0xc(%rbp), %xmm0
callq 0x5810
movq -0x28(%rbp), %rdi
movlpd %xmm0, -0x1c(%rbp)
addq $0x14, %rdi
movsd -0x1c(%rbp), %xmm0
callq 0x5410
movq -0x28(%rbp), %rax
movss 0x2c(%rax), %xmm0
movss -0xc(%rbp), %xmm1
callq 0x42220
movq -0x28(%rbp), %rdi
addq $0x1c, %rdi
callq 0x420d0
movq -0x28(%rbp), %rax
movss 0x10(%rax), %xmm0
movss -0xc(%rbp), %xmm2
movss 0xc(%rax), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0xc(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/renderer/camera.cpp
// Function: Renderer::turn_on_camera(unsigned int)
void turn_on_camera(u32 camera_id) {
    ASSERT(camera_id < OPENGL_NUM_CAMERAS, "Invalid camera id");
    u32 bit = (camera_id == 0) ? 1 : (1 << camera_id);
    if (bit & _fog_active_cameras) return;
    _fog_active_cameras |= 1 << camera_id;
    _fog_num_active_cameras++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x2, -0x4(%rbp)
setb %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
leaq 0x1682d(%rip), %rdi     # 0x46503
movl $0x10, %esi
leaq 0x16840(%rip), %rdx     # 0x46522
movzbl %al, %ecx
callq 0xb210
cmpl $0x0, -0x4(%rbp)
jne 0x2fcfa
movl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2fd07
movl -0x4(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
leaq 0x3ac31(%rip), %rcx     # 0x6a948
andl (%rcx), %eax
cmpl $0x0, %eax
je 0x2fd20
jmp 0x2fd53
movl -0x4(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, %ecx
leaq 0x3ac15(%rip), %rax     # 0x6a948
orl (%rax), %ecx
leaq 0x3ac0c(%rip), %rax     # 0x6a948
movl %ecx, (%rax)
leaq 0x3ac07(%rip), %rax     # 0x6a94c
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x3abfb(%rip), %rax     # 0x6a94c
movl %ecx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/renderer/camera.cpp
// Function: Renderer::turn_off_camera(unsigned int)
void turn_off_camera(u32 camera_id) {
    ASSERT(camera_id < OPENGL_NUM_CAMERAS, "Invalid camera id");
    u32 bit = (camera_id == 0) ? 1 : (1 << camera_id);
    if (bit & _fog_active_cameras) {
        _fog_active_cameras &= ~(1 << camera_id);
        _fog_num_active_cameras--;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x2, -0x4(%rbp)
setb %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
leaq 0x1677d(%rip), %rdi     # 0x46503
movl $0x18, %esi
leaq 0x16790(%rip), %rdx     # 0x46522
movzbl %al, %ecx
callq 0xb210
cmpl $0x0, -0x4(%rbp)
jne 0x2fdaa
movl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2fdb7
movl -0x4(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
leaq 0x3ab81(%rip), %rcx     # 0x6a948
andl (%rcx), %eax
cmpl $0x0, %eax
je 0x2fe04
movl -0x4(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, %ecx
xorl $-0x1, %ecx
leaq 0x3ab64(%rip), %rax     # 0x6a948
andl (%rax), %ecx
leaq 0x3ab5b(%rip), %rax     # 0x6a948
movl %ecx, (%rax)
leaq 0x3ab56(%rip), %rax     # 0x6a94c
movl (%rax), %ecx
addl $-0x1, %ecx
leaq 0x3ab4a(%rip), %rax     # 0x6a94c
movl %ecx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/renderer/camera.cpp
// Function: Renderer::camera_fit(unsigned int, Vec2*, float)
Camera camera_fit(u32 num_points, Vec2 *points, f32 border) {
    ASSERT(num_points, "No points given for camera to fit!");
    Camera camera = {};
    camera.zoom = 1.0;
    camera.aspect_ratio = fetch_camera()->aspect_ratio;
    camera_fit_inplace(&camera, num_points, points, border);
    return camera;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x20(%rbp)
movl %esi, -0x4(%rbp)
movq %rdx, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
cmpl $0x0, -0x4(%rbp)
setne %al
andb $0x1, %al
leaq 0x166c7(%rip), %rdi     # 0x46503
movl $0x21, %esi
leaq 0x166fb(%rip), %rdx     # 0x46543
movzbl %al, %ecx
callq 0xb210
movq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x21c0
movq -0x28(%rbp), %rdi
movss 0x1519c(%rip), %xmm0    # 0x45008
movss %xmm0, 0x10(%rdi)
xorl %edi, %edi
callq 0xf980
movq -0x28(%rbp), %rdi
movss 0x14(%rax), %xmm0
movss %xmm0, 0x14(%rdi)
movl -0x4(%rbp), %esi
movq -0x10(%rbp), %rdx
movss -0x14(%rbp), %xmm0
callq 0x2feb0
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/renderer/camera.cpp
// Function: Renderer::camera_lerp(Renderer::Camera, Renderer::Camera, float)
Camera camera_lerp(Camera camera_a, Camera camera_b, f32 lerp) {
    return {
        LERP(camera_a.position    , camera_b.position, lerp),
        LERP(camera_a.offset      , camera_b.offset, lerp),
        (f32) LERP(camera_a.zoom  , camera_b.zoom, lerp),
        LERP(camera_a.aspect_ratio, camera_b.aspect_ratio, lerp),
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, -0x30(%rbp)
leaq 0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm1
movss 0x14e66(%rip), %xmm0    # 0x45008
movss %xmm0, -0x4c(%rbp)
subss %xmm1, %xmm0
callq 0x5810
movq -0x40(%rbp), %rdi
movlpd %xmm0, -0xc(%rbp)
movss -0x4(%rbp), %xmm0
callq 0x5810
movlpd %xmm0, -0x14(%rbp)
movsd -0x14(%rbp), %xmm0
leaq -0xc(%rbp), %rdi
callq 0x40dc0
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rax
movaps %xmm0, %xmm1
movss -0x4c(%rbp), %xmm0
movlpd %xmm1, (%rax)
addq $0x8, %rdi
movss -0x4(%rbp), %xmm1
subss %xmm1, %xmm0
callq 0x5810
movq -0x40(%rbp), %rdi
movlpd %xmm0, -0x1c(%rbp)
addq $0x8, %rdi
movss -0x4(%rbp), %xmm0
callq 0x5810
movlpd %xmm0, -0x24(%rbp)
movsd -0x24(%rbp), %xmm0
leaq -0x1c(%rbp), %rdi
callq 0x40dc0
movq -0x48(%rbp), %rcx
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rdi
movlpd %xmm0, 0x8(%rdi)
movss 0x10(%rcx), %xmm0
movss 0x14dc4(%rip), %xmm2    # 0x45008
subss -0x4(%rbp), %xmm2
movss 0x10(%rax), %xmm1
mulss -0x4(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x10(%rdi)
movss 0x14(%rcx), %xmm0
movss 0x14d9b(%rip), %xmm2    # 0x45008
subss -0x4(%rbp), %xmm2
movss 0x14(%rax), %xmm1
mulss -0x4(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x14(%rdi)
addq $0x18, %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x21c0
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/renderer/camera.cpp
// Function: Renderer::debug_camera(unsigned int)
void debug_camera(u32 camera_id) {
    const f32 ZOOM_SCALE_MOVE = 1.0 / 50.0;
    const f32 ZOOM_SCALE_WHEEL = 1.0 / 5.0;
    ASSERT(0 <= camera_id && camera_id < OPENGL_NUM_CAMERAS, "Not a valid camera");

    Camera *camera = fetch_camera(camera_id);
    if (Input::mouse_down(0))
        camera->position += Input::world_mouse_move(camera_id);

    f32 zoom_strength = 1.0;
    if (Input::mouse_down(2))
        zoom_strength = (1.0 - Input::mouse_move().y * ZOOM_SCALE_MOVE);
    if (Input::mouse_scroll().y != 0)
        zoom_strength = 1.0 + Input::mouse_scroll().y * ZOOM_SCALE_WHEEL;

    // TODO(ed): Figure out how those cool cameras that you can move
    // by zooming work...
    camera->zoom *= zoom_strength;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movss 0x14e01(%rip), %xmm0    # 0x45234
movss %xmm0, -0x8(%rbp)
movss 0x14bcc(%rip), %xmm0    # 0x4500c
movss %xmm0, -0xc(%rbp)
xorl %eax, %eax
xorl %ecx, %ecx
cmpl -0x4(%rbp), %ecx
movb %al, -0x3d(%rbp)
ja 0x3045b
cmpl $0x2, -0x4(%rbp)
setb %al
movb %al, -0x3d(%rbp)
movb -0x3d(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
leaq 0x16091(%rip), %rdi     # 0x46503
movl $0x59, %esi
leaq 0x160f4(%rip), %rdx     # 0x46572
movzbl %al, %ecx
callq 0xb210
movl -0x4(%rbp), %edi
callq 0xf980
movq %rax, -0x18(%rbp)
xorl %edi, %edi
callq 0x11cf0
cmpb $0x0, %al
je 0x304b8
movl -0x4(%rbp), %edi
callq 0x11b80
movlpd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movsd -0x20(%rbp), %xmm0
callq 0x5410
movss 0x14b48(%rip), %xmm0    # 0x45008
movss %xmm0, -0x24(%rbp)
movl $0x2, %edi
callq 0x11cf0
cmpb $0x0, %al
je 0x30503
callq 0x11c30
movlpd %xmm0, -0x2c(%rbp)
movss 0x14d4f(%rip), %xmm0    # 0x45234
mulss -0x28(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x14b6a(%rip), %xmm0    # 0x45060
subsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x24(%rbp)
callq 0x11b40
movlpd %xmm0, -0x34(%rbp)
movss -0x30(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x3051e
jp 0x3051e
jmp 0x3054e
callq 0x11b40
movlpd %xmm0, -0x3c(%rbp)
movss 0x14adc(%rip), %xmm0    # 0x4500c
mulss -0x38(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x14b1f(%rip), %xmm0    # 0x45060
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x24(%rbp)
movss -0x24(%rbp), %xmm0
movq -0x18(%rbp), %rax
mulss 0x10(%rax), %xmm0
movss %xmm0, 0x10(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/asset/asset.cpp
// Function: Asset::raw_fetch(unsigned long long, Asset::Type)
Data *raw_fetch(AssetID id, Type type) {
    if (system.file_header.number_of_assets < id) {
        ERR("Invalid asset id (%d)", id);
        HALT_AND_CATCH_FIRE;
        return nullptr;
    }
    if (type == Type::NONE || system.headers[id].type == type) {
        return &system.assets[id];
    } else {
        ERR("Not the expected type (%d)", id);
        HALT_AND_CATCH_FIRE;
        return nullptr;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
leaq 0x54d3a(%rip), %rax     # 0x852d0
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jae 0x305e8
movq 0x38a3a(%rip), %rax     # 0x68fe0
movq (%rax), %rsi
movq -0x10(%rbp), %rax
leaq 0x156bb(%rip), %rdi     # 0x45c6f
leaq 0x15feb(%rip), %rdx     # 0x465a6
movl $0xf, %ecx
leaq 0x15ffa(%rip), %r8      # 0x465c1
leaq 0x15ffd(%rip), %r9      # 0x465cb
movq %rax, (%rsp)
movb $0x0, %al
callq 0xb100
callq 0xb1f0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2330
cmpl $0x0, -0x14(%rbp)
je 0x30608
leaq 0x54cdb(%rip), %rax     # 0x852d0
movq 0x28(%rax), %rax
imulq $0x38, -0x10(%rbp), %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x30621
leaq 0x54cc1(%rip), %rax     # 0x852d0
movq 0x30(%rax), %rax
imulq $0x30, -0x10(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x3066a
movq 0x389b8(%rip), %rax     # 0x68fe0
movq (%rax), %rsi
movq -0x10(%rbp), %rax
leaq 0x15639(%rip), %rdi     # 0x45c6f
leaq 0x15f69(%rip), %rdx     # 0x465a6
movl $0x16, %ecx
leaq 0x15f78(%rip), %r8      # 0x465c1
leaq 0x15f91(%rip), %r9      # 0x465e1
movq %rax, (%rsp)
movb $0x0, %al
callq 0xb100
callq 0xb1f0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2330
movq -0x8(%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/performance.cpp
// Function: Perf::clear()
void clear() {
    for (u64 i = 0; i < NUMBER_OF_MARKERS; i++) {
        volatile Clock *clock = clocks + i;
        if (clock->other_thread) continue;
        if (clock->active) {
            ERR("Never resetting clock \"%s\"", clock->name);
        }
        f64 time = clock->time / 1000.0f;
        clock->total_time += time;
        clock->last_time = time;
        clock->time = 0;
        clock->total_count += clock->count;
        clock->last_count = clock->count;
        clock->count = 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq $0x0, -0x8(%rbp)
cmpq $0xa, -0x8(%rbp)
jae 0x30d95
leaq 0x399ce(%rip), %rax     # 0x6a670
imulq $0x48, -0x8(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb 0x9(%rax), %al
cmpb $0x0, %al
je 0x30cbe
jmp 0x30d84
movq -0x10(%rbp), %rax
movb 0x8(%rax), %al
cmpb $0x0, %al
je 0x30d06
movq 0x38310(%rip), %rax     # 0x68fe0
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rax
leaq 0x14f8e(%rip), %rdi     # 0x45c6f
leaq 0x159c6(%rip), %rdx     # 0x466ae
movl $0x8, %ecx
leaq 0x159da(%rip), %r8      # 0x466ce
leaq 0x159d9(%rip), %r9      # 0x466d4
movq %rax, (%rsp)
movb $0x0, %al
callq 0xb100
movq -0x10(%rbp), %rax
movsd 0x20(%rax), %xmm0
movsd 0x14d31(%rip), %xmm1    # 0x45a48
divsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm1
movq -0x10(%rbp), %rax
movsd 0x38(%rax), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x38(%rax)
movsd -0x18(%rbp), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x28(%rax)
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
addq %rdx, %rcx
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x30c90
addq $0x20, %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::clear_tweak_values()
void clear_tweak_values() {
    global_tweak.yoffset = debug_top_of_screen();
    global_tweak.indentation = 0;

    if (Input::mouse_pressed(0)) {
        if (global_tweak.active) global_tweak.hot = global_tweak.active;
        else global_tweak.active = "NO-DEBUG-VALUE";
    }

    if (!Input::mouse_down(0)) {
        global_tweak.hot = nullptr;
        global_tweak.active = nullptr;
    }

    if (global_tweak.active && Input::mouse_pressed(0))
        global_tweak.click_pos = Input::mouse_position();

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0xf930
leaq 0x38ce4(%rip), %rax     # 0x69e28
movss %xmm0, 0xc(%rax)
leaq 0x38cd8(%rip), %rax     # 0x69e28
movl $0x0, 0x10(%rax)
xorl %edi, %edi
callq 0x11c90
cmpb $0x0, %al
je 0x3119c
leaq 0x38cbf(%rip), %rax     # 0x69e28
cmpq $0x0, 0x18(%rax)
je 0x31188
leaq 0x38cb1(%rip), %rax     # 0x69e28
movq 0x18(%rax), %rcx
leaq 0x38ca6(%rip), %rax     # 0x69e28
movq %rcx, 0x20(%rax)
jmp 0x3119a
leaq 0x38c99(%rip), %rax     # 0x69e28
leaq 0x156bd(%rip), %rcx     # 0x46853
movq %rcx, 0x18(%rax)
jmp 0x3119c
xorl %edi, %edi
callq 0x11cf0
cmpb $0x0, %al
jne 0x311c5
leaq 0x38c7a(%rip), %rax     # 0x69e28
movq $0x0, 0x20(%rax)
leaq 0x38c6b(%rip), %rax     # 0x69e28
movq $0x0, 0x18(%rax)
leaq 0x38c5c(%rip), %rax     # 0x69e28
cmpq $0x0, 0x18(%rax)
je 0x311f7
xorl %edi, %edi
callq 0x11c90
cmpb $0x0, %al
je 0x311f7
callq 0x11a40
movlpd %xmm0, -0x8(%rbp)
leaq 0x38c39(%rip), %rax     # 0x69e28
movq -0x8(%rbp), %rcx
movq %rcx, 0x28(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/util/tweak_values.cpp
// Function: Util::mouse_in_range(float, float)
b8 mouse_in_range(f32 height, f32 offset) {
    const f32 BASE_OFFSET = 1.2;
    f32 min = offset - height * (1.0 + BASE_OFFSET);
    f32 max = offset - height * (0.0 + BASE_OFFSET);
    f32 y = Input::normalized_mouse_position().y;
    return min < y && y < max;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movss %xmm0, -0x4(%rbp)
movss %xmm1, -0x8(%rbp)
movl $0x3f99999a, -0xc(%rbp) # imm = 0x3F99999A
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movss -0x4(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
movsd 0x14825(%rip), %xmm2    # 0x45a58
mulsd %xmm2, %xmm1
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x10(%rbp)
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movss -0x4(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
movsd 0x14802(%rip), %xmm2    # 0x45a60
mulsd %xmm2, %xmm1
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x14(%rbp)
callq 0x11a70
movlpd %xmm0, -0x20(%rbp)
movss -0x1c(%rbp), %xmm0
movss %xmm0, -0x18(%rbp)
movss -0x10(%rbp), %xmm1
movss -0x18(%rbp), %xmm0
xorl %eax, %eax
ucomiss %xmm1, %xmm0
movb %al, -0x21(%rbp)
jbe 0x312aa
movss -0x18(%rbp), %xmm1
movss -0x14(%rbp), %xmm0
ucomiss %xmm1, %xmm0
seta %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %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::debug_value_logic(char const*, char const*)
void debug_value_logic(const char *name, const char *buffer) {
    f32 height = debug_line_height();
    b8 in_range = mouse_in_range(height, global_tweak.yoffset);

    if (global_tweak.active == nullptr && in_range)
        global_tweak.active = name;

    u32 color;
    if (global_tweak.hot == name)
        color = 2;
    else if (global_tweak.active == name)
        color = 1;
    else
        color = 0;

    if (color)
        Input::eat_mouse();

    debug_text(buffer, -1 + global_tweak.indentation * height, global_tweak.yoffset -= height, color);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0xf7b0
movss %xmm0, -0x14(%rbp)
movss -0x14(%rbp), %xmm0
leaq 0x38b42(%rip), %rax     # 0x69e28
movss 0xc(%rax), %xmm1
callq 0x31200
movb %al, -0x15(%rbp)
leaq 0x38b2e(%rip), %rax     # 0x69e28
cmpq $0x0, 0x18(%rax)
jne 0x31316
cmpb $0x0, -0x15(%rbp)
je 0x31316
movq -0x8(%rbp), %rcx
leaq 0x38b16(%rip), %rax     # 0x69e28
movq %rcx, 0x18(%rax)
leaq 0x38b0b(%rip), %rax     # 0x69e28
movq 0x20(%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x31330
movl $0x2, -0x1c(%rbp)
jmp 0x31353
leaq 0x38af1(%rip), %rax     # 0x69e28
movq 0x18(%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x3134a
movl $0x1, -0x1c(%rbp)
jmp 0x31351
movl $0x0, -0x1c(%rbp)
jmp 0x31353
cmpl $0x0, -0x1c(%rbp)
je 0x3135e
callq 0x11d30
movq -0x10(%rbp), %rdi
leaq 0x38abf(%rip), %rax     # 0x69e28
movl 0x10(%rax), %eax
cvtsi2ss %rax, %xmm0
movss -0x14(%rbp), %xmm1
mulss %xmm1, %xmm0
movss 0x13c96(%rip), %xmm1    # 0x45018
addss %xmm1, %xmm0
movss -0x14(%rbp), %xmm2
leaq 0x38a96(%rip), %rax     # 0x69e28
movss 0xc(%rax), %xmm1
subss %xmm2, %xmm1
leaq 0x38a86(%rip), %rax     # 0x69e28
movss %xmm1, 0xc(%rax)
movl -0x1c(%rbp), %esi
callq 0xf9f0
addq $0x20, %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::movement_scale()
f32 movement_scale() {
    if (Input::down(TWEAK_SMOOTH))
        return global_tweak.smooth_pixels_to_unit;
    else
        return global_tweak.pixels_to_unit;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x4d5dd(%rip), %rax     # 0x7e9ac
movl (%rax), %edi
movl $0xf, %esi
callq 0x11650
cmpb $0x0, %al
je 0x313f2
leaq 0x38a42(%rip), %rax     # 0x69e28
movss 0x4(%rax), %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x31402
leaq 0x38a2f(%rip), %rax     # 0x69e28
movss (%rax), %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/util/tweak_values.cpp
// Function: Util::moved_over_boundry()
Vec2i moved_over_boundry() {
    const Vec2 mpos = Input::mouse_position();
    const Vec2 mmov = Input::mouse_move();
    const Vec2 cpos = global_tweak.click_pos;
    const f32 scale = global_tweak.snapping_pixels_to_unit;
    s32 upper_x = (mpos.x - cpos.x) * scale;
    s32 upper_y = (mpos.y - cpos.y) * scale;
    s32 lower_x = (mpos.x - mmov.x - cpos.x) * scale;
    s32 lower_y = (mpos.y - mmov.y - cpos.y) * scale;
    return {upper_x - lower_x, lower_y - upper_y};
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
callq 0x11a40
movlpd %xmm0, -0x10(%rbp)
callq 0x11c30
movlpd %xmm0, -0x18(%rbp)
leaq 0x389c5(%rip), %rax     # 0x69e28
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
leaq 0x389b6(%rip), %rax     # 0x69e28
movss 0x8(%rax), %xmm0
movss %xmm0, -0x24(%rbp)
movss -0x10(%rbp), %xmm0
subss -0x20(%rbp), %xmm0
mulss -0x24(%rbp), %xmm0
cvttss2si %xmm0, %eax
movl %eax, -0x28(%rbp)
movss -0xc(%rbp), %xmm0
subss -0x1c(%rbp), %xmm0
mulss -0x24(%rbp), %xmm0
cvttss2si %xmm0, %eax
movl %eax, -0x2c(%rbp)
movss -0x10(%rbp), %xmm0
subss -0x18(%rbp), %xmm0
subss -0x20(%rbp), %xmm0
mulss -0x24(%rbp), %xmm0
cvttss2si %xmm0, %eax
movl %eax, -0x30(%rbp)
movss -0xc(%rbp), %xmm0
subss -0x14(%rbp), %xmm0
subss -0x1c(%rbp), %xmm0
mulss -0x24(%rbp), %xmm0
cvttss2si %xmm0, %eax
movl %eax, -0x34(%rbp)
movl -0x28(%rbp), %eax
subl -0x30(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x34(%rbp), %eax
subl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %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::begin_tweak_section(char const*, unsigned char*)
b8 begin_tweak_section(const char *name, b8 *active) {
    if (!debug_values_are_on()) return false;
    const char *buffer = Util::format_int(" - %s -", name);
    debug_value_logic(name, buffer);

    if (name == global_tweak.active && Input::mouse_pressed(0))
        *active = !*active;

    global_tweak.indentation += *active;

    return *active;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
callq 0xf630
cmpb $0x0, %al
jne 0x315bf
movb $0x0, -0x1(%rbp)
jmp 0x31638
movq -0x10(%rbp), %rsi
leaq 0x15298(%rip), %rdi     # 0x46862
movb $0x0, %al
callq 0x102c0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x312c0
movq -0x10(%rbp), %rax
leaq 0x3883b(%rip), %rcx     # 0x69e28
cmpq 0x18(%rcx), %rax
jne 0x31614
xorl %edi, %edi
callq 0x11c90
cmpb $0x0, %al
je 0x31614
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
setne %cl
xorb $-0x1, %cl
andb $0x1, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x18(%rbp), %rax
movzbl (%rax), %ecx
leaq 0x38806(%rip), %rax     # 0x69e28
addl 0x10(%rax), %ecx
leaq 0x387fc(%rip), %rax     # 0x69e28
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rax
movb (%rax), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/logic/logic.cpp
// Function: Logic::init()
b8 init() {
    logic_system.arena = Util::request_arena();
    for (s32 i = 0; i < At::COUNT; i++) {
        TimerBucket *bucket = logic_system.buckets + i;
        bucket->active = TimerBucket::NONE;
        bucket->free = 0;
        for (s32 j = 0; j < TimerBucket::NUM_TIMERS - 1; j++) {
            bucket->timers[j].forward = j + 1;
        }
        bucket->timers[TimerBucket::NUM_TIMERS - 1].forward = TimerBucket::NONE;
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
xorl %edi, %edi
callq 0x10890
movq %rax, %rcx
leaq 0x39227(%rip), %rax     # 0x6a950
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
cmpl $0x4, -0x4(%rbp)
jge 0x317c5
movslq -0x4(%rbp), %rcx
leaq 0x39208(%rip), %rax     # 0x6a950
addq $0x8, %rax
imulq $0x5008, %rcx, %rcx     # imm = 0x5008
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movw $0xffff, 0x5000(%rax)   # imm = 0xFFFF
movq -0x10(%rbp), %rax
movw $0x0, 0x5002(%rax)
movl $0x0, -0x14(%rbp)
cmpl $0x1ff, -0x14(%rbp)     # imm = 0x1FF
jge 0x317aa
movl -0x14(%rbp), %eax
addl $0x1, %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rdx
imulq $0x28, %rdx, %rdx
addq %rdx, %rax
movw %cx, (%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3177b
movq -0x10(%rbp), %rax
movw $0xffff, 0x4fd8(%rax)   # imm = 0xFFFF
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x31733
movb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/logic/logic.cpp
// Function: Logic::frame(float)
void frame(f32 time) {
    if (!logic_system.time) {
        logic_system.delta = 0;
        logic_system.time = time;
        return;
    }
    logic_system.delta = time - logic_system.time;
    logic_system.time = time;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movss %xmm0, -0x4(%rbp)
leaq 0x39170(%rip), %rax     # 0x6a950
movss 0x14028(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x3181a
jp 0x3181a
leaq 0x39157(%rip), %rax     # 0x6a950
xorps %xmm0, %xmm0
movss %xmm0, 0x1402c(%rax)
movss -0x4(%rbp), %xmm0
leaq 0x39140(%rip), %rax     # 0x6a950
movss %xmm0, 0x14028(%rax)
jmp 0x31851
movss -0x4(%rbp), %xmm0
leaq 0x3912a(%rip), %rax     # 0x6a950
subss 0x14028(%rax), %xmm0
leaq 0x3911b(%rip), %rax     # 0x6a950
movss %xmm0, 0x1402c(%rax)
movss -0x4(%rbp), %xmm0
leaq 0x39107(%rip), %rax     # 0x6a950
movss %xmm0, 0x14028(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/logic/logic.cpp
// Function: Logic::TimerBucket::update(float, float)
void TimerBucket::update(f32 time, f32 delta) {
    s16 *slot = &active;
    while (*slot != TimerBucket::NONE) {
        Timer *timer = timers + *slot;
        if (timer->next != FOREVER) timer->call(time, delta);
        if (timer->done(time)) {
            s16 forward = timer->forward;
            timer->forward = free;
            free = *slot;
            *slot = forward;
        } else {
            slot = &timer->forward;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movss %xmm1, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x5000, %rax           # imm = 0x5000
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movswl (%rax), %eax
cmpl $-0x1, %eax
je 0x31975
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movswl (%rcx), %ecx
movslq %ecx, %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movss 0x8(%rax), %xmm0
movss 0x13716(%rip), %xmm1    # 0x45018
ucomiss %xmm1, %xmm0
jne 0x3190b
jp 0x3190b
jmp 0x3191e
movq -0x20(%rbp), %rdi
movss -0xc(%rbp), %xmm0
movss -0x10(%rbp), %xmm1
callq 0x43340
movq -0x20(%rbp), %rdi
movss -0xc(%rbp), %xmm0
callq 0x434e0
cmpb $0x0, %al
je 0x31968
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movw (%rcx), %cx
movw %cx, -0x22(%rbp)
movw 0x5002(%rax), %dx
movq -0x20(%rbp), %rcx
movw %dx, (%rcx)
movq -0x18(%rbp), %rcx
movw (%rcx), %cx
movw %cx, 0x5002(%rax)
movw -0x22(%rbp), %cx
movq -0x18(%rbp), %rax
movw %cx, (%rax)
jmp 0x31970
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x318c8
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)