LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/FredTheDino[P]Fog/src/engine/math/block_matrix.h
// Function: create_perspective_projection(float, float, float, float)
Mat4 create_perspective_projection(real fov, real aspect_ratio, real near_clip,
                                   real far_clip) {
    real w = tan(fov / 2.0f);

    Mat4 m = {};
    m._00 = 1.0f / (aspect_ratio * w);
    m._11 = 1.0f / w;
    m._22 = -(far_clip + near_clip) / (far_clip - near_clip);
    m._32 = -1.0f;
    m._23 = -(2.0f * far_clip * near_clip) / (far_clip - near_clip);
    return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movss %xmm3, -0x14(%rbp)
movss %xmm2, -0x10(%rbp)
movss %xmm1, -0xc(%rbp)
movq %rdi, %rbx
mulss 0x15a00(%rip), %xmm0    # 0x1900c
callq 0x22d0
xorps %xmm1, %xmm1
movups %xmm1, 0x14(%rbx)
movups %xmm1, 0x24(%rbx)
movups %xmm1, 0x30(%rbx)
movups %xmm1, 0x4(%rbx)
movss -0xc(%rbp), %xmm3
mulss %xmm0, %xmm3
movss 0x159cf(%rip), %xmm1    # 0x19004
movaps %xmm1, %xmm2
divss %xmm3, %xmm2
movss %xmm2, (%rbx)
divss %xmm0, %xmm1
movss -0x10(%rbp), %xmm3
movaps %xmm3, %xmm0
movss -0x14(%rbp), %xmm2
addss %xmm2, %xmm0
xorps 0x159d4(%rip), %xmm0    # 0x19030
movss %xmm1, 0x14(%rbx)
movaps %xmm2, %xmm1
subss %xmm3, %xmm1
divss %xmm1, %xmm0
movss %xmm0, 0x28(%rbx)
movl $0xbf800000, 0x38(%rbx) # imm = 0xBF800000
mulss 0x15990(%rip), %xmm2    # 0x19010
mulss %xmm3, %xmm2
divss %xmm1, %xmm2
movss %xmm2, 0x2c(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/FredTheDino[P]Fog/src/engine/math/block_matrix.h
// Function: transpose(Mat4)
Mat4 transpose(Mat4 m) {
    Mat4 t = {};

    for (u8 i = 0; i < 4; i++)
        for (u8 j = 0; j < 4; j++) t._[i][j] = m._[j][i];

    return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
leaq 0x10(%rbp), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %edx, %edx
movq %rdi, %rsi
xorl %edi, %edi
movss (%rcx,%rdi,4), %xmm0
movss %xmm0, (%rsi,%rdi)
addq $0x4, %rdi
cmpq $0x10, %rdi
jne 0x36bb
incq %rdx
addq $0x4, %rcx
addq $0x10, %rsi
cmpq $0x4, %rdx
jne 0x36b9
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/FredTheDino[P]Fog/src/engine/math/block_math.h
// Function: std_progress_func_vec4(Vec4, float, Vec4, float, float)
Vec4 std_progress_func_vec4(Vec4 start_value, f32 start_slope, Vec4 end_value, f32 end_slope, f32 progress) {
    f32 p = -2 + start_slope + end_slope;
    f32 q = -(-3 + 2 * start_slope + end_slope);
    f32 y = p * pow(progress, 3) + q * pow(progress, 2) + start_slope*progress;
    return LERP(start_value, end_value, y);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movss %xmm6, -0x8(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm3, -0x50(%rbp)
movaps %xmm1, -0x40(%rbp)
movaps %xmm0, -0x30(%rbp)
movss 0x14d43(%rip), %xmm0    # 0x19010
movss %xmm2, -0xc(%rbp)
addss %xmm2, %xmm0
addss %xmm2, %xmm2
addss 0x14d32(%rip), %xmm2    # 0x19014
addss %xmm5, %xmm0
addss %xmm5, %xmm2
movss %xmm2, -0x4(%rbp)
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
cvtss2sd %xmm6, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd 0x14e94(%rip), %xmm1    # 0x191a0
callq 0x2370
xorps %xmm1, %xmm1
cvtss2sd -0x4(%rbp), %xmm1
movsd -0x18(%rbp), %xmm2
mulsd %xmm2, %xmm2
mulsd %xmm1, %xmm2
mulsd -0x20(%rbp), %xmm0
subsd %xmm2, %xmm0
movss -0xc(%rbp), %xmm1
mulss -0x8(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
addsd %xmm0, %xmm1
xorps %xmm2, %xmm2
cvtsd2ss %xmm1, %xmm2
movss 0x14cb4(%rip), %xmm0    # 0x19004
subss %xmm2, %xmm0
movaps -0x30(%rbp), %xmm1
movaps %xmm1, %xmm3
mulss %xmm0, %xmm3
shufps $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
mulss %xmm0, %xmm1
movaps %xmm1, %xmm8
movaps -0x40(%rbp), %xmm1
movaps %xmm1, %xmm4
mulss %xmm0, %xmm4
shufps $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
mulss %xmm0, %xmm1
movaps %xmm1, %xmm6
movaps -0x50(%rbp), %xmm1
movaps %xmm1, %xmm0
mulss %xmm2, %xmm0
shufps $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
mulss %xmm2, %xmm1
movaps %xmm1, %xmm7
movaps -0x60(%rbp), %xmm5
movaps %xmm5, %xmm1
mulss %xmm2, %xmm1
shufps $0x55, %xmm5, %xmm5     # xmm5 = xmm5[1,1,1,1]
mulss %xmm2, %xmm5
addss %xmm3, %xmm0
addss %xmm8, %xmm7
unpcklps %xmm7, %xmm0            # xmm0 = xmm0[0],xmm7[0],xmm0[1],xmm7[1]
addss %xmm4, %xmm1
addss %xmm6, %xmm5
unpcklps %xmm5, %xmm1            # xmm1 = xmm1[0],xmm5[0],xmm1[1],xmm5[1]
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/FredTheDino[P]Fog/src/engine/math/block_math.h
// Function: binomial(unsigned int, unsigned int)
u32 binomial(u32 n, u32 k) {
    u32 res = 1;

    // k and n-k have the same binomial coeff so only calculate the "shorter"
    if (k > n - k)
        k = n - k;

    for (u32 i = 0; i < k; i++) {
        res *= (n - i);
        res /= (i + 1);
    }
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, %ecx
subl %esi, %ecx
cmpl %esi, %ecx
cmovael %esi, %ecx
testl %ecx, %ecx
je 0x43fb
negl %ecx
movl $0x1, %esi
movl $0x1, %eax
imull %edi, %eax
xorl %edx, %edx
divl %esi
leal (%rcx,%rsi), %edx
incl %edx
incl %esi
decl %edi
cmpl $0x1, %edx
jne 0x43e4
jmp 0x4400
movl $0x1, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/FredTheDino[P]Fog/src/engine/math/random.cpp
// Function: random_seed(unsigned int)
void random_seed(u32 seed) {
    // Generated random numbers from random.org.
    //
    // This makes it deterministic, which you might
    // not want.
    random_state.a = 398973565 ^ seed;
    random_state.b = 141307319 ^ seed;
    random_state.c =  15804145 ^ seed;
    random_state.d = 296129167 ^ seed;
    random_state.counter = 100;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, %eax
xorl $0x17c7da7d, %eax       # imm = 0x17C7DA7D
movl %eax, 0x1be1d(%rip)     # 0x20230
movl %edi, %eax
xorl $0x86c2db7, %eax        # imm = 0x86C2DB7
movl %eax, 0x1be14(%rip)     # 0x20234
movl %edi, %eax
xorl $0xf126f1, %eax         # imm = 0xF126F1
movl %eax, 0x1be0b(%rip)     # 0x20238
xorl $0x11a6928f, %edi       # imm = 0x11A6928F
movl %edi, 0x1be03(%rip)     # 0x2023c
movl $0x64, 0x1bdfd(%rip)    # 0x20240
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/FredTheDino[P]Fog/src/engine/math/random.cpp
// Function: xorwow()
u32 xorwow() {
    // Algorithm "xorwow" from p. 5 of Marsaglia, "Xorshift RNGs"
    // Stolen straight from Wikipedia.
    u32 t = random_state.d;

    u32 s = random_state.a;
    random_state.d = random_state.c;
    random_state.c = random_state.b;
    random_state.b = s;

    t ^= t >> 2;
    t ^= t << 1;
    t ^= s ^ (s << 4);
    random_state.a = t;

    random_state.counter += 362437;
    return t + random_state.counter;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x1bded(%rip), %eax     # 0x2023c
movl 0x1bddb(%rip), %ecx     # 0x20230
movq 0x1bdd8(%rip), %rdx     # 0x20234
movq %rdx, 0x1bdd5(%rip)     # 0x20238
movl %ecx, 0x1bdcb(%rip)     # 0x20234
movl %eax, %edx
shrl $0x2, %edx
xorl %eax, %edx
movl %ecx, %eax
shll $0x4, %eax
xorl %ecx, %eax
xorl %edx, %eax
addl %edx, %edx
xorl %eax, %edx
movl %edx, 0x1bdad(%rip)     # 0x20230
movl 0x1bdb7(%rip), %eax     # 0x20240
leal 0x587c5(%rax), %ecx
movl %ecx, 0x1bdab(%rip)     # 0x20240
addl %edx, %eax
addl $0x587c5, %eax          # imm = 0x587C5
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/FredTheDino[P]Fog/src/engine/math/random.cpp
// Function: random_unit_vec2()
Vec2 random_unit_vec2() {
    Vec2 out;
    while (true) {
        out = {random_real(-1, 1), random_real(-1, 1)};
        f32 sq = length_squared(out);
        if (sq > 1.0 || sq == 0.0)
            continue;
        return normalize(out);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x1bc68(%rip), %edx     # 0x2023c
movl 0x1bc56(%rip), %edi     # 0x20230
movl 0x1bc57(%rip), %r8d     # 0x20238
movl 0x1bc4d(%rip), %ecx     # 0x20234
movl 0x1bc53(%rip), %eax     # 0x20240
movss 0x14a27(%rip), %xmm2    # 0x1901c
movss 0x14a23(%rip), %xmm3    # 0x19020
movss 0x149ff(%rip), %xmm1    # 0x19004
xorps %xmm4, %xmm4
movl %edx, %r9d
movl %edi, %esi
movl %ecx, %edx
movl %r9d, %ecx
shrl $0x2, %ecx
xorl %r9d, %ecx
shll $0x4, %edi
xorl %esi, %edi
xorl %ecx, %edi
addl %ecx, %ecx
xorl %edi, %ecx
movl %eax, %r9d
leal (%r9,%rcx), %edi
addl $0x587c5, %edi          # imm = 0x587C5
xorps %xmm0, %xmm0
cvtsi2ss %rdi, %xmm0
mulss %xmm2, %xmm0
addss %xmm0, %xmm0
addss %xmm3, %xmm0
movl %r8d, %r10d
shrl $0x2, %r10d
xorl %r8d, %r10d
leal (%r10,%r10), %edi
movl %ecx, %r8d
shll $0x4, %r8d
xorl %r10d, %edi
xorl %ecx, %edi
xorl %r8d, %edi
leal (%r9,%rdi), %r8d
addl $0xb0f8a, %r8d          # imm = 0xB0F8A
xorps %xmm5, %xmm5
cvtsi2ss %r8, %xmm5
addl $0xb0f8a, %eax          # imm = 0xB0F8A
mulss %xmm2, %xmm5
addss %xmm5, %xmm5
addss %xmm3, %xmm5
movaps %xmm5, %xmm7
mulss %xmm5, %xmm7
movaps %xmm0, %xmm6
mulss %xmm0, %xmm6
addss %xmm7, %xmm6
ucomiss %xmm1, %xmm6
movl %esi, %r8d
ja 0x4608
ucomiss %xmm4, %xmm6
movl %esi, %r8d
jne 0x46b1
jnp 0x4608
movl %edx, 0x1bb85(%rip)     # 0x2023c
movl %edi, 0x1bb73(%rip)     # 0x20230
movl %esi, 0x1bb75(%rip)     # 0x20238
movl %ecx, 0x1bb6b(%rip)     # 0x20234
movl %eax, 0x1bb71(%rip)     # 0x20240
xorps %xmm2, %xmm2
sqrtss %xmm6, %xmm2
divss %xmm2, %xmm1
mulss %xmm1, %xmm0
mulss %xmm1, %xmm5
unpcklps %xmm5, %xmm0            # xmm0 = xmm0[0],xmm5[0],xmm0[1],xmm5[1]
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/FredTheDino[P]Fog/src/engine/math/random.cpp
// Function: random_unit_vec3()
Vec3 random_unit_vec3() {
    Vec3 out;
    while (true) {
        out = {random_real(-1, 1), random_real(-1, 1), random_real(-1, 1)};
        f32 sq = length_squared(out);
        if (sq > 1.0 || sq == 0.0)
            continue;
        return normalize(out);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x1bb4b(%rip), %esi     # 0x2023c
movl 0x1bb39(%rip), %edi     # 0x20230
movl 0x1bb3b(%rip), %edx     # 0x20238
movl 0x1bb31(%rip), %ecx     # 0x20234
movl 0x1bb37(%rip), %eax     # 0x20240
movss 0x1490b(%rip), %xmm3    # 0x1901c
movss 0x14907(%rip), %xmm4    # 0x19020
movss 0x148e3(%rip), %xmm2    # 0x19004
xorps %xmm5, %xmm5
movl %edx, %r8d
shrl $0x2, %r8d
xorl %edx, %r8d
movl %esi, %edx
shrl $0x2, %edx
xorl %esi, %edx
movl %edi, %esi
movl %ecx, %edi
movl %esi, %r9d
shll $0x4, %r9d
xorl %esi, %r9d
xorl %edx, %r9d
movl %ecx, %r10d
addl %edx, %edx
leal (%r8,%r8), %ecx
xorl %r8d, %ecx
movl %eax, %r8d
xorl %r9d, %edx
leal (%r8,%rdx), %r9d
addl $0x587c5, %r9d          # imm = 0x587C5
xorps %xmm0, %xmm0
cvtsi2ss %r9, %xmm0
movl %edx, %r9d
shll $0x4, %r9d
xorl %edx, %ecx
xorl %r9d, %ecx
leal (%r8,%rcx), %r9d
addl $0xb0f8a, %r9d          # imm = 0xB0F8A
xorps %xmm6, %xmm6
cvtsi2ss %r9, %xmm6
shrl $0x2, %r10d
xorl %edi, %r10d
leal (%r10,%r10), %edi
mulss %xmm3, %xmm0
movl %ecx, %r9d
shll $0x4, %r9d
xorl %r10d, %edi
mulss %xmm3, %xmm6
xorl %ecx, %edi
xorl %r9d, %edi
addl %edi, %r8d
addl $0x10974f, %r8d         # imm = 0x10974F
addss %xmm0, %xmm0
xorps %xmm1, %xmm1
cvtsi2ss %r8, %xmm1
addss %xmm4, %xmm0
addss %xmm6, %xmm6
addl $0x10974f, %eax         # imm = 0x10974F
mulss %xmm3, %xmm1
addss %xmm4, %xmm6
addss %xmm1, %xmm1
addss %xmm4, %xmm1
movaps %xmm6, %xmm8
mulss %xmm6, %xmm8
movaps %xmm0, %xmm9
mulss %xmm0, %xmm9
movaps %xmm1, %xmm7
addss %xmm8, %xmm9
mulss %xmm1, %xmm7
addss %xmm9, %xmm7
ucomiss %xmm2, %xmm7
ja 0x4724
ucomiss %xmm5, %xmm7
jne 0x4816
jnp 0x4724
movl %esi, 0x1ba20(%rip)     # 0x2023c
movl %edi, 0x1ba0e(%rip)     # 0x20230
movl %edx, 0x1ba10(%rip)     # 0x20238
movl %ecx, 0x1ba06(%rip)     # 0x20234
movl %eax, 0x1ba0c(%rip)     # 0x20240
sqrtss %xmm7, %xmm3
divss %xmm3, %xmm2
mulss %xmm2, %xmm0
mulss %xmm2, %xmm6
unpcklps %xmm6, %xmm0            # xmm0 = xmm0[0],xmm6[0],xmm0[1],xmm6[1]
mulss %xmm2, %xmm1
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/FredTheDino[P]Fog/src/engine/asset/asset.h
// Function: Asset::asset_hash(char const*)
u64 asset_hash(const char *str) {
    // This number is pretty arbitrary, it's prime and that's nice.
    u64 hash = 5351;
    while (*str) {
        char c = (*str++);
        hash = hash * c + c;
    }
    return hash % 0x0FFFFFFF;
}

// Assembly:
movb (%rdi), %al
testb %al, %al
je 0x48a2
pushq %rbp
movq %rsp, %rbp
incq %rdi
movl $0x14e7, %ecx           # imm = 0x14E7
movsbq %al, %rax
incq %rcx
imulq %rax, %rcx
movb (%rdi), %al
incq %rdi
testb %al, %al
jne 0x485f
movabsq $0x1000000101, %rdx     # imm = 0x1000000101
movq %rcx, %rax
mulq %rdx
movq %rcx, %rax
subq %rdx, %rax
shrq %rax
addq %rdx, %rax
shrq $0x1b, %rax
movq %rax, %rdx
shlq $0x1c, %rdx
subq %rdx, %rax
addq %rcx, %rax
popq %rbp
retq
movl $0x14e7, %eax           # imm = 0x14E7
retq
// File: /workspace/github_c_makefile_star2_O3/FredTheDino[P]Fog/src/engine/unix_assets.cpp
// Function: get_asset_header(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const*, Asset::Type)
Asset::Header get_asset_header(const std::string *path, Asset::Type type) {
    char *file_path = (char *) malloc(path->size() * sizeof(path[0]));
    const char *from = path->c_str();
    char *to = file_path;
    while (*from) *(to++) = *(from++);
    *(to++) = *(from++);
    // struct stat buffer;
    // if (stat(file_path, &buffer) == -1) return {};

    return {type,
            file_path,
            path->size() + 1,
            0,  // buffer.st_mtime,
            0,  //(u32) buffer.st_size,
            0,
            Asset::ASSET_ID_NO_ASSET};
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %r12
movq %r12, %rdi
shlq $0x5, %rdi
callq 0x2270
movq (%r15), %rcx
movb (%rcx), %dl
movq %rax, %rsi
testb %dl, %dl
je 0x6b85
incq %rcx
movq %rax, %rsi
movb %dl, (%rsi)
incq %rsi
movb (%rcx), %dl
incq %rcx
testb %dl, %dl
jne 0x6b77
movb $0x0, (%rsi)
movl %r14d, (%rbx)
movq %rax, 0x8(%rbx)
incq %r12
movq %r12, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
movq $0x0, 0x28(%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, 0x30(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/FredTheDino[P]Fog/src/engine/unix_assets.cpp
// Function: add_asset_to_file(AssetFile*, Asset::Header*, Asset::Data*)
void add_asset_to_file(AssetFile *file, Asset::Header *header, Asset::Data *asset) {
    assert(header);
    assert(asset);
    header->asset_id = file->asset_headers.size();

    file->header.number_of_assets++;
    file->header.size_of_strings += header->file_path_length;
    file->header.size_of_headers += sizeof(Asset::Header);
    file->header.size_of_data += header->asset_size;

    file->asset_headers.push_back(*header);
    file->assets.push_back(*asset);
    assert(file->asset_headers.size() == file->assets.size());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x6cba
movq %rdx, %r14
testq %rdx, %rdx
je 0x6cd9
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x28(%rdi), %rsi
movq %rsi, %rax
subq 0x20(%rdi), %rax
shrq $0x3, %rax
imull $0xb6db6db7, %eax, %eax # imm = 0xB6DB6DB7
movl %eax, 0x34(%rdx)
incq (%rdi)
movq 0x10(%rdx), %rax
addq %rax, 0x10(%rdi)
addq $0x38, 0x8(%rdi)
movl 0x30(%rdx), %eax
addq %rax, 0x18(%rdi)
cmpq 0x30(%rdi), %rsi
je 0x6c36
movq 0x30(%rdx), %rax
movq %rax, 0x30(%rsi)
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movups 0x20(%rdx), %xmm2
movups %xmm2, 0x20(%rsi)
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
addq $0x38, 0x28(%rbx)
jmp 0x6c3f
leaq 0x20(%rbx), %rdi
callq 0x17592
movq 0x40(%rbx), %rsi
cmpq 0x48(%rbx), %rsi
je 0x6c70
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%rsi)
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
movq 0x40(%rbx), %rax
addq $0x30, %rax
movq %rax, 0x40(%rbx)
jmp 0x6c80
leaq 0x38(%rbx), %rdi
movq %r14, %rdx
callq 0x17720
movq 0x40(%rbx), %rax
movq 0x28(%rbx), %rcx
subq 0x20(%rbx), %rcx
sarq $0x3, %rcx
movabsq $0x6db6db6db6db6db7, %rdx # imm = 0x6DB6DB6DB6DB6DB7
imulq %rcx, %rdx
subq 0x38(%rbx), %rax
sarq $0x4, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rcx
cmpq %rcx, %rdx
jne 0x6cf8
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x130f7(%rip), %rdi     # 0x19db8
leaq 0x12bec(%rip), %rsi     # 0x198b4
leaq 0x12c00(%rip), %rcx     # 0x198cf
movl $0x57, %edx
callq 0x2120
leaq 0x12c33(%rip), %rdi     # 0x19913
leaq 0x12bcd(%rip), %rsi     # 0x198b4
leaq 0x12be1(%rip), %rcx     # 0x198cf
movl $0x58, %edx
callq 0x2120
leaq 0x12c1a(%rip), %rdi     # 0x19919
leaq 0x12bae(%rip), %rsi     # 0x198b4
leaq 0x12bc2(%rip), %rcx     # 0x198cf
movl $0x62, %edx
callq 0x2120
// File: /workspace/github_c_makefile_star2_O3/FredTheDino[P]Fog/src/engine/unix_assets.cpp
// Function: load_texture(AssetFile*, Asset::Header*, unsigned char)
void load_texture(AssetFile *file, Asset::Header *header, b8 flip=true) {
    static u16 id = 0;
    int w, h, c;
    // NOTE(ed): Kinda a ugly hack, the sprite atlases aren't flipped, but the
    // normal sprites are.
    stbi_set_flip_vertically_on_load(flip);
    u8 *buffer = stbi_load(header->file_path, &w, &h, &c, 0);
    if (w > 512 || h > 512) {
        printf("\tCannot load %s, because it is too large.\n", header->file_path);
        return;
    }
    if (!buffer) {
        printf("\tFailed to load image %s", header->file_path);
        return;
    }
    Image image = {buffer, (u32) w, (u32) h, (u8) c, id++};
    header->asset_size = sizeof(Asset::Data) + w * h * c * sizeof(u8);
    Asset::Data asset = {image};

    add_asset_to_file(file, header, &asset);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, 0x1951e(%rip)     # 0x20250
movq 0x8(%rsi), %rdi
leaq -0x2c(%rbp), %r15
leaq -0x28(%rbp), %r12
leaq -0x24(%rbp), %rcx
movq %r15, %rsi
movq %r12, %rdx
xorl %r8d, %r8d
callq 0x48cb
movl (%r15), %ecx
movl $0x201, %edx            # imm = 0x201
cmpl %edx, %ecx
setge %dil
movl (%r12), %esi
cmpl %edx, %esi
setge %dl
orb %dil, %dl
cmpb $0x1, %dl
jne 0x6d7c
movq 0x8(%rbx), %rsi
leaq 0x12bd1(%rip), %rdi     # 0x1994b
jmp 0x6dd4
testq %rax, %rax
je 0x6dc9
movl -0x24(%rbp), %edi
movzwl 0x1950c(%rip), %r8d     # 0x20298
movl %r8d, %edx
incl %edx
movw %dx, 0x19500(%rip)      # 0x20298
movl %esi, %edx
imull %ecx, %edx
imull %edi, %edx
addl $0x30, %edx
movl %edx, 0x30(%rbx)
leaq -0x60(%rbp), %rdx
movq %rax, (%rdx)
movl %ecx, 0x8(%rdx)
movl %esi, 0xc(%rdx)
movb %dil, 0x10(%rdx)
movw %r8w, 0x12(%rdx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6bba
jmp 0x6ddb
movq 0x8(%rbx), %rsi
leaq 0x12ba2(%rip), %rdi     # 0x19976
xorl %eax, %eax
callq 0x2050
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/FredTheDino[P]Fog/src/engine/unix_assets.cpp
// Function: load_shader(AssetFile*, Asset::Header*)
void load_shader(AssetFile *file, Asset::Header *header) {
    FILE *shader_file = fopen(header->file_path, "rb");
    fseek(shader_file, 0, SEEK_END);
    long size = ftell(shader_file) + 1;
    rewind(shader_file);

    header->asset_size = size;
    Asset::Data asset = {.shader_source = (char *) malloc(size)};
    fread(asset.shader_source, 1, size, shader_file);
    asset.shader_source[size - 1] = '\0';

    add_asset_to_file(file, header, &asset);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, -0x38(%rbp)
movq 0x8(%rsi), %rdi
movq %rsi, %rbx
movq %rsi, -0x30(%rbp)
leaq 0x124a0(%rip), %rsi     # 0x198a5
callq 0x2220
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x2210
movq %r15, %rdi
callq 0x2030
movq %rax, %r12
leaq 0x1(%rax), %r13
movq %r15, %rdi
callq 0x2070
movl %r13d, 0x30(%rbx)
xorps %xmm0, %xmm0
leaq -0x68(%rbp), %r14
movups %xmm0, 0x18(%r14)
movups %xmm0, 0x8(%r14)
movq $0x0, 0x28(%r14)
movq %r13, %rdi
callq 0x2270
movq %rax, %rbx
movq %rax, (%r14)
movl $0x1, %esi
movq %rax, %rdi
movq %r13, %rdx
movq %r15, %rcx
callq 0x22f0
movb $0x0, (%rbx,%r12)
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %r14, %rdx
callq 0x6bba
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/FredTheDino[P]Fog/src/engine/unix_assets.cpp
// Function: process_asset(AssetFile*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const*)
void process_asset(AssetFile *file, const std::string *path) {
    size_t pos = path->find_last_of(".");
    if (pos == std::string::npos) return;
    std::string file_ending = path->substr(pos);
    if (!valid_endings.count(file_ending)) return;
    Asset::Type type = valid_endings[file_ending];

    Asset::Header header = get_asset_header(path, type);
    switch (header.type) {
        case (Asset::Type::TEXTURE): load_texture(file, &header); break;
        case (Asset::Type::FONT):    load_font(file, &header);    break;
        case (Asset::Type::SOUND):   load_sound(file, &header);   break;
        case (Asset::Type::SHADER):  load_shader(file, &header);  break;
        case (Asset::Type::SPRITE):  load_sprite(file, &header);  break;
        default:
            printf("!!!! Unhandled asset, unkown type: %s, %d\n", path->c_str(),
                   (int) header.type);
            return;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x120d5(%rip), %rsi     # 0x19b36
movl $0x1, %ecx
movq %r14, %rdi
movq $-0x1, %rdx
callq 0x23b0
cmpq $-0x1, %rax
je 0x7b61
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
movq $-0x1, %rcx
callq 0x2200
leaq 0x187c1(%rip), %rdi     # 0x20260
movq %r15, %rsi
callq 0x17d36
testq %rax, %rax
je 0x7b48
leaq 0x187a9(%rip), %rdi     # 0x20260
leaq -0x38(%rbp), %rsi
callq 0x17e62
movl (%rax), %edx
leaq -0x70(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x6b41
movl (%r15), %edx
leal -0x1(%rdx), %eax
cmpl $0x4, %eax
ja 0x7b37
leaq 0x116dd(%rip), %rcx     # 0x191c0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x6d17
jmp 0x7b48
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
callq 0x73de
jmp 0x7b48
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
callq 0x7495
jmp 0x7b48
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
callq 0x7852
jmp 0x7b48
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
callq 0x6e6b
jmp 0x7b48
movq (%r14), %rsi
leaq 0x11ff7(%rip), %rdi     # 0x19b38
xorl %eax, %eax
callq 0x2050
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7b61
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x21e0
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7b70
jmp 0x7b70
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7b8c
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_c_makefile_star2_O3/FredTheDino[P]Fog/src/engine/unix_assets.cpp
// Function: copy_string(char*, unsigned int)
char *copy_string(char *str, u32 size) {
    char *ptr = str;
    char *out = (char *) malloc(size);
    char *copy = out;
    while (*ptr) *(copy++) = *(ptr++);
    *copy = '\0';
    return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, %edi
callq 0x2270
movb (%rbx), %cl
movq %rax, %rdx
testb %cl, %cl
je 0x7bc1
incq %rbx
movq %rax, %rdx
movb %cl, (%rdx)
incq %rdx
movb (%rbx), %cl
incq %rbx
testb %cl, %cl
jne 0x7bb3
movb $0x0, (%rdx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/FredTheDino[P]Fog/src/engine/unix_assets.cpp
// Function: strip_file_ending(char*)
void strip_file_ending(char *str) {
    s32 last_dot = -1;
    char *ptr = str;
    for (s32 index = 0; ptr[index]; index++) {
        if (ptr[index] == '.')
            last_dot = index;
    }
    if (last_dot != -1)
        str[last_dot] = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
movzbl (%rdi,%rcx), %edx
cmpl $0x2e, %edx
je 0x7c2a
testl %edx, %edx
jne 0x7c2c
jmp 0x7c31
movl %ecx, %eax
incq %rcx
jmp 0x7c1b
cmpl $-0x1, %eax
je 0x7c3c
cltq
movb $0x0, (%rdi,%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/FredTheDino[P]Fog/src/engine/unix_assets.cpp
// Function: append(char*, char const*)
void append(char *str, const char *postfix) {
    while (*(str++)) /* NO-OP */;
    str--;
    while (*postfix)
        *(str++) = *(postfix++);
    *str = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rcx
incq %rdi
cmpb $0x0, (%rcx)
jne 0x7c42
movb (%rsi), %al
testb %al, %al
je 0x7c6e
movq $-0x1, %rcx
movb %al, (%rdi,%rcx)
movb 0x2(%rsi,%rcx), %al
incq %rcx
testb %al, %al
jne 0x7c5a
addq %rcx, %rdi
movq %rdi, %rcx
movb $0x0, (%rcx)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/FredTheDino[P]Fog/src/engine/unix_assets.cpp
// Function: asset_name_from_file(char*, Asset::Type)
char *asset_name_from_file(char *path, Asset::Type type) {
    u32 start = (strncmp(path, "res/", 4) == 0) * 3;
    while (path[start] == '/')
        start++;
    path += start; // Strip leading "res\/*"
    const u32 len = strlen(path) + (type == Asset::Type::FONT) * 5 + 1;
    char *name = copy_string(path, len);
    strip_file_ending(name);
    replace_all(name, '/', '_');
    replace_all(name, '-', '_');
    make_uppercase(name);
    if (type == Asset::Type::FONT)
        append(name, "_FONT");
    return name;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leaq 0x11ed9(%rip), %rsi     # 0x19b63
movl $0x4, %edx
callq 0x20f0
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
leal (%rcx,%rcx,2), %r12d
movl %r12d, %edi
movb (%r14,%rdi), %r15b
incl %r12d
cmpb $0x2f, %r15b
je 0x7c9f
addq %r14, %rdi
callq 0x20e0
xorl %ecx, %ecx
cmpl $0x2, %ebx
sete %cl
leal (%rcx,%rcx,4), %ecx
leal (%rax,%rcx), %edi
incl %edi
callq 0x2270
movq %rax, %rcx
testb %r15b, %r15b
je 0x7cf5
decl %r12d
movl %r12d, %ecx
leaq (%r14,%rcx), %rdx
incq %rdx
movq %rax, %rcx
movb %r15b, (%rcx)
incq %rcx
movb (%rdx), %r15b
incq %rdx
testb %r15b, %r15b
jne 0x7ce4
movb $0x0, (%rcx)
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
xorl %edx, %edx
movzbl (%rax,%rdx), %esi
cmpl $0x2e, %esi
je 0x7d0e
testl %esi, %esi
jne 0x7d10
jmp 0x7d15
movl %edx, %ecx
incq %rdx
jmp 0x7cff
cmpl $-0x1, %ecx
je 0x7d21
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movb (%rax), %dl
testb %dl, %dl
je 0x7d7d
leaq 0x1(%rax), %rcx
cmpb $0x2f, %dl
jne 0x7d34
movb $0x5f, -0x1(%rcx)
movb (%rcx), %dl
incq %rcx
testb %dl, %dl
jne 0x7d2b
movb (%rax), %dl
testb %dl, %dl
je 0x7d7d
leaq 0x1(%rax), %rcx
cmpb $0x2d, %dl
jne 0x7d50
movb $0x5f, -0x1(%rcx)
movb (%rcx), %dl
incq %rcx
testb %dl, %dl
jne 0x7d47
movb (%rax), %cl
testb %cl, %cl
je 0x7d7d
movq %rax, %rdx
incq %rdx
leal -0x61(%rcx), %esi
cmpb $0x19, %sil
ja 0x7d74
addb $-0x20, %cl
movb %cl, -0x1(%rdx)
movb (%rdx), %cl
incq %rdx
testb %cl, %cl
jne 0x7d65
cmpl $0x2, %ebx
jne 0x7db5
movq %rax, %rcx
cmpb $0x0, (%rcx)
leaq 0x1(%rcx), %rcx
jne 0x7d85
movb $0x5f, %sil
movq $-0x1, %rdx
leaq 0x11dc9(%rip), %rdi     # 0x19b68
movb %sil, (%rcx,%rdx)
movb 0x2(%rdx,%rdi), %sil
incq %rdx
cmpq $0x4, %rdx
jne 0x7d9f
movb $0x0, (%rcx,%rdx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ffoissey[P]minishell_42/srcs/ft_minishell.c
// Function: ft_prepare_cd
void		ft_prepare_cd(char **tab, t_list_ex **lst)
{
	char			*oldpwd;

	oldpwd = NULL;
	if (tab[1] && tab[2])
	{
		ft_dprintf(2, "cd: %s: string not in pwd\n", tab[1]);
		return ;
	}
	if (ft_lst_returnvalue(*lst, "PWD"))
		oldpwd = ft_strdup(ft_lst_returnvalue(*lst, "PWD"));
	else
	{
		if (!(oldpwd = getcwd(oldpwd, 0)))
		{
			ft_dprintf(2, "minishell: current dir not found\n");
			return ;
		}
		ft_lst_changevalue(lst, "PWD", oldpwd);
	}
	if (!ft_lst_returnvalue(*lst, "OLDPWD"))
		ft_lst_changevalue(lst, "OLDPWD", oldpwd);
	ft_cd(*lst, tab[1]);
	chdir(ft_lst_returnvalue(*lst, "PWD"));
	ft_lst_changevalue(lst, "OLDPWD", oldpwd);
	ft_strdel(&oldpwd);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdx
testq %rdx, %rdx
je 0x12b7
cmpq $0x0, 0x10(%r14)
je 0x12b7
leaq 0x5d62(%rip), %rsi      # 0x7004
movl $0x2, %edi
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x3ad4
movq (%rbx), %rdi
leaq 0x5d83(%rip), %rsi      # 0x7044
callq 0x23f7
testq %rax, %rax
je 0x12ec
movq (%rbx), %rdi
leaq 0x5d6f(%rip), %rsi      # 0x7044
callq 0x23f7
movq %rax, %rdi
callq 0x2b6c
movq %rax, %r15
movq %rax, 0x8(%rsp)
jmp 0x1318
xorl %edi, %edi
xorl %esi, %esi
callq 0x10b0
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x1387
movq %rax, %r15
leaq 0x5d37(%rip), %rsi      # 0x7044
movq %rbx, %rdi
movq %rax, %rdx
callq 0x2358
movq (%rbx), %rdi
leaq 0x5d1f(%rip), %rsi      # 0x7041
callq 0x23f7
testq %rax, %rax
jne 0x133e
leaq 0x5d0e(%rip), %rsi      # 0x7041
movq %rbx, %rdi
movq %r15, %rdx
callq 0x2358
movq (%rbx), %rdi
movq 0x8(%r14), %rsi
callq 0x2110
movq (%rbx), %rdi
leaq 0x5cf0(%rip), %rsi      # 0x7044
callq 0x23f7
movq %rax, %rdi
callq 0x1080
leaq 0x5cd9(%rip), %rsi      # 0x7041
movq %rbx, %rdi
movq %r15, %rdx
callq 0x2358
leaq 0x8(%rsp), %rdi
callq 0x2d50
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x5c91(%rip), %rsi      # 0x701f
movl $0x2, %edi
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x3ad4
// File: /workspace/github_c_makefile_star2_O3/ffoissey[P]minishell_42/srcs/ft_tool_minishell.c
// Function: ft_ctrlc
void	ft_ctrlc(int c)
{
	(void)c;
	if (g_glob.pid)
	{
		kill(g_glob.pid, SIGINT);
		g_glob.ret = c;
	}
	else
	{
		ft_putchar('\n');
		ft_print_prompt();
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0xaa3b(%rip), %r14      # 0xc0d8
movl (%r14), %edi
testl %edi, %edi
je 0x16ba
movl $0x2, %esi
callq 0x1110
movl %ebx, 0x4(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0xa, %edi
callq 0x31a8
movq 0x8(%r14), %rdx
movq 0x10(%r14), %rsi
leaq 0x59d5(%rip), %rdi      # 0x70a8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3785
// File: /workspace/github_c_makefile_star2_O3/ffoissey[P]minishell_42/srcs/ft_tool_minishell.c
// Function: ft_set_global
void	ft_set_global(t_list_ex *lst)
{
	struct passwd	*pw;

	ft_free_global();
	if (!ft_lst_returnvalue(lst, "USER"))
	{
		pw = getpwuid(geteuid());
		g_glob.user = ft_strdup(pw->pw_name);
	}
	else
		g_glob.user = ft_strdup(ft_lst_returnvalue(lst, "USER"));
	g_glob.cur_dir = ft_curdir();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xa9cc(%rip), %r14      # 0xc0d8
movq 0x8(%r14), %rdi
callq 0x1030
movq 0x10(%r14), %rdi
callq 0x1030
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r14)
leaq 0x5976(%rip), %rsi      # 0x70a3
movq %rbx, %rdi
callq 0x23f7
testq %rax, %rax
je 0x174e
leaq 0x5962(%rip), %rsi      # 0x70a3
movq %rbx, %rdi
callq 0x23f7
movq %rax, %rdi
jmp 0x175d
callq 0x10a0
movl %eax, %edi
callq 0x1070
movq (%rax), %rdi
callq 0x2b6c
movq %rax, 0x10(%r14)
callq 0x1e2c
movq %rax, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/ffoissey[P]minishell_42/srcs/ft_tool_minishell.c
// Function: ft_shlvl
void	ft_shlvl(t_list_ex **lst)
{
	char	*tmp;
	char	*tmp2;
	int		lvl;

	tmp = NULL;
	if (!(tmp2 = getcwd(tmp, 0)))
		ft_dprintf(2, "minishell: shell path not found\n");
	ft_lst_changevalue(lst, "SHELL", tmp2);
	ft_strdel(&tmp2);
	if ((tmp = ft_lst_returnvalue(*lst, "SHLVL")))
		lvl = ft_atoi(tmp) + 1;
	else
		lvl = 1;
	tmp = ft_itoa(lvl);
	ft_lst_changevalue(lst, "SHLVL", tmp);
	ft_strdel(&tmp);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorl %edi, %edi
xorl %esi, %esi
callq 0x10b0
movq %rax, %r14
movq %rax, 0x8(%rsp)
testq %rax, %rax
jne 0x17cd
leaq 0x5909(%rip), %rsi      # 0x70ca
movl $0x2, %edi
xorl %eax, %eax
callq 0x3ad4
leaq 0x5917(%rip), %rsi      # 0x70eb
movq %rbx, %rdi
movq %r14, %rdx
callq 0x2358
leaq 0x8(%rsp), %rdi
callq 0x2d50
movq (%rbx), %rdi
leaq 0x58fe(%rip), %rsi      # 0x70f1
callq 0x23f7
testq %rax, %rax
je 0x180b
movq %rax, %rdi
callq 0x3258
movl %eax, %edi
incl %edi
jmp 0x1810
movl $0x1, %edi
callq 0x32b4
leaq 0x10(%rsp), %r14
movq %rax, (%r14)
leaq 0x58cd(%rip), %rsi      # 0x70f1
movq %rbx, %rdi
movq %rax, %rdx
callq 0x2358
movq %r14, %rdi
callq 0x2d50
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/ffoissey[P]minishell_42/srcs/ft_echo.c
// Function: ft_echo
void		ft_echo(char **tab)
{
	int		i;
	int		flag_n;
	char	*s;

	flag_n = 0;
	i = 0;
	s = NULL;
	ft_quote(tab);
	if (tab[0] && !ft_strcmp(tab[0], "-n"))
	{
		flag_n = 1;
		i++;
	}
	while (tab[i])
	{
		s = ft_strjoinfree(s, tab[i++], FIRST);
		if (tab[i])
			s = ft_strjoinfree(s, " ", FIRST);
	}
	if (!flag_n)
		s = ft_strjoinfree(s, "\n", FIRST);
	ft_putstr(s);
	ft_strdel(&s);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq (%rdi), %rdi
movl $0x27, %esi
callq 0x2e10
movq %rax, %rbx
movq %r14, %rdi
callq 0x2d50
movq %rbx, (%r14)
movq %rbx, %rdi
movl $0x22, %esi
callq 0x2e10
movq %rax, %rbx
movq %r14, %rdi
callq 0x2d50
movq %rbx, (%r14)
testq %rbx, %rbx
je 0x18fa
leaq 0x5869(%rip), %rsi      # 0x70f7
movq %rbx, %rdi
callq 0x2a50
movl %eax, %ebx
xorl %eax, %eax
testl %ebx, %ebx
sete %al
movq (%r14,%rax,8), %rsi
xorl %eax, %eax
testq %rsi, %rsi
je 0x18ef
testl %ebx, %ebx
sete %al
leaq (%r14,%rax,8), %r15
addq $0x8, %r15
xorl %eax, %eax
leaq 0x5808(%rip), %r14      # 0x70c8
movq %rax, %rdi
movl $0x1, %edx
callq 0x2c89
cmpq $0x0, (%r15)
je 0x18ef
movq %rax, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x2c89
movq (%r15), %rsi
addq $0x8, %r15
testq %rsi, %rsi
jne 0x18c0
movq %rax, 0x8(%rsp)
testl %ebx, %ebx
jne 0x18fc
jmp 0x1915
xorl %eax, %eax
leaq 0x584c(%rip), %rsi      # 0x714f
movq %rax, %rdi
movl $0x1, %edx
callq 0x2c89
movq %rax, 0x8(%rsp)
movq %rax, %rdi
callq 0x31c4
leaq 0x8(%rsp), %rdi
callq 0x2d50
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/ffoissey[P]minishell_42/srcs/ft_env.c
// Function: ft_unsetenv
void		ft_unsetenv(t_list_ex **lst, char **tab)
{
	int		i;

	i = 0;
	while (tab[i])
		ft_lstexpop(lst, tab[i++]);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rsi), %rsi
testq %rsi, %rsi
je 0x195e
movq %rdi, %r14
addq $0x8, %rbx
movq %r14, %rdi
callq 0x22aa
movq (%rbx), %rsi
addq $0x8, %rbx
testq %rsi, %rsi
jne 0x194a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/ffoissey[P]minishell_42/srcs/ft_env.c
// Function: ft_setenv
void		ft_setenv(t_list_ex **lst, char **tab)
{
	char	*tmp;
	char	*tmp2;

	if (!tab || !tab[0])
		return ;
	if (tab[0] && (tmp = ft_strchr(tab[0], '=')))
	{
		tmp2 = ft_strcdup(tab[0], '=');
		tmp = ft_strdup(tmp + 1);
		if (tmp && *(tmp) == '~')
			if (!ft_tilde(&tmp, *lst, NULL, 0))
				return ;
		ft_lst_changevalue(lst, tmp2, tmp);
		ft_strdel(&tmp2);
		ft_strdel(&tmp);
	}
	else if (tab[0] && tab[1])
	{
		tmp2 = ft_strcdup(tab[0], '=');
		if (tab[1][0] == '~')
			if (!ft_tilde(tab, *lst, NULL, 1))
				return ;
		ft_lst_changevalue(lst, tmp2, tab[1]);
		ft_strdel(&tmp2);
	}
}

// Assembly:
testq %rsi, %rsi
je 0x1a65
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x1a5c
movl $0x3d, %esi
callq 0x2ad4
movq (%r14), %rdi
testq %rax, %rax
je 0x19ea
movq %rax, %r15
movl $0x3d, %esi
callq 0x2b94
movq %rax, %r14
movq %rax, (%rsp)
incq %r15
movq %r15, %rdi
callq 0x2b6c
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x1a3a
cmpb $0x7e, (%rax)
jne 0x1a3c
movq (%rbx), %rsi
leaq 0x8(%rsp), %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x24a8
testl %eax, %eax
je 0x1a5c
movq (%rsp), %r14
movq 0x8(%rsp), %rax
jmp 0x1a3c
testq %rdi, %rdi
je 0x1a5c
cmpq $0x0, 0x8(%r14)
je 0x1a5c
movl $0x3d, %esi
callq 0x2b94
movq %rax, %r15
movq %rax, (%rsp)
movq 0x8(%r14), %rdx
cmpb $0x7e, (%rdx)
jne 0x1a2a
movq (%rbx), %rsi
movq %r14, %rdi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x24a8
testl %eax, %eax
je 0x1a5c
movq 0x8(%r14), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2358
movq %rsp, %rdi
jmp 0x1a57
xorl %eax, %eax
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2358
movq %rsp, %rdi
callq 0x2d50
leaq 0x8(%rsp), %rdi
callq 0x2d50
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/ffoissey[P]minishell_42/srcs/ft_env_extend.c
// Function: ft_lst_to_tab
char		**ft_lst_to_tab(t_list_ex *lst)
{
	char	**tab;
	int		count;
	int		i;

	count = ft_lstexsize(lst);
	if (!(tab = (char **)malloc(sizeof(char *) * (count + 1))))
		return (NULL);
	tab[count] = NULL;
	i = 0;
	while (lst)
	{
		tab[i] = ft_strnew(ft_strlen(lst->name) + ft_strlen(lst->value) + 2);
		ft_strcat(tab[i], lst->name);
		ft_strcat(tab[i], "=");
		ft_strcat(tab[i], lst->value);
		lst = lst->next;
		i++;
	}
	return (tab);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x2346
movslq %eax, %r15
leaq 0x8(,%r15,8), %rdi
callq 0x1130
movq %rax, %r14
testq %rax, %rax
je 0x1d88
movq $0x0, (%r14,%r15,8)
testq %rbx, %rbx
je 0x1d88
leaq 0x5441(%rip), %r15      # 0x716e
movq %r14, %r13
movq 0x10(%rbx), %rdi
callq 0x2d18
movq %rax, %r12
movq 0x8(%rbx), %rdi
callq 0x2d18
leaq (%r12,%rax), %rdi
addq $0x2, %rdi
callq 0x2de4
movq %rax, %r12
movq %rax, (%r13)
movq 0x10(%rbx), %rsi
movq %rax, %rdi
callq 0x2a18
movq %r12, %rdi
movq %r15, %rsi
callq 0x2a18
movq 0x8(%rbx), %rsi
movq %r12, %rdi
callq 0x2a18
movq (%rbx), %rbx
addq $0x8, %r13
testq %rbx, %rbx
jne 0x1d30
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/ffoissey[P]minishell_42/srcs/ft_env_extend.c
// Function: ft_dup_env
t_list_ex	*ft_dup_env(char **env)
{
	t_list_ex	*lst;
	char		*tmp;
	char		*tmp2;

	lst = NULL;
	while (*env)
	{
		ft_lstexadd(&lst, ft_lstexnew((tmp = ft_strcdup(*env, '=')),
					(tmp2 = ft_strchr(*env, '=')) ? tmp2 + 1 : NULL));
		ft_strdel(&tmp);
		env++;
	}
	return (lst);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq $0x0, 0x8(%rsp)
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x1e1b
addq $0x8, %rbx
leaq 0x8(%rsp), %r14
leaq 0x10(%rsp), %r15
movl $0x3d, %esi
callq 0x2b94
movq %rax, %r12
movq %rax, 0x10(%rsp)
movq -0x8(%rbx), %rdi
movl $0x3d, %esi
callq 0x2ad4
leaq 0x1(%rax), %rsi
testq %rax, %rax
cmoveq %rax, %rsi
movq %r12, %rdi
callq 0x2238
movq %r14, %rdi
movq %rax, %rsi
callq 0x2322
movq %r15, %rdi
callq 0x2d50
movq (%rbx), %rdi
addq $0x8, %rbx
testq %rdi, %rdi
jne 0x1dc2
movq 0x8(%rsp), %rax
jmp 0x1e1d
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/ffoissey[P]minishell_42/srcs/ft_cd.c
// Function: ft_curdir
char	*ft_curdir(void)
{
	char	*tmp;
	char	*tmp2;

	tmp = NULL;
	if (!(tmp2 = getcwd(tmp, 0)))
	{
		ft_dprintf(2, "minishell: current dir not found\n");
		return (NULL);
	}
	tmp = ft_strdup(ft_strrchr(tmp2, '/'));
	ft_strdel(&tmp2);
	if (tmp && *(tmp + 1))
	{
		tmp2 = ft_strdup(tmp + 1);
		ft_strdel(&tmp);
		return (tmp2);
	}
	return (tmp);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
xorl %edi, %edi
xorl %esi, %esi
callq 0x10b0
movq %rax, (%rsp)
testq %rax, %rax
je 0x1e92
movq %rax, %rdi
movl $0x2f, %esi
callq 0x2b04
movq %rax, %rdi
callq 0x2b6c
movq %rax, %rbx
movq %rax, 0x8(%rsp)
movq %rsp, %rdi
callq 0x2d50
testq %rbx, %rbx
je 0x1ea9
cmpb $0x0, 0x1(%rbx)
je 0x1eab
incq %rbx
movq %rbx, %rdi
callq 0x2b6c
movq %rax, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x2d50
movq (%rsp), %rbx
jmp 0x1eab
leaq 0x5186(%rip), %rsi      # 0x701f
xorl %ebx, %ebx
movl $0x2, %edi
xorl %eax, %eax
callq 0x3ad4
jmp 0x1eab
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/ffoissey[P]minishell_42/srcs/ft_cd.c
// Function: ft_cd_access
int		ft_cd_access(t_list_ex *lst, char *tmp, char *s)
{
	DIR		*dir;
	int		ret;

	ret = 0;
	if (access(tmp, F_OK) == -1)
		ret = 1;
	else if (access(tmp, R_OK) == -1)
		ret = -1;
	else if (!(dir = opendir(tmp)))
		ret = -2;
	else
	{
		closedir(dir);
		ft_lst_changevalue(&lst, "PWD", tmp);
		ft_strdel(&tmp);
		return (ft_process_cd(lst, ft_strchr(s, '/')));
	}
	ft_strdel(&tmp);
	g_glob.ret = ret;
	return (ret);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq %rsi, %rdi
xorl %esi, %esi
callq 0x1150
cmpl $-0x1, %eax
je 0x1f40
movq %r14, %rdi
movl $0x4, %esi
callq 0x1150
cmpl $-0x1, %eax
je 0x1f47
movq %r14, %rdi
callq 0x1060
testq %rax, %rax
je 0x1f4e
movq %rax, %rdi
callq 0x10c0
leaq 0x513b(%rip), %rsi      # 0x7044
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x2358
movq %rsp, %rdi
callq 0x2d50
movq (%r15), %r14
movq %rbx, %rdi
movl $0x2f, %esi
callq 0x2ad4
movq %r14, %rdi
movq %rax, %rsi
callq 0x1f71
movl %eax, %ebx
jmp 0x1f65
movl $0x1, %ebx
jmp 0x1f53
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x1f53
movl $0xfffffffe, %ebx       # imm = 0xFFFFFFFE
movq %rsp, %rdi
callq 0x2d50
leaq 0xa176(%rip), %rax      # 0xc0d8
movl %ebx, 0x4(%rax)
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/ffoissey[P]minishell_42/srcs/ft_cd.c
// Function: ft_process_cd
int		ft_process_cd(t_list_ex *lst, char *s)
{
	char	*new;
	char	*tmp;
	char	*tmp2;

	new = NULL;
	tmp = ft_lst_returnvalue(lst, "PWD");
	if (!s || !s[0])
		return (0);
	else if (s[0] == '/')
		return (ft_process_cd(lst, s + 1));
	else if (!ft_strncmp(s, "..", 2))
	{
		tmp2 = ft_strrchr(tmp + 1, '/');
		new = tmp2 ? ft_strsub(tmp, 0, tmp2 - tmp) : ft_strdup("/");
		ft_lst_changevalue(&lst, "PWD", new);
		ft_strdel(&new);
		return (ft_process_cd(lst, s + 2));
	}
	else if (!ft_strncmp(s, ".", 1) && (*(s + 1) == '/' || !*(s + 1)))
		return (ft_process_cd(lst, s + 1));
	tmp = ft_strcmp(tmp, "/") ? ft_strjoin(tmp, "/") : ft_strdup(tmp);
	tmp2 = ft_strchr(s, '/');
	new = tmp2 ? ft_strsub(s, 0, tmp2 - s) : ft_strdup(s);
	tmp = ft_strjoinfree_n(&tmp, &new, BOTH);
	return (ft_cd_access(lst, tmp, s));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rdi, 0x18(%rsp)
leaq 0x50b8(%rip), %rsi      # 0x7044
callq 0x23f7
testq %rbx, %rbx
je 0x1fc0
movq %rax, %r15
movzbl (%rbx), %eax
testl %eax, %eax
je 0x2106
cmpl $0x2f, %eax
jne 0x1fc7
incq %rbx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x1f71
xorl %eax, %eax
jmp 0x2106
leaq 0x51b2(%rip), %rsi      # 0x7180
movl $0x2, %edx
movq %rbx, %rdi
callq 0x2a78
testl %eax, %eax
je 0x201b
leaq 0x519b(%rip), %rsi      # 0x7181
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2a78
testl %eax, %eax
je 0x2047
leaq 0x5185(%rip), %rsi      # 0x7183
movq %r15, %rdi
callq 0x2a50
testl %eax, %eax
je 0x205e
leaq 0x5172(%rip), %rsi      # 0x7183
movq %r15, %rdi
callq 0x2bac
jmp 0x2066
leaq 0x1(%r15), %rdi
movl $0x2f, %esi
callq 0x2b04
testq %rax, %rax
je 0x20c4
subq %r15, %rax
movq %r15, %rdi
xorl %esi, %esi
movq %rax, %rdx
callq 0x2cd4
jmp 0x20d0
movzbl 0x1(%rbx), %eax
cmpl $0x2f, %eax
je 0x1fa9
testl %eax, %eax
je 0x1fa9
jmp 0x1ff7
movq %r15, %rdi
callq 0x2b6c
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movl $0x2f, %esi
callq 0x2ad4
testq %rax, %rax
je 0x208f
subq %rbx, %rax
movq %rbx, %rdi
xorl %esi, %esi
movq %rax, %rdx
callq 0x2cd4
jmp 0x2097
movq %rbx, %rdi
callq 0x2b6c
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movl $0x3, %edx
callq 0x2c3c
movq %rax, (%r15)
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x1eb4
jmp 0x2106
leaq 0x50b8(%rip), %rdi      # 0x7183
callq 0x2b6c
leaq 0x10(%rsp), %r14
movq %rax, (%r14)
leaq 0x4f65(%rip), %rsi      # 0x7044
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %rax, %rdx
callq 0x2358
movq %r14, %rdi
callq 0x2d50
movq (%r15), %rdi
addq $0x2, %rbx
movq %rbx, %rsi
callq 0x1f71
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/ffoissey[P]minishell_42/srcs/ft_cd.c
// Function: ft_cd
void	ft_cd(t_list_ex *lst, char *s)
{
	int				ret;
	char			*tru;
	struct passwd	*pwd;

	tru = ft_lst_returnvalue(lst, "PWD");
	if (!s)
	{
		pwd = getpwuid(geteuid());
		if (!(s = ft_lst_returnvalue(lst, "HOME")))
			s = pwd->pw_dir;
	}
	else if (!ft_strcmp(s, "."))
		return ;
	else if (!ft_strcmp(s, "-"))
		s = ft_lst_returnvalue(lst, "OLDPWD");
	if (s && s[0] == '/')
		ft_lst_changevalue(&lst, "PWD", "/");
	if ((ret = ft_process_cd(lst, s)) == 1)
		ft_dprintf(2, "cd: %s: No such file or directory\n", s);
	else if (ret == -1)
		ft_dprintf(2, "cd: %s: Permission denied\n", s);
	else if (ret == -2)
		ft_dprintf(2, "cd: %s: Not a directory\n", s);
	if (ret)
		ft_lst_changevalue(&lst, "PWD", ft_strdup(tru));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movq %rdi, (%rsp)
leaq 0x4f1b(%rip), %rsi      # 0x7044
callq 0x23f7
movq %rax, %rbx
testq %r14, %r14
je 0x2174
leaq 0x5044(%rip), %rsi      # 0x7181
movq %r14, %rdi
callq 0x2a50
testl %eax, %eax
je 0x222b
leaq 0x5036(%rip), %rsi      # 0x718a
movq %r14, %rdi
callq 0x2a50
testl %eax, %eax
jne 0x21a4
leaq 0x4eda(%rip), %rsi      # 0x7041
movq %r15, %rdi
callq 0x23f7
movq %rax, %r14
jmp 0x219f
callq 0x10a0
movl %eax, %edi
callq 0x1070
movq %rax, %r12
leaq 0x4ffb(%rip), %rsi      # 0x7185
movq %r15, %rdi
callq 0x23f7
movq %rax, %r14
testq %rax, %rax
jne 0x21a4
movq 0x20(%r12), %r14
testq %r14, %r14
je 0x21c8
cmpb $0x2f, (%r14)
jne 0x21cb
leaq 0x4e93(%rip), %rsi      # 0x7044
leaq 0x4fcb(%rip), %rdx      # 0x7183
movq %rsp, %r15
movq %r15, %rdi
callq 0x2358
movq (%r15), %r15
jmp 0x21cb
xorl %r14d, %r14d
movq %r15, %rdi
movq %r14, %rsi
callq 0x1f71
addl $0x2, %eax
leaq 0x4f90(%rip), %rcx      # 0x7170
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x4fda(%rip), %rsi      # 0x71ca
jmp 0x2202
leaq 0x4fb6(%rip), %rsi      # 0x71af
jmp 0x2202
leaq 0x4f8a(%rip), %rsi      # 0x718c
movl $0x2, %edi
movq %r14, %rdx
xorl %eax, %eax
callq 0x3ad4
movq %rbx, %rdi
callq 0x2b6c
leaq 0x4e24(%rip), %rsi      # 0x7044
movq %rsp, %rdi
movq %rax, %rdx
callq 0x2358
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/ffoissey[P]minishell_42/srcs/ft_list.c
// Function: ft_lstexnew
t_list_ex	*ft_lstexnew(char *name, char *value)
{
	t_list_ex	*list;

	if (!(list = (t_list_ex *)malloc(sizeof(t_list_ex))))
		return (NULL);
	list->next = NULL;
	list->name = ft_strdup(name);
	list->value = ft_strdup(value);
	return (list);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x18, %edi
callq 0x1130
movq %rax, %rbx
testq %rax, %rax
je 0x2274
movq $0x0, (%rbx)
movq %r15, %rdi
callq 0x2b6c
movq %rax, 0x10(%rbx)
movq %r14, %rdi
callq 0x2b6c
movq %rax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/ffoissey[P]minishell_42/srcs/ft_list.c
// Function: ft_free_node
void		ft_free_node(t_list_ex **lst)
{
	ft_strdel(&(*lst)->name);
	ft_strdel(&(*lst)->value);
	free(*lst);
	*lst = NULL;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x10, %rdi
callq 0x2d50
movq (%rbx), %rdi
addq $0x8, %rdi
callq 0x2d50
movq (%rbx), %rdi
callq 0x1030
movq $0x0, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/ffoissey[P]minishell_42/srcs/ft_list.c
// Function: ft_lstexpop
void		ft_lstexpop(t_list_ex **lst, char *name)
{
	t_list_ex	*before;
	t_list_ex	*tmp;
	int			first;

	before = *lst;
	tmp = *lst;
	first = 0;
	while (tmp)
	{
		if (tmp->name && !ft_strcmp(tmp->name, name))
		{
			if (first != 0)
				before->next = tmp->next;
			else
			{
				before = tmp->next;
				*lst = before;
			}
			ft_free_node(&tmp);
			return ;
		}
		before = tmp;
		first++;
		tmp = tmp->next;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq (%rdi), %r12
testq %r12, %r12
je 0x22ea
movq %rsi, %r15
movq %rdi, %rbx
xorl %ebp, %ebp
movq %r12, %r14
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x22da
movq %r15, %rsi
callq 0x2a50
testl %eax, %eax
je 0x22f3
movq %r14, %r12
movq (%r14), %rax
decl %ebp
movq %rax, %r14
testq %rax, %rax
jne 0x22c5
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10(%r14), %rdi
testl %ebp, %ebp
movq (%r14), %rax
cmoveq %rbx, %r12
movq %rax, (%r12)
callq 0x2d50
leaq 0x8(%r14), %rdi
callq 0x2d50
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1030