LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/platform/input.cpp
// Function: Input::down(unsigned int, Input::Player)
b8 down(Name name, Player player) {
    BEGIN_BINDINGS_BLOCK {
        if (button.is_down()) return true;
    }
    END_BINDINGS_BLOCK
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x57c7b(%rip), %rax     # 0x692e0
cmpb $0x0, 0x40(%rax)
je 0x11674
movb $0x0, -0x1(%rbp)
jmp 0x1173f
movl $0x0, -0x10(%rbp)
cmpl $0x4, -0x10(%rbp)
jae 0x1173b
movl -0x10(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %edi
movl -0x14(%rbp), %esi
callq 0xf3a0
cmpb $0x0, %al
jne 0x116a6
jmp 0x1172d
movl $0x0, -0x24(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x1c(%rbp)
movb $0x0, -0x18(%rbp)
movl $0x0, -0x28(%rbp)
cmpl $0x4, -0x28(%rbp)
jae 0x1172b
movl -0x28(%rbp), %eax
movb %al, -0x18(%rbp)
movq -0x24(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x1c(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
leaq 0x57bf1(%rip), %rdi     # 0x692e0
callq 0x416e0
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x415c0
cmpb $0x0, %al
jne 0x1170b
jmp 0x11720
leaq -0x38(%rbp), %rdi
callq 0x41750
cmpb $0x0, %al
je 0x1171e
movb $0x1, -0x1(%rbp)
jmp 0x1173f
jmp 0x11720
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x116c4
jmp 0x1172d
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1167b
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/platform/input.cpp
// Function: Input::value(unsigned int, Input::Player)
f32 value(Name name, Player player) {
    u32 num_down = 0;
    f32 value = 0;
    BEGIN_BINDINGS_BLOCK {
        if (!button.is_down()) continue;
        num_down++;
        value += button.value * button.modifier;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x14(%rbp)
leaq 0x57b6c(%rip), %rax     # 0x692e0
cmpb $0x0, 0x40(%rax)
je 0x11787
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x1189a
movl $0x0, -0x18(%rbp)
cmpl $0x4, -0x18(%rbp)
jae 0x11874
movl -0x18(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %edi
movl -0x1c(%rbp), %esi
callq 0xf3a0
cmpb $0x0, %al
jne 0x117b9
jmp 0x11866
movl $0x0, -0x2c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x24(%rbp)
movb $0x0, -0x20(%rbp)
movl $0x0, -0x30(%rbp)
cmpl $0x4, -0x30(%rbp)
jae 0x11864
movl -0x30(%rbp), %eax
movb %al, -0x20(%rbp)
movq -0x2c(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x24(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
leaq 0x57ada(%rip), %rdi     # 0x692e0
callq 0x416e0
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x415c0
cmpb $0x0, %al
jne 0x11822
jmp 0x11856
leaq -0x40(%rbp), %rdi
callq 0x41750
cmpb $0x0, %al
jne 0x11831
jmp 0x11856
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movss -0x34(%rbp), %xmm0
movss -0x3c(%rbp), %xmm2
movss -0x14(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x14(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x117d7
jmp 0x11866
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1178e
cmpl $0x0, -0x10(%rbp)
je 0x11892
movss -0x14(%rbp), %xmm0
movl -0x10(%rbp), %eax
cvtsi2ss %rax, %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x1189a
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/platform/input.cpp
// Function: Input::scale_screen_to_world(Vec2, unsigned int)
Vec2 scale_screen_to_world(Vec2 p, u32 camera_id = 0) {
    Renderer::Camera *camera = Renderer::fetch_camera(camera_id);
    const f32 inv_width = 1.0 / Renderer::get_window_width();
    const f32 scale_factor = 1.0 / camera->zoom;
    Vec2 opengl = V2( p.x * 2 * scale_factor * inv_width,
                     -p.y * 2 * scale_factor * inv_width);
    Vec2 world = opengl + V2(-scale_factor, scale_factor * camera->aspect_ratio);
    return world;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movlpd %xmm0, -0x10(%rbp)
movl %edi, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0xf980
movq %rax, -0x20(%rbp)
callq 0xf7a0
cvtss2sd %xmm0, %xmm2
movsd 0x33783(%rip), %xmm0    # 0x45060
movaps %xmm0, %xmm1
divsd %xmm2, %xmm1
cvtsd2ss %xmm1, %xmm1
movss %xmm1, -0x24(%rbp)
movq -0x20(%rbp), %rax
movss 0x10(%rax), %xmm1
cvtss2sd %xmm1, %xmm1
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x10(%rbp), %xmm0
movss -0xc(%rbp), %xmm4
addss %xmm0, %xmm0
movss -0x28(%rbp), %xmm3
mulss %xmm3, %xmm0
movss -0x24(%rbp), %xmm2
mulss %xmm2, %xmm0
movaps %xmm4, %xmm1
movaps 0x340cf(%rip), %xmm5    # 0x45a00
movaps %xmm5, -0x50(%rbp)
pxor %xmm5, %xmm1
subss %xmm4, %xmm1
mulss %xmm3, %xmm1
mulss %xmm2, %xmm1
callq 0xbc10
movaps -0x50(%rbp), %xmm2
movlpd %xmm0, -0x30(%rbp)
movss -0x28(%rbp), %xmm1
movaps %xmm1, %xmm0
pxor %xmm2, %xmm0
movq -0x20(%rbp), %rax
movss 0x14(%rax), %xmm2
mulss %xmm2, %xmm1
callq 0xbc10
movlpd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
leaq -0x30(%rbp), %rdi
callq 0x40dc0
movlpd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/platform/input.cpp
// Function: Input::normalized_mouse_position()
Vec2 normalized_mouse_position() {
    const f32 inv_width = 1.0 / Renderer::get_window_width();
    Vec2 opengl = V2( mouse_position().x * 2 * inv_width,
                     -mouse_position().y * 2 * inv_width);
    Vec2 normalized = opengl + V2(-1, 1 * Renderer::get_window_aspect_ratio());
    return normalized;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
callq 0xf7a0
cvtss2sd %xmm0, %xmm1
movsd 0x335d7(%rip), %xmm0    # 0x45060
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0xc(%rbp)
callq 0x11a40
movlpd %xmm0, -0x1c(%rbp)
movss -0x1c(%rbp), %xmm0
addss %xmm0, %xmm0
movss -0xc(%rbp), %xmm1
mulss %xmm1, %xmm0
movss %xmm0, -0x30(%rbp)
callq 0x11a40
movaps %xmm0, %xmm1
movss -0x30(%rbp), %xmm0
movlpd %xmm1, -0x24(%rbp)
movss -0x20(%rbp), %xmm2
movaps %xmm2, %xmm1
movaps 0x33f28(%rip), %xmm3    # 0x45a00
pxor %xmm3, %xmm1
subss %xmm2, %xmm1
movss -0xc(%rbp), %xmm2
mulss %xmm2, %xmm1
callq 0xbc10
movlpd %xmm0, -0x14(%rbp)
callq 0x11b30
movaps %xmm0, %xmm1
movss 0x33515(%rip), %xmm0    # 0x45018
callq 0xbc10
movlpd %xmm0, -0x2c(%rbp)
movsd -0x2c(%rbp), %xmm0
leaq -0x14(%rbp), %rdi
callq 0x40dc0
movlpd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/platform/input.cpp
// Function: Input::world_mouse_move(unsigned int)
Vec2 world_mouse_move(u32 camera_id) {
    Vec2 p = mouse_move();
    Renderer::Camera *camera = Renderer::fetch_camera(camera_id);
    const f32 inv_width = 1.0 / Renderer::get_window_width();
    const f32 scale_factor = 1.0 / camera->zoom;
    Vec2 opengl = V2( p.x * 2 * scale_factor * inv_width,
            -p.y * 2 * scale_factor * inv_width);
    return opengl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
callq 0x11c30
movlpd %xmm0, -0x14(%rbp)
movl -0xc(%rbp), %edi
callq 0xf980
movq %rax, -0x20(%rbp)
callq 0xf7a0
cvtss2sd %xmm0, %xmm2
movsd 0x334ae(%rip), %xmm0    # 0x45060
movaps %xmm0, %xmm1
divsd %xmm2, %xmm1
cvtsd2ss %xmm1, %xmm1
movss %xmm1, -0x24(%rbp)
movq -0x20(%rbp), %rax
movss 0x10(%rax), %xmm1
cvtss2sd %xmm1, %xmm1
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x14(%rbp), %xmm0
movss -0x10(%rbp), %xmm4
addss %xmm0, %xmm0
movss -0x28(%rbp), %xmm3
mulss %xmm3, %xmm0
movss -0x24(%rbp), %xmm2
mulss %xmm2, %xmm0
movaps %xmm4, %xmm1
movaps 0x33dfa(%rip), %xmm5    # 0x45a00
pxor %xmm5, %xmm1
subss %xmm4, %xmm1
mulss %xmm3, %xmm1
mulss %xmm2, %xmm1
callq 0xbc10
movlpd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/platform/input.cpp
// Function: Input::request_name(unsigned int)
Name request_name(u32 num) {
    ASSERT(global_mapping.next_name, "Invalid mapping name");
    ASSERT(global_mapping.num_total_bindings == 0, "Cannot add mappings as game is running");
    Name name = global_mapping.next_name;
    global_mapping.next_name += num;
    return name;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x5756e(%rip), %rax     # 0x692e0
cmpl $0x0, 0x90(%rax)
setne %al
andb $0x1, %al
leaq 0x340fa(%rip), %rdi     # 0x45e7f
movl $0x120, %esi            # imm = 0x120
leaq 0x3422a(%rip), %rdx     # 0x45fbb
movzbl %al, %ecx
callq 0xb210
leaq 0x57540(%rip), %rax     # 0x692e0
cmpl $0x0, 0xc(%rax)
sete %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
leaq 0x340c4(%rip), %rdi     # 0x45e7f
movl $0x121, %esi            # imm = 0x121
leaq 0x34223(%rip), %rdx     # 0x45fea
movzbl %al, %ecx
callq 0xb210
leaq 0x5750a(%rip), %rax     # 0x692e0
movl 0x90(%rax), %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %ecx
leaq 0x574f7(%rip), %rax     # 0x692e0
addl 0x90(%rax), %ecx
leaq 0x574ea(%rip), %rax     # 0x692e0
movl %ecx, 0x90(%rax)
movl -0x8(%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/input.cpp
// Function: Input::init()
b8 init() {
    u32 number_of_bindings = global_mapping.next_name;
    global_mapping.num_bindings_per_controller = number_of_bindings * NUM_ALTERNATIVE_BINDINGS;
    global_mapping.num_total_bindings = (u32) Player::NUM * global_mapping.num_bindings_per_controller;

    global_mapping.arena = Util::request_arena();
    for (u32 i = 0; i < (u32) Player::NUM; i++)
        global_mapping.buttons[i] = global_mapping.arena->push<Mapping::VirtualButton>(global_mapping.num_bindings_per_controller);
    global_mapping.bindings = global_mapping.arena->push<Binding>(global_mapping.num_total_bindings);
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x574c1(%rip), %rax     # 0x692e0
movl 0x90(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %ecx
shll $0x2, %ecx
leaq 0x574ab(%rip), %rax     # 0x692e0
movl %ecx, 0x8(%rax)
leaq 0x574a1(%rip), %rax     # 0x692e0
movl 0x8(%rax), %ecx
shll $0x2, %ecx
leaq 0x57494(%rip), %rax     # 0x692e0
movl %ecx, 0xc(%rax)
xorl %edi, %edi
callq 0x10890
movq %rax, %rcx
leaq 0x57480(%rip), %rax     # 0x692e0
movq %rcx, (%rax)
movl $0x0, -0x8(%rbp)
cmpl $0x4, -0x8(%rbp)
jae 0x11eaa
leaq 0x57469(%rip), %rax     # 0x692e0
movq (%rax), %rdi
leaq 0x5745f(%rip), %rax     # 0x692e0
movl 0x8(%rax), %eax
movl %eax, %esi
callq 0x41770
movq %rax, %rdx
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x57446(%rip), %rax     # 0x692e0
movq %rdx, 0x20(%rax,%rcx,8)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x11e6a
leaq 0x5742f(%rip), %rax     # 0x692e0
movq (%rax), %rdi
leaq 0x57425(%rip), %rax     # 0x692e0
movl 0xc(%rax), %eax
movl %eax, %esi
callq 0x418a0
movq %rax, %rcx
leaq 0x57411(%rip), %rax     # 0x692e0
movq %rcx, 0x18(%rax)
movb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/inc/glad/glad.c
// Function: gladLoadGL
int gladLoadGL(void) {
    int status = 0;

    if(open_gl()) {
        status = gladLoadGLLoader(&get_proc);
        close_gl();
    }

    return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
callq 0x11f20
cmpl $0x0, %eax
je 0x11f0d
leaq 0xc80(%rip), %rdi       # 0x12b80
callq 0x11fc0
movl %eax, -0x4(%rbp)
callq 0x12bf0
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/inc/glad/glad.c
// Function: open_gl()
static
int open_gl(void) {
#ifdef __APPLE__
    static const char *NAMES[] = {
        "../Frameworks/OpenGL.framework/OpenGL",
        "/Library/Frameworks/OpenGL.framework/OpenGL",
        "/System/Library/Frameworks/OpenGL.framework/OpenGL",
        "/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL"
    };
#else
    static const char *NAMES[] = {"libGL.so.1", "libGL.so"};
#endif

    unsigned int index = 0;
    for(index = 0; index < (sizeof(NAMES) / sizeof(NAMES[0])); index++) {
        libGL = dlopen(NAMES[index], RTLD_NOW | RTLD_GLOBAL);

        if(libGL != NULL) {
#if defined(__APPLE__) || defined(__HAIKU__)
            return 1;
#else
            gladGetProcAddressPtr = (PFNGLXGETPROCADDRESSPROC_PRIVATE)dlsym(libGL,
                "glXGetProcAddressARB");
            return gladGetProcAddressPtr != NULL;
#endif
        }
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x8(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpq $0x2, %rax
jae 0x11fa6
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x57e45(%rip), %rax     # 0x69d90
movq (%rax,%rcx,8), %rdi
movl $0x102, %esi            # imm = 0x102
callq 0x2400
movq %rax, 0x733d8(%rip)     # 0x85338
cmpq $0x0, 0x733d0(%rip)     # 0x85338
je 0x11f99
movq 0x733c7(%rip), %rdi     # 0x85338
leaq 0x357ab(%rip), %rsi     # 0x47723
callq 0x2150
movq %rax, 0x733bc(%rip)     # 0x85340
cmpq $0x0, 0x733b4(%rip)     # 0x85340
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x11fad
jmp 0x11f9b
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x11f36
movl $0x0, -0x4(%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/inc/glad/glad.c
// Function: get_proc(char const*)
static
void* get_proc(const char *namez) {
    void* result = NULL;
    if(libGL == NULL) return NULL;

#if !defined(__APPLE__) && !defined(__HAIKU__)
    if(gladGetProcAddressPtr != NULL) {
        result = gladGetProcAddressPtr(namez);
    }
#endif
    if(result == NULL) {
#if defined(_WIN32) || defined(__CYGWIN__)
        result = (void*)GetProcAddress((HMODULE) libGL, namez);
#else
        result = dlsym(libGL, namez);
#endif
    }

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, 0x7279c(%rip)     # 0x85338
jne 0x12ba8
movq $0x0, -0x8(%rbp)
jmp 0x12be6
cmpq $0x0, 0x72790(%rip)     # 0x85340
je 0x12bc3
movq 0x72787(%rip), %rax     # 0x85340
movq -0x10(%rbp), %rdi
callq *%rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x12bde
movq 0x72767(%rip), %rdi     # 0x85338
movq -0x10(%rbp), %rsi
callq 0x2150
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/inc/glad/glad.c
// Function: load_GL_AMD_debug_output(void* (*)(char const*))
static void load_GL_AMD_debug_output(GLADloadproc load) {
	if(!GLAD_GL_AMD_debug_output) return;
	glad_glDebugMessageEnableAMD = (PFNGLDEBUGMESSAGEENABLEAMDPROC)load("glDebugMessageEnableAMD");
	glad_glDebugMessageInsertAMD = (PFNGLDEBUGMESSAGEINSERTAMDPROC)load("glDebugMessageInsertAMD");
	glad_glDebugMessageCallbackAMD = (PFNGLDEBUGMESSAGECALLBACKAMDPROC)load("glDebugMessageCallbackAMD");
	glad_glGetDebugMessageLogAMD = (PFNGLGETDEBUGMESSAGELOGAMDPROC)load("glGetDebugMessageLogAMD");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x65be9(%rip), %rax     # 0x7ff3c
cmpl $0x0, (%rax)
jne 0x1a35a
jmp 0x1a3b6
leaq 0x3376c(%rip), %rdi     # 0x4dacd
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x6651a(%rip), %rax     # 0x80888
movq %rcx, (%rax)
leaq 0x3376d(%rip), %rdi     # 0x4dae5
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x6650b(%rip), %rax     # 0x80890
movq %rcx, (%rax)
leaq 0x3376e(%rip), %rdi     # 0x4dafd
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x664fc(%rip), %rax     # 0x80898
movq %rcx, (%rax)
leaq 0x33771(%rip), %rdi     # 0x4db17
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x664ed(%rip), %rax     # 0x808a0
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/inc/glad/glad.c
// Function: load_GL_AMD_draw_buffers_blend(void* (*)(char const*))
static void load_GL_AMD_draw_buffers_blend(GLADloadproc load) {
	if(!GLAD_GL_AMD_draw_buffers_blend) return;
	glad_glBlendFuncIndexedAMD = (PFNGLBLENDFUNCINDEXEDAMDPROC)load("glBlendFuncIndexedAMD");
	glad_glBlendFuncSeparateIndexedAMD = (PFNGLBLENDFUNCSEPARATEINDEXEDAMDPROC)load("glBlendFuncSeparateIndexedAMD");
	glad_glBlendEquationIndexedAMD = (PFNGLBLENDEQUATIONINDEXEDAMDPROC)load("glBlendEquationIndexedAMD");
	glad_glBlendEquationSeparateIndexedAMD = (PFNGLBLENDEQUATIONSEPARATEINDEXEDAMDPROC)load("glBlendEquationSeparateIndexedAMD");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x65b71(%rip), %rax     # 0x7ff44
cmpl $0x0, (%rax)
jne 0x1a3da
jmp 0x1a436
leaq 0x3374e(%rip), %rdi     # 0x4db2f
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x664ba(%rip), %rax     # 0x808a8
movq %rcx, (%rax)
leaq 0x3374d(%rip), %rdi     # 0x4db45
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x664ab(%rip), %rax     # 0x808b0
movq %rcx, (%rax)
leaq 0x33754(%rip), %rdi     # 0x4db63
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x6649c(%rip), %rax     # 0x808b8
movq %rcx, (%rax)
leaq 0x33757(%rip), %rdi     # 0x4db7d
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x6648d(%rip), %rax     # 0x808c0
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/inc/glad/glad.c
// Function: load_GL_AMD_framebuffer_sample_positions(void* (*)(char const*))
static void load_GL_AMD_framebuffer_sample_positions(GLADloadproc load) {
	if(!GLAD_GL_AMD_framebuffer_sample_positions) return;
	glad_glFramebufferSamplePositionsfvAMD = (PFNGLFRAMEBUFFERSAMPLEPOSITIONSFVAMDPROC)load("glFramebufferSamplePositionsfvAMD");
	glad_glNamedFramebufferSamplePositionsfvAMD = (PFNGLNAMEDFRAMEBUFFERSAMPLEPOSITIONSFVAMDPROC)load("glNamedFramebufferSamplePositionsfvAMD");
	glad_glGetFramebufferParameterfvAMD = (PFNGLGETFRAMEBUFFERPARAMETERFVAMDPROC)load("glGetFramebufferParameterfvAMD");
	glad_glGetNamedFramebufferParameterfvAMD = (PFNGLGETNAMEDFRAMEBUFFERPARAMETERFVAMDPROC)load("glGetNamedFramebufferParameterfvAMD");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x65aa9(%rip), %rax     # 0x7ff4c
cmpl $0x0, (%rax)
jne 0x1a4aa
jmp 0x1a506
leaq 0x3374b(%rip), %rdi     # 0x4dbfc
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x6641a(%rip), %rax     # 0x808d8
movq %rcx, (%rax)
leaq 0x33756(%rip), %rdi     # 0x4dc1e
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x6640b(%rip), %rax     # 0x808e0
movq %rcx, (%rax)
leaq 0x33766(%rip), %rdi     # 0x4dc45
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x663fc(%rip), %rax     # 0x808e8
movq %rcx, (%rax)
leaq 0x3376e(%rip), %rdi     # 0x4dc64
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x663ed(%rip), %rax     # 0x808f0
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/inc/glad/glad.c
// Function: load_GL_AMD_name_gen_delete(void* (*)(char const*))
static void load_GL_AMD_name_gen_delete(GLADloadproc load) {
	if(!GLAD_GL_AMD_name_gen_delete) return;
	glad_glGenNamesAMD = (PFNGLGENNAMESAMDPROC)load("glGenNamesAMD");
	glad_glDeleteNamesAMD = (PFNGLDELETENAMESAMDPROC)load("glDeleteNamesAMD");
	glad_glIsNameAMD = (PFNGLISNAMEAMDPROC)load("glIsNameAMD");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x65675(%rip), %rax     # 0x7ff68
cmpl $0x0, (%rax)
jne 0x1a8fa
jmp 0x1a93f
leaq 0x33696(%rip), %rdi     # 0x4df97
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x66112(%rip), %rax     # 0x80a20
movq %rcx, (%rax)
leaq 0x3368d(%rip), %rdi     # 0x4dfa5
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x66103(%rip), %rax     # 0x80a28
movq %rcx, (%rax)
leaq 0x33687(%rip), %rdi     # 0x4dfb6
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x660f4(%rip), %rax     # 0x80a30
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/inc/glad/glad.c
// Function: load_GL_AMD_performance_monitor(void* (*)(char const*))
static void load_GL_AMD_performance_monitor(GLADloadproc load) {
	if(!GLAD_GL_AMD_performance_monitor) return;
	glad_glGetPerfMonitorGroupsAMD = (PFNGLGETPERFMONITORGROUPSAMDPROC)load("glGetPerfMonitorGroupsAMD");
	glad_glGetPerfMonitorCountersAMD = (PFNGLGETPERFMONITORCOUNTERSAMDPROC)load("glGetPerfMonitorCountersAMD");
	glad_glGetPerfMonitorGroupStringAMD = (PFNGLGETPERFMONITORGROUPSTRINGAMDPROC)load("glGetPerfMonitorGroupStringAMD");
	glad_glGetPerfMonitorCounterStringAMD = (PFNGLGETPERFMONITORCOUNTERSTRINGAMDPROC)load("glGetPerfMonitorCounterStringAMD");
	glad_glGetPerfMonitorCounterInfoAMD = (PFNGLGETPERFMONITORCOUNTERINFOAMDPROC)load("glGetPerfMonitorCounterInfoAMD");
	glad_glGenPerfMonitorsAMD = (PFNGLGENPERFMONITORSAMDPROC)load("glGenPerfMonitorsAMD");
	glad_glDeletePerfMonitorsAMD = (PFNGLDELETEPERFMONITORSAMDPROC)load("glDeletePerfMonitorsAMD");
	glad_glSelectPerfMonitorCountersAMD = (PFNGLSELECTPERFMONITORCOUNTERSAMDPROC)load("glSelectPerfMonitorCountersAMD");
	glad_glBeginPerfMonitorAMD = (PFNGLBEGINPERFMONITORAMDPROC)load("glBeginPerfMonitorAMD");
	glad_glEndPerfMonitorAMD = (PFNGLENDPERFMONITORAMDPROC)load("glEndPerfMonitorAMD");
	glad_glGetPerfMonitorCounterDataAMD = (PFNGLGETPERFMONITORCOUNTERDATAAMDPROC)load("glGetPerfMonitorCounterDataAMD");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x655cd(%rip), %rax     # 0x7ff70
cmpl $0x0, (%rax)
jne 0x1a9ad
jmp 0x1aaaa
leaq 0x3362a(%rip), %rdi     # 0x4dfde
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x6607f(%rip), %rax     # 0x80a40
movq %rcx, (%rax)
leaq 0x3362d(%rip), %rdi     # 0x4dff8
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x66070(%rip), %rax     # 0x80a48
movq %rcx, (%rax)
leaq 0x33632(%rip), %rdi     # 0x4e014
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x66061(%rip), %rax     # 0x80a50
movq %rcx, (%rax)
leaq 0x3363a(%rip), %rdi     # 0x4e033
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x66052(%rip), %rax     # 0x80a58
movq %rcx, (%rax)
leaq 0x33644(%rip), %rdi     # 0x4e054
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x66043(%rip), %rax     # 0x80a60
movq %rcx, (%rax)
leaq 0x3364c(%rip), %rdi     # 0x4e073
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x66034(%rip), %rax     # 0x80a68
movq %rcx, (%rax)
leaq 0x3364a(%rip), %rdi     # 0x4e088
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x66025(%rip), %rax     # 0x80a70
movq %rcx, (%rax)
leaq 0x3364b(%rip), %rdi     # 0x4e0a0
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x66016(%rip), %rax     # 0x80a78
movq %rcx, (%rax)
leaq 0x33653(%rip), %rdi     # 0x4e0bf
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x66007(%rip), %rax     # 0x80a80
movq %rcx, (%rax)
leaq 0x33652(%rip), %rdi     # 0x4e0d5
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x65ff8(%rip), %rax     # 0x80a88
movq %rcx, (%rax)
leaq 0x3364f(%rip), %rdi     # 0x4e0e9
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x65fe9(%rip), %rax     # 0x80a90
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/inc/glad/glad.c
// Function: load_GL_APPLE_element_array(void* (*)(char const*))
static void load_GL_APPLE_element_array(GLADloadproc load) {
	if(!GLAD_GL_APPLE_element_array) return;
	glad_glElementPointerAPPLE = (PFNGLELEMENTPOINTERAPPLEPROC)load("glElementPointerAPPLE");
	glad_glDrawElementArrayAPPLE = (PFNGLDRAWELEMENTARRAYAPPLEPROC)load("glDrawElementArrayAPPLE");
	glad_glDrawRangeElementArrayAPPLE = (PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC)load("glDrawRangeElementArrayAPPLE");
	glad_glMultiDrawElementArrayAPPLE = (PFNGLMULTIDRAWELEMENTARRAYAPPLEPROC)load("glMultiDrawElementArrayAPPLE");
	glad_glMultiDrawRangeElementArrayAPPLE = (PFNGLMULTIDRAWRANGEELEMENTARRAYAPPLEPROC)load("glMultiDrawRangeElementArrayAPPLE");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x653e9(%rip), %rax     # 0x7ffcc
cmpl $0x0, (%rax)
jne 0x1abea
jmp 0x1ac5d
leaq 0x3359f(%rip), %rdi     # 0x4e190
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x65eca(%rip), %rax     # 0x80ac8
movq %rcx, (%rax)
leaq 0x3359e(%rip), %rdi     # 0x4e1a6
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x65ebb(%rip), %rax     # 0x80ad0
movq %rcx, (%rax)
leaq 0x3359f(%rip), %rdi     # 0x4e1be
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x65eac(%rip), %rax     # 0x80ad8
movq %rcx, (%rax)
leaq 0x335a5(%rip), %rdi     # 0x4e1db
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x65e9d(%rip), %rax     # 0x80ae0
movq %rcx, (%rax)
leaq 0x335ab(%rip), %rdi     # 0x4e1f8
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x65e8e(%rip), %rax     # 0x80ae8
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/inc/glad/glad.c
// Function: load_GL_APPLE_fence(void* (*)(char const*))
static void load_GL_APPLE_fence(GLADloadproc load) {
	if(!GLAD_GL_APPLE_fence) return;
	glad_glGenFencesAPPLE = (PFNGLGENFENCESAPPLEPROC)load("glGenFencesAPPLE");
	glad_glDeleteFencesAPPLE = (PFNGLDELETEFENCESAPPLEPROC)load("glDeleteFencesAPPLE");
	glad_glSetFenceAPPLE = (PFNGLSETFENCEAPPLEPROC)load("glSetFenceAPPLE");
	glad_glIsFenceAPPLE = (PFNGLISFENCEAPPLEPROC)load("glIsFenceAPPLE");
	glad_glTestFenceAPPLE = (PFNGLTESTFENCEAPPLEPROC)load("glTestFenceAPPLE");
	glad_glFinishFenceAPPLE = (PFNGLFINISHFENCEAPPLEPROC)load("glFinishFenceAPPLE");
	glad_glTestObjectAPPLE = (PFNGLTESTOBJECTAPPLEPROC)load("glTestObjectAPPLE");
	glad_glFinishObjectAPPLE = (PFNGLFINISHOBJECTAPPLEPROC)load("glFinishObjectAPPLE");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x6534d(%rip), %rax     # 0x7ffd0
cmpl $0x0, (%rax)
jne 0x1ac8d
jmp 0x1ad45
leaq 0x33586(%rip), %rdi     # 0x4e21a
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x65e4f(%rip), %rax     # 0x80af0
movq %rcx, (%rax)
leaq 0x33580(%rip), %rdi     # 0x4e22b
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x65e40(%rip), %rax     # 0x80af8
movq %rcx, (%rax)
leaq 0x3357d(%rip), %rdi     # 0x4e23f
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x65e31(%rip), %rax     # 0x80b00
movq %rcx, (%rax)
leaq 0x33576(%rip), %rdi     # 0x4e24f
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x65e22(%rip), %rax     # 0x80b08
movq %rcx, (%rax)
leaq 0x3356e(%rip), %rdi     # 0x4e25e
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x65e13(%rip), %rax     # 0x80b10
movq %rcx, (%rax)
leaq 0x33568(%rip), %rdi     # 0x4e26f
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x65e04(%rip), %rax     # 0x80b18
movq %rcx, (%rax)
leaq 0x33564(%rip), %rdi     # 0x4e282
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x65df5(%rip), %rax     # 0x80b20
movq %rcx, (%rax)
leaq 0x3355f(%rip), %rdi     # 0x4e294
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x65de6(%rip), %rax     # 0x80b28
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/inc/glad/glad.c
// Function: load_GL_APPLE_object_purgeable(void* (*)(char const*))
static void load_GL_APPLE_object_purgeable(GLADloadproc load) {
	if(!GLAD_GL_APPLE_object_purgeable) return;
	glad_glObjectPurgeableAPPLE = (PFNGLOBJECTPURGEABLEAPPLEPROC)load("glObjectPurgeableAPPLE");
	glad_glObjectUnpurgeableAPPLE = (PFNGLOBJECTUNPURGEABLEAPPLEPROC)load("glObjectUnpurgeableAPPLE");
	glad_glGetObjectParameterivAPPLE = (PFNGLGETOBJECTPARAMETERIVAPPLEPROC)load("glGetObjectParameterivAPPLE");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x65229(%rip), %rax     # 0x7ffdc
cmpl $0x0, (%rax)
jne 0x1adba
jmp 0x1adff
leaq 0x3351d(%rip), %rdi     # 0x4e2de
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x65d72(%rip), %rax     # 0x80b40
movq %rcx, (%rax)
leaq 0x3351d(%rip), %rdi     # 0x4e2f5
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x65d63(%rip), %rax     # 0x80b48
movq %rcx, (%rax)
leaq 0x3351f(%rip), %rdi     # 0x4e30e
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x65d54(%rip), %rax     # 0x80b50
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/inc/glad/glad.c
// Function: load_GL_APPLE_vertex_array_object(void* (*)(char const*))
static void load_GL_APPLE_vertex_array_object(GLADloadproc load) {
	if(!GLAD_GL_APPLE_vertex_array_object) return;
	glad_glBindVertexArrayAPPLE = (PFNGLBINDVERTEXARRAYAPPLEPROC)load("glBindVertexArrayAPPLE");
	glad_glDeleteVertexArraysAPPLE = (PFNGLDELETEVERTEXARRAYSAPPLEPROC)load("glDeleteVertexArraysAPPLE");
	glad_glGenVertexArraysAPPLE = (PFNGLGENVERTEXARRAYSAPPLEPROC)load("glGenVertexArraysAPPLE");
	glad_glIsVertexArrayAPPLE = (PFNGLISVERTEXARRAYAPPLEPROC)load("glIsVertexArrayAPPLE");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x65181(%rip), %rax     # 0x7fff4
cmpl $0x0, (%rax)
jne 0x1ae7a
jmp 0x1aed6
leaq 0x334dc(%rip), %rdi     # 0x4e35d
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x65cda(%rip), %rax     # 0x80b68
movq %rcx, (%rax)
leaq 0x334dc(%rip), %rdi     # 0x4e374
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x65ccb(%rip), %rax     # 0x80b70
movq %rcx, (%rax)
leaq 0x334df(%rip), %rdi     # 0x4e38e
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x65cbc(%rip), %rax     # 0x80b78
movq %rcx, (%rax)
leaq 0x334df(%rip), %rdi     # 0x4e3a5
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x65cad(%rip), %rax     # 0x80b80
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/inc/glad/glad.c
// Function: load_GL_APPLE_vertex_array_range(void* (*)(char const*))
static void load_GL_APPLE_vertex_array_range(GLADloadproc load) {
	if(!GLAD_GL_APPLE_vertex_array_range) return;
	glad_glVertexArrayRangeAPPLE = (PFNGLVERTEXARRAYRANGEAPPLEPROC)load("glVertexArrayRangeAPPLE");
	glad_glFlushVertexArrayRangeAPPLE = (PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC)load("glFlushVertexArrayRangeAPPLE");
	glad_glVertexArrayParameteriAPPLE = (PFNGLVERTEXARRAYPARAMETERIAPPLEPROC)load("glVertexArrayParameteriAPPLE");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x65105(%rip), %rax     # 0x7fff8
cmpl $0x0, (%rax)
jne 0x1aefa
jmp 0x1af3f
leaq 0x334b9(%rip), %rdi     # 0x4e3ba
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x65c7a(%rip), %rax     # 0x80b88
movq %rcx, (%rax)
leaq 0x334ba(%rip), %rdi     # 0x4e3d2
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x65c6b(%rip), %rax     # 0x80b90
movq %rcx, (%rax)
leaq 0x334c0(%rip), %rdi     # 0x4e3ef
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x65c5c(%rip), %rax     # 0x80b98
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/inc/glad/glad.c
// Function: load_GL_APPLE_vertex_program_evaluators(void* (*)(char const*))
static void load_GL_APPLE_vertex_program_evaluators(GLADloadproc load) {
	if(!GLAD_GL_APPLE_vertex_program_evaluators) return;
	glad_glEnableVertexAttribAPPLE = (PFNGLENABLEVERTEXATTRIBAPPLEPROC)load("glEnableVertexAttribAPPLE");
	glad_glDisableVertexAttribAPPLE = (PFNGLDISABLEVERTEXATTRIBAPPLEPROC)load("glDisableVertexAttribAPPLE");
	glad_glIsVertexAttribEnabledAPPLE = (PFNGLISVERTEXATTRIBENABLEDAPPLEPROC)load("glIsVertexAttribEnabledAPPLE");
	glad_glMapVertexAttrib1dAPPLE = (PFNGLMAPVERTEXATTRIB1DAPPLEPROC)load("glMapVertexAttrib1dAPPLE");
	glad_glMapVertexAttrib1fAPPLE = (PFNGLMAPVERTEXATTRIB1FAPPLEPROC)load("glMapVertexAttrib1fAPPLE");
	glad_glMapVertexAttrib2dAPPLE = (PFNGLMAPVERTEXATTRIB2DAPPLEPROC)load("glMapVertexAttrib2dAPPLE");
	glad_glMapVertexAttrib2fAPPLE = (PFNGLMAPVERTEXATTRIB2FAPPLEPROC)load("glMapVertexAttrib2fAPPLE");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x65099(%rip), %rax     # 0x7fffc
cmpl $0x0, (%rax)
jne 0x1af6d
jmp 0x1b00e
leaq 0x33498(%rip), %rdi     # 0x4e40c
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x65c1f(%rip), %rax     # 0x80ba0
movq %rcx, (%rax)
leaq 0x3349b(%rip), %rdi     # 0x4e426
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x65c10(%rip), %rax     # 0x80ba8
movq %rcx, (%rax)
leaq 0x3349f(%rip), %rdi     # 0x4e441
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x65c01(%rip), %rax     # 0x80bb0
movq %rcx, (%rax)
leaq 0x334a5(%rip), %rdi     # 0x4e45e
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x65bf2(%rip), %rax     # 0x80bb8
movq %rcx, (%rax)
leaq 0x334a7(%rip), %rdi     # 0x4e477
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x65be3(%rip), %rax     # 0x80bc0
movq %rcx, (%rax)
leaq 0x334a9(%rip), %rdi     # 0x4e490
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x65bd4(%rip), %rax     # 0x80bc8
movq %rcx, (%rax)
leaq 0x334ab(%rip), %rdi     # 0x4e4a9
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x65bc5(%rip), %rax     # 0x80bd0
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/inc/glad/glad.c
// Function: load_GL_ARB_ES2_compatibility(void* (*)(char const*))
static void load_GL_ARB_ES2_compatibility(GLADloadproc load) {
	if(!GLAD_GL_ARB_ES2_compatibility) return;
	glad_glReleaseShaderCompiler = (PFNGLRELEASESHADERCOMPILERPROC)load("glReleaseShaderCompiler");
	glad_glShaderBinary = (PFNGLSHADERBINARYPROC)load("glShaderBinary");
	glad_glGetShaderPrecisionFormat = (PFNGLGETSHADERPRECISIONFORMATPROC)load("glGetShaderPrecisionFormat");
	glad_glDepthRangef = (PFNGLDEPTHRANGEFPROC)load("glDepthRangef");
	glad_glClearDepthf = (PFNGLCLEARDEPTHFPROC)load("glClearDepthf");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x64fd1(%rip), %rax     # 0x80004
cmpl $0x0, (%rax)
jne 0x1b03a
jmp 0x1b0ad
leaq 0x33481(%rip), %rdi     # 0x4e4c2
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x65b8a(%rip), %rax     # 0x80bd8
movq %rcx, (%rax)
leaq 0x33482(%rip), %rdi     # 0x4e4da
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x65b7b(%rip), %rax     # 0x80be0
movq %rcx, (%rax)
leaq 0x3347a(%rip), %rdi     # 0x4e4e9
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x65b6c(%rip), %rax     # 0x80be8
movq %rcx, (%rax)
leaq 0x3347e(%rip), %rdi     # 0x4e504
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x65b5d(%rip), %rax     # 0x80bf0
movq %rcx, (%rax)
leaq 0x33475(%rip), %rdi     # 0x4e512
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x65b4e(%rip), %rax     # 0x80bf8
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/inc/glad/glad.c
// Function: load_GL_ARB_base_instance(void* (*)(char const*))
static void load_GL_ARB_base_instance(GLADloadproc load) {
	if(!GLAD_GL_ARB_base_instance) return;
	glad_glDrawArraysInstancedBaseInstance = (PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC)load("glDrawArraysInstancedBaseInstance");
	glad_glDrawElementsInstancedBaseInstance = (PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC)load("glDrawElementsInstancedBaseInstance");
	glad_glDrawElementsInstancedBaseVertexBaseInstance = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC)load("glDrawElementsInstancedBaseVertexBaseInstance");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x64ec5(%rip), %rax     # 0x80018
cmpl $0x0, (%rax)
jne 0x1b15a
jmp 0x1b19f
leaq 0x333f1(%rip), %rdi     # 0x4e552
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x65aa2(%rip), %rax     # 0x80c10
movq %rcx, (%rax)
leaq 0x333fc(%rip), %rdi     # 0x4e574
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x65a93(%rip), %rax     # 0x80c18
movq %rcx, (%rax)
leaq 0x33409(%rip), %rdi     # 0x4e598
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x65a84(%rip), %rax     # 0x80c20
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/inc/glad/glad.c
// Function: load_GL_ARB_debug_output(void* (*)(char const*))
static void load_GL_ARB_debug_output(GLADloadproc load) {
	if(!GLAD_GL_ARB_debug_output) return;
	glad_glDebugMessageControlARB = (PFNGLDEBUGMESSAGECONTROLARBPROC)load("glDebugMessageControlARB");
	glad_glDebugMessageInsertARB = (PFNGLDEBUGMESSAGEINSERTARBPROC)load("glDebugMessageInsertARB");
	glad_glDebugMessageCallbackARB = (PFNGLDEBUGMESSAGECALLBACKARBPROC)load("glDebugMessageCallbackARB");
	glad_glGetDebugMessageLogARB = (PFNGLGETDEBUGMESSAGELOGARBPROC)load("glGetDebugMessageLogARB");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x649fd(%rip), %rax     # 0x80060
cmpl $0x0, (%rax)
jne 0x1b66a
jmp 0x1b6c6
leaq 0x3322b(%rip), %rdi     # 0x4e89c
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x6569a(%rip), %rax     # 0x80d18
movq %rcx, (%rax)
leaq 0x3322d(%rip), %rdi     # 0x4e8b5
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x6568b(%rip), %rax     # 0x80d20
movq %rcx, (%rax)
leaq 0x3322e(%rip), %rdi     # 0x4e8cd
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x6567c(%rip), %rax     # 0x80d28
movq %rcx, (%rax)
leaq 0x33231(%rip), %rdi     # 0x4e8e7
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x6566d(%rip), %rax     # 0x80d30
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/inc/glad/glad.c
// Function: load_GL_ARB_draw_buffers_blend(void* (*)(char const*))
static void load_GL_ARB_draw_buffers_blend(GLADloadproc load) {
	if(!GLAD_GL_ARB_draw_buffers_blend) return;
	glad_glBlendEquationiARB = (PFNGLBLENDEQUATIONIARBPROC)load("glBlendEquationiARB");
	glad_glBlendEquationSeparateiARB = (PFNGLBLENDEQUATIONSEPARATEIARBPROC)load("glBlendEquationSeparateiARB");
	glad_glBlendFunciARB = (PFNGLBLENDFUNCIARBPROC)load("glBlendFunciARB");
	glad_glBlendFuncSeparateiARB = (PFNGLBLENDFUNCSEPARATEIARBPROC)load("glBlendFuncSeparateiARB");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x64079(%rip), %rax     # 0x8007c
cmpl $0x0, (%rax)
jne 0x1c00a
jmp 0x1c066
leaq 0x33294(%rip), %rdi     # 0x4f2a5
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x6502a(%rip), %rax     # 0x81048
movq %rcx, (%rax)
leaq 0x33291(%rip), %rdi     # 0x4f2b9
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x6501b(%rip), %rax     # 0x81050
movq %rcx, (%rax)
leaq 0x33296(%rip), %rdi     # 0x4f2d5
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x6500c(%rip), %rax     # 0x81058
movq %rcx, (%rax)
leaq 0x3328f(%rip), %rdi     # 0x4f2e5
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x64ffd(%rip), %rax     # 0x81060
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/inc/glad/glad.c
// Function: load_GL_ARB_draw_elements_base_vertex(void* (*)(char const*))
static void load_GL_ARB_draw_elements_base_vertex(GLADloadproc load) {
	if(!GLAD_GL_ARB_draw_elements_base_vertex) return;
	glad_glDrawElementsBaseVertex = (PFNGLDRAWELEMENTSBASEVERTEXPROC)load("glDrawElementsBaseVertex");
	glad_glDrawRangeElementsBaseVertex = (PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)load("glDrawRangeElementsBaseVertex");
	glad_glDrawElementsInstancedBaseVertex = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)load("glDrawElementsInstancedBaseVertex");
	glad_glMultiDrawElementsBaseVertex = (PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)load("glMultiDrawElementsBaseVertex");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x63ffd(%rip), %rax     # 0x80080
cmpl $0x0, (%rax)
jne 0x1c08a
jmp 0x1c0e6
leaq 0x2dd9f(%rip), %rdi     # 0x49e30
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x62d82(%rip), %rax     # 0x7ee20
movq %rcx, (%rax)
leaq 0x2dda1(%rip), %rdi     # 0x49e49
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x62d93(%rip), %rax     # 0x7ee48
movq %rcx, (%rax)
leaq 0x2dda8(%rip), %rdi     # 0x49e67
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x62d64(%rip), %rax     # 0x7ee30
movq %rcx, (%rax)
leaq 0x2ddb3(%rip), %rdi     # 0x49e89
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x6338d(%rip), %rax     # 0x7f470
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/inc/glad/glad.c
// Function: load_GL_ARB_geometry_shader4(void* (*)(char const*))
static void load_GL_ARB_geometry_shader4(GLADloadproc load) {
	if(!GLAD_GL_ARB_geometry_shader4) return;
	glad_glProgramParameteriARB = (PFNGLPROGRAMPARAMETERIARBPROC)load("glProgramParameteriARB");
	glad_glFramebufferTextureARB = (PFNGLFRAMEBUFFERTEXTUREARBPROC)load("glFramebufferTextureARB");
	glad_glFramebufferTextureLayerARB = (PFNGLFRAMEBUFFERTEXTURELAYERARBPROC)load("glFramebufferTextureLayerARB");
	glad_glFramebufferTextureFaceARB = (PFNGLFRAMEBUFFERTEXTUREFACEARBPROC)load("glFramebufferTextureFaceARB");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x63af9(%rip), %rax     # 0x800bc
cmpl $0x0, (%rax)
jne 0x1c5ca
jmp 0x1c626
leaq 0x32fa0(%rip), %rdi     # 0x4f571
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x64b52(%rip), %rax     # 0x81130
movq %rcx, (%rax)
leaq 0x32fa0(%rip), %rdi     # 0x4f588
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x64b43(%rip), %rax     # 0x81138
movq %rcx, (%rax)
leaq 0x32fa1(%rip), %rdi     # 0x4f5a0
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x64b34(%rip), %rax     # 0x81140
movq %rcx, (%rax)
leaq 0x32fa7(%rip), %rdi     # 0x4f5bd
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x64b25(%rip), %rax     # 0x81148
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/inc/glad/glad.c
// Function: load_GL_ARB_get_program_binary(void* (*)(char const*))
static void load_GL_ARB_get_program_binary(GLADloadproc load) {
	if(!GLAD_GL_ARB_get_program_binary) return;
	glad_glGetProgramBinary = (PFNGLGETPROGRAMBINARYPROC)load("glGetProgramBinary");
	glad_glProgramBinary = (PFNGLPROGRAMBINARYPROC)load("glProgramBinary");
	glad_glProgramParameteri = (PFNGLPROGRAMPARAMETERIPROC)load("glProgramParameteri");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x63a7d(%rip), %rax     # 0x800c0
cmpl $0x0, (%rax)
jne 0x1c64a
jmp 0x1c68f
leaq 0x32f88(%rip), %rdi     # 0x4f5d9
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x64af2(%rip), %rax     # 0x81150
movq %rcx, (%rax)
leaq 0x32f84(%rip), %rdi     # 0x4f5ec
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x64ae3(%rip), %rax     # 0x81158
movq %rcx, (%rax)
leaq 0x32f7d(%rip), %rdi     # 0x4f5fc
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x64ad4(%rip), %rax     # 0x81160
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/inc/glad/glad.c
// Function: load_GL_ARB_invalidate_subdata(void* (*)(char const*))
static void load_GL_ARB_invalidate_subdata(GLADloadproc load) {
	if(!GLAD_GL_ARB_invalidate_subdata) return;
	glad_glInvalidateTexSubImage = (PFNGLINVALIDATETEXSUBIMAGEPROC)load("glInvalidateTexSubImage");
	glad_glInvalidateTexImage = (PFNGLINVALIDATETEXIMAGEPROC)load("glInvalidateTexImage");
	glad_glInvalidateBufferSubData = (PFNGLINVALIDATEBUFFERSUBDATAPROC)load("glInvalidateBufferSubData");
	glad_glInvalidateBufferData = (PFNGLINVALIDATEBUFFERDATAPROC)load("glInvalidateBufferData");
	glad_glInvalidateFramebuffer = (PFNGLINVALIDATEFRAMEBUFFERPROC)load("glInvalidateFramebuffer");
	glad_glInvalidateSubFramebuffer = (PFNGLINVALIDATESUBFRAMEBUFFERPROC)load("glInvalidateSubFramebuffer");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x63031(%rip), %rax     # 0x800f4
cmpl $0x0, (%rax)
jne 0x1d0cd
jmp 0x1d157
leaq 0x32ce4(%rip), %rdi     # 0x4fdb8
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x64377(%rip), %rax     # 0x81458
movq %rcx, (%rax)
leaq 0x32ce5(%rip), %rdi     # 0x4fdd0
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x64368(%rip), %rax     # 0x81460
movq %rcx, (%rax)
leaq 0x32ce3(%rip), %rdi     # 0x4fde5
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x64359(%rip), %rax     # 0x81468
movq %rcx, (%rax)
leaq 0x32ce6(%rip), %rdi     # 0x4fdff
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x6434a(%rip), %rax     # 0x81470
movq %rcx, (%rax)
leaq 0x32ce6(%rip), %rdi     # 0x4fe16
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x6433b(%rip), %rax     # 0x81478
movq %rcx, (%rax)
leaq 0x32ce7(%rip), %rdi     # 0x4fe2e
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x6432c(%rip), %rax     # 0x81480
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/inc/glad/glad.c
// Function: load_GL_ARB_matrix_palette(void* (*)(char const*))
static void load_GL_ARB_matrix_palette(GLADloadproc load) {
	if(!GLAD_GL_ARB_matrix_palette) return;
	glad_glCurrentPaletteMatrixARB = (PFNGLCURRENTPALETTEMATRIXARBPROC)load("glCurrentPaletteMatrixARB");
	glad_glMatrixIndexubvARB = (PFNGLMATRIXINDEXUBVARBPROC)load("glMatrixIndexubvARB");
	glad_glMatrixIndexusvARB = (PFNGLMATRIXINDEXUSVARBPROC)load("glMatrixIndexusvARB");
	glad_glMatrixIndexuivARB = (PFNGLMATRIXINDEXUIVARBPROC)load("glMatrixIndexuivARB");
	glad_glMatrixIndexPointerARB = (PFNGLMATRIXINDEXPOINTERARBPROC)load("glMatrixIndexPointerARB");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x62f3d(%rip), %rax     # 0x80100
cmpl $0x0, (%rax)
jne 0x1d1ca
jmp 0x1d23d
leaq 0x32c78(%rip), %rdi     # 0x4fe49
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x642aa(%rip), %rax     # 0x81488
movq %rcx, (%rax)
leaq 0x32c7b(%rip), %rdi     # 0x4fe63
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x6429b(%rip), %rax     # 0x81490
movq %rcx, (%rax)
leaq 0x32c78(%rip), %rdi     # 0x4fe77
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x6428c(%rip), %rax     # 0x81498
movq %rcx, (%rax)
leaq 0x32c75(%rip), %rdi     # 0x4fe8b
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x6427d(%rip), %rax     # 0x814a0
movq %rcx, (%rax)
leaq 0x32c72(%rip), %rdi     # 0x4fe9f
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x6426e(%rip), %rax     # 0x814a8
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/inc/glad/glad.c
// Function: load_GL_ARB_multi_bind(void* (*)(char const*))
static void load_GL_ARB_multi_bind(GLADloadproc load) {
	if(!GLAD_GL_ARB_multi_bind) return;
	glad_glBindBuffersBase = (PFNGLBINDBUFFERSBASEPROC)load("glBindBuffersBase");
	glad_glBindBuffersRange = (PFNGLBINDBUFFERSRANGEPROC)load("glBindBuffersRange");
	glad_glBindTextures = (PFNGLBINDTEXTURESPROC)load("glBindTextures");
	glad_glBindSamplers = (PFNGLBINDSAMPLERSPROC)load("glBindSamplers");
	glad_glBindImageTextures = (PFNGLBINDIMAGETEXTURESPROC)load("glBindImageTextures");
	glad_glBindVertexBuffers = (PFNGLBINDVERTEXBUFFERSPROC)load("glBindVertexBuffers");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x62ea1(%rip), %rax     # 0x80104
cmpl $0x0, (%rax)
jne 0x1d26d
jmp 0x1d2f7
leaq 0x32c43(%rip), %rdi     # 0x4feb7
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x6422f(%rip), %rax     # 0x814b0
movq %rcx, (%rax)
leaq 0x32c3e(%rip), %rdi     # 0x4fec9
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x64220(%rip), %rax     # 0x814b8
movq %rcx, (%rax)
leaq 0x32c3a(%rip), %rdi     # 0x4fedc
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x64211(%rip), %rax     # 0x814c0
movq %rcx, (%rax)
leaq 0x32c32(%rip), %rdi     # 0x4feeb
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x64202(%rip), %rax     # 0x814c8
movq %rcx, (%rax)
leaq 0x32c2a(%rip), %rdi     # 0x4fefa
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x641f3(%rip), %rax     # 0x814d0
movq %rcx, (%rax)
leaq 0x32c27(%rip), %rdi     # 0x4ff0e
callq *-0x8(%rbp)
movq %rax, %rcx
leaq 0x641e4(%rip), %rax     # 0x814d8
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)