LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/FredTheDino[P]Fog/src/engine/platform/mixer.cpp
// Function: Mixer::init()
b8 init() {
    OTHER_THREAD(AUDIO);
    OTHER_THREAD(AUDIO_SOURCES);
    OTHER_THREAD(AUDIO_EFFECTS);

    audio_mixer.arena = Util::request_arena();

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

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
leaq 0x28ffc(%rip), %rax     # 0x50640
movb $0x1, %cl
movb %cl, 0x201(%rax)
movb %cl, 0x249(%rax)
movb %cl, 0x291(%rax)
xorl %r15d, %r15d
xorl %edi, %edi
callq 0xaf5a
leaq 0x43c87(%rip), %r14     # 0x6b2f0
movq %rax, 0x10(%r14)
leaq 0x27d04(%rip), %rbx     # 0x4f378
movw $0x20, 0x600(%rbx)
movw %r15w, 0x602(%rbx,%r15,2)
incq %r15
cmpq $0x20, %r15
jne 0x2767d
xorl %r15d, %r15d
movq 0x10(%r14), %rdi
movl $0x46500, %esi          # imm = 0x46500
callq 0x2f3f8
movq %rax, 0x648(%rbx,%r15)
addq $0x58, %r15
cmpq $0x370, %r15            # imm = 0x370
jne 0x27692
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rdx)
movl $0xbb80, (%rdx)         # imm = 0xBB80
movw $0x8120, 0x4(%rdx)      # imm = 0x8120
movw $0x800, 0x8(%rdx)       # imm = 0x800
movb $0x2, 0x6(%rdx)
leaq -0x5ff(%rip), %rax      # 0x270e1
movq %rax, 0x10(%rdx)
movl $0x37aec33e, 0x9c8(%rbx) # imm = 0x37AEC33E
movq %rbx, 0x18(%rdx)
leaq -0x60(%rbp), %rcx
xorl %edi, %edi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x2420
movl %eax, 0x9cc(%rbx)
testl %eax, %eax
je 0x27719
movl %eax, %edi
xorl %esi, %esi
callq 0x21a0
movb $0x1, %bl
jmp 0x27759
movq 0x278b0(%rip), %rax     # 0x4efd0
movq (%rax), %r14
callq 0x24b0
movq %rax, (%rsp)
leaq 0x957c(%rip), %rdi      # 0x30caf
leaq 0xa460(%rip), %rdx      # 0x31b9a
leaq 0x94b6(%rip), %r8       # 0x30bf7
leaq 0x9b73(%rip), %r9       # 0x312bb
xorl %ebx, %ebx
movq %r14, %rsi
movl $0x147, %ecx            # imm = 0x147
xorl %eax, %eax
callq 0x711f
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xbfe6
leaq 0x3d130(%rip), %rcx     # 0x64978
movl %eax, (%rcx)
movl $0x1, %edi
callq 0xbfe6
leaq 0x3d121(%rip), %rcx     # 0x6497c
movl %eax, (%rcx)
movl $0x1, %edi
callq 0xbfe6
leaq 0x3d112(%rip), %rcx     # 0x64980
movl %eax, (%rcx)
movl $0x1, %edi
callq 0xbfe6
leaq 0x3d103(%rip), %rcx     # 0x64984
movl %eax, (%rcx)
movl $0x1, %edi
callq 0xbfe6
leaq 0x3d0f4(%rip), %rcx     # 0x64988
movl %eax, (%rcx)
movl $0x1, %edi
callq 0xbfe6
leaq 0x3d0e5(%rip), %rcx     # 0x6498c
movl %eax, (%rcx)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/FredTheDino[P]Fog/src/engine/unix_main.cpp
// Function: Fog::update()
void update() {
    Logic::frame(SDL_GetTicks() / 1000.0f);

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
callq 0x2500
movl %eax, %eax
cvtsi2ss %rax, %xmm0
divss 0x851b(%rip), %xmm0     # 0x30020
leaq 0x28e14(%rip), %rbx     # 0x50920
movss 0x14028(%rbx), %xmm1
movaps %xmm0, %xmm2
subss %xmm1, %xmm2
xorps %xmm3, %xmm3
cmpneqss %xmm1, %xmm3
andps %xmm2, %xmm3
movss %xmm3, 0x1402c(%rbx)
movss %xmm0, 0x14028(%rbx)
cmpb $0x0, 0x437cc(%rip)     # 0x6b309
je 0x27b44
callq 0x23ab0
callq 0x23e47
callq 0x23952
leaq 0xa3c6(%rip), %rsi      # 0x31f1b
xorl %edi, %edi
callq 0x22084
leaq 0xa3bd(%rip), %rsi      # 0x31f20
movl $0x1, %edi
callq 0x22084
callq 0xb2a2
movl $0x1, %edi
callq 0x22154
callq 0x27bd5
movss 0x14028(%rbx), %xmm0
movss 0x1402c(%rbx), %xmm1
leaq 0x8(%rbx), %rdi
callq 0x24410
movss 0x14028(%rbx), %xmm0
movss 0x1402c(%rbx), %xmm1
addq $0x5010, %rbx           # imm = 0x5010
movq %rbx, %rdi
callq 0x24410
movq 0x43690(%rip), %rax     # 0x6b250
leaq 0x277b1(%rip), %rcx     # 0x4f378
movq %rax, 0x9bc(%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/FredTheDino[P]Fog/src/engine/unix_main.cpp
// Function: Fog::draw()
void draw() {
    START_PERF(RENDER);
    Renderer::clear();

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

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

    STOP_PERF(MAIN);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x9d92(%rip), %rsi      # 0x31f26
movl $0x2, %edi
callq 0x22084
leaq 0x3c983(%rip), %rax     # 0x64b28
movl $0x4100, %edi           # imm = 0x4100
callq *(%rax)
leaq 0x2876d(%rip), %rbx     # 0x50920
movss 0x14028(%rbx), %xmm0
movss 0x1402c(%rbx), %xmm1
leaq 0xa018(%rbx), %rdi
callq 0x24410
movss 0x14028(%rbx), %xmm0
movss 0x1402c(%rbx), %xmm1
addq $0xf020, %rbx           # imm = 0xF020
movq %rbx, %rdi
callq 0x24410
callq 0x214af
movl $0x2, %edi
callq 0x22154
xorl %edi, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x22154
// File: /workspace/github_c_makefile_star2_O1/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 0x278ab
movl $0x1, 0x2701b(%rip)     # 0x4f374
callq 0x2500
movl %eax, %eax
cvtsi2ss %rax, %xmm0
divss 0x7cb3(%rip), %xmm0     # 0x30020
leaq 0x285ac(%rip), %rax     # 0x50920
movss 0x14028(%rax), %xmm1
movaps %xmm0, %xmm2
subss %xmm1, %xmm2
xorps %xmm3, %xmm3
cmpneqss %xmm1, %xmm3
andps %xmm2, %xmm3
movss %xmm3, 0x1402c(%rax)
movss %xmm0, 0x14028(%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/FredTheDino[P]Fog/src/engine/unix_main.cpp
// Function: Fog::run(void (*)(), void (*)())
void run(FogCallback user_update, FogCallback user_draw) {
    post_init();
    while (SDL::running) {
        Logic::frame(SDL_GetTicks() / 1000.0f);

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

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

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

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

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

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

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

        STOP_PERF(MAIN);
    }

    _fog_close_app_responsibly();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, -0x30(%rbp)
callq 0x28346
cmpb $0x0, 0x42f43(%rip)     # 0x6b308
jne 0x28565
leaq 0x2854e(%rip), %r14     # 0x50920
leaq 0x8(%r14), %r13
leaq 0x5010(%r14), %r15
leaq 0xa018(%r14), %r12
leaq 0xf020(%r14), %rbx
callq 0x2500
movl %eax, %eax
xorps %xmm0, %xmm0
cvtsi2ss %rax, %xmm0
divss 0x7c1e(%rip), %xmm0     # 0x30020
movss 0x14028(%r14), %xmm1
movaps %xmm0, %xmm2
subss %xmm1, %xmm2
cmpneqss 0x7e1d(%rip), %xmm1     # 0x30238
andps %xmm2, %xmm1
movss %xmm1, 0x1402c(%r14)
movss %xmm0, 0x14028(%r14)
cmpb $0x0, 0x42ed2(%rip)     # 0x6b309
je 0x2843e
callq 0x23ab0
callq 0x23e47
callq 0x23952
xorl %edi, %edi
leaq 0x9aca(%rip), %rsi      # 0x31f1b
callq 0x22084
movl $0x1, %edi
leaq 0x9abe(%rip), %rsi      # 0x31f20
callq 0x22084
callq 0xb2a2
movl $0x1, %edi
callq 0x22154
callq 0x27bd5
leaq 0x3c4f6(%rip), %rax     # 0x64978
movl (%rax), %edi
movl $0xf, %esi
callq 0xbb5a
ucomiss 0x7da3(%rip), %xmm0     # 0x30238
jne 0x28499
jnp 0x284a0
movb $0x1, 0x42e68(%rip)     # 0x6b308
movss 0x14028(%r14), %xmm0
movss 0x1402c(%r14), %xmm1
movq %r13, %rdi
callq 0x24410
callq *-0x30(%rbp)
movss 0x14028(%r14), %xmm0
movss 0x1402c(%r14), %xmm1
movq %r15, %rdi
callq 0x24410
movq 0x42d72(%rip), %rax     # 0x6b250
leaq 0x26e93(%rip), %rcx     # 0x4f378
movq %rax, 0x9bc(%rcx)
movl $0x4100, %edi           # imm = 0x4100
leaq 0x3c630(%rip), %rax     # 0x64b28
callq *(%rax)
movl $0x2, %edi
leaq 0x9a20(%rip), %rsi      # 0x31f26
callq 0x22084
movss 0x14028(%r14), %xmm0
movss 0x1402c(%r14), %xmm1
movq %r12, %rdi
callq 0x24410
callq *-0x38(%rbp)
movss 0x14028(%r14), %xmm0
movss 0x1402c(%r14), %xmm1
movq %rbx, %rdi
callq 0x24410
movl $0x2, %edi
callq 0x22154
callq 0x214af
xorl %edi, %edi
callq 0x22154
cmpb $0x1, 0x42da9(%rip)     # 0x6b308
jne 0x283eb
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x71d6
// File: /workspace/github_c_makefile_star2_O1/FredTheDino[P]Fog/src/engine/util/printf.c
// Function: out_rev(void (*)(char, void*, unsigned long, unsigned long), char*, unsigned long, unsigned long, char const*, unsigned long, unsigned int, unsigned int)
static size_t _out_rev(out_fct_type out, char* buffer, size_t idx, size_t maxlen, const char* buf, size_t len, unsigned int width, unsigned int flags)
{
  const size_t start_idx = idx;

  // pad spaces up to given width
  if (!(flags & FLAGS_LEFT) && !(flags & FLAGS_ZEROPAD)) {
    for (size_t i = len; i < width; i++) {
      out(' ', buffer, idx++, maxlen);
    }
  }

  // reverse string
  while (len) {
    out(buf[--len], buffer, idx++, maxlen);
  }

  // append pad spaces up to given width
  if (flags & FLAGS_LEFT) {
    while (idx - start_idx < width) {
      out(' ', buffer, idx++, maxlen);
    }
  }

  return idx;
}

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

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

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

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

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x2, 0x3d76a(%rip)     # 0x6b320
jg 0x2dc28
movq 0x3d769(%rip), %r15     # 0x6b328
testq %r15, %r15
sete %al
testq %rbx, %rbx
sete %cl
xorl %r14d, %r14d
orb %al, %cl
jne 0x2dc6e
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2290
testq %rax, %rax
je 0x2dc6e
movq %rax, %r13
movq %rbx, %rdi
callq 0x2250
movq %rax, %r12
movq %r15, %rax
leaq (%r12,%r13), %r15
cmpq %rax, %r13
je 0x2dc0b
cmpb $0x20, -0x1(%r13)
jne 0x2dc13
movzbl (%r15), %eax
testb $-0x21, %al
je 0x2dc68
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2290
movq %rax, %r13
testq %rax, %rax
jne 0x2dbf8
jmp 0x2dc6e
movq 0x3d709(%rip), %r15     # 0x6b338
xorl %r14d, %r14d
testq %r15, %r15
je 0x2dc6e
movslq 0x3d6f2(%rip), %r12     # 0x6b330
testq %r12, %r12
jle 0x2dc6e
xorl %r14d, %r14d
movq (%r15,%r14,8), %rdi
testq %rdi, %rdi
je 0x2dc5b
movq %rbx, %rsi
callq 0x23d0
testl %eax, %eax
je 0x2dc68
incq %r14
cmpq %r14, %r12
jne 0x2dc46
xorl %r14d, %r14d
jmp 0x2dc6e
movl $0x1, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/FredTheDino[P]Fog/src/engine/util/memory.cpp
// Function: Input::Mapping::VirtualButton* Util::MemoryArena::push<Input::Mapping::VirtualButton>(unsigned long long)
T *MemoryArena::push(u64 count) {
    CHECK_ILLEGAL_ALLOC;
    u64 allocation_size = sizeof(T) * count;
    ASSERT(allocation_size <= ARENA_SIZE_IN_BYTES, "Too large allocation");
    if (watermark + allocation_size > ARENA_SIZE_IN_BYTES) {
        if (!next) {
            if (only_one) HALT_AND_CATCH_FIRE;
            // Only complain once.
            allow_allocation();
            next = request_arena();
        }
        return next->push<T>(count);
    }
    void *region = (void *) (((u8 *) memory) + watermark);
    watermark += allocation_size;
    return (T *) region;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
shlq $0x4, %r14
movl $0x200001, %r13d        # imm = 0x200001
leaq 0x2f30(%rip), %r15      # 0x30cdf
leaq 0x17a4e(%rip), %r12     # 0x45804
movl 0x215b8(%rip), %eax     # 0x4f374
cmpl $0x2, %eax
je 0x2de0f
cmpl $0x1, %eax
jne 0x2de05
movl 0x36c04(%rip), %eax     # 0x649d0
incl %eax
movl %eax, 0x36bfc(%rip)     # 0x649d0
movq 0x211f5(%rip), %rcx     # 0x4efd0
movq (%rcx), %rsi
movl %eax, (%rsp)
leaq 0x2ec7(%rip), %rdi      # 0x30caf
movq %r15, %rdx
movl $0x2a, %ecx
leaq 0x2f03(%rip), %r8       # 0x30cfa
leaq 0x2f14(%rip), %r9       # 0x30d12
xorl %eax, %eax
callq 0x711f
movl $0x1, 0x21565(%rip)     # 0x4f374
xorl %ecx, %ecx
cmpq %r13, %r14
setb %cl
movq %r15, %rdi
movl $0x7c, %esi
movq %r12, %rdx
callq 0x722f
movq 0x8(%rbx), %rax
leaq (%rax,%r14), %rcx
cmpq %r13, %rcx
jb 0x2de67
cmpq $0x0, 0x10(%rbx)
jne 0x2de5e
cmpb $0x0, (%rbx)
jne 0x2de7e
cmpl $0x1, 0x2152d(%rip)     # 0x4f374
jne 0x2de53
movl $0x0, 0x21521(%rip)     # 0x4f374
xorl %edi, %edi
callq 0xaf5a
movq %rax, 0x10(%rbx)
movq 0x10(%rbx), %rbx
jmp 0x2ddb6
addq 0x18(%rbx), %rax
movq %rcx, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x71d6
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2330
nop
// File: /workspace/github_c_makefile_star2_O1/FredTheDino[P]Fog/src/engine/renderer/opengl_renderer.cpp
// Function: Renderer::Impl::RenderQueue<Renderer::Impl::Vertex>::create(unsigned int)
void RenderQueue<T>::create(u32 triangles_per_buffer) {
    ASSERT(gl_draw_hint == 0,
           "Cannot create same RenderQueue twice without deleting.");
    buffer_size = triangles_per_buffer * 3;
    arena = Util::request_arena(true);
    vertex_buffers = arena->push<GLBuffer>(num_buffers);

    gl_draw_hint = GL_TRIANGLES;

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

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, -0x38(%rbp)
movl %esi, %r14d
movq %rdi, %r15
xorl %ecx, %ecx
cmpl $0x0, 0x4(%rdi)
setne %cl
leaq 0x2ff0(%rip), %r12      # 0x31085
leaq 0x17825(%rip), %rdx     # 0x458c1
movq %r12, %rdi
movl $0x6c, %esi
callq 0x722f
xorl %ecx, %ecx
cmpl $0x4, 0x4(%r15)
sete %cl
leaq 0x1783e(%rip), %rdx     # 0x458f8
movq %r12, %rdi
movl $0x6d, %esi
callq 0x722f
testl %r14d, %r14d
je 0x2e176
movl 0x8(%r15), %r13d
movl %r13d, 0x8(%r15)
cmpl 0xc(%r15), %r13d
jne 0x2e0e6
movq %r15, %rdi
callq 0x2f600
movq 0x10(%r15), %rax
movl (%r15), %ebx
movl 0x8(%r15), %ecx
leaq (%rcx,%rcx,2), %rcx
subl (%rax,%rcx,4), %ebx
je 0x2e16a
movl %r14d, -0x2c(%rbp)
leaq (%rax,%rcx,4), %r14
cmpl %ebx, -0x2c(%rbp)
cmovbl -0x2c(%rbp), %ebx
movl 0x8(%r14), %edi
leaq 0x369a4(%rip), %rax     # 0x64ab8
callq *(%rax)
movl 0x4(%r14), %esi
movl $0x8892, %edi           # imm = 0x8892
leaq 0x3695a(%rip), %rax     # 0x64a80
callq *(%rax)
movl (%r14), %eax
shlq $0x2, %rax
leaq (%rax,%rax,8), %rsi
leaq (,%rbx,4), %rax
leaq (%rax,%rax,8), %rdx
movq %rdx, -0x40(%rbp)
movl $0x8892, %edi           # imm = 0x8892
movq -0x38(%rbp), %r12
movq %r12, %rcx
leaq 0x369aa(%rip), %rax     # 0x64b00
callq *(%rax)
addl %ebx, (%r14)
movl -0x2c(%rbp), %r14d
subl %ebx, %r14d
addq -0x40(%rbp), %r12
movq %r12, -0x38(%rbp)
incl %r13d
testl %r14d, %r14d
jne 0x2e0d4
leaq 0x3693b(%rip), %rax     # 0x64ab8
xorl %edi, %edi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *(%rax)
nop
// File: /workspace/github_c_makefile_star2_O1/FredTheDino[P]Fog/src/engine/renderer/opengl_renderer.cpp
// Function: Renderer::Impl::RenderQueue<Renderer::Impl::Vertex>::draw() const
void RenderQueue<T>::draw() const {
    ASSERT(gl_draw_hint, "Trying to use uninitalized render queue");
    for (u32 i = 0; i < num_buffers; i++) {
        GLBuffer buffer = vertex_buffers[i];
        if (buffer.draw_length == 0) break;
        buffer.bind();
        glBindBuffer(GL_ARRAY_BUFFER, buffer.gl_buffer);
        glDrawArrays(gl_draw_hint, 0, buffer.draw_length);
    }
    glBindVertexArray(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %ecx, %ecx
cmpl $0x0, 0x4(%rdi)
setne %cl
leaq 0x2daa(%rip), %rdi      # 0x31085
leaq 0x175a9(%rip), %rdx     # 0x4588b
movl $0xcf, %esi
callq 0x722f
cmpl $0x0, 0xc(%rbx)
je 0x2e35b
xorl %r12d, %r12d
movl $0x8, %r13d
movq 0x10(%rbx), %rax
movl -0x8(%rax,%r13), %r14d
testl %r14d, %r14d
je 0x2e35b
movl -0x4(%rax,%r13), %r15d
movl (%rax,%r13), %edi
leaq 0x3679f(%rip), %rax     # 0x64ab8
callq *(%rax)
movl $0x8892, %edi           # imm = 0x8892
movl %r15d, %esi
leaq 0x36756(%rip), %rax     # 0x64a80
callq *(%rax)
movl $0x8892, %edi           # imm = 0x8892
movl %r15d, %esi
leaq 0x36745(%rip), %rax     # 0x64a80
callq *(%rax)
movl 0x4(%rbx), %edi
xorl %esi, %esi
movl %r14d, %edx
leaq 0x36a7c(%rip), %rax     # 0x64dc8
callq *(%rax)
incl %r12d
addq $0xc, %r13
cmpl 0xc(%rbx), %r12d
jb 0x2e2fb
leaq 0x36756(%rip), %rax     # 0x64ab8
xorl %edi, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *(%rax)
// File: /workspace/github_c_makefile_star2_O1/FredTheDino[P]Fog/src/engine/asset/asset.h
// Function: Asset::Font::find_kerning(char, char)
f32 find_kerning(char a, char b) {
        u16 key = (a << 8) | b;
        s64 low = 0;
        s64 high = num_kernings;
        s64 last_guess = -1;
        while (low <= high) {
            s64 cur = (low + high) / 2;
            if (cur < 0 || num_kernings < cur || cur == last_guess)
                break;
            last_guess = cur;
            u16 cur_key = kernings[cur].key;
            if (cur_key > key)
                high = cur + 1;
            else if (cur_key < key)
                low = cur + 1;
            else
                return kernings[cur].ammount;
        }
        return 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movzbl %sil, %esi
shll $0x8, %esi
movq 0x18(%rdi), %rax
movq 0x28(%rdi), %rcx
movzwl %dx, %edx
orl %esi, %edx
movq $-0x1, %r10
xorl %esi, %esi
movq %rax, %rdi
xorps %xmm0, %xmm0
cmpq %rdi, %rsi
jg 0x2e4bc
leaq (%rsi,%rdi), %r8
shrq %r8
cmpq %r8, %rax
setl %r9b
cmpq %r10, %r8
sete %r11b
orb %r9b, %r11b
movl $0x3, %r9d
je 0x2e47f
movq %r10, %r8
jmp 0x2e4ab
movzwl (%rcx,%r8,8), %r9d
cmpl %r9d, %edx
jae 0x2e491
movq %r8, %rdi
incq %rdi
jmp 0x2e499
jbe 0x2e49e
movq %r8, %rsi
incq %rsi
xorl %r9d, %r9d
jmp 0x2e4ab
movss 0x4(%rcx,%r8,8), %xmm1
movl $0x1, %r9d
movq %r8, %r10
testl %r9d, %r9d
je 0x2e455
cmpl $0x3, %r9d
je 0x2e4bc
movaps %xmm1, %xmm0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/FredTheDino[P]Fog/src/engine/asset/asset.cpp
// Function: unsigned long Asset::read_from_file<Asset::FileHeader>(_IO_FILE*, void*, unsigned long)
size_t read_from_file(FILE *stream, void *ptr, size_t num = 1) {
    if (!num) {
        ERR("Has to read something from file, invalid read");
        return 0;
    }
    size_t read = 0;
    do {
        size_t last_read = fread(ptr, sizeof(T), num - read, stream);
        ASSERT(last_read, "Failed to read anything from asset file.");
        read += last_read;
        ptr = (void *) ((u8 *) ptr + last_read * sizeof(T));
    } while (read < num);
    return read;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x2e62d
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %ebx, %ebx
movq %r14, %rdx
subq %rbx, %rdx
movl $0x20, %esi
movq %r15, %rdi
movq %r12, %rcx
callq 0x22c0
movq %rax, %r13
xorl %ecx, %ecx
testq %rax, %rax
setne %cl
leaq 0x2fdb(%rip), %rdi      # 0x315e6
movl $0x4d, %esi
leaq 0x17353(%rip), %rdx     # 0x4596a
callq 0x722f
addq %r13, %rbx
shlq $0x5, %r13
addq %r13, %r15
cmpq %r14, %rbx
jb 0x2e5e3
jmp 0x2e661
movq 0x2099c(%rip), %rax     # 0x4efd0
movq (%rax), %rsi
leaq 0x2671(%rip), %rdi      # 0x30caf
leaq 0x2fa1(%rip), %rdx      # 0x315e6
leaq 0x172e1(%rip), %r8      # 0x4592d
leaq 0x172e9(%rip), %r9      # 0x4593c
xorl %ebx, %ebx
movl $0x47, %ecx
xorl %eax, %eax
callq 0x711f
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/FredTheDino[P]Fog/src/engine/logic/logic.h
// Function: Logic::Timer::call(float, float)
void call(f32 time, f32 delta) {
        if (next <= time && next != -1) {
            if (end == FOREVER) {
                callback(delta, time, 0, aux);
            } else if (end == ONCE) {
                callback(delta, time, 1, aux);
            } else {
                f32 percent = CLAMP(0, 1, (time - start) / (end - start));
                callback(delta, time, percent, aux);
            }
            next += spacing;
        }
    }

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

        data[length - 1] = element;
    }

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorl %ecx, %ecx
cmpl $0x0, 0x4(%rdi)
setne %cl
leaq 0x1a61(%rip), %rdi      # 0x31085
leaq 0x16260(%rip), %rdx     # 0x4588b
movl $0x88, %esi
callq 0x722f
movq 0x18(%rbx), %r14
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x2f651
movq 0x10(%rdi), %rax
movq %rax, 0x10(%r14)
callq 0xb0dd
jmp 0x2f639
movq $0x0, 0x8(%r14)
movl 0xc(%rbx), %r14d
leal 0x3(%r14), %esi
movl %esi, 0xc(%rbx)
movq 0x18(%rbx), %rdi
callq 0x2f4fc
cmpq 0x10(%rbx), %rax
je 0x2f6a7
testq %r14, %r14
je 0x2f6a3
leaq (,%r14,4), %rcx
leaq (%rcx,%rcx,2), %rcx
xorl %edx, %edx
movq 0x10(%rbx), %rsi
movl 0x8(%rsi,%rdx), %edi
movl %edi, 0x8(%rax,%rdx)
movq (%rsi,%rdx), %rsi
movq %rsi, (%rax,%rdx)
addq $0xc, %rdx
cmpq %rdx, %rcx
jne 0x2f686
movq %rax, 0x10(%rbx)
leaq 0x35912(%rip), %rax     # 0x64fc0
leaq -0x40(%rbp), %rsi
movl $0x3, %edi
callq *(%rax)
leaq 0x358d0(%rip), %rax     # 0x64f90
leaq -0x34(%rbp), %rsi
movl $0x3, %edi
callq *(%rax)
xorl %r12d, %r12d
movl -0x34(%rbp,%r12,4), %eax
movl -0x40(%rbp,%r12,4), %edi
movq 0x10(%rbx), %r13
leal (%r14,%r12), %ecx
leaq (%rcx,%rcx,2), %r15
movl $0x0, (%r13,%r15,4)
movl %eax, 0x4(%r13,%r15,4)
movl %edi, 0x8(%r13,%r15,4)
leaq 0x353ba(%rip), %rax     # 0x64ab8
callq *(%rax)
movl 0x4(%r13,%r15,4), %esi
movl $0x8892, %edi           # imm = 0x8892
leaq 0x3536f(%rip), %rax     # 0x64a80
callq *(%rax)
movl (%rbx), %eax
shlq $0x2, %rax
leaq (%rax,%rax,8), %rsi
movl $0x8892, %edi           # imm = 0x8892
xorl %edx, %edx
movl $0x88e0, %ecx           # imm = 0x88E0
leaq 0x353c8(%rip), %rax     # 0x64af8
callq *(%rax)
callq 0x1feee
incq %r12
cmpq $0x3, %r12
jne 0x2f6ce
xorl %edi, %edi
leaq 0x3536f(%rip), %rax     # 0x64ab8
callq *(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/FredTheDino[P]Fog/src/engine/util/block_list.h
// Function: Util::List<Vec2>::resize(unsigned int)
void resize(u32 new_size)
    {
        ASSERT(initalized, "Trying to use uninitalized list");
        // Only expand it. No need to free memory.
        if (capacity < new_size)
        {
            data = resize_memory<T>(data, sizeof(T) * new_size);
            capacity = new_size;
        }
    }

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

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

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

  puts("main process exited");

  return 0;
}

// Assembly:
pushq %rax
movq %rsp, %rdi
callq 0x179f
testl %eax, %eax
jne 0x1360
movq (%rsp), %rdi
leaq 0x89(%rip), %r8         # 0x13bd
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x21f3
testl %eax, %eax
jne 0x137f
movq (%rsp), %rdi
callq 0x23ae
testl %eax, %eax
jne 0x139e
leaq 0x1d54(%rip), %rdi      # 0x30ab
callq 0x1070
xorl %eax, %eax
popq %rcx
retq
leaq 0x1c9d(%rip), %rdi      # 0x3004
leaq 0x1cbb(%rip), %rsi      # 0x3029
leaq 0x1cc5(%rip), %rcx      # 0x303a
movl $0x15, %edx
callq 0x10c0
leaq 0x1cbf(%rip), %rdi      # 0x3045
leaq 0x1c9c(%rip), %rsi      # 0x3029
leaq 0x1ca6(%rip), %rcx      # 0x303a
movl $0x1d, %edx
callq 0x10c0
leaq 0x1ce3(%rip), %rdi      # 0x3088
leaq 0x1c7d(%rip), %rsi      # 0x3029
leaq 0x1c87(%rip), %rcx      # 0x303a
movl $0x20, %edx
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O1/motet-a[P]libforks/examples/basic.c
// Function: child_main
static void child_main(libforks_ServerConn conn, int socket_fd) {
  // not strictly required but recommended
  assert(libforks_free_conn(conn) == libforks_OK);

  assert(socket_fd == -1);
  puts("child process started");
  sleep(1);
  puts("child process exited");
}

// Assembly:
pushq %rbx
movl %esi, %ebx
callq 0x23db
testl %eax, %eax
jne 0x13f1
cmpl $-0x1, %ebx
jne 0x1410
leaq 0x1d4c(%rip), %rdi      # 0x3121
callq 0x1070
movl $0x1, %edi
callq 0x11e0
leaq 0x1d4c(%rip), %rdi      # 0x3137
popq %rbx
jmp 0x1070
leaq 0x1cc7(%rip), %rdi      # 0x30bf
leaq 0x1c2a(%rip), %rsi      # 0x3029
leaq 0x1ce1(%rip), %rcx      # 0x30e7
movl $0xb, %edx
callq 0x10c0
leaq 0x1cfa(%rip), %rdi      # 0x3111
leaq 0x1c0b(%rip), %rsi      # 0x3029
leaq 0x1cc2(%rip), %rcx      # 0x30e7
movl $0xd, %edx
callq 0x10c0
nop
// File: /workspace/github_c_makefile_star2_O1/ramirezsebas[P]TP-LISTINGS/./src/capitulo_3/3.3/fork.c
// Function: main
int main ()
{
	pid_t child_pid;
  //El id de proceso main
  printf("the main program process ID is %d\n", (int) getpid ());
	child_pid = fork ();
	if (child_pid != 0) {
		printf("this is the parent process, with id %d\n", (int) getpid ());
		printf("the child’s process ID is %d\n", (int) child_pid);
	}
	else
    printf ("this is the child process, with id %d\n", (int) getpid ());
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
callq 0x1050
leaq 0xe96(%rip), %rdi       # 0x2004
movl %eax, %esi
xorl %eax, %eax
callq 0x1030
callq 0x1040
movl %eax, %ebx
callq 0x1050
testl %ebx, %ebx
je 0x11a2
leaq 0xe99(%rip), %rdi       # 0x2027
movl %eax, %esi
xorl %eax, %eax
callq 0x1030
leaq 0xeb1(%rip), %rdi       # 0x204f
movl %ebx, %esi
jmp 0x11ab
leaq 0xec6(%rip), %rdi       # 0x206f
movl %eax, %esi
xorl %eax, %eax
callq 0x1030
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ikbenlike[P]nngutils/src/pwd.c
// Function: main
int main(int argc, char **argv){
    char pwd[PATH_MAX];

    if(!getcwd(pwd, sizeof(pwd))){
        fprintf(stderr, "%s: %s\n", argv[0], strerror(errno));
        return 1;
    }
    puts(pwd);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movq %rsi, %rbx
leaq -0x1010(%rbp), %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0x1050
testq %rax, %rax
je 0x11f9
leaq -0x1010(%rbp), %rdi
callq 0x1040
xorl %eax, %eax
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
callq 0x1090
movl $0x1, %eax
jmp 0x11ef
// File: /workspace/github_c_makefile_star2_O1/sushant8421[P]create_your_own_shell/break.c
// Function: main
int main(int argc , char *argv[]) {
	FILE *read;
	FILE *write;
	char line [128]; 
	int split_no=1, nof_lines=1,total_lines ;
	sscanf(argv[1], "%d", &total_lines); 
   
	read = fopen(argv[2],"r");
	if (!read)
		return 1;

	write= write_in(split_no);

	while (fgets(line, sizeof(line), read)!=NULL) {
		if (nof_lines == (total_lines+1)) 
		{
			fclose(write);
			nof_lines = 1;
			split_no++;
			write= write_in(split_no);	
			if (!write)
			return 1;
		}
		fprintf(write,"%s", line);
		nof_lines++;
	}
	fclose(read);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rsi, %rbx
movq 0x8(%rsi), %rdi
leaq 0xe29(%rip), %rsi       # 0x2016
leaq -0x2c(%rbp), %rdx
xorl %eax, %eax
callq 0x1060
movq 0x10(%rbx), %rdi
leaq 0xe16(%rip), %rsi       # 0x2019
callq 0x1070
testq %rax, %rax
je 0x12ec
movq %rax, %rbx
leaq 0xde9(%rip), %rsi       # 0x2004
leaq -0x1e0(%rbp), %r15
movl $0x1, %r14d
movq %r15, %rdi
movl $0x1, %edx
xorl %eax, %eax
callq 0x1080
leaq 0xdd6(%rip), %rsi       # 0x2014
movq %r15, %rdi
callq 0x1070
movq %rax, %r13
leaq -0xb0(%rbp), %rdi
movl $0x80, %esi
movq %rbx, %rdx
callq 0x1050
testq %rax, %rax
je 0x12df
leaq -0xb0(%rbp), %r15
movl $0x1, %r12d
movl -0x2c(%rbp), %eax
incl %eax
cmpl %eax, %r14d
jne 0x12bc
movq %r13, %rdi
callq 0x1030
incl %r12d
leaq -0x1e0(%rbp), %r14
movq %r14, %rdi
leaq 0xd6f(%rip), %rsi       # 0x2004
movl %r12d, %edx
xorl %eax, %eax
callq 0x1080
movq %r14, %rdi
leaq 0xd6b(%rip), %rsi       # 0x2014
callq 0x1070
movq %rax, %r13
movl $0x1, %r14d
testq %rax, %rax
je 0x12f2
movq %r15, %rdi
movq %r13, %rsi
callq 0x1040
incl %r14d
movq %r15, %rdi
movl $0x80, %esi
movq %rbx, %rdx
callq 0x1050
testq %rax, %rax
jne 0x126f
movq %rbx, %rdi
callq 0x1030
xorl %r14d, %r14d
jmp 0x12f2
movl $0x1, %r14d
movl %r14d, %eax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/neovim[P]libtermkey/demo-glib.c
// Function: main
int main(int argc, char *argv[])
{
  TERMKEY_CHECK_VERSION;

  tk = termkey_new(0, 0);

  if(!tk) {
    fprintf(stderr, "Cannot allocate termkey instance\n");
    exit(1);
  }

  GMainLoop *loop = g_main_loop_new(NULL, FALSE);

  g_io_add_watch(g_io_channel_unix_new(0), G_IO_IN, stdin_io, NULL);

  g_main_loop_run(loop);

  termkey_destroy(tk);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
xorl %edi, %edi
movl $0x17, %esi
callq 0x1080
xorl %edi, %edi
xorl %esi, %esi
callq 0x10b0
movq %rax, 0x2e2a(%rip)      # 0x40b8
testq %rax, %rax
je 0x12d9
xorl %edi, %edi
xorl %esi, %esi
callq 0x10a0
movq %rax, %rbx
xorl %edi, %edi
callq 0x1050
leaq 0x31(%rip), %rdx        # 0x12de
movq %rax, %rdi
movl $0x1, %esi
xorl %ecx, %ecx
callq 0x10d0
movq %rbx, %rdi
callq 0x1130
movq 0x2ded(%rip), %rdi      # 0x40b8
callq 0x1030
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x1150
// File: /workspace/github_c_makefile_star2_O1/neovim[P]libtermkey/demo-glib.c
// Function: stdin_io
static gboolean stdin_io(GIOChannel *source, GIOCondition condition, gpointer data)
{
  if(condition && G_IO_IN) {
    if(timeout_id)
      g_source_remove(timeout_id);

    termkey_advisereadable(tk);

    TermKeyResult ret;
    TermKeyKey key;
    while((ret = termkey_getkey(tk, &key)) == TERMKEY_RES_KEY) {
      on_key(tk, &key);
    }

    if(ret == TERMKEY_RES_AGAIN)
      timeout_id = g_timeout_add(termkey_get_waittime(tk), key_timer, NULL);
  }

  return TRUE;
}

// Assembly:
testl %esi, %esi
je 0x137e
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movl 0x2dc9(%rip), %edi      # 0x40c0
testl %edi, %edi
je 0x1300
callq 0x10f0
movq 0x2db1(%rip), %rdi      # 0x40b8
callq 0x1100
leaq -0x30(%rbp), %rbx
leaq -0x70(%rbp), %r14
movq 0x2d9d(%rip), %rdi      # 0x40b8
movq %rbx, %rsi
callq 0x10c0
cmpl $0x1, %eax
jne 0x134f
movq 0x2d89(%rip), %rdi      # 0x40b8
movl $0x32, %edx
movq %r14, %rsi
movq %rbx, %rcx
movl $0xc, %r8d
callq 0x1040
movq %r14, %rdi
callq 0x1060
jmp 0x1314
cmpl $0x3, %eax
jne 0x1376
movq 0x2d5d(%rip), %rdi      # 0x40b8
callq 0x10e0
leaq 0x1d(%rip), %rsi        # 0x1384
movl %eax, %edi
xorl %edx, %edx
callq 0x1110
movl %eax, 0x2d4a(%rip)      # 0x40c0
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/neovim[P]libtermkey/demo-glib.c
// Function: key_timer
static gboolean key_timer(gpointer data)
{
  TermKeyKey key;

  if(termkey_getkey_force(tk, &key) == TERMKEY_RES_KEY)
    on_key(tk, &key);

  return FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x58, %rsp
movq 0x2d24(%rip), %rdi      # 0x40b8
leaq -0x28(%rbp), %rsi
callq 0x1090
cmpl $0x1, %eax
jne 0x13cc
movq 0x2d0f(%rip), %rdi      # 0x40b8
leaq -0x60(%rbp), %rbx
leaq -0x28(%rbp), %rcx
movl $0x32, %edx
movq %rbx, %rsi
movl $0xc, %r8d
callq 0x1040
movq %rbx, %rdi
callq 0x1060
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ammarfaizi2[P]riyuu/src/main.c
// Function: main
int main(int argc, char *argv[], char *envp[])
{
	uint8_t exit_code = 0;
	riyuu_run run;

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

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

	exit_code = riyuu_exec_run(&run);

out:
	exit(exit_code);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb $0x0, -0x1(%rbp)
cmpl $0x1, %edi
jne 0x2557
movq (%rsi), %rdi
callq 0x7160
jmp 0x2574
leaq -0x18(%rbp), %rcx
leaq -0x1(%rbp), %r8
callq 0x7190
testb %al, %al
je 0x2574
leaq -0x18(%rbp), %rdi
callq 0x72c0
movb %al, -0x1(%rbp)
movzbl -0x1(%rbp), %edi
callq 0x21a0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/ammarfaizi2[P]riyuu/src/third_party/cjson/cJSON_Utils.c
// Function: cJSONUtils_strdup(unsigned char const*)
static unsigned char* cJSONUtils_strdup(const unsigned char* const string)
{
    size_t length = 0;
    unsigned char *copy = NULL;

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

    return copy;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x2140
movq %rax, %r14
incq %r14
movq %r14, %rdi
callq 0x5169
testq %rax, %rax
je 0x5b29
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x2040
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ammarfaizi2[P]riyuu/src/third_party/cjson/cJSON_Utils.c
// Function: cJSONUtils_ApplyPatches
CJSON_PUBLIC(int) cJSONUtils_ApplyPatches(cJSON * const object, const cJSON * const patches)
{
    const cJSON *current_patch = NULL;
    int status = 0;

    if (!cJSON_IsArray(patches))
    {
        /* malformed patches. */
        return 1;
    }

    if (patches != NULL)
    {
        current_patch = patches->child;
    }

    while (current_patch != NULL)
    {
        status = apply_patch(object, current_patch, false);
        if (status != 0)
        {
            return status;
        }
        current_patch = current_patch->next;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x4f5d
testl %eax, %eax
je 0x5d09
xorl %eax, %eax
testq %r14, %r14
je 0x5d10
movq 0x10(%r14), %r14
jmp 0x5d13
movl $0x1, %eax
jmp 0x5d33
xorl %r14d, %r14d
testq %r14, %r14
je 0x5d33
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x5d38
testl %eax, %eax
jne 0x5d33
movq (%r14), %r14
testq %r14, %r14
jne 0x5d18
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ammarfaizi2[P]riyuu/src/third_party/cjson/cJSON_Utils.c
// Function: cJSONUtils_GeneratePatches
CJSON_PUBLIC(cJSON *) cJSONUtils_GeneratePatches(cJSON * const from, cJSON * const to)
{
    cJSON *patches = NULL;

    if ((from == NULL) || (to == NULL))
    {
        return NULL;
    }

    patches = cJSON_CreateArray();
    create_patches(patches, (const unsigned char*)"", from, to, false);

    return patches;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0x64c5
xorl %r15d, %r15d
jmp 0x64eb
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4449
movq %rax, %r15
leaq 0x1fdc(%rip), %rsi      # 0x84b6
movq %rax, %rdi
movq %r14, %rdx
movq %rbx, %rcx
xorl %r8d, %r8d
callq 0x64f9
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ammarfaizi2[P]riyuu/src/third_party/cjson/cJSON_Utils.c
// Function: cJSONUtils_GeneratePatchesCaseSensitive
CJSON_PUBLIC(cJSON *) cJSONUtils_GeneratePatchesCaseSensitive(cJSON * const from, cJSON * const to)
{
    cJSON *patches = NULL;

    if ((from == NULL) || (to == NULL))
    {
        return NULL;
    }

    patches = cJSON_CreateArray();
    create_patches(patches, (const unsigned char*)"", from, to, true);

    return patches;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0x6875
xorl %r15d, %r15d
jmp 0x689e
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4449
movq %rax, %r15
leaq 0x1c2c(%rip), %rsi      # 0x84b6
movq %rax, %rdi
movq %r14, %rdx
movq %rbx, %rcx
movl $0x1, %r8d
callq 0x64f9
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ammarfaizi2[P]riyuu/src/third_party/cjson/cJSON_Utils.c
// Function: merge_patch(cJSON*, cJSON const*, int)
static cJSON *merge_patch(cJSON *target, const cJSON * const patch, const cJSON_bool case_sensitive)
{
    cJSON *patch_child = NULL;

    if (!cJSON_IsObject(patch))
    {
        /* scalar value, array or NULL, just duplicate */
        cJSON_Delete(target);
        return cJSON_Duplicate(patch, 1);
    }

    if (!cJSON_IsObject(target))
    {
        cJSON_Delete(target);
        target = cJSON_CreateObject();
    }

    patch_child = patch->child;
    while (patch_child != NULL)
    {
        if (cJSON_IsNull(patch_child))
        {
            /* NULL is the indicator to remove a value, see RFC7396 */
            if (case_sensitive)
            {
                cJSON_DeleteItemFromObjectCaseSensitive(target, patch_child->string);
            }
            else
            {
                cJSON_DeleteItemFromObject(target, patch_child->string);
            }
        }
        else
        {
            cJSON *replace_me = NULL;
            cJSON *replacement = NULL;

            if (case_sensitive)
            {
                replace_me = cJSON_DetachItemFromObjectCaseSensitive(target, patch_child->string);
            }
            else
            {
                replace_me = cJSON_DetachItemFromObject(target, patch_child->string);
            }

            replacement = merge_patch(replace_me, patch_child, case_sensitive);
            if (replacement == NULL)
            {
                return NULL;
            }

            cJSON_AddItemToObject(target, patch_child->string, replacement);
        }
        patch_child = patch_child->next;
    }
    return target;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x4f71
testl %eax, %eax
je 0x69a6
movq %rbx, %rdi
callq 0x4f71
testl %eax, %eax
jne 0x693f
movq %rbx, %rdi
callq 0x2cdd
callq 0x43b2
movq %rax, %rbx
movq 0x10(%r15), %r15
testq %r15, %r15
je 0x69c7
movq %r15, %rdi
callq 0x4f35
movq 0x38(%r15), %rsi
movq %rbx, %rdi
testl %eax, %eax
je 0x6967
testl %r14d, %r14d
je 0x6973
callq 0x4574
jmp 0x69a1
testl %r14d, %r14d
je 0x697a
callq 0x4527
jmp 0x697f
callq 0x454b
jmp 0x69a1
callq 0x4506
movq %rax, %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0x6900
testq %rax, %rax
je 0x69c5
movq 0x38(%r15), %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x3bde
movq (%r15), %r15
jmp 0x6943
movq %rbx, %rdi
callq 0x2cdd
movq %r15, %rdi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4c70
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq