LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ebiggers[P]mysh/mysh_main.c
// Function: interrupt_children
static void interrupt_children(const pid_t child_pids[], unsigned npids)
{
	unsigned i = 0;
	do {
		if (kill(child_pids[i], SIGINT)) {
			mysh_error_with_errno("failed to interrupt child "
					      "process (pid %d)",
					      child_pids[i]);
		}
	} while (++i != npids);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
movl (%rax,%rcx,4), %edi
movl $0x2, %esi
callq 0x2270
cmpl $0x0, %eax
je 0x5447
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
movl (%rax,%rcx,4), %esi
leaq 0x54e1(%rip), %rdi      # 0xa921
movb $0x0, %al
callq 0x8cf0
jmp 0x5449
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
cmpl -0xc(%rbp), %eax
jne 0x5416
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ebiggers[P]mysh/mysh_main.c
// Function: check_for_finished_background_pipelines
static void check_for_finished_background_pipelines()
{
	struct background_pipeline *p, *tmp;

	list_for_each_entry_safe(p, tmp, &background_pipelines, list) {
		unsigned rem_pids = p->npids;
		unsigned i = 0;
		do {
			if (p->pids[i] < 0) {
				rem_pids--;
			} else {
				int status;
				int ret;
				ret = waitpid(p->pids[i], &status, WNOHANG);
				if (ret == -1) {
					mysh_error_with_errno("wait error");
				} else if (ret != 0) {
					rem_pids--;
					p->pids[i] = -1;
				}
			}
		} while (++i != p->npids);
		if (rem_pids == 0) {
			printf("[%u]+ Done                  %d\n", p->num, p->last_pid);
			list_del(&p->list);
			free(p);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x9119(%rip), %rax      # 0xe5f8
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
leaq 0x90df(%rip), %rcx      # 0xe5f8
cmpq %rcx, %rax
je 0x5616
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movq -0x8(%rbp), %rax
movl -0x38(%rbp), %ecx
cmpl $0x0, 0x1c(%rax,%rcx,4)
jge 0x554c
movl -0x34(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x55a0
movq -0x8(%rbp), %rax
movl -0x38(%rbp), %ecx
movl 0x1c(%rax,%rcx,4), %edi
leaq -0x3c(%rbp), %rsi
movl $0x1, %edx
callq 0x22b0
movl %eax, -0x40(%rbp)
cmpl $-0x1, -0x40(%rbp)
jne 0x557e
leaq 0x53d7(%rip), %rdi      # 0xa94c
movb $0x0, %al
callq 0x8cf0
jmp 0x559e
cmpl $0x0, -0x40(%rbp)
je 0x559c
movl -0x34(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rax
movl -0x38(%rbp), %ecx
movl $0xffffffff, 0x1c(%rax,%rcx,4) # imm = 0xFFFFFFFF
jmp 0x559e
jmp 0x55a0
jmp 0x55a2
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
movq -0x8(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jne 0x5533
cmpl $0x0, -0x34(%rbp)
jne 0x55ec
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
movq -0x8(%rbp), %rax
movl 0x18(%rax), %edx
leaq 0x5384(%rip), %rdi      # 0xa957
movb $0x0, %al
callq 0x2140
movq -0x8(%rbp), %rdi
callq 0x54a0
movq -0x8(%rbp), %rdi
callq 0x2050
jmp 0x55ee
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x550e
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ebiggers[P]mysh/mysh_main.c
// Function: source_myshrc
static void source_myshrc()
{
	/* source $HOME/.myshrc */
	char *home = getenv("HOME");
	if (home) {
		size_t len = strlen(home);
		char filename[len + sizeof("/.myshrc")];
		stpcpy(filename, home);
		strcat(filename, "/.myshrc");
		do_source(filename, 0, NULL);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x48b8(%rip), %rdi      # 0xa277
callq 0x2030
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5a36
movq -0x8(%rbp), %rdi
callq 0x2100
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, %rax
addq $0x9, %rax
movq %rsp, %rdx
movq %rdx, -0x18(%rbp)
addq $0x18, %rcx
andq $-0x10, %rcx
movq %rsp, %rdi
subq %rcx, %rdi
movq %rdi, -0x28(%rbp)
movq %rdi, %rsp
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rsi
callq 0x20f0
movq -0x28(%rbp), %rdi
leaq 0x4f8e(%rip), %rsi      # 0xa9a9
callq 0x2320
movq -0x28(%rbp), %rdi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x4170
movq -0x18(%rbp), %rax
movq %rax, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ebiggers[P]mysh/mysh_param.c
// Function: export_variable
int export_variable(const char *name)
{
	const char *value = lookup_shell_param(name);
	int ret;
	if (value)
		ret = setenv(name, value, 1);
	else
		ret = unsetenv(name);
	if (ret)
		mysh_error_with_errno("can't export variable %s", name);
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5e80
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5e47
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x20d0
movl %eax, -0x14(%rbp)
jmp 0x5e53
movq -0x8(%rbp), %rdi
callq 0x22f0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x5e6b
movq -0x8(%rbp), %rsi
leaq 0x4bd8(%rip), %rdi      # 0xaa3c
movb $0x0, %al
callq 0x8cf0
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ebiggers[P]mysh/mysh_param.c
// Function: init_param_map
void init_param_map()
{
	char **env_p;
	extern char **environ;

	init_trie_slot_tabs();
	for (env_p = environ; *env_p != NULL; env_p++)
		make_param_assignment(*env_p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x6c30
movq 0x810c(%rip), %rax      # 0xdfd0
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x5eef
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x5dc0
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0x5ecb
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ebiggers[P]mysh/mysh_param.c
// Function: free_param_trie
static void free_param_trie(struct param_trie_node *node)
{
	size_t i, j;
	for (i = 0; i < ARRAY_SIZE(node->children); i++) {
		if (node->children[i]) {
			free_param_trie(node->children[i]);


			for (j = 0; j < NUM_VALUES; j++)
				free(node->children[i]->values[j]);
			free(node->children[i]);
			node->children[i] = NULL;
			mysh_assert(node->num_children > 0);
			node->num_children--;
		}
	}
	mysh_assert(node->num_children == 0);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
cmpq $0x3f, -0x10(%rbp)
jae 0x6016
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x6003
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x5f20
movq $0x0, -0x18(%rbp)
cmpq $0x2, -0x18(%rbp)
jae 0x5f9d
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x18(%rbp), %rcx
movq 0x208(%rax,%rcx,8), %rdi
callq 0x2050
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x5f6b
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2050
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x218(%rax)
jbe 0x5fce
jmp 0x5fed
leaq 0x4c52(%rip), %rdi      # 0xac27
leaq 0x4abe(%rip), %rsi      # 0xaa9a
movl $0xcc, %edx
leaq 0x4c56(%rip), %rcx      # 0xac3e
callq 0x2160
movq -0x8(%rbp), %rax
movq 0x218(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x218(%rax)
jmp 0x6005
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x5f34
movq -0x8(%rbp), %rax
cmpq $0x0, 0x218(%rax)
jne 0x6026
jmp 0x6045
leaq 0x4c40(%rip), %rdi      # 0xac6d
leaq 0x4a66(%rip), %rsi      # 0xaa9a
movl $0xd0, %edx
leaq 0x4bfe(%rip), %rcx      # 0xac3e
callq 0x2160
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ebiggers[P]mysh/mysh_param.c
// Function: string_matches_param_assignment
bool string_matches_param_assignment(const struct string *s)
{
	size_t i;
	if (!(shell_char_type(s->chars[0]) & SHELL_NORMAL_PARAM_FIRST_CHAR))
		return false;
	for (i = 1; i < s->len; i++)
		if (!(shell_char_type(s->chars[i]) & SHELL_NORMAL_PARAM_CHAR))
			return (s->chars[i] == '=');
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %edi
callq 0x60f0
andl $0x5, %eax
cmpl $0x0, %eax
jne 0x6079
movb $0x0, -0x1(%rbp)
jmp 0x60db
movq $0x1, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x60d7
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x60f0
andl $0x7, %eax
cmpl $0x0, %eax
jne 0x60c7
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3d, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x60db
jmp 0x60c9
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x6081
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ebiggers[P]mysh/mysh_param.c
// Function: do_lookup_shell_variable
static const char *
do_lookup_shell_variable(const char *name, size_t len, int value_idx)
{
	struct param_trie_node *node = &param_trie_root;
	while (len--) {
		int slot = trie_get_slot(*name++);
		if (slot < 0)
			return NULL;
		mysh_assert(slot < ARRAY_SIZE(node->children));
		node = node->children[slot];
		if (!node)
			return NULL;
	}
	return node->values[value_idx];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
leaq 0x8566(%rip), %rax      # 0xe6c0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x18(%rbp)
cmpq $0x0, %rax
je 0x61ee
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movsbl (%rax), %edi
callq 0x6b80
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0x619d
movq $0x0, -0x8(%rbp)
jmp 0x6202
movslq -0x2c(%rbp), %rax
cmpq $0x3f, %rax
jae 0x61a9
jmp 0x61c8
leaq 0x493c(%rip), %rdi      # 0xaaec
leaq 0x48e3(%rip), %rsi      # 0xaa9a
movl $0x100, %edx            # imm = 0x100
leaq 0x4ac2(%rip), %rcx      # 0xac85
callq 0x2160
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x61e9
movq $0x0, -0x8(%rbp)
jmp 0x6202
jmp 0x615e
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq 0x208(%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ebiggers[P]mysh/mysh_param.c
// Function: do_print_all_shell_variables
static int do_print_all_shell_variables(struct param_trie_node *node,
					int value_idx, const char *format)
{
	size_t i;
	int ret = 0;

	if (node->values[value_idx]) {
		ret = node_print_variable(node, value_idx, format);
		if (ret)
			goto out;
	}
	for (i = 0; i < ARRAY_SIZE(node->children); i++) {
		if (node->children[i]) {
			ret = do_print_all_shell_variables(node->children[i],
							   value_idx, format);
			if (ret)
				goto out;
		}
	}
out:
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, 0x208(%rax,%rcx,8)
je 0x649a
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x6e20
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x6498
jmp 0x64ef
jmp 0x649a
movq $0x0, -0x20(%rbp)
cmpq $0x3f, -0x20(%rbp)
jae 0x64ed
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x64dd
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x6450
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x64db
jmp 0x64ef
jmp 0x64dd
jmp 0x64df
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x64a2
jmp 0x64ef
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ebiggers[P]mysh/mysh_param.c
// Function: append_param
static void
append_param(const char *name, size_t len, struct list_head *out_list)
{
	const char *value = lookup_param(name, len);
	if (value) {
		struct string *s = new_string_with_data(value, strlen(value));
		list_add_tail(&s->list, out_list);
		s->flags |= STRING_FLAG_WAS_PARAM;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6270
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x6a3e
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2100
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x8fa0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
callq 0x6f60
movq -0x28(%rbp), %rax
movl 0x10(%rax), %ecx
orl $0x100, %ecx            # imm = 0x100
movl %ecx, 0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ebiggers[P]mysh/mysh_param.c
// Function: set_positional_params
void set_positional_params(int num_params, const char *param0,
			   const char * const *params)
{
	unsigned i;
	destroy_positional_params();
	num_positional_parameters = num_params;
	positional_parameters = xmalloc((num_positional_parameters + 1) * sizeof(char *));
	positional_parameters[0] = xstrdup(param0);
	for (i = 0; i < num_positional_parameters; i++)
		positional_parameters[i + 1] = xstrdup(params[i]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x6af0
movl -0x4(%rbp), %eax
movl %eax, 0x7e83(%rip)      # 0xe8f4
movl 0x7e7d(%rip), %eax      # 0xe8f4
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
shlq $0x3, %rdi
callq 0x8e00
movq %rax, 0x7e6a(%rip)      # 0xe8f8
movq -0x10(%rbp), %rdi
callq 0x8ee0
movq %rax, %rcx
movq 0x7e57(%rip), %rax      # 0xe8f8
movq %rcx, (%rax)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl 0x7e40(%rip), %eax      # 0xe8f4
jae 0x6ae7
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x8ee0
movq %rax, %rdx
movq 0x7e28(%rip), %rax      # 0xe8f8
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movq %rdx, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6aab
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ebiggers[P]mysh/mysh_param.c
// Function: destroy_positional_params
void destroy_positional_params()
{
	unsigned i;
	if (positional_parameters) {
		for (i = 0; i <= num_positional_parameters; i++)
			free(positional_parameters[i]);
		free(positional_parameters);
		positional_parameters = NULL;
		if (all_positional_params) {
			free(all_positional_params);
			all_positional_params = NULL;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x7df8(%rip)      # 0xe8f8
je 0x6b6c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x7de2(%rip), %eax      # 0xe8f4
ja 0x6b32
movq 0x7ddd(%rip), %rax      # 0xe8f8
movl -0x4(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x2050
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x6b09
movq 0x7dbf(%rip), %rdi      # 0xe8f8
callq 0x2050
movq $0x0, 0x7daf(%rip) # 0xe8f8
cmpq $0x0, 0x7daf(%rip)      # 0xe900
je 0x6b6a
movq 0x7da6(%rip), %rdi      # 0xe900
callq 0x2050
movq $0x0, 0x7d96(%rip) # 0xe900
jmp 0x6b6c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ebiggers[P]mysh/mysh_param.c
// Function: node_has_values
static bool node_has_values(const struct param_trie_node *node)
{
	int i;
	for (i = 0; i < NUM_VALUES; i++)
		if (node->values[i])
			return true;
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x2, -0x14(%rbp)
jge 0x6c1b
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, 0x208(%rax,%rcx,8)
je 0x6c0e
movb $0x1, -0x1(%rbp)
jmp 0x6c1f
jmp 0x6c10
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6bef
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ebiggers[P]mysh/mysh_param.c
// Function: init_trie_slot_tabs
static void init_trie_slot_tabs()
{
	unsigned i, n;
	for (i = 0; i < 256; i++)
		trie_char_to_slot_tab[i] = -1;
	n = 0;
	for (i = 0; i < ARRAY_SIZE(trie_slot_ranges); i++) {
		unsigned char range_begin = trie_slot_ranges[i][0];
		unsigned char range_end = trie_slot_ranges[i][1];
		unsigned char c;
		for (c = range_begin; c <= range_end; c++) {
			trie_char_to_slot_tab[c] = n;
			trie_slot_to_char_tab[n] = c;
			n++;
		}
	}
	mysh_assert(n == NUM_SHELL_PARAM_VALID_CHARS);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0x100, -0x4(%rbp)      # imm = 0x100
jae 0x6c63
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0x7cbc(%rip), %rax      # 0xe910
movb $-0x1, (%rax,%rcx)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x6c3f
movl $0x0, -0x8(%rbp)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpq $0x4, %rax
jae 0x6cff
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0x3daa(%rip), %rax      # 0xaa34
movb (%rax,%rcx,2), %al
movb %al, -0x9(%rbp)
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0x3d98(%rip), %rax      # 0xaa34
movb 0x1(%rax,%rcx,2), %al
movb %al, -0xa(%rbp)
movb -0x9(%rbp), %al
movb %al, -0xb(%rbp)
movzbl -0xb(%rbp), %eax
movzbl -0xa(%rbp), %ecx
cmpl %ecx, %eax
jg 0x6cef
movl -0x8(%rbp), %eax
movb %al, %dl
movzbl -0xb(%rbp), %eax
movl %eax, %ecx
leaq 0x7c49(%rip), %rax      # 0xe910
movb %dl, (%rax,%rcx)
movb -0xb(%rbp), %dl
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x7d37(%rip), %rax      # 0xea10
movb %dl, (%rax,%rcx)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
movb -0xb(%rbp), %al
addb $0x1, %al
movb %al, -0xb(%rbp)
jmp 0x6ca9
jmp 0x6cf1
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x6c71
cmpl $0x3f, -0x8(%rbp)
jne 0x6d07
jmp 0x6d26
leaq 0x3edd(%rip), %rdi      # 0xabeb
leaq 0x3d85(%rip), %rsi      # 0xaa9a
movl $0x40, %edx
leaq 0x3eeb(%rip), %rcx      # 0xac0c
callq 0x2160
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ebiggers[P]mysh/mysh_param.c
// Function: get_all_positional_params
static char *get_all_positional_params()
{
	size_t total_len = 1;
	unsigned i;
	char *p;

	if (all_positional_params)
		free(all_positional_params);
	for (i = 1; i <= num_positional_parameters; i++)
		total_len += strlen(positional_parameters[i]);
	total_len += num_positional_parameters;
	all_positional_params = p = xmalloc(total_len);
	*p = '\0';
	for (i = 1; i <= num_positional_parameters; i++) {
		p = stpcpy(p, positional_parameters[i]);
		if (i != num_positional_parameters)
			p = stpcpy(p, " ");
	}
	return all_positional_params;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq $0x1, -0x8(%rbp)
cmpq $0x0, 0x7bb8(%rip)      # 0xe900
je 0x6d56
movq 0x7baf(%rip), %rdi      # 0xe900
callq 0x2050
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x7b8e(%rip), %eax      # 0xe8f4
ja 0x6d8e
movq 0x7b89(%rip), %rax      # 0xe8f8
movl -0xc(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x2100
addq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6d5d
movl 0x7b60(%rip), %eax      # 0xe8f4
addq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8e00
movq %rax, -0x18(%rbp)
movq %rax, 0x7b50(%rip)      # 0xe900
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x7b2d(%rip), %eax      # 0xe8f4
ja 0x6e10
movq -0x18(%rbp), %rdi
movq 0x7b24(%rip), %rax      # 0xe8f8
movl -0xc(%rbp), %ecx
movq (%rax,%rcx,8), %rsi
callq 0x20f0
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x7b07(%rip), %eax      # 0xe8f4
je 0x6e03
movq -0x18(%rbp), %rdi
leaq 0x3b88(%rip), %rsi      # 0xa982
callq 0x20f0
movq %rax, -0x18(%rbp)
jmp 0x6e05
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6dbe
movq 0x7ae9(%rip), %rax      # 0xe900
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ebiggers[P]mysh/mysh_param.c
// Function: node_print_variable
static int node_print_variable(struct param_trie_node *node,
			       int value_idx, const char *format)
{
	size_t len;
	size_t i;
	struct param_trie_node *p;
	int ret;

	p = node;
	len = 0;
	while (p != &param_trie_root) {
		p = p->parent;
		len++;
	}
	char name[len + 1];
	name[len] = '\0';

	p = node;
	i = len - 1;
	do {
		name[i] = trie_slot_to_char_tab[p->parent_child_ptr - p->parent->children];
		p = p->parent;
	} while (i-- != 0);

	ret = printf(format, name, node->values[value_idx]);
	if (ret >= 0)
		ret = 0;
	else
		mysh_error_with_errno("write error");
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x20(%rbp)
leaq 0x7876(%rip), %rax      # 0xe6c0
cmpq %rax, -0x30(%rbp)
je 0x6e6d
movq -0x30(%rbp), %rax
movq 0x1f8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x6e43
movq -0x20(%rbp), %rdx
movq %rdx, %rcx
incq %rcx
movq %rsp, %rax
movq %rax, -0x40(%rbp)
addq $0x10, %rdx
andq $-0x10, %rdx
movq %rsp, %rax
subq %rdx, %rax
movq %rax, -0x50(%rbp)
movq %rax, %rsp
movq %rcx, -0x48(%rbp)
movq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x50(%rbp), %rax
movq -0x30(%rbp), %rcx
movq 0x200(%rcx), %rdx
movq -0x30(%rbp), %rcx
movq 0x1f8(%rcx), %rcx
subq %rcx, %rdx
sarq $0x3, %rdx
leaq 0x7b35(%rip), %rcx      # 0xea10
movb (%rcx,%rdx), %dl
movq -0x28(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x30(%rbp), %rax
movq 0x1f8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x6eb3
movq -0x50(%rbp), %rsi
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x208(%rax,%rcx,8), %rdx
movb $0x0, %al
callq 0x2140
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jl 0x6f3a
movl $0x0, -0x34(%rbp)
jmp 0x6f48
leaq 0x33b5(%rip), %rdi      # 0xa2f6
movb $0x0, %al
callq 0x8cf0
movl -0x34(%rbp), %eax
movq -0x40(%rbp), %rcx
movq %rcx, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ebiggers[P]mysh/mysh_parse.c
// Function: expand_alias
static void expand_alias(struct token *tok)
{
	const char *alias_value;

	if (tok->type & TOK_UNQUOTED_STRING) {
		alias_value = lookup_alias(tok->tok_data);
		if (alias_value) {
			free(tok->tok_data);
			tok->tok_data = xstrdup(alias_value);
			tok->type |= TOK_FLAG_EXPANDED_ALIAS;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x7393
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6240
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7391
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2050
movq -0x10(%rbp), %rdi
callq 0x8ee0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
orl $0x20, %ecx
movl %ecx, 0x4(%rax)
jmp 0x7393
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ebiggers[P]mysh/mysh_parse.c
// Function: do_filename_expansion
static int do_filename_expansion(struct list_head *string_list)
{
	struct string *s, *tmp;
	int ret = 0;

	LIST_HEAD(new_list);
	list_for_each_entry_safe(s, tmp, string_list, list)
		ret |= string_do_filename_expansion(s, &new_list);
	INIT_LIST_HEAD(string_list);
	if (ret)
		free_string_list(&new_list);
	else
		list_splice_tail(&new_list, string_list);
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x1c(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $-0x18, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
addq $-0x18, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x18, %rax
cmpq -0x8(%rbp), %rax
je 0x77fd
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x7e90
orl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
addq $-0x18, %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x77b2
movq -0x8(%rbp), %rdi
callq 0x8000
cmpl $0x0, -0x1c(%rbp)
je 0x7817
leaq -0x30(%rbp), %rdi
callq 0x9050
jmp 0x7824
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x7540
movl -0x1c(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ebiggers[P]mysh/mysh_parse.c
// Function: transfer_var_assignments
static void transfer_var_assignments(struct list_head *string_list,
				     struct list_head *var_assignments)
{
	struct string *s, *tmp;
	list_for_each_entry_safe(s, tmp, string_list, list) {
		if (s->flags & STRING_FLAG_VAR_ASSIGNMENT)
			list_move_tail(&s->list, var_assignments);
		else
			break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $-0x18, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $-0x18, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x18, %rax
cmpq -0x8(%rbp), %rax
je 0x78df
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
andl $0x200, %eax            # imm = 0x200
cmpl $0x0, %eax
je 0x78b1
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
callq 0x7e30
jmp 0x78b3
jmp 0x78df
jmp 0x78b5
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
addq $-0x18, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x787f
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ebiggers[P]mysh/./list.h
// Function: _list_splice
static inline void __list_splice(const struct list_head *list,
				 struct list_head *prev,
				 struct list_head *next)
{
	struct list_head *first = list->next;
	struct list_head *last = list->prev;

	first->prev = prev;
	prev->next = first;

	last->next = next;
	next->prev = last;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ebiggers[P]mysh/mysh_parse.c
// Function: string_do_filename_expansion
static int
string_do_filename_expansion(struct string *s, struct list_head *out_list)
{
	int ret;
	glob_t glob_buf;

	ret = glob(s->chars,
		   GLOB_NOESCAPE | GLOB_TILDE | GLOB_BRACE,
		   NULL, &glob_buf);
	if (ret) {
		switch (ret) {
		case GLOB_NOMATCH:
			/* If the glob does not match, use the literal string. */
			list_add_tail(&s->list, out_list);
			break;
		case GLOB_NOSPACE:
			/* Be consistent with xmalloc() and just abort the shell
			 * if memory has been exhausted */
			mysh_error_with_errno("out of memory");
			exit(1);
		default:
			/* Other error, such as a read error. */
			mysh_error_with_errno("glob()");
			return -1;
		}
	} else {
		size_t i;
		int flags;
		struct string *s2;

		/* glob completed successfully and produced one or more strings.
		 * Free the original string, and add the new strings to
		 * @out_list. */
 		flags = s->flags;
		if (glob_buf.gl_pathc > 1 || strcmp(glob_buf.gl_pathv[0], s->chars) != 0)
			flags |= STRING_FLAG_FILENAME_EXPANDED;
		free_string(s);
		for (i = 0; i < glob_buf.gl_pathc; i++) {
			s2 = new_string_with_data(glob_buf.gl_pathv[i],
						  strlen(glob_buf.gl_pathv[i]));
			s2->flags = flags;
			list_add_tail(&s2->list, out_list);
		}
		globfree(&glob_buf);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0x1440, %esi           # imm = 0x1440
xorl %eax, %eax
movl %eax, %edx
leaq -0x68(%rbp), %rcx
callq 0x2340
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x7f2c
movl -0x1c(%rbp), %eax
movl %eax, -0x84(%rbp)
subl $0x1, %eax
je 0x7ef5
jmp 0x7ed5
movl -0x84(%rbp), %eax
subl $0x3, %eax
jne 0x7f0d
jmp 0x7ee2
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
callq 0x7d30
jmp 0x7f27
leaq 0x308c(%rip), %rdi      # 0xaf88
movb $0x0, %al
callq 0x8cf0
movl $0x1, %edi
callq 0x2360
leaq 0x3082(%rip), %rdi      # 0xaf96
movb $0x0, %al
callq 0x8cf0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7fe9
jmp 0x7fe2
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x74(%rbp)
cmpq $0x1, -0x68(%rbp)
ja 0x7f55
movq -0x60(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x2230
cmpl $0x0, %eax
je 0x7f5e
movl -0x74(%rbp), %eax
orl $0x40, %eax
movl %eax, -0x74(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9020
movq $0x0, -0x70(%rbp)
movq -0x70(%rbp), %rax
cmpq -0x68(%rbp), %rax
jae 0x7fd9
movq -0x60(%rbp), %rax
movq -0x70(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x90(%rbp)
movq -0x60(%rbp), %rax
movq -0x70(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2100
movq -0x90(%rbp), %rdi
movq %rax, %rsi
callq 0x8fa0
movq %rax, -0x80(%rbp)
movl -0x74(%rbp), %ecx
movq -0x80(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x80(%rbp), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
callq 0x7d30
movq -0x70(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x70(%rbp)
jmp 0x7f6f
leaq -0x68(%rbp), %rdi
callq 0x2040
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ebiggers[P]mysh/mysh_parse.c
// Function: expand_single_string
static int expand_single_string(struct token *tok, struct token *next,
				struct string **string_ret)
{
	int ret;
	LIST_HEAD(string_list);
	ret = expand_params_and_word_split(tok, next, &string_list);
	if (ret)
		goto out_free_string_list;
	ret = glue_strings(&string_list);
	if (ret)
		goto out_free_string_list;
	if (!mysh_filename_expansion_disabled) {
		ret = do_filename_expansion(&string_list);
		if (ret)
			goto out_free_string_list;
	}
	if (list_empty(&string_list))
		*string_ret = NULL;
	else if (list_is_singular(&string_list))
		*string_ret = list_entry(string_list.next, struct string, list);
	else {
		ret = -1;
		goto out_free_string_list;
	}
out:
	return ret;
out_free_string_list:
	free_string_list(&string_list);
	goto out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x73a0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x85b3
jmp 0x864c
leaq -0x30(%rbp), %rdi
callq 0x75b0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x85ca
jmp 0x864c
leaq 0x605f(%rip), %rax      # 0xe630
cmpl $0x0, (%rax)
jne 0x85ec
leaq -0x30(%rbp), %rdi
callq 0x7750
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x85ea
jmp 0x864c
jmp 0x85ec
leaq -0x30(%rbp), %rdi
callq 0x7310
cmpl $0x0, %eax
je 0x8607
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
jmp 0x8641
leaq -0x30(%rbp), %rdi
callq 0x8960
cmpl $0x0, %eax
je 0x8636
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $-0x18, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x863f
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
jmp 0x864c
jmp 0x8641
jmp 0x8643
movl -0x1c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x9050
jmp 0x8643
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ebiggers[P]mysh/mysh_parse.c
// Function: next_token
static struct token *next_token(struct list_head *toks)
{
	struct token *tok = next_token_nodel(toks);
	if (tok)
		list_del(&tok->list);
	return tok;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x88c0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x868d
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x7580
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ebiggers[P]mysh/mysh_parse.c
// Function: next_token_nodel
static struct token *next_token_nodel(struct list_head *toks)
{
	struct token *tok;

	if (list_empty(toks))
		tok = NULL;
	else
		tok = list_entry(toks->next, struct token, list);
	return tok;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7310
cmpl $0x0, %eax
je 0x88e4
movq $0x0, -0x10(%rbp)
jmp 0x8903
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $-0x10, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ebiggers[P]mysh/mysh_parse.c
// Function: add_stderr_to_stdout_redirection
static void add_stderr_to_stdout_redirection(struct list_head *redirs)
{
	struct redirection *redir;

	redir = xmalloc(sizeof(*redir));
	redir->is_file = false;
	redir->src_fd = 1;
	redir->dest_fd = 2;
	list_add_tail(&redir->list, redirs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x30, %edi
callq 0x8e00
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x2, 0x18(%rax)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
movq -0x8(%rbp), %rsi
callq 0x7d30
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ebiggers[P]mysh/mysh_redir.c
// Function: undo_redirections
int undo_redirections(const struct orig_fds *orig)
{
	int ret = 0;
	int i;
	for (i = 0; i < ARRAY_SIZE(orig->fds); i++) {
		if (orig->fds[i] >= 0) {
			if (dup2(orig->fds[i], i) < 0)
				ret = -1;
			if (close(orig->fds[i]) < 0)
				ret = -1;
		}
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movslq -0x10(%rbp), %rax
cmpq $0x3, %rax
jae 0x8a2c
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jl 0x8a1f
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %edi
movl -0x10(%rbp), %esi
callq 0x2120
cmpl $0x0, %eax
jge 0x8a01
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %edi
callq 0x21c0
cmpl $0x0, %eax
jge 0x8a1d
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
jmp 0x8a1f
jmp 0x8a21
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x89ca
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ebiggers[P]mysh/mysh_util.c
// Function: mysh_error
void mysh_error(const char *fmt, ...)
{
	va_list va;
	va_start(va, fmt);
	fputs(SHELL_NAME ": error: ", stderr);
	vfprintf(stderr, fmt, va);
	fputc('\n', stderr);
	va_end(va);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x8c55
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0xd0(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x30, -0x1c(%rbp)
movl $0x8, -0x20(%rbp)
movq 0x534c(%rip), %rax      # 0xdff0
movq %rax, -0xd8(%rbp)
movq (%rax), %rsi
leaq 0x242f(%rip), %rdi      # 0xb0e4
callq 0x2170
movq -0xd8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x22e0
movq -0xd8(%rbp), %rax
movq (%rax), %rsi
movl $0xa, %edi
callq 0x21f0
addq $0xe0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ebiggers[P]mysh/mysh_util.c
// Function: mysh_error_with_errno
void mysh_error_with_errno(const char *fmt, ...)
{
	va_list va;
	va_start(va, fmt);
	fputs(SHELL_NAME ": error: ", stderr);
	vfprintf(stderr, fmt, va);
	fprintf(stderr, ": %s", strerror(errno));
	fputc('\n', stderr);
	va_end(va);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x8d25
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0xd0(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x30, -0x1c(%rbp)
movl $0x8, -0x20(%rbp)
movq 0x527c(%rip), %rax      # 0xdff0
movq %rax, -0xd8(%rbp)
movq (%rax), %rsi
leaq 0x235f(%rip), %rdi      # 0xb0e4
callq 0x2170
movq -0xd8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x22e0
movq -0xd8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xe0(%rbp)
callq 0x2060
movl (%rax), %edi
callq 0x2390
movq -0xe0(%rbp), %rdi
movq %rax, %rdx
leaq 0x14c0(%rip), %rsi      # 0xa28f
xorl %eax, %eax
callq 0x2240
movq -0xd8(%rbp), %rax
movq (%rax), %rsi
movl $0xa, %edi
callq 0x21f0
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ebiggers[P]mysh/mysh_util.c
// Function: xmalloc
void *xmalloc(size_t size)
{
	void *p = malloc(size);
	if (!p) {
		mysh_error("out of memory");
		exit(-1);
	}
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2280
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x8e38
leaq 0x2161(%rip), %rdi      # 0xaf88
movb $0x0, %al
callq 0x8c20
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2360
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ebiggers[P]mysh/mysh_util.c
// Function: xrealloc
void *xrealloc(void *ptr, size_t size)
{
	void *p = realloc(ptr, size);
	if (!p) {
		mysh_error("out of memory");
		exit(-1);
	}
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2290
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x8e90
leaq 0x2109(%rip), %rdi      # 0xaf88
movb $0x0, %al
callq 0x8c20
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2360
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ebiggers[P]mysh/mysh_util.c
// Function: xstrdup
char *xstrdup(const char *s)
{
	if (!s)
		return NULL;
	char *p = strdup(s);
	if (!p) {
		mysh_error("out of memory");
		exit(-1);
	}
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x8efd
movq $0x0, -0x8(%rbp)
jmp 0x8f31
movq -0x10(%rbp), %rdi
callq 0x2380
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x8f29
leaq 0x2070(%rip), %rdi      # 0xaf88
movb $0x0, %al
callq 0x8c20
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2360
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ebiggers[P]mysh/mysh_util.c
// Function: new_string
struct string *
new_string(size_t len)
{
	struct string *s = xmalloc(sizeof(struct string));
	s->chars = xzalloc(len + 1);
	s->len = len;
	s->flags = 0;
	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x28, %edi
callq 0x8e00
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x1, %rdi
callq 0x8ea0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ebiggers[P]mysh/mysh_util.c
// Function: free_string_list
void
free_string_list(struct list_head *string_list)
{
	struct string *s, *tmp;
	list_for_each_entry_safe(s, tmp, string_list, list) {
		list_del(&s->list);
		free_string(s);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $-0x18, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $-0x18, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x18, %rax
cmpq -0x8(%rbp), %rax
je 0x90e9
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x90f0
movq -0x10(%rbp), %rdi
callq 0x9020
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
addq $-0x18, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x909b
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ebiggers[P]mysh/mysh_util.c
// Function: join_strings
struct string *
join_strings(struct list_head *strings)
{
	struct string *s, *new, *tmp;
	size_t len = 0;
	char *p;

	mysh_assert(!list_empty(strings));
	if (list_is_singular(strings)) /* no-op */
		return list_entry(strings->next, struct string, list);
	list_for_each_entry(s, strings, list)
		len += s->len;
	new = new_string(len);
	p = new->chars;
	list_for_each_entry_safe(s, tmp, strings, list) {
		p = mempcpy(p, s->chars, s->len);
		free_string(s);
	}
	return new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9300
cmpl $0x0, %eax
jne 0x9147
jmp 0x9166
leaq 0x1fa4(%rip), %rdi      # 0xb0f2
leaq 0x1fb2(%rip), %rsi      # 0xb107
movl $0x86, %edx
leaq 0x1fb2(%rip), %rcx      # 0xb113
callq 0x2160
movq -0x10(%rbp), %rdi
callq 0x9320
cmpl $0x0, %eax
je 0x9198
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
addq $-0x18, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x92e7
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
addq $-0x18, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x18, %rax
cmpq -0x10(%rbp), %rax
je 0x91f7
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
addq $-0x18, %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x91b7
movq -0x30(%rbp), %rdi
callq 0x8f40
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
addq $-0x18, %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
addq $-0x18, %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
addq $0x18, %rax
cmpq -0x10(%rbp), %rax
je 0x92df
movq -0x38(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
movq %rdx, -0xa0(%rbp)
callq 0x2260
movq -0xa8(%rbp), %rax
movq -0xa0(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9020
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rax
addq $-0x18, %rax
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x9254
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MAGI003769[P]EE450-Socket-Project/client.c
// Function: get_in_addr
void *get_in_addr(struct sockaddr *sa) {
    if(sa->sa_family == AF_INET6) {
        // IPv6
        return &(((struct sockaddr_in6*)sa)->sin6_addr);
    }
    // IPv4
    return &(((struct sockaddr_in*)sa)->sin_addr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
cmpl $0xa, %eax
jne 0x1282
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0x128e
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MAGI003769[P]EE450-Socket-Project/client.c
// Function: parse_result
void parse_result(char *args[], char *message) {
    char *p = strtok (message, "\n");
    int i = 0;
    while (p != NULL)
    {
        args[i++] = p;
        p = strtok (NULL, "\n");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xd73(%rip), %rsi       # 0x202e
callq 0x10e0
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1302
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x1c(%rbp)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
xorl %eax, %eax
movl %eax, %edi
leaq 0xd37(%rip), %rsi       # 0x202e
callq 0x10e0
movq %rax, -0x18(%rbp)
jmp 0x12cb
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MAGI003769[P]EE450-Socket-Project/client.c
// Function: print_result
void print_result(char *src, char *target, char *args[]) {
    printf("The client has received results from AWS: \n");
    printf("-------------------------------------------------------------------------------\n");
    printf("Source\tDestination\tMin Length\tTt\tTp\tDelay\n");
    printf("-------------------------------------------------------------------------------\n");
    printf("%s\t\t%s\t%s\t%s\t%s\t%s\n", src, target, args[0], args[1], args[2], args[3]);
    printf("-------------------------------------------------------------------------------\n");
    printf("%s\n", args[4]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0xcd9(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1070
leaq 0xcf7(%rip), %rdi       # 0x2030
movb $0x0, %al
callq 0x1070
leaq 0xd3a(%rip), %rdi       # 0x2081
movb $0x0, %al
callq 0x1070
leaq 0xcdb(%rip), %rdi       # 0x2030
movb $0x0, %al
callq 0x1070
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %r8
movq -0x18(%rbp), %rax
movq 0x10(%rax), %r9
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
leaq 0xd22(%rip), %rdi       # 0x20ac
movq %rax, (%rsp)
movb $0x0, %al
callq 0x1070
leaq 0xc94(%rip), %rdi       # 0x2030
movb $0x0, %al
callq 0x1070
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
leaq 0xd0a(%rip), %rdi       # 0x20bc
movb $0x0, %al
callq 0x1070
addq $0x20, %rsp
popq %rbp
retq
nop