LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/logic/logic.cpp
// Function: Logic::TimerBucket::add_timer(Logic::Timer*)
LogicID TimerBucket::add_timer(Timer *timer) {
    ASSERT(free != NONE, "Using too many callbacks");
    s16 slot = free;
    Timer *to = timers + slot;
    free = to->forward;
    to->forward = active;
    active = slot;

    // This is kinda messy, if we were to reimplement
    // std::function<>() we could do a simple struct copy
    // here, alternatively we bite the bullet and actually
    // implement an assignment operator.
    to->gen++;
    to->end = timer->end;
    to->start = timer->start;
    to->next = timer->next;
    to->spacing = timer->spacing;
    to->callback = timer->callback;
    return {At::COUNT, slot, to->gen};
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movswl 0x5002(%rax), %eax
cmpl $-0x1, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
leaq 0x14eee(%rip), %rdi     # 0x468a7
movl $0x34, %esi
leaq 0x14efd(%rip), %rdx     # 0x468c2
movzbl %al, %ecx
callq 0xb210
movq -0x30(%rbp), %rax
movw 0x5002(%rax), %cx
movw %cx, -0x1a(%rbp)
movswl -0x1a(%rbp), %ecx
movslq %ecx, %rcx
imulq $0x28, %rcx, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movw (%rcx), %cx
movw %cx, 0x5002(%rax)
movw 0x5000(%rax), %dx
movq -0x28(%rbp), %rcx
movw %dx, (%rcx)
movw -0x1a(%rbp), %cx
movw %cx, 0x5000(%rax)
movq -0x28(%rbp), %rax
movb 0x2(%rax), %cl
addb $0x1, %cl
movb %cl, 0x2(%rax)
movq -0x18(%rbp), %rax
movss 0xc(%rax), %xmm0
movq -0x28(%rbp), %rax
movss %xmm0, 0xc(%rax)
movq -0x18(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x28(%rbp), %rax
movss %xmm0, 0x4(%rax)
movq -0x18(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x28(%rbp), %rax
movss %xmm0, 0x8(%rax)
movq -0x18(%rbp), %rax
movss 0x10(%rax), %xmm0
movq -0x28(%rbp), %rax
movss %xmm0, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movl $0x4, -0x8(%rbp)
movw -0x1a(%rbp), %ax
movw %ax, -0x4(%rbp)
movq -0x28(%rbp), %rax
movb 0x2(%rax), %al
movb %al, -0x2(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/logic/logic.cpp
// Function: Logic::TimerBucket::remove_timer(Logic::LogicID)
void TimerBucket::remove_timer(LogicID id) {
    Timer *timer = get_timer(id);
    CHECK(timer, "Trying to delete unkown callback");
    timer->next = -1.0;
    timer->end = -1.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
callq 0x31b20
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
setne %al
andb $0x1, %al
leaq 0x14dcd(%rip), %rdi     # 0x468a7
movl $0x4a, %esi
leaq 0x14e03(%rip), %rdx     # 0x468e9
movzbl %al, %ecx
callq 0xb270
movq -0x18(%rbp), %rax
movss 0x1351e(%rip), %xmm0    # 0x45018
movss %xmm0, 0x8(%rax)
movq -0x18(%rbp), %rax
movss 0x1350d(%rip), %xmm0    # 0x45018
movss %xmm0, 0xc(%rax)
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::TimerBucket::get_timer(Logic::LogicID)
Timer *TimerBucket::get_timer(LogicID id) {
    ASSERT(0 <= id.slot && id.slot < NUM_TIMERS, "Invalid LogicID");
    Timer *timer = timers + id.slot;
    if (timer->gen == id.gen)
        return timer;
    ERR("Failed to get timer");
    return nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movswl -0xc(%rbp), %edx
xorl %eax, %eax
xorl %ecx, %ecx
cmpl %edx, %ecx
movb %al, -0x21(%rbp)
jg 0x31b56
movswl -0xc(%rbp), %eax
cmpl $0x200, %eax            # imm = 0x200
setl %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
leaq 0x14d3a(%rip), %rdi     # 0x468a7
movl $0x50, %esi
leaq 0x14d9a(%rip), %rdx     # 0x46913
movzbl %al, %ecx
callq 0xb210
movq -0x30(%rbp), %rax
movswl -0xc(%rbp), %ecx
movslq %ecx, %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movzbl 0x2(%rax), %eax
movzbl -0xa(%rbp), %ecx
cmpl %ecx, %eax
jne 0x31bb1
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x31beb
movq 0x37428(%rip), %rax     # 0x68fe0
movq (%rax), %rsi
leaq 0x140ad(%rip), %rdi     # 0x45c6f
leaq 0x14cde(%rip), %rdx     # 0x468a7
movl $0x54, %ecx
leaq 0x14d74(%rip), %r8      # 0x46949
leaq 0x14d77(%rip), %r9      # 0x46953
movb $0x0, %al
callq 0xb100
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/logic/logic.cpp
// Function: Logic::add_callback(Logic::At, void (*)(float, float, float, void*), float, float, float, void*)
LogicID add_callback(At at, Callback callback, f32 start, f32 end,
                            f32 spacing, void *aux) {
    ASSERT(start != FOREVER, "I'm sorry Dave, I can't let you do that, I have to start some time!");
    Timer t = {0, 0, start, start, end, spacing, callback, aux};
    LogicID id = logic_system.buckets[at].add_timer(&t);
    id.at = at;
    return id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movss %xmm0, -0x1c(%rbp)
movss %xmm1, -0x20(%rbp)
movss %xmm2, -0x24(%rbp)
movq %rdx, -0x30(%rbp)
movss -0x1c(%rbp), %xmm0
movss 0x133e9(%rip), %xmm1    # 0x45018
ucomiss %xmm1, %xmm0
setne %al
setp %cl
orb %cl, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
leaq 0x14c59(%rip), %rdi     # 0x468a7
movl $0x5a, %esi
leaq 0x14d0d(%rip), %rdx     # 0x46967
movzbl %al, %ecx
callq 0xb210
movw $0x0, -0x58(%rbp)
movb $0x0, -0x56(%rbp)
movss -0x1c(%rbp), %xmm0
movss %xmm0, -0x54(%rbp)
movss -0x1c(%rbp), %xmm0
movss %xmm0, -0x50(%rbp)
movss -0x20(%rbp), %xmm0
movss %xmm0, -0x4c(%rbp)
movss -0x24(%rbp), %xmm0
movss %xmm0, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0xc(%rbp), %eax
leaq 0x38ca2(%rip), %rdi     # 0x6a950
addq $0x8, %rdi
imulq $0x5008, %rax, %rax     # imm = 0x5008
addq %rax, %rdi
leaq -0x58(%rbp), %rsi
callq 0x31980
movq %rax, -0x8(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/logic/logic.cpp
// Function: Logic::update_callback(Logic::LogicID, void (*)(float, float, float, void*), float, float, float, void*)
void update_callback(LogicID id, Callback callback,
                            f32 start, f32 end, f32 spacing, void *aux) {
    ASSERT(start != FOREVER, "I'm sorry Dave, I can't let you do that, I have to start some time!");
    Timer *timer = logic_system.buckets[id.at].get_timer(id);
    CHECK(timer, "Failed to find timer");
    timer->start = start;
    timer->next = start;
    timer->end = end;
    timer->spacing = spacing;
    timer->callback = callback;
    if (aux)
        timer->aux = aux;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movss %xmm1, -0x18(%rbp)
movss %xmm2, -0x1c(%rbp)
movq %rdx, -0x28(%rbp)
movss -0x14(%rbp), %xmm0
movss 0x132c8(%rip), %xmm1    # 0x45018
ucomiss %xmm1, %xmm0
setne %al
setp %cl
orb %cl, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
leaq 0x14b38(%rip), %rdi     # 0x468a7
movl $0x67, %esi
leaq 0x14bec(%rip), %rdx     # 0x46967
movzbl %al, %ecx
callq 0xb210
movl -0x8(%rbp), %eax
leaq 0x38bc3(%rip), %rdi     # 0x6a950
addq $0x8, %rdi
imulq $0x5008, %rax, %rax     # imm = 0x5008
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
callq 0x31b20
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
setne %al
andb $0x1, %al
leaq 0x14ae6(%rip), %rdi     # 0x468a7
movl $0x69, %esi
leaq 0x14bf0(%rip), %rdx     # 0x469bd
movzbl %al, %ecx
callq 0xb270
movss -0x14(%rbp), %xmm0
movq -0x30(%rbp), %rax
movss %xmm0, 0x4(%rax)
movss -0x14(%rbp), %xmm0
movq -0x30(%rbp), %rax
movss %xmm0, 0x8(%rax)
movss -0x18(%rbp), %xmm0
movq -0x30(%rbp), %rax
movss %xmm0, 0xc(%rax)
movss -0x1c(%rbp), %xmm0
movq -0x30(%rbp), %rax
movss %xmm0, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
cmpq $0x0, -0x28(%rbp)
je 0x31e2c
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x20(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/logic/block_physics.cpp
// Function: Physics::add_shape_from_sprite(unsigned long long)
ShapeID add_shape_from_sprite(Asset::AssetID sprite_id) {
    Sprite *sprite = Asset::fetch_sprite(sprite_id);
    Vec2 *points = Util::request_temporary_memory<Vec2>(sprite->num_points);
    for (u32 i = 0; i < sprite->num_points; i++)
        points[i] = V2(sprite->points[i]);
    return add_shape(sprite->num_points, points);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2dcb0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %edi
callq 0x437c0
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jae 0x32683
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x1c(%rbp), %ecx
shlq $0x4, %rcx
movups (%rax,%rcx), %xmm0
movaps %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
movsd -0x38(%rbp), %xmm1
callq 0xbb90
movlpd %xmm0, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movq -0x24(%rbp), %rdx
movq %rdx, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x32632
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edi
movq -0x18(%rbp), %rsi
callq 0x31ef0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/logic/block_physics.cpp
// Function: Physics::find_shape(unsigned int)
Shape find_shape(ShapeID id) {
    ASSERT(id < (u32) global_shape_list.length, "Invalid id, shape does not exist.");
    Shape shape = global_shape_list[id];
    ASSERT(id == shape.id, "You have passed in a stale shape ID, this shape doesn't exist.");
    return shape;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x4(%rbp)
movl -0x4(%rbp), %eax
leaq 0x4c2c3(%rip), %rcx     # 0x7e980
cmpl 0x4(%rcx), %eax
setb %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
leaq 0x14304(%rip), %rdi     # 0x469db
movl $0x6e, %esi
leaq 0x143ab(%rip), %rdx     # 0x46a8e
movzbl %al, %ecx
callq 0xb210
movl -0x4(%rbp), %esi
leaq 0x4c28b(%rip), %rdi     # 0x7e980
callq 0x43800
movq -0x18(%rbp), %rdi
movq %rax, %rsi
movl $0x40, %edx
callq 0x2090
movq -0x18(%rbp), %rdi
movl -0x4(%rbp), %eax
cmpl (%rdi), %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
leaq 0x142b0(%rip), %rdi     # 0x469db
movl $0x70, %esi
leaq 0x1439e(%rip), %rdx     # 0x46ad5
movzbl %al, %ecx
callq 0xb210
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/logic/block_physics.cpp
// Function: Physics::project_shape(Physics::Shape, Vec2, Vec2, Vec2)
Limit project_shape(Shape shape, Vec2 axis,
        Vec2 scale=V2(1, 1), Vec2 offset=V2(0, 0))
{
    Limit limit = {};
    f32 delta = dot(offset, axis);
    for (u32 i = 0; i < shape.points.length; i++)
    {
        f32 projection = dot(hadamard(shape.points.data[i], scale), axis);
        limit.upper = MAX(limit.upper, projection + delta);
        limit.lower = MIN(limit.lower, projection + delta);
    }
    return limit;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movlpd %xmm0, -0x10(%rbp)
movlpd %xmm1, -0x18(%rbp)
movlpd %xmm2, -0x20(%rbp)
movq $0x0, -0x8(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movsd -0x30(%rbp), %xmm0
movsd -0x38(%rbp), %xmm1
callq 0xb340
movss %xmm0, -0x24(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x68(%rbp), %rcx
movl -0x3c(%rbp), %eax
cmpl 0x2c(%rcx), %eax
jae 0x3291d
movq -0x68(%rbp), %rax
movq 0x30(%rax), %rax
movl -0x3c(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movsd -0x50(%rbp), %xmm0
movsd -0x58(%rbp), %xmm1
callq 0xb450
movlpd %xmm0, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movsd -0x48(%rbp), %xmm0
movsd -0x60(%rbp), %xmm1
callq 0xb340
movss %xmm0, -0x40(%rbp)
movss -0x4(%rbp), %xmm0
movss -0x40(%rbp), %xmm1
addss -0x24(%rbp), %xmm1
ucomiss %xmm1, %xmm0
jbe 0x328bd
movss -0x4(%rbp), %xmm0
movss %xmm0, -0x6c(%rbp)
jmp 0x328cc
movss -0x40(%rbp), %xmm0
addss -0x24(%rbp), %xmm0
movss %xmm0, -0x6c(%rbp)
movss -0x6c(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x8(%rbp), %xmm1
movss -0x40(%rbp), %xmm0
addss -0x24(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x328f6
movss -0x8(%rbp), %xmm0
movss %xmm0, -0x70(%rbp)
jmp 0x32905
movss -0x40(%rbp), %xmm0
addss -0x24(%rbp), %xmm0
movss %xmm0, -0x70(%rbp)
movss -0x70(%rbp), %xmm0
movss %xmm0, -0x8(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x32842
movsd -0x8(%rbp), %xmm0
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x30(%rbp)
movl %esi, -0x4(%rbp)
movss %xmm0, -0x8(%rbp)
movss %xmm1, -0xc(%rbp)
movss %xmm2, -0x10(%rbp)
leaq 0x14082(%rip), %rdi     # 0x469db
movq %rdi, -0x28(%rbp)
leaq 0x141c0(%rip), %rdx     # 0x46b24
movl $0x8d, %esi
movl $0x1, %ecx
callq 0xb210
movq -0x28(%rbp), %rdi
movl -0x4(%rbp), %eax
leaq 0x4bfff(%rip), %rcx     # 0x7e980
movl 0x4(%rcx), %ecx
subl %ecx, %eax
setb %al
movzbl %al, %ecx
leaq 0x141b1(%rip), %rdx     # 0x46b44
movl $0x8e, %esi
callq 0xb210
movq -0x20(%rbp), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq $0x0, 0x40(%rdi)
movss 0x12645(%rip), %xmm1    # 0x45008
movaps %xmm1, %xmm0
callq 0xbc10
movq -0x20(%rbp), %rdi
movlpd %xmm0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, 0x1c(%rdi)
movl $0xffffffff, 0x4(%rdi)  # imm = 0xFFFFFFFF
movss -0x10(%rbp), %xmm0
movss %xmm0, 0x40(%rdi)
movl -0x4(%rbp), %eax
movl %eax, (%rdi)
movss -0xc(%rbp), %xmm0
movss %xmm0, 0x44(%rdi)
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x32a1e
jp 0x32a1e
movq -0x20(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x3c(%rax)
jmp 0x32a34
movq -0x20(%rbp), %rax
movss 0x125de(%rip), %xmm0    # 0x45008
divss -0x8(%rbp), %xmm0
movss %xmm0, 0x3c(%rax)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rdi
addq $0x34, %rdi
movss 0x3c(%rax), %xmm0
callq 0x5810
movlpd %xmm0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
addq $0x2c, %rdi
movsd -0x14(%rbp), %xmm0
callq 0x5410
movq -0x8(%rbp), %rdi
addq $0x2c, %rdi
movss -0xc(%rbp), %xmm0
callq 0x5810
movlpd %xmm0, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
addq $0x24, %rdi
movsd -0x1c(%rbp), %xmm0
callq 0x5410
movq -0x8(%rbp), %rdi
addq $0x24, %rdi
movss -0xc(%rbp), %xmm0
callq 0x5810
movlpd %xmm0, -0x24(%rbp)
movq -0x8(%rbp), %rdi
addq $0x14, %rdi
movsd -0x24(%rbp), %xmm0
callq 0x5410
movq -0x8(%rbp), %rax
movss 0x11e0d(%rip), %xmm1    # 0x45008
subss 0x40(%rax), %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm1, %xmm0
jbe 0x33212
xorps %xmm0, %xmm0
movss %xmm0, -0x34(%rbp)
jmp 0x3325f
movq -0x8(%rbp), %rax
movss 0x11dea(%rip), %xmm0    # 0x45008
subss 0x40(%rax), %xmm0
movss 0x11ddd(%rip), %xmm1    # 0x45008
ucomiss %xmm1, %xmm0
jbe 0x3323f
movss 0x11dd0(%rip), %xmm0    # 0x45008
movss %xmm0, -0x38(%rbp)
jmp 0x33255
movq -0x8(%rbp), %rax
movss 0x11dbd(%rip), %xmm0    # 0x45008
subss 0x40(%rax), %xmm0
movss %xmm0, -0x38(%rbp)
movss -0x38(%rbp), %xmm0
movss %xmm0, -0x34(%rbp)
movss -0x34(%rbp), %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x28(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x3327a
jp 0x3327a
jmp 0x332af
movq -0x8(%rbp), %rax
addq $0x24, %rax
movq %rax, -0x40(%rbp)
movss -0x28(%rbp), %xmm0
movss -0xc(%rbp), %xmm1
callq 0x42220
movq -0x40(%rbp), %rdi
callq 0x5810
movlpd %xmm0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x24(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/logic/block_physics.cpp
// Function: Physics::reversed(Physics::Overlap)
Overlap reversed(Overlap overlap)
{
    return {
        overlap.b,
        overlap.a,
        overlap.depth,
        -overlap.normal,
        overlap.is_valid
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, %rax
movq %rax, -0x10(%rbp)
movq %rax, %rdi
movq %rdi, -0x8(%rbp)
leaq 0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq 0x8(%rdi), %rcx
movq %rcx, (%rax)
movq (%rdi), %rcx
movq %rcx, 0x8(%rax)
movss 0x10(%rdi), %xmm0
movss %xmm0, 0x10(%rax)
addq $0x14, %rdi
callq 0x40d80
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movlpd %xmm0, 0x14(%rdi)
movb 0x1c(%rcx), %cl
movb %cl, 0x1c(%rdi)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movss %xmm1, -0x10(%rbp)
movss -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x34355
movq -0x8(%rbp), %rax
movss (%rax), %xmm1
movss -0xc(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x34355
movq -0x8(%rbp), %rax
movss (%rax), %xmm1
addss -0x10(%rbp), %xmm1
movss -0xc(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x3433c
movq -0x8(%rbp), %rax
movss (%rax), %xmm0
addss -0x10(%rbp), %xmm0
movss %xmm0, -0x14(%rbp)
jmp 0x34346
movss -0xc(%rbp), %xmm0
movss %xmm0, -0x14(%rbp)
movss -0x14(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, (%rax)
jmp 0x343ac
xorps %xmm0, %xmm0
ucomiss -0x10(%rbp), %xmm0
jbe 0x343aa
movq -0x8(%rbp), %rax
movss (%rax), %xmm0
ucomiss -0xc(%rbp), %xmm0
jbe 0x343aa
movq -0x8(%rbp), %rax
movss (%rax), %xmm0
addss -0x10(%rbp), %xmm0
ucomiss -0xc(%rbp), %xmm0
jbe 0x34393
movq -0x8(%rbp), %rax
movss (%rax), %xmm0
addss -0x10(%rbp), %xmm0
movss %xmm0, -0x18(%rbp)
jmp 0x3439d
movss -0xc(%rbp), %xmm0
movss %xmm0, -0x18(%rbp)
movss -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, (%rax)
jmp 0x343ac
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movss %xmm1, -0x10(%rbp)
movss %xmm2, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movss -0xc(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x348fa
movq -0x20(%rbp), %rax
movss -0xc(%rbp), %xmm0
movss %xmm0, 0xc(%rax)
movss -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x34915
movq -0x20(%rbp), %rax
movss -0x10(%rbp), %xmm0
movss %xmm0, 0x1c(%rax)
movq -0x20(%rbp), %rax
movss 0xc(%rax), %xmm0
subss 0x8(%rax), %xmm0
movss 0x10921(%rip), %xmm1    # 0x4524c
mulss -0x14(%rbp), %xmm1
movss 0x10918(%rip), %xmm2    # 0x45250
divss %xmm2, %xmm1
divss %xmm1, %xmm0
movss %xmm0, 0x10(%rax)
movss 0x1c(%rax), %xmm0
subss 0x18(%rax), %xmm0
movss 0x108f5(%rip), %xmm1    # 0x4524c
mulss -0x14(%rbp), %xmm1
movss 0x108ec(%rip), %xmm2    # 0x45250
divss %xmm2, %xmm1
divss %xmm1, %xmm0
movss %xmm0, 0x20(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x34da0
leaq 0x346d4(%rip), %rax     # 0x69380
cmpw $0x0, 0x600(%rax)
je 0x34d49
movq -0x10(%rbp), %rsi
leaq 0x346bb(%rip), %rax     # 0x69380
movw 0x600(%rax), %ax
addw $-0x1, %ax
leaq 0x346a9(%rip), %rcx     # 0x69380
movw %ax, 0x600(%rcx)
movzwl %ax, %eax
movl %eax, %ecx
leaq 0x34696(%rip), %rax     # 0x69380
movw 0x602(%rax,%rcx,2), %ax
movw %ax, -0x6(%rbp)
movzwl -0x6(%rbp), %eax
movl %eax, %ecx
leaq 0x3467d(%rip), %rax     # 0x69380
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movzbl 0x26(%rax), %eax
addl $0x1, %eax
movb %al, 0x26(%rsi)
movzwl -0x6(%rbp), %eax
leaq 0x34661(%rip), %rdi     # 0x69380
imulq $0x30, %rax, %rax
addq %rax, %rdi
movl $0x30, %edx
callq 0x2090
callq 0x34dc0
movq -0x10(%rbp), %rax
movb 0x26(%rax), %al
movb %al, -0x4(%rbp)
movw -0x6(%rbp), %ax
movw %ax, -0x2(%rbp)
jmp 0x34d8a
movq 0x34290(%rip), %rax     # 0x68fe0
movq (%rax), %rsi
leaq 0x10f15(%rip), %rdi     # 0x45c6f
leaq 0x11e19(%rip), %rdx     # 0x46b7a
movl $0x7e, %ecx
leaq 0x11e96(%rip), %r8      # 0x46c03
leaq 0x11e9a(%rip), %r9      # 0x46c0e
movb $0x0, %al
callq 0xb100
callq 0x34dc0
movb $0x0, -0x4(%rbp)
movw $0x20, -0x2(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0xa0, %rsp
movb %dl, %al
movlpd %xmm0, -0xc(%rbp)
movl %edi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movss %xmm1, -0x1c(%rbp)
movss %xmm2, -0x20(%rbp)
movss %xmm3, -0x24(%rbp)
movss %xmm4, -0x28(%rbp)
movb %al, -0x29(%rbp)
cmpl $0xa, -0x10(%rbp)
setb %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
leaq 0x11baf(%rip), %rdi     # 0x46b7a
movl $0x93, %esi
leaq 0x11c01(%rip), %rdx     # 0x46bd8
movzbl %al, %ecx
callq 0xb210
xorps %xmm0, %xmm0
movss %xmm0, -0x60(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x50(%rbp)
movss -0x1c(%rbp), %xmm0
movss %xmm0, -0x68(%rbp)
movss 0x10011(%rip), %xmm0    # 0x45018
movss 0xfff9(%rip), %xmm1     # 0x45008
callq 0xe2d0
movss -0x68(%rbp), %xmm1
movss -0x24(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x4c(%rbp)
movss -0x20(%rbp), %xmm0
movss %xmm0, -0x64(%rbp)
movss 0xffdb(%rip), %xmm0     # 0x45018
movss 0xffc3(%rip), %xmm1     # 0x45008
callq 0xe2d0
movss -0x64(%rbp), %xmm1
movss -0x28(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x48(%rbp)
movb -0x29(%rbp), %al
movb %al, -0x44(%rbp)
movb $0x1, -0x43(%rbp)
movq -0xc(%rbp), %rax
movq %rax, -0x42(%rbp)
movb $0x0, -0x3a(%rbp)
movq $0x0, -0x38(%rbp)
movups -0x60(%rbp), %xmm0
movups -0x50(%rbp), %xmm1
movups -0x40(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x34c90
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movzwl -0x2(%rbp), %eax
cmpl $0x20, %eax
setb %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
leaq 0x11aa1(%rip), %rdi     # 0x46b7a
movl $0x9a, %esi
leaq 0x11b9d(%rip), %rdx     # 0x46c82
movzbl %al, %ecx
callq 0xb210
callq 0x34da0
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0x34de0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x26(%rax), %eax
movzbl -0x4(%rbp), %ecx
cmpl %ecx, %eax
jne 0x3515d
movw -0x2(%rbp), %dx
leaq 0x34261(%rip), %rax     # 0x69380
movw 0x600(%rax), %ax
movw %ax, %si
addw $0x1, %si
leaq 0x3424c(%rip), %rcx     # 0x69380
movw %si, 0x600(%rcx)
movzwl %ax, %eax
movl %eax, %ecx
leaq 0x34239(%rip), %rax     # 0x69380
movw %dx, 0x602(%rax,%rcx,2)
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x18(%rax)
jmp 0x3518f
movq 0x33e7c(%rip), %rax     # 0x68fe0
movq (%rax), %rsi
leaq 0x10b01(%rip), %rdi     # 0x45c6f
leaq 0x11a05(%rip), %rdx     # 0x46b7a
movl $0xa1, %ecx
leaq 0x11b2c(%rip), %r8      # 0x46cad
leaq 0x11b30(%rip), %r9      # 0x46cb8
movb $0x0, %al
callq 0xb100
callq 0x34dc0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movzwl -0x2(%rbp), %eax
cmpl $0x20, %eax
setb %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
leaq 0x119ad(%rip), %rdi     # 0x46b7a
movl $0xa7, %esi
leaq 0x11aa9(%rip), %rdx     # 0x46c82
movzbl %al, %ecx
callq 0xb210
callq 0x34da0
movl -0x4(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
callq 0x34de0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzbl 0x26(%rax), %eax
movzbl -0x4(%rbp), %ecx
cmpl %ecx, %eax
jne 0x35216
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0x35248
movq 0x33dc3(%rip), %rax     # 0x68fe0
movq (%rax), %rsi
leaq 0x10a48(%rip), %rdi     # 0x45c6f
leaq 0x1194c(%rip), %rdx     # 0x46b7a
movl $0xad, %ecx
leaq 0x11aad(%rip), %r8      # 0x46ce7
leaq 0x11ab6(%rip), %r9      # 0x46cf7
movb $0x0, %al
callq 0xb100
callq 0x34dc0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 0x11d60
movl %eax, %ecx
leaq 0x489d1(%rip), %rax     # 0x7e9a8
movl %ecx, (%rax)
movl $0x1, %edi
callq 0x11d60
movl %eax, %ecx
leaq 0x489c0(%rip), %rax     # 0x7e9ac
movl %ecx, (%rax)
movl $0x1, %edi
callq 0x11d60
movl %eax, %ecx
leaq 0x489af(%rip), %rax     # 0x7e9b0
movl %ecx, (%rax)
movl $0x1, %edi
callq 0x11d60
movl %eax, %ecx
leaq 0x4899e(%rip), %rax     # 0x7e9b4
movl %ecx, (%rax)
movl $0x1, %edi
callq 0x11d60
movl %eax, %ecx
leaq 0x4898d(%rip), %rax     # 0x7e9b8
movl %ecx, (%rax)
movl $0x1, %edi
callq 0x11d60
movl %eax, %ecx
leaq 0x4897c(%rip), %rax     # 0x7e9bc
movl %ecx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
callq 0x24f0
movl %eax, %eax
cvtsi2ss %rax, %xmm0
movss 0xedac(%rip), %xmm1     # 0x45024
divss %xmm1, %xmm0
callq 0x317d0
cmpb $0x0, 0x4f0a8(%rip)     # 0x85330
je 0x3628f
callq 0x30e40
callq 0x31130
callq 0x30c80
xorl %edi, %edi
leaq 0x10c59(%rip), %rsi     # 0x46efb
callq 0x2e590
movl $0x1, %edi
leaq 0x10c4d(%rip), %rsi     # 0x46f00
callq 0x2e590
callq 0x10dd0
movl $0x1, %edi
callq 0x2e670
callq 0x36300
xorl %edi, %edi
callq 0x31e40
movl $0x1, %edi
callq 0x31e40
xorl %edi, %edi
callq 0xf980
movq %rax, %rcx
leaq 0x33092(%rip), %rax     # 0x69380
movq (%rcx), %rcx
movq %rcx, 0x9bc(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movl $0x2, %edi
leaq 0x10616(%rip), %rsi     # 0x46f06
callq 0x2e590
callq 0x2d6b0
movl $0x2, %edi
callq 0x31e40
movl $0x3, %edi
callq 0x31e40
callq 0x2e480
movl $0x2, %edi
callq 0x2e670
xorl %edi, %edi
callq 0x2e670
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 0x36050
callq 0x10780
callq 0x24f0
movl %eax, %eax
cvtsi2ss %rax, %xmm0
movss 0xe502(%rip), %xmm1     # 0x45024
divss %xmm1, %xmm0
callq 0x317d0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x36b00
cmpb $0x0, 0x33204(%rip)     # 0x69d50
je 0x36c57
callq 0x24f0
movl %eax, %eax
cvtsi2ss %rax, %xmm0
movss 0xe4be(%rip), %xmm1     # 0x45024
divss %xmm1, %xmm0
callq 0x317d0
cmpb $0x0, 0x4e7ba(%rip)     # 0x85330
je 0x36b7d
callq 0x30e40
callq 0x31130
callq 0x30c80
xorl %edi, %edi
leaq 0x1036b(%rip), %rsi     # 0x46efb
callq 0x2e590
movl $0x1, %edi
leaq 0x1035f(%rip), %rsi     # 0x46f00
callq 0x2e590
callq 0x10dd0
movl $0x1, %edi
callq 0x2e670
callq 0x36300
leaq 0x47de7(%rip), %rax     # 0x7e9a8
movl (%rax), %edi
movl $0xf, %esi
callq 0x11750
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x36bd9
jp 0x36bd9
jmp 0x36be0
movb $0x0, 0x33170(%rip)     # 0x69d50
xorl %edi, %edi
callq 0x31e40
callq *-0x8(%rbp)
movl $0x1, %edi
callq 0x31e40
xorl %edi, %edi
callq 0xf980
movq %rax, %rcx
leaq 0x3277b(%rip), %rax     # 0x69380
movq (%rcx), %rcx
movq %rcx, 0x9bc(%rax)
callq 0x2d6b0
movl $0x2, %edi
leaq 0x102e6(%rip), %rsi     # 0x46f06
callq 0x2e590
movl $0x2, %edi
callq 0x31e40
callq *-0x10(%rbp)
movl $0x3, %edi
callq 0x31e40
movl $0x2, %edi
callq 0x2e670
callq 0x2e480
xorl %edi, %edi
callq 0x2e670
jmp 0x36b45
callq 0xb1f0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movl 0x18(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x404fa
movl 0x18(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x404fa
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movl 0x10(%rbp), %ecx
cmpq %rcx, %rax
jae 0x404f8
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq %rdx, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movl $0x20, %edi
callq *%rax
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x404bc
jmp 0x404fa
jmp 0x404fc
cmpq $0x0, -0x30(%rbp)
je 0x4053e
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rdx
movq %rdx, %rsi
addq $-0x1, %rsi
movq %rsi, -0x30(%rbp)
movb -0x1(%rcx,%rdx), %dil
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq %rdx, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movsbl %dil, %edi
callq *%rax
jmp 0x404fc
movl 0x18(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x40581
jmp 0x4054b
movq -0x18(%rbp), %rax
subq -0x38(%rbp), %rax
movl 0x10(%rbp), %ecx
cmpq %rcx, %rax
jae 0x4057f
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq %rdx, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movl $0x20, %edi
callq *%rax
jmp 0x4054b
jmp 0x40581
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/platform/input_sdl.cpp
// Function: (anonymous namespace)::get_contoller_id(int)
s32 get_contoller_id(s32 slot) {
    for (u32 i = 0; i < NUM_PLAYERS; i++) {
        if (_fog_global_controller_mapping[i].slot == slot)
            return i;
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x4, -0xc(%rbp)
jae 0x409a3
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x449f0(%rip), %rax     # 0x85370
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl -0x8(%rbp), %eax
jne 0x40996
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x409aa
jmp 0x40998
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4096e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/platform/input_sdl.cpp
// Function: (anonymous namespace)::s16_to_float(short)
f32 s16_to_float(s16 value) {
    // This makes the values normalized, so
    // you don't "run faster to the left".
    f32 normalzed;
    if (value == -32768) normalzed = -1.0;
    else normalzed = value / 32767.0;
    if (ABS(normalzed) < _fog_controller_deadzone) return 0.0;
    return normalzed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %di, %ax
movw %ax, -0x6(%rbp)
movswl -0x6(%rbp), %eax
cmpl $0xffff8000, %eax       # imm = 0xFFFF8000
jne 0x409d5
movss 0x464a(%rip), %xmm0     # 0x45018
movss %xmm0, -0xc(%rbp)
jmp 0x409f2
movswl -0x6(%rbp), %eax
cvtsi2sd %eax, %xmm0
movsd 0x510b(%rip), %xmm1     # 0x45af0
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0xc(%rbp)
xorps %xmm0, %xmm0
ucomiss -0xc(%rbp), %xmm0
jbe 0x40a14
movss -0xc(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, -0x10(%rbp)
jmp 0x40a1e
movss -0xc(%rbp), %xmm0
movss %xmm0, -0x10(%rbp)
movss -0x10(%rbp), %xmm1
movss 0x29375(%rip), %xmm0    # 0x69da0
ucomiss %xmm1, %xmm0
jbe 0x40a3a
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x40a44
movss -0xc(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/platform/input_sdl.cpp
// Function: (anonymous namespace)::register_controller(int)
void register_controller(s32 slot) {
    for (u32 i = 0; i < NUM_PLAYERS; i++) {
        if (_fog_global_controller_mapping[i].controller)
            continue;
        _fog_global_controller_mapping[i] = {
            slot,
            SDL_GameControllerOpen(slot),
        };
        return;
    }
    ERR("Too many controllers connected, cannot connect more.");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
cmpl $0x4, -0x8(%rbp)
jae 0x40ac5
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x448fc(%rip), %rax     # 0x85370
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
je 0x40a84
jmp 0x40aba
movl -0x4(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x4(%rbp), %edi
callq 0x2370
movq %rax, -0x10(%rbp)
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x448ce(%rip), %rax     # 0x85370
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x40af7
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x40a62
movq 0x28514(%rip), %rax     # 0x68fe0
movq (%rax), %rsi
leaq 0x5199(%rip), %rdi      # 0x45c6f
leaq 0x6289(%rip), %rdx      # 0x46d66
movl $0x3f, %ecx
leaq 0x19dc0(%rip), %r8      # 0x5a8a9
leaq 0x19d82(%rip), %r9      # 0x5a872
movb $0x0, %al
callq 0xb100
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/platform/input_sdl.cpp
// Function: (anonymous namespace)::unregister_controller(int)
void unregister_controller(s32 slot) {
    for (u32 i = 0; i < NUM_PLAYERS; i++) {
        ControllerMapping mapping = _fog_global_controller_mapping[i];
        if (!mapping.controller || mapping.slot != slot)
            continue;
        SDL_GameControllerClose(mapping.controller);
        _fog_global_controller_mapping[i] = {};
        return;
    }
    ERR("Trying to disconnect unconnected controller");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
cmpl $0x4, -0x8(%rbp)
jae 0x40b92
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x4484c(%rip), %rax     # 0x85370
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0x18(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x40b49
movl -0x18(%rbp), %eax
cmpl -0x4(%rbp), %eax
je 0x40b4b
jmp 0x40b87
movq -0x10(%rbp), %rdi
callq 0x2200
movl $0x0, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x44801(%rip), %rax     # 0x85370
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x40bc4
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x40b12
movq 0x28447(%rip), %rax     # 0x68fe0
movq (%rax), %rsi
leaq 0x50cc(%rip), %rdi      # 0x45c6f
leaq 0x61bc(%rip), %rdx      # 0x46d66
movl $0x53, %ecx
leaq 0x19cf1(%rip), %r8      # 0x5a8a7
leaq 0x19d00(%rip), %r9      # 0x5a8bd
movb $0x0, %al
callq 0xb100
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl 0x27bee(%rip), %eax     # 0x6937c
movl %eax, -0x34(%rbp)
testl %eax, %eax
je 0x417b2
jmp 0x41797
movl -0x34(%rbp), %eax
subl $0x1, %eax
je 0x417ab
jmp 0x417a1
movl -0x34(%rbp), %eax
subl $0x2, %eax
je 0x417bc
jmp 0x417b0
callq 0x10700
jmp 0x417b2
movl $0x1, 0x27bc0(%rip)     # 0x6937c
jmp 0x417be
jmp 0x417c0
movq -0x18(%rbp), %rax
shlq $0x4, %rax
movq %rax, -0x20(%rbp)
cmpq $0x200000, -0x20(%rbp)  # imm = 0x200000
setbe %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
leaq 0x44b4(%rip), %rdi      # 0x45c9f
movl $0x7c, %esi
leaq 0x190f2(%rip), %rdx     # 0x5a8e9
movzbl %al, %ecx
callq 0xb210
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
addq -0x20(%rbp), %rax
cmpq $0x200000, %rax         # imm = 0x200000
jbe 0x41866
movq -0x30(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x4184f
movq -0x30(%rbp), %rax
cmpb $0x0, (%rax)
je 0x41838
jmp 0x41829
callq 0xb1f0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2330
callq 0x10760
xorl %edi, %edi
callq 0x10890
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x41770
movq %rax, -0x8(%rbp)
jmp 0x4188a
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rcx
addq 0x8(%rax), %rcx
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rcx
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, 0x4(%rax)
sete %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
leaq 0x45d3(%rip), %rdi      # 0x46045
movl $0x5e, %esi
leaq 0x18ea8(%rip), %rdx     # 0x5a926
movzbl %al, %ecx
callq 0xb210
movq -0x18(%rbp), %rax
imull $0x3, -0xc(%rbp), %ecx
movl %ecx, (%rax)
movl $0x1, %edi
callq 0x10890
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq 0x18(%rax), %rdi
movl 0xc(%rax), %eax
movl %eax, %esi
callq 0x43b40
movq -0x18(%rbp), %rdi
movq %rax, 0x10(%rdi)
movl $0x4, 0x4(%rdi)
movl $0x0, 0x8(%rdi)
movl $0x0, 0xc(%rdi)
callq 0x43c70
addq $0x20, %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::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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, 0x4(%rax)
setne %al
andb $0x1, %al
leaq 0x4191(%rip), %rdi      # 0x46045
movl $0xcf, %esi
leaq 0x18ab0(%rip), %rdx     # 0x5a970
movzbl %al, %ecx
callq 0xb210
movl $0x0, -0xc(%rbp)
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0xc(%rcx), %eax
jae 0x41f42
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0x18(%rbp)
movl 0x8(%rax), %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x41f02
jmp 0x41f42
leaq -0x18(%rbp), %rdi
callq 0x43e20
leaq 0x3cb9e(%rip), %rax     # 0x7eab0
movq (%rax), %rax
movl -0x14(%rbp), %esi
movl $0x8892, %edi           # imm = 0x8892
callq *%rax
movq -0x20(%rbp), %rcx
leaq 0x3cece(%rip), %rax     # 0x7edf8
movq (%rax), %rax
movl 0x4(%rcx), %edi
movl -0x18(%rbp), %edx
xorl %esi, %esi
callq *%rax
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x41ecf
xorl %edi, %edi
leaq 0x3cb9d(%rip), %rax     # 0x7eae8
callq *(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)