LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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, 0x13fac(%rip)     # 0x1a290
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 0x4333
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 0x632e
movq 0x8(%rbx), %rsi
leaq 0xd5ff(%rip), %rdi      # 0x1392b
jmp 0x6386
testq %rax, %rax
je 0x637b
movl -0x24(%rbp), %edi
movzwl 0x13f9a(%rip), %r8d     # 0x1a2d8
movl %r8d, %edx
incl %edx
movw %dx, 0x13f8e(%rip)      # 0x1a2d8
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 0x61e5
jmp 0x638d
movq 0x8(%rbx), %rsi
leaq 0xd5d0(%rip), %rdi      # 0x13956
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_O2/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 0xcfe3(%rip), %rsi      # 0x13885
callq 0x2250
movq %rax, %r15
pushq $0x2
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x2240
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)
andq $0x0, 0x28(%r14)
movq %r13, %rdi
callq 0x22b0
movq %rax, %rbx
movq %rax, (%r14)
pushq $0x1
popq %rsi
movq %rax, %rdi
movq %r13, %rdx
movq %r15, %rcx
callq 0x2340
movb $0x0, (%rbx,%r12)
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %r14, %rdx
callq 0x61e5
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xcd0b(%rip), %rsi      # 0x13b16
pushq $-0x1
popq %rdx
movq %r14, %rdi
callq 0x21e0
cmpq $-0x1, %rax
je 0x6eec
leaq -0x38(%rbp), %r15
pushq $-0x1
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2230
leaq 0x13464(%rip), %rdi     # 0x1a2a0
movq %r15, %rsi
callq 0x11a18
testq %rax, %rax
je 0x6ee3
leaq 0x1344c(%rip), %rdi     # 0x1a2a0
leaq -0x38(%rbp), %rsi
callq 0x11b6c
movl (%rax), %edx
leaq -0x70(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x6177
movl (%r15), %edx
leal -0x1(%rdx), %eax
cmpl $0x4, %eax
ja 0x6ed2
leaq 0xc320(%rip), %rcx      # 0x131a0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq -0x70(%rbp), %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x62c9
jmp 0x6ee3
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
callq 0x687b
jmp 0x6ee3
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
callq 0x692b
jmp 0x6ee3
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
callq 0x6c20
jmp 0x6ee3
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
callq 0x6407
jmp 0x6ee3
movq (%r14), %rsi
leaq 0xcc3c(%rip), %rdi      # 0x13b18
xorl %eax, %eax
callq 0x2050
leaq -0x38(%rbp), %rdi
callq 0x2100
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6efb
jmp 0x6efb
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x23d0
// File: /workspace/github_c_makefile_star2_O2/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 0x22b0
xorl %ecx, %ecx
movb (%rbx,%rcx), %dl
testb %dl, %dl
je 0x6f30
movb %dl, (%rax,%rcx)
incq %rcx
jmp 0x6f21
movb $0x0, (%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6f8a
testl %edx, %edx
jne 0x6f8c
jmp 0x6f91
movl %ecx, %eax
incq %rcx
jmp 0x6f7b
cmpl $-0x1, %eax
je 0x6f9c
cltq
movb $0x0, (%rdi,%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
cmpb $0x0, (%rdi)
leaq 0x1(%rdi), %rdi
jne 0x6fa2
movabsq $-0x1, %rax
movb 0x1(%rsi,%rax), %cl
testb %cl, %cl
je 0x6fc5
movb %cl, (%rdi,%rax)
incq %rax
jmp 0x6fb5
movb $0x0, (%rdi,%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0xcb62(%rip), %rsi      # 0x13b43
pushq $0x4
popq %rdx
callq 0x2110
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
leal (%rcx,%rcx,2), %eax
movl %eax, %ecx
incl %eax
cmpb $0x2f, (%r14,%rcx)
je 0x6ff3
addq %rcx, %r14
movq %r14, %rdi
callq 0x20e0
xorl %ecx, %ecx
cmpl $0x2, %ebx
sete %cl
leal (%rcx,%rcx,4), %ecx
leal (%rax,%rcx), %esi
incl %esi
movq %r14, %rdi
callq 0x6f0f
movq %rax, %r14
movq %rax, %rdi
callq 0x6f70
pushq $0x2f
popq %rsi
pushq $0x5f
popq %r15
movq %r14, %rdi
movl %r15d, %edx
callq 0x6f3b
pushq $0x2d
popq %rsi
movq %r14, %rdi
movl %r15d, %edx
callq 0x6f3b
movq %r14, %rdi
callq 0x6f53
cmpl $0x2, %ebx
jne 0x7068
leaq 0xcae8(%rip), %rsi      # 0x13b48
movq %r14, %rdi
callq 0x6f9e
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/FredTheDino[P]Fog/src/engine/math/block_vector.h
// Function: Vec4::operator==(Vec4)
b8 operator==(Vec4 other) {
        return (x - other.x) * (x - other.x) < FLOAT_EQ_MARGIN &&
               (y - other.y) * (y - other.y) < FLOAT_EQ_MARGIN &&
               (z - other.z) * (z - other.z) < FLOAT_EQ_MARGIN &&
               (w - other.w) * (w - other.w) < FLOAT_EQ_MARGIN;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movss (%rdi), %xmm2
subss %xmm0, %xmm2
mulss %xmm2, %xmm2
cvtss2sd %xmm2, %xmm3
movsd 0x25d0(%rip), %xmm2     # 0x13188
ucomisd %xmm3, %xmm2
jbe 0x10c0e
movss 0x4(%rdi), %xmm3
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
subss %xmm0, %xmm3
mulss %xmm3, %xmm3
cvtss2sd %xmm3, %xmm0
ucomisd %xmm0, %xmm2
jbe 0x10c0e
movss 0x8(%rdi), %xmm0
subss %xmm1, %xmm0
mulss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
ucomisd %xmm0, %xmm2
jbe 0x10c0e
movss 0xc(%rdi), %xmm0
shufps $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
subss %xmm1, %xmm0
mulss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
ucomisd %xmm0, %xmm2
seta %al
jmp 0x10c10
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x12a5
cmpq $0x0, 0x10(%r14)
je 0x12a5
leaq 0x5d72(%rip), %rsi      # 0x7004
pushq $0x2
popq %rdi
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x38b8
movq (%rbx), %rdi
leaq 0x5d95(%rip), %rsi      # 0x7044
callq 0x22f9
testq %rax, %rax
je 0x12da
movq (%rbx), %rdi
leaq 0x5d81(%rip), %rsi      # 0x7044
callq 0x22f9
movq %rax, %rdi
callq 0x29d0
movq %rax, %r15
movq %rax, 0x8(%rsp)
jmp 0x1306
xorl %edi, %edi
xorl %esi, %esi
callq 0x10a0
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x1375
movq %rax, %r15
leaq 0x5d49(%rip), %rsi      # 0x7044
movq %rbx, %rdi
movq %rax, %rdx
callq 0x2258
movq (%rbx), %rdi
leaq 0x5d31(%rip), %rsi      # 0x7041
callq 0x22f9
testq %rax, %rax
jne 0x132c
leaq 0x5d20(%rip), %rsi      # 0x7041
movq %rbx, %rdi
movq %r15, %rdx
callq 0x2258
movq (%rbx), %rdi
movq 0x8(%r14), %rsi
callq 0x202a
movq (%rbx), %rdi
leaq 0x5d02(%rip), %rsi      # 0x7044
callq 0x22f9
movq %rax, %rdi
callq 0x1080
leaq 0x5ceb(%rip), %rsi      # 0x7041
movq %rbx, %rdi
movq %r15, %rdx
callq 0x2258
leaq 0x8(%rsp), %rdi
callq 0x2ba8
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x5ca3(%rip), %rsi      # 0x701f
pushq $0x2
popq %rdi
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x38b8
// File: /workspace/github_c_makefile_star2_O2/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 0xaa63(%rip), %r14      # 0xc0d0
movl (%r14), %edi
testl %edi, %edi
je 0x1688
pushq $0x2
popq %rsi
callq 0x1100
movl %ebx, 0x4(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0xa
popq %rdi
callq 0x3008
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x169c
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
callq 0x1714
leaq 0x59da(%rip), %rsi      # 0x70a3
movq %rbx, %rdi
callq 0x22f9
testq %rax, %rax
je 0x16ea
leaq 0x59c6(%rip), %rsi      # 0x70a3
movq %rbx, %rdi
callq 0x22f9
movq %rax, %rdi
jmp 0x16f9
callq 0x1090
movl %eax, %edi
callq 0x1070
movq (%rax), %rdi
callq 0x29d0
leaq 0xa9cb(%rip), %rbx      # 0xc0d0
movq %rax, 0x10(%rbx)
callq 0x1d60
movq %rax, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x10a0
movq %rax, %r14
movq %rax, 0x8(%rsp)
testq %rax, %rax
jne 0x1768
leaq 0x596c(%rip), %rsi      # 0x70ca
pushq $0x2
popq %rdi
xorl %eax, %eax
callq 0x38b8
leaq 0x597c(%rip), %rsi      # 0x70eb
movq %rbx, %rdi
movq %r14, %rdx
callq 0x2258
leaq 0x8(%rsp), %rdi
callq 0x2ba8
movq (%rbx), %rdi
leaq 0x5963(%rip), %rsi      # 0x70f1
callq 0x22f9
testq %rax, %rax
je 0x17a6
movq %rax, %rdi
callq 0x30b4
movl %eax, %edi
incl %edi
jmp 0x17a9
pushq $0x1
popq %rdi
callq 0x3104
leaq 0x10(%rsp), %r14
movq %rax, (%r14)
leaq 0x5934(%rip), %rsi      # 0x70f1
movq %rbx, %rdi
movq %rax, %rdx
callq 0x2258
movq %r14, %rdi
callq 0x2ba8
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
pushq $0x27
popq %rsi
callq 0x2c50
movq %rax, %r14
movq %rbx, %rdi
callq 0x2ba8
movq %r14, (%rbx)
pushq $0x22
popq %rsi
movq %r14, %rdi
callq 0x2c50
movq %rax, %r14
movq %rbx, %rdi
callq 0x2ba8
movq %r14, (%rbx)
testq %r14, %r14
je 0x1835
leaq 0x58d7(%rip), %rsi      # 0x70f7
movq %r14, %rdi
callq 0x28e0
xorl %ecx, %ecx
testl %eax, %eax
setne %bpl
sete %cl
jmp 0x183a
movb $0x1, %bpl
xorl %ecx, %ecx
leaq (%rbx,%rcx,8), %r15
addq $0x8, %r15
xorl %edi, %edi
pushq $0x1
popq %rbx
leaq 0x587a(%rip), %r14      # 0x70c8
movq -0x8(%r15), %rsi
testq %rsi, %rsi
je 0x187a
movl %ebx, %edx
callq 0x2aed
movq %rax, %rdi
cmpq $0x0, (%r15)
je 0x1874
movq %r14, %rsi
movl %ebx, %edx
callq 0x2aed
movq %rax, %rdi
addq $0x8, %r15
jmp 0x184e
movq %rdi, (%rsp)
testb %bpl, %bpl
je 0x1899
leaq 0x58c5(%rip), %rsi      # 0x714f
pushq $0x1
popq %rdx
callq 0x2aed
movq %rax, %rdi
movq %rax, (%rsp)
callq 0x3020
movq %rsp, %rdi
callq 0x2ba8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x19d3
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x19ca
pushq $0x3d
popq %rsi
callq 0x2958
movq (%r14), %rdi
testq %rax, %rax
je 0x195c
movq %rax, %r15
pushq $0x3d
popq %rsi
callq 0x29f8
movq %rax, %r14
movq %rax, (%rsp)
incq %r15
movq %r15, %rdi
callq 0x29d0
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x19a8
cmpb $0x7e, (%rax)
jne 0x19aa
movq (%rbx), %rsi
leaq 0x8(%rsp), %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2398
testl %eax, %eax
je 0x19ca
movq (%rsp), %r14
movq 0x8(%rsp), %rax
jmp 0x19aa
testq %rdi, %rdi
je 0x19ca
cmpq $0x0, 0x8(%r14)
je 0x19ca
pushq $0x3d
popq %rsi
callq 0x29f8
movq %rax, %r15
movq %rax, (%rsp)
movq 0x8(%r14), %rdx
cmpb $0x7e, (%rdx)
jne 0x1998
movq (%rbx), %rsi
pushq $0x1
popq %rcx
movq %r14, %rdi
xorl %edx, %edx
callq 0x2398
testl %eax, %eax
je 0x19ca
movq 0x8(%r14), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2258
movq %rsp, %rdi
jmp 0x19c5
xorl %eax, %eax
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2258
movq %rsp, %rdi
callq 0x2ba8
leaq 0x8(%rsp), %rdi
callq 0x2ba8
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2247
movslq %eax, %r15
leaq 0x8(,%r15,8), %rdi
callq 0x1120
movq %rax, %r14
testq %rax, %rax
je 0x1cd6
andq $0x0, (%r14,%r15,8)
leaq 0x54f5(%rip), %r15      # 0x716e
movq %r14, %r13
testq %rbx, %rbx
je 0x1cd6
movq 0x10(%rbx), %rdi
callq 0x2b7c
movq %rax, %r12
movq 0x8(%rbx), %rdi
callq 0x2b7c
leaq (%r12,%rax), %rdi
addq $0x2, %rdi
callq 0x2c28
movq %rax, %r12
movq %rax, (%r13)
movq 0x10(%rbx), %rsi
movq %rax, %rdi
callq 0x28ac
movq %r12, %rdi
movq %r15, %rsi
callq 0x28ac
movq 0x8(%rbx), %rsi
movq %r12, %rdi
callq 0x28ac
movq (%rbx), %rbx
addq $0x8, %r13
jmp 0x1c7c
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %rbx
andq $0x0, (%rbx)
movq %rdi, %r14
pushq $0x3d
popq %rbp
movq %rsp, %r15
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1d4d
movl %ebp, %esi
callq 0x29f8
movq %rax, %r12
movq %rax, (%rsp)
movq (%r14), %rdi
movl %ebp, %esi
callq 0x2958
leaq 0x1(%rax), %rsi
testq %rax, %rax
cmoveq %rax, %rsi
movq %r12, %rdi
callq 0x2150
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2223
movq %r15, %rdi
callq 0x2ba8
addq $0x8, %r14
jmp 0x1d01
movq 0x8(%rsp), %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x10a0
movq %rax, (%rsp)
testq %rax, %rax
je 0x1dc4
pushq $0x2f
popq %rsi
movq %rax, %rdi
callq 0x2978
movq %rax, %rdi
callq 0x29d0
movq %rax, %rbx
movq %rax, 0x8(%rsp)
movq %rsp, %rdi
callq 0x2ba8
testq %rbx, %rbx
je 0x1dd9
cmpb $0x0, 0x1(%rbx)
je 0x1ddb
incq %rbx
movq %rbx, %rdi
callq 0x29d0
movq %rax, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x2ba8
movq (%rsp), %rbx
jmp 0x1ddb
leaq 0x5254(%rip), %rsi      # 0x701f
xorl %ebx, %ebx
pushq $0x2
popq %rdi
xorl %eax, %eax
callq 0x38b8
jmp 0x1ddb
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1140
cmpl $-0x1, %eax
je 0x1e6c
pushq $0x4
popq %rsi
movq %r14, %rdi
callq 0x1140
cmpl $-0x1, %eax
je 0x1e70
movq %r14, %rdi
callq 0x1060
testq %rax, %rax
je 0x1e74
movq %rax, %rdi
callq 0x10b0
leaq 0x520d(%rip), %rsi      # 0x7044
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x2258
movq %rsp, %rdi
callq 0x2ba8
movq (%r15), %r14
pushq $0x2f
popq %rsi
movq %rbx, %rdi
callq 0x2958
movq %r14, %rdi
movq %rax, %rsi
callq 0x1e95
movl %eax, %ebx
jmp 0x1e89
pushq $0x1
jmp 0x1e76
pushq $-0x1
jmp 0x1e76
pushq $-0x2
popq %rbx
movq %rsp, %rdi
callq 0x2ba8
leaq 0xa24a(%rip), %rax      # 0xc0d0
movl %ebx, 0x4(%rax)
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5194(%rip), %rsi      # 0x7044
callq 0x22f9
testq %rbx, %rbx
je 0x1ee4
movq %rax, %r15
movzbl (%rbx), %eax
testl %eax, %eax
je 0x2020
cmpl $0x2f, %eax
jne 0x1eeb
incq %rbx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x1e95
xorl %eax, %eax
jmp 0x2020
leaq 0x528e(%rip), %rsi      # 0x7180
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x28fc
testl %eax, %eax
je 0x1f3b
leaq 0x5279(%rip), %rsi      # 0x7181
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x28fc
testl %eax, %eax
je 0x1f65
leaq 0x5265(%rip), %rsi      # 0x7183
movq %r15, %rdi
callq 0x28e0
testl %eax, %eax
je 0x1f7c
leaq 0x5252(%rip), %rsi      # 0x7183
movq %r15, %rdi
callq 0x2a10
jmp 0x1f84
leaq 0x1(%r15), %rdi
pushq $0x2f
popq %rsi
callq 0x2978
testq %rax, %rax
je 0x1fde
subq %r15, %rax
movq %r15, %rdi
xorl %esi, %esi
movq %rax, %rdx
callq 0x2b38
jmp 0x1fea
movzbl 0x1(%rbx), %eax
cmpl $0x2f, %eax
je 0x1ecd
testl %eax, %eax
je 0x1ecd
jmp 0x1f17
movq %r15, %rdi
callq 0x29d0
movq %rax, 0x8(%rsp)
pushq $0x2f
popq %rsi
movq %rbx, %rdi
callq 0x2958
testq %rax, %rax
je 0x1fab
subq %rbx, %rax
movq %rbx, %rdi
xorl %esi, %esi
movq %rax, %rdx
callq 0x2b38
jmp 0x1fb3
movq %rbx, %rdi
callq 0x29d0
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x8(%rsp), %r15
pushq $0x3
popq %rdx
movq %r15, %rdi
callq 0x2aa0
movq %rax, (%r15)
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x1de4
jmp 0x2020
leaq 0x519e(%rip), %rdi      # 0x7183
callq 0x29d0
leaq 0x10(%rsp), %r14
movq %rax, (%r14)
leaq 0x504b(%rip), %rsi      # 0x7044
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %rax, %rdx
callq 0x2258
movq %r14, %rdi
callq 0x2ba8
movq (%r15), %rdi
addq $0x2, %rbx
movq %rbx, %rsi
callq 0x1e95
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5001(%rip), %rsi      # 0x7044
callq 0x22f9
movq %rax, %rbx
testq %r14, %r14
je 0x208e
leaq 0x512a(%rip), %rsi      # 0x7181
movq %r14, %rdi
callq 0x28e0
testl %eax, %eax
je 0x2143
leaq 0x511c(%rip), %rsi      # 0x718a
movq %r14, %rdi
callq 0x28e0
testl %eax, %eax
jne 0x20be
leaq 0x4fc0(%rip), %rsi      # 0x7041
movq %r15, %rdi
callq 0x22f9
movq %rax, %r14
jmp 0x20b9
callq 0x1090
movl %eax, %edi
callq 0x1070
movq %rax, %r12
leaq 0x50e1(%rip), %rsi      # 0x7185
movq %r15, %rdi
callq 0x22f9
movq %rax, %r14
testq %rax, %rax
jne 0x20be
movq 0x20(%r12), %r14
testq %r14, %r14
je 0x20e2
cmpb $0x2f, (%r14)
jne 0x20e5
leaq 0x4f79(%rip), %rsi      # 0x7044
leaq 0x50b1(%rip), %rdx      # 0x7183
movq %rsp, %r15
movq %r15, %rdi
callq 0x2258
movq (%r15), %r15
jmp 0x20e5
xorl %r14d, %r14d
movq %r15, %rdi
movq %r14, %rsi
callq 0x1e95
addl $0x2, %eax
leaq 0x5076(%rip), %rcx      # 0x7170
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x50c0(%rip), %rsi      # 0x71ca
jmp 0x211c
leaq 0x509c(%rip), %rsi      # 0x71af
jmp 0x211c
leaq 0x5070(%rip), %rsi      # 0x718c
pushq $0x2
popq %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x38b8
movq %rbx, %rdi
callq 0x29d0
leaq 0x4f0c(%rip), %rsi      # 0x7044
movq %rsp, %rdi
movq %rax, %rdx
callq 0x2258
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
movq %rdi, %r15
pushq $0x18
popq %rdi
callq 0x1120
movq %rax, %r14
testq %rax, %rax
je 0x2187
andq $0x0, (%r14)
movq %r15, %rdi
callq 0x29d0
movq %rax, 0x10(%r14)
movq %rbx, %rdi
callq 0x29d0
movq %rax, 0x8(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2ba8
movq (%rbx), %rdi
addq $0x8, %rdi
callq 0x2ba8
movq (%rbx), %rdi
callq 0x1030
andq $0x0, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
xorl %ebp, %ebp
movq %rax, %r15
testq %rax, %rax
je 0x2216
movq %rax, %r12
movq 0x10(%rax), %rdi
testq %rdi, %rdi
je 0x21f1
movq %r14, %rsi
callq 0x28e0
testl %eax, %eax
je 0x21fc
movq (%r12), %rax
decl %ebp
movq %r12, %r15
jmp 0x21d4
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
testl %ebp, %ebp
movq (%r12), %rax
cmoveq %rbx, %r15
movq %rax, (%r15)
callq 0x2190
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ffoissey[P]minishell_42/srcs/ft_list_extend.c
// Function: ft_lst_changevalue
int			ft_lst_changevalue(t_list_ex **lst, char *name, char *value)
{
	t_list_ex	*tmp;

	tmp = *lst;
	while (tmp)
	{
		if (!ft_strcmp(tmp->name, name))
		{
			ft_strdel(&tmp->value);
			tmp->value = ft_strdup(value);
			return (TRUE);
		}
		tmp = tmp->next;
	}
	ft_lstexadd(lst, ft_lstexnew(name, value));
	return (FALSE);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rdi, %r12
movq (%r12), %r12
testq %r12, %r12
je 0x22a2
movq 0x10(%r12), %rdi
movq %r15, %rsi
callq 0x28e0
testl %eax, %eax
jne 0x226c
leaq 0x8(%r12), %rdi
callq 0x2ba8
movq %rbx, %rdi
callq 0x29d0
movq %rax, 0x8(%r12)
pushq $0x1
popq %rax
jmp 0x22ba
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2150
movq %r14, %rdi
movq %rax, %rsi
callq 0x2223
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/ffoissey[P]minishell_42/srcs/ft_list_extend.c
// Function: ft_lst_printenv
void		ft_lst_printenv(t_list_ex *lst)
{
	while (lst)
	{
		ft_putstr(lst->name);
		ft_putchar('=');
		ft_putendl(lst->value);
		lst = lst->next;
	}
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x3d
popq %rbp
testq %rbx, %rbx
je 0x22f2
movq 0x10(%rbx), %rdi
callq 0x3020
movl %ebp, %edi
callq 0x3008
movq 0x8(%rbx), %rdi
callq 0x3040
movq (%rbx), %rbx
jmp 0x22cf
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ffoissey[P]minishell_42/srcs/ft_list_extend.c
// Function: ft_lst_returnvalue
char		*ft_lst_returnvalue(t_list_ex *lst, char *name)
{
	while (lst)
	{
		if (!ft_strcmp(lst->name, name))
			return (lst->value);
		lst = lst->next;
	}
	return (NULL);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
xorl %ebx, %ebx
testq %r14, %r14
je 0x2324
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x28e0
testl %eax, %eax
je 0x2320
movq (%r14), %r14
jmp 0x2306
movq 0x8(%r14), %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/ffoissey[P]minishell_42/srcs/ft_list_extend.c
// Function: ft_freelistex
void		ft_freelistex(t_list_ex *lst)
{
	if (lst)
	{
		ft_freelistex(lst->next);
		ft_strdel(&lst->name);
		ft_strdel(&lst->value);
		free(lst);
		lst = NULL;
	}
}

// Assembly:
testq %rdi, %rdi
je 0x2359
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x232d
leaq 0x10(%rbx), %rdi
callq 0x2ba8
leaq 0x8(%rbx), %rdi
callq 0x2ba8
movq %rbx, %rdi
popq %rbx
jmp 0x1030
retq
// File: /workspace/github_c_makefile_star2_O2/ffoissey[P]minishell_42/srcs/ft_list_extend.c
// Function: ft_duplist
t_list_ex	*ft_duplist(t_list_ex *lst)
{
	t_list_ex	*new;

	new = NULL;
	while (lst)
	{
		ft_lstexadd(&new, ft_lstexnew(lst->name, lst->value));
		lst = lst->next;
	}
	return (new);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
andq $0x0, (%r14)
testq %rbx, %rbx
je 0x238a
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdi
callq 0x2150
movq %r14, %rdi
movq %rax, %rsi
callq 0x2223
movq (%rbx), %rbx
jmp 0x2368
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/ffoissey[P]minishell_42/srcs/ft_expansion.c
// Function: ft_tilde
int			ft_tilde(char **tab, t_list_ex *lst, char *value, int i)
{
	char			*tmp;
	struct passwd	*pwd;

	pwd = getpwuid(geteuid());
	value = ft_lst_returnvalue(lst, "HOME");
	value = ft_strdup(value
			? value : pwd->pw_dir);
	if (!tab[i][1] || tab[i][1] == '/')
	{
		tmp = tab[i];
		value = ft_strjoinfree(value, tab[i] + 1, FIRST);
		ft_strdel(&tmp);
		tab[i] = value;
		return (TRUE);
	}
	tmp = ft_strcdup(tab[i] + 1, '/');
	if (!(pwd = getpwnam(tmp)))
		return (ft_error_tilde(tab[i], value));
	ft_strdel(&tmp);
	tmp = ft_strchr(tab[i], '/');
	tab[i] = ft_strdup(pwd->pw_dir);
	tab[i] = ft_strjoinfree(tab[i], tmp, FIRST);
	return (TRUE);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
callq 0x1090
movl %eax, %edi
callq 0x1070
movq %rax, %r14
leaq 0x4dc3(%rip), %rsi      # 0x7185
movq %r15, %rdi
callq 0x22f9
testq %rax, %rax
jne 0x23d3
movq 0x20(%r14), %rax
movq %rax, %rdi
callq 0x29d0
movq %rax, %r14
movslq %ebp, %r12
movq (%rbx,%r12,8), %rax
leaq 0x1(%rax), %rsi
movzbl 0x1(%rax), %ecx
cmpl $0x2f, %ecx
je 0x23f6
testl %ecx, %ecx
jne 0x241d
movq %rsp, %r15
movq %rax, (%r15)
pushq $0x1
popq %rbp
movq %r14, %rdi
movl %ebp, %edx
callq 0x2aed
movq %rax, %r14
movq %r15, %rdi
callq 0x2ba8
movq %r14, (%rbx,%r12,8)
jmp 0x24a5
pushq $0x2f
popq %rax
movq %rsi, %rdi
movl %eax, %esi
callq 0x29f8
movq %rax, (%rsp)
movq %rax, %rdi
callq 0x10f0
testq %rax, %rax
je 0x247b
movq %rax, %r15
movq %rsp, %r14
movq %r14, %rdi
callq 0x2ba8
movq (%rbx,%r12,8), %rdi
pushq $0x2f
popq %rsi
callq 0x2958
movq %rax, (%r14)
movq 0x20(%r15), %rdi
callq 0x29d0
movq %rax, (%rbx,%r12,8)
movq (%r14), %rsi
pushq $0x1
popq %rbp
movq %rax, %rdi
movl %ebp, %edx
callq 0x2aed
movq %rax, (%rbx,%r12,8)
jmp 0x24a5
movq (%rbx,%r12,8), %rdx
leaq 0x8(%rsp), %rbx
movq %r14, (%rbx)
incq %rdx
leaq 0x4d52(%rip), %rsi      # 0x71e3
xorl %ebp, %ebp
pushq $0x2
popq %rdi
xorl %eax, %eax
callq 0x38b8
movq %rbx, %rdi
callq 0x2ba8
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ffoissey[P]minishell_42/srcs/ft_expansion.c
// Function: ft_change_dollar_and_tild
int			ft_change_dollar_and_tild(char **tab, t_list_ex *lst)
{
	int		i;
	char	*value;
	char	*tmp;

	i = 0;
	value = NULL;
	while (tab && tab[i])
	{
		if ((tmp = ft_strchr(tab[i], '$')))
		{
			if (*(tmp + 1))
				ft_dollar(tab, lst, value, i);
		}
		else if (tab[i][0] == '~')
		{
			if (!(ft_tilde(tab, lst, value, i)))
				return (FALSE);
		}
		ft_strdel(&value);
		i++;
	}
	return (TRUE);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, 0x20(%rsp)
andq $0x0, 0x10(%rsp)
testq %rdi, %rdi
je 0x2650
movq %rdi, %r14
xorl %r12d, %r12d
pushq $0x1
popq %r15
leaq 0x10(%rsp), %rbx
leaq 0x18(%rsp), %rbp
movq %rdi, 0x28(%rsp)
movq (%r14,%r12,8), %rdi
testq %rdi, %rdi
je 0x2659
leaq (%r14,%r12,8), %r13
pushq $0x24
popq %rsi
callq 0x2958
testq %rax, %rax
je 0x2623
cmpb $0x0, 0x1(%rax)
je 0x2640
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %r13, 0x30(%rsp)
movq (%r13), %r14
movq %r14, %rdi
movq %rbp, %r13
pushq $0x24
popq %rbp
movl %ebp, %esi
callq 0x29f8
movq %rax, 0x8(%rsp)
movq %r14, %rdi
movl %ebp, %esi
movq %r13, %rbp
callq 0x2958
movq %rax, %r14
testq %r14, %r14
je 0x2602
cmpb $0x0, (%r14)
je 0x2602
movzbl 0x1(%r14), %eax
cmpl $0x3f, %eax
je 0x257e
cmpl $0x24, %eax
jne 0x25ad
callq 0x1050
movl %eax, %edi
jmp 0x2588
leaq 0x9b4b(%rip), %rax      # 0xc0d0
movl 0x4(%rax), %edi
callq 0x3104
movq %rax, 0x18(%rsp)
leaq 0x8(%rsp), %rdi
movq %rbp, %rsi
pushq $0x3
popq %rdx
callq 0x2aa0
movq %rax, 0x8(%rsp)
addq $0x2, %r14
jmp 0x2553
incq %r14
movq %r14, %rdi
pushq $0x24
popq %rbx
movl %ebx, %esi
callq 0x29f8
movq %rax, 0x18(%rsp)
movl %r15d, %ebp
movq 0x8(%rsp), %r15
movq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x22f9
movq %r15, %rdi
movl %ebp, %r15d
movq %r13, %rbp
movq %rax, %rsi
movl %r15d, %edx
callq 0x2aed
movq %rax, 0x8(%rsp)
movq %r13, %rdi
callq 0x2ba8
movq %r14, %rdi
movl %ebx, %esi
jmp 0x254b
movq 0x30(%rsp), %rbx
movq %rbx, %rdi
callq 0x2ba8
movq 0x8(%rsp), %rax
movq %rax, (%rbx)
movq 0x28(%rsp), %r14
leaq 0x10(%rsp), %rbx
jmp 0x2640
movq (%r13), %rax
cmpb $0x7e, (%rax)
jne 0x2640
movq %r14, %rdi
movq 0x20(%rsp), %rsi
movl %r12d, %ecx
callq 0x2398
testl %eax, %eax
je 0x2656
movq %rbx, %rdi
callq 0x2ba8
incq %r12
jmp 0x24ef
pushq $0x1
popq %r15
jmp 0x2659
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/ffoissey[P]minishell_42/libft/srcs/string/ft_strcat.c
// Function: ft_strcat
char	*ft_strcat(char *s1, const char *s2)
{
	size_t		i;
	size_t		j;

	i = ft_strlen(s1);
	j = 0;
	while (s2[j])
		s1[i++] = s2[j++];
	s1[i] = '\0';
	return (s1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2b7c
addq %rbx, %rax
xorl %ecx, %ecx
movb (%r14,%rcx), %dl
testb %dl, %dl
je 0x28d0
movb %dl, (%rax,%rcx)
incq %rcx
jmp 0x28c0
movb $0x0, (%rcx,%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/ffoissey[P]minishell_42/libft/srcs/string/ft_strncmp.c
// Function: ft_strncmp
int		ft_strncmp(const char *s1, const char *s2, size_t n)
{
	size_t		i;

	i = 0;
	if (!s1 && !s2)
		return (0);
	if (!s1)
		return (-s2[i]);
	if (!s2)
		return (s1[i]);
	while ((s1[i] || s2[i]) && i < n)
	{
		if (s1[i] != s2[i])
			return ((int)((unsigned char)s1[i] - (unsigned char)s2[i]));
		i++;
	}
	return (0);
}

// Assembly:
movq %rdi, %rax
orq %rsi, %rax
je 0x2948
testq %rdi, %rdi
je 0x294b
testq %rsi, %rsi
je 0x2951
xorl %ecx, %ecx
xorl %eax, %eax
movzbl (%rdi,%rcx), %r8d
testl %r8d, %r8d
je 0x2927
cmpq %rdx, %rcx
jae 0x2948
movb (%rsi,%rcx), %r9b
jmp 0x2935
cmpq %rdx, %rcx
jae 0x2947
movb (%rsi,%rcx), %r9b
testb %r9b, %r9b
je 0x2947
incq %rcx
cmpb %r9b, %r8b
je 0x2912
movzbl %r9b, %eax
subl %eax, %r8d
movl %r8d, %eax
retq
xorl %eax, %eax
retq
movsbl (%rsi), %eax
negl %eax
retq
movsbl (%rdi), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/ffoissey[P]minishell_42/libft/srcs/string/ft_strrchr.c
// Function: ft_strrchr
char	*ft_strrchr(const char *s, int c)
{
	size_t			i;
	size_t			j;
	unsigned char	c_cp;

	i = 0;
	c_cp = (unsigned char)c;
	if (!c_cp)
		return ((char *)s + ft_strlen(s));
	while (s[i])
	{
		if (c_cp == s[i])
		{
			j = i + 1;
			while (s[j] && s[j] != c_cp)
				j++;
			if (!s[j])
				return ((char *)(s + i));
		}
		i++;
	}
	return ((s[i] == c_cp) ? ((char *)s + i) : NULL);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
andl $0xff, %esi
je 0x29b9
leaq 0x1(%rbx), %rcx
xorl %eax, %eax
xorl %edx, %edx
movsbl (%rbx,%rdx), %edi
testl %edi, %edi
je 0x29cc
cmpl %edi, %esi
jne 0x29b1
movq %rcx, %rdi
movsbl (%rdi), %r8d
testl %r8d, %r8d
je 0x29ac
incq %rdi
cmpl %r8d, %esi
jne 0x299b
testb %r8b, %r8b
je 0x29c6
incq %rdx
incq %rcx
jmp 0x298c
movq %rbx, %rdi
callq 0x2b7c
addq %rbx, %rax
jmp 0x29cc
addq %rdx, %rbx
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/ffoissey[P]minishell_42/libft/srcs/string/ft_strctrim.c
// Function: ft_strctrim
char			*ft_strctrim(char const *s, char c)
{
	char	*tmp;
	char	*new_str;
	size_t	len;
	size_t	cp_len;

	tmp = (char *)s;
	if (!s)
		return (NULL);
	while (*tmp && *tmp == c)
		tmp++;
	len = ft_strlen(tmp);
	cp_len = len;
	while ((tmp[len - 1] == c) && len >= 1)
		len--;
	if (len == cp_len)
		return (ft_strdup(tmp));
	if (!(new_str = (char *)malloc(sizeof(char) * (len + 1))))
		return (NULL);
	ft_strncpy(new_str, tmp, len);
	new_str[len] = '\0';
	return (new_str);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x2cd0
movl %esi, %ebp
movq %rdi, %rbx
decq %rbx
movb 0x1(%rbx), %al
incq %rbx
testb %al, %al
je 0x2c74
cmpb %bpl, %al
je 0x2c65
movq %rbx, %rdi
callq 0x2b7c
movq %rax, %r14
xorl %r12d, %r12d
leaq (%r14,%r12), %rax
decq %r12
testq %rax, %rax
je 0x2c95
cmpb %bpl, -0x1(%rbx,%rax)
je 0x2c82
cmpq $-0x1, %r12
je 0x2cdf
leaq (%r14,%r12), %rdi
addq $0x2, %rdi
callq 0x1120
testq %rax, %rax
je 0x2cd0
movq %rax, %r15
leaq (%r14,%r12), %rdx
incq %rdx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x6348
movq %r15, %rax
addq %r14, %rax
movb $0x0, 0x1(%r12,%rax)
jmp 0x2cd3
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x29d0
nop
// File: /workspace/github_c_makefile_star2_O2/ffoissey[P]minishell_42/libft/srcs/string/ft_strsplit_whitespaces.c
// Function: ft_strsplit_whitespaces
char			**ft_strsplit_whitespaces(char const *s)
{
	char				**tab;
	size_t				count;
	size_t				i;

	if (!s)
		return (NULL);
	i = 0;
	count = 0;
	while (s[i] == ' ' || s[i] == '\t')
		i++;
	if (s[i])
		count = ft_count_words(s);
	if (!(tab = (char **)malloc(sizeof(char *) * (count + 1))))
		return (NULL);
	tab[count] = NULL;
	if (count)
	{
		if (!(tab = ft_fill_table(s + i, tab)))
		{
			free(tab);
			tab = NULL;
			return (NULL);
		}
	}
	return (tab);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x2fe6
movq %rdi, %r14
xorl %r13d, %r13d
movzbl (%r14,%r13), %r15d
cmpl $0x9, %r15d
je 0x2eae
cmpl $0x20, %r15d
jne 0x2eb3
incq %r13
jmp 0x2e9d
movabsq $0x100000201, %r12      # imm = 0x100000201
testl %r15d, %r15d
jne 0x2f8f
xorl %ebp, %ebp
leaq 0x8(,%rbp,8), %rdi
callq 0x1120
testq %rax, %rax
je 0x2fe6
movq %rax, %rbx
andq $0x0, (%rax,%rbp,8)
testq %rbp, %rbp
je 0x2fe8
leaq (%r14,%r13), %rbp
leaq (%r14,%r13), %rax
incq %rax
movq %rax, 0x10(%rsp)
pushq $-0x1
popq %rax
movq %rax, (%rsp)
xorl %r13d, %r13d
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rax
addq %r13, %rax
xorl %r14d, %r14d
testb %r15b, %r15b
je 0x2fe8
movzbl (%rax,%r14), %r15d
incq %r14
cmpq $0x20, %r15
ja 0x2f1d
btq %r15, %r12
jae 0x2f1d
leaq 0x1(%r14), %rdi
callq 0x1120
movq %rax, %r15
movq 0x8(%rsp), %rax
movq %r15, (%rbx,%rax,8)
testq %r15, %r15
je 0x2fc6
movq %rbp, %rsi
addq %r13, %rsi
addq %r14, %r13
movq %r15, %rdi
movq %r14, %rdx
callq 0x6348
movb $0x0, (%r15,%r14)
jmp 0x2f72
incq %r13
movzbl (%rbp,%r13), %r15d
cmpl $0x20, %r15d
je 0x2f6f
cmpl $0x9, %r15d
je 0x2f6f
incq 0x8(%rsp)
incq (%rsp)
jmp 0x2f12
movb (%r14), %cl
xorl %ebp, %ebp
xorl %eax, %eax
incq %rax
testb %cl, %cl
je 0x2ec8
movl %ecx, %edx
movzbl (%r14,%rax), %ecx
cmpq $0x20, %rcx
ja 0x2f96
btq %rcx, %r12
jae 0x2f96
cmpb $0x20, %dl
je 0x2f96
movzbl %dl, %edx
cmpl $0x9, %edx
je 0x2f96
incq %rbp
jmp 0x2f96
movq (%rsp), %r15
movq %r15, %r14
subq $0x1, %r14
jb 0x2fe6
movq (%rbx,%r15,8), %rdi
callq 0x1030
andq $0x0, (%rbx,%r15,8)
movq %r14, %r15
jmp 0x2fcd
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/ffoissey[P]minishell_42/libft/srcs/conversion/ft_itoa.c
// Function: ft_itoa
char		*ft_itoa(int n)
{
	int		tmp;
	size_t	size;
	char	*str;
	int		i;

	i = 0;
	tmp = n;
	size = 0;
	if (n <= 0)
		size = 1;
	while (tmp)
	{
		tmp /= 10;
		size++;
	}
	if (n == -2147483648)
		return (ft_strdup("-2147483648"));
	if (!(str = (char *)malloc(sizeof(char) * (size + 1))))
		return (NULL);
	ft_strnbr(n, str, &i);
	str[size] = '\0';
	return (str);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
andl $0x0, 0xc(%rsp)
movl %edi, %ebp
xorl %ebx, %ebx
testl %edi, %edi
setle %bl
incq %rbx
pushq $0xa
popq %rcx
movl %edi, %eax
testl %eax, %eax
je 0x312e
cltd
idivl %ecx
incq %rbx
jmp 0x3122
movl %ebp, %eax
negl %eax
jno 0x3148
leaq 0x41b1(%rip), %rdi      # 0x72ec
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x29d0
movq %rbx, %rdi
callq 0x1120
testq %rax, %rax
je 0x316f
movq %rax, %r14
leaq 0xc(%rsp), %rdx
movl %ebp, %edi
movq %rax, %rsi
callq 0x317e
movb $0x0, -0x1(%r14,%rbx)
jmp 0x3172
xorl %r14d, %r14d
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ffoissey[P]minishell_42/libft/srcs/conversion/ft_itoa.c
// Function: ft_strnbr
static void	ft_strnbr(int nbr, char *str, int *i)
{
	if (nbr < 0)
	{
		str[*i] = '-';
		(*i)++;
		ft_strnbr(-nbr, str, i);
	}
	else if (nbr <= 9)
	{
		str[*i] = (char)(nbr + '0');
		(*i)++;
	}
	else
	{
		ft_strnbr(nbr / 10, str, i);
		ft_strnbr(nbr % 10, str, i);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
pushq $0xa
popq %r15
testl %ebp, %ebp
js 0x31b2
cmpl $0x9, %ebp
jbe 0x31c0
movl %ebp, %eax
xorl %edx, %edx
divl %r15d
movl %edx, %ebp
movl %eax, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x317e
jmp 0x3191
movslq (%rbx), %rax
movb $0x2d, (%r14,%rax)
incl (%rbx)
negl %ebp
jmp 0x3191
orb $0x30, %bpl
movslq (%rbx), %rax
movb %bpl, (%r14,%rax)
incl (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mruby-zest[P]osc-bridge/src/bridge.c
// Function: on_read
void on_read(uv_udp_t *req, ssize_t nread, const uv_buf_t *buf,
             const struct sockaddr *addr, unsigned flags) {
    (void) flags;
    if(nread > 0) {

        const struct sockaddr_in *addr_in = (const struct sockaddr_in *)addr;
        if(addr) {
            char sender[17] = { 0 };
            uv_ip4_name(addr_in, sender, 16);
            //printf("Recv from %s\n", sender);
            //printf("port = %d\n", addr_in->sin_port);
        }
        //printf("buffer[%d] = %s\n", nread, buf->base);
        //hexdump(buf->base, 0, nread);
        bridge_t *br = (bridge_t*)req->data;
        br_recv(br, buf->base);
    }
    free(buf->base);
    //free(req);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
testq %rsi, %rsi
jle 0x245b
movq %rdi, %r14
testq %rcx, %rcx
je 0x2450
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %rsi
movaps %xmm0, (%rsi)
movb $0x0, 0x10(%rsi)
pushq $0x10
popq %rdx
movq %rcx, %rdi
callq 0x2260
movq (%r14), %rdi
movq (%rbx), %rsi
callq 0x246c
movq (%rbx), %rdi
callq 0x2030
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq