LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/path.c
// Function: path_set_from_string
int path_set_from_string(struct path *path, const char *cstr)
{
	if(strcmp(cstr, "~") == 0) {
		const char *home = getenv("HOME");
		if(home == NULL || strcmp(home, "~") == 0)
			return EINVAL;
		return path_set_from_string(path, home);
	}

	if(!(path_cstr_is_valid(cstr)))
		return EINVAL;

	if(!path_make_room(path, strlen(cstr) + 1))
		return ENOMEM;
	strcpy(path->path, cstr);

	/* reduce multiple consecutive slashes to a single one */
	size_t s = 0, d = 0;
	do {
		s++;
		if(path->path[s] == '/' && path->path[d] == '/')
			continue;
		d++;
		path->path[d] = path->path[s];
	} while(path->path[s] != '\0');

	/* remove trailing slash, this also ensures that the string will be
	 * empty for the root directory */
	if(path->path[d - 1] == '/')
		path->path[d - 1] = '\0';

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x1f25(%rip), %rsi      # 0xd480
callq 0x33d0
cmpl $0x0, %eax
jne 0xb5b2
leaq 0x1f21(%rip), %rdi      # 0xd48d
callq 0x3070
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xb591
movq -0x20(%rbp), %rdi
leaq 0x1ef9(%rip), %rsi      # 0xd480
callq 0x33d0
cmpl $0x0, %eax
jne 0xb59d
movl $0x16, -0x4(%rbp)
jmp 0xb6c0
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xb540
movl %eax, -0x4(%rbp)
jmp 0xb6c0
movq -0x18(%rbp), %rdi
callq 0xb6d0
testb $0x1, %al
jne 0xb5cb
movl $0x16, -0x4(%rbp)
jmp 0xb6c0
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3230
movq -0x38(%rbp), %rdi
movq %rax, %rsi
addq $0x1, %rsi
callq 0xb3e0
testb $0x1, %al
jne 0xb5fc
movl $0xc, -0x4(%rbp)
jmp 0xb6c0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x3110
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
jne 0xb652
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
jne 0xb652
jmp 0xb67a
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0xb61c
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
jne 0xb6b9
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/path.c
// Function: path_new_from_string
int path_new_from_string(struct path **path, const char *cstr)
{
	/* this check is done again in path_set_from_string,
	 * but the the allocations can be saved, if cstr is invalid */
	if(!(path_cstr_is_valid(cstr)))
		return EINVAL;

	*path = path_new();
	if(*path == NULL)
		return ENOMEM;

	int ret = path_set_from_string(*path, cstr);
	if(ret != 0) {
		path_delete(*path);
		*path = NULL;
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xb6d0
testb $0x1, %al
jne 0xb726
movl $0x16, -0x4(%rbp)
jmp 0xb77e
callq 0xb790
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xb748
movl $0xc, -0x4(%rbp)
jmp 0xb77e
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xb540
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0xb778
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xb7f0
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/path.c
// Function: path_new
struct path *path_new(void)
{
	struct path *path = malloc(sizeof(*path));
	if(path == NULL)
		return NULL;

	if(!path_init(path, 0)) {
		free(path);
		return NULL;
	}
	return path;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x10, %edi
callq 0x3490
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xb7b7
movq $0x0, -0x8(%rbp)
jmp 0xb7e3
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xb820
testb $0x1, %al
jne 0xb7db
movq -0x10(%rbp), %rdi
callq 0x3740
movq $0x0, -0x8(%rbp)
jmp 0xb7e3
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/path.c
// Function: path_delete
void path_delete(struct path *path)
{
	if(path == NULL)
		return;
	path_destroy(path);
	free(path);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xb805
jmp 0xb817
movq -0x8(%rbp), %rdi
callq 0xb8a0
movq -0x8(%rbp), %rdi
callq 0x3740
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/path.c
// Function: path_init
bool path_init(struct path *path, size_t size)
{
	path->allocated_size = size;
	if(path->allocated_size < 1)
		path->allocated_size = 1;

	path->path = malloc(path->allocated_size);
	if(path->path == NULL)
		return false;

	path->path[0] = '\0';

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x1, 0x8(%rax)
jae 0xb853
movq -0x10(%rbp), %rax
movq $0x1, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3490
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xb87a
movb $0x0, -0x1(%rbp)
jmp 0xb888
movq -0x10(%rbp), %rax
movq (%rax), %rax
movb $0x0, (%rax)
movb $0x1, -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/cglindkamp[P]dfm/src/processmanager.c
// Function: processmanager_spawn
int processmanager_spawn(struct processmanager *pm, const char *program, char * const argv[], const char *tmpdir, pre_exec_callback cb, pid_t *pid)
{
	struct process *process = NULL;

	if(tmpdir) {
		if(!pm->processlist) {
			pm->processlist = list_new(0);
			if(!pm->processlist)
				return ENOMEM;
		}

		process = malloc(sizeof(*process));
		if(!process)
			return ENOMEM;

		process->tmpdir = strdup(tmpdir);
		if(!process->tmpdir) {
			free(process);
			return ENOMEM;
		}

		if(!list_append(pm->processlist, process)) {
			process_delete(process);
			return ENOMEM;
		}
	}

	*pid = fork();

	if(*pid < 0)
		return errno;
	if(*pid > 0) {
		if(process)
			process->pid = *pid;
		return 0;
	}

	if(cb)
		cb();

	execvp(program, argv);
	exit(EXIT_FAILURE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xb9d5
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xb958
xorl %eax, %eax
movl %eax, %edi
callq 0x9f60
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xb956
movl $0xc, -0x4(%rbp)
jmp 0xba3d
jmp 0xb958
movl $0x10, %edi
callq 0x3490
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0xb979
movl $0xc, -0x4(%rbp)
jmp 0xba3d
movq -0x28(%rbp), %rdi
callq 0x36a0
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xb9ad
movq -0x40(%rbp), %rdi
callq 0x3740
movl $0xc, -0x4(%rbp)
jmp 0xba3d
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x40(%rbp), %rsi
callq 0xa0b0
testb $0x1, %al
jne 0xb9d3
movq -0x40(%rbp), %rdi
callq 0xb8c0
movl $0xc, -0x4(%rbp)
jmp 0xba3d
jmp 0xb9d5
callq 0x3700
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
cmpl $0x0, (%rax)
jge 0xb9f7
callq 0x30d0
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0xba3d
movq -0x38(%rbp), %rax
cmpl $0x0, (%rax)
jle 0xba1c
cmpq $0x0, -0x40(%rbp)
je 0xba13
movq -0x38(%rbp), %rax
movl (%rax), %ecx
movq -0x40(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0xba3d
cmpq $0x0, -0x30(%rbp)
je 0xba26
callq *-0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3640
movl $0x1, %edi
callq 0x3690
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/processmanager.c
// Function: processmanager_waitpid
pid_t processmanager_waitpid(struct processmanager *pm, pid_t pid, int *wstatus)
{
	pid = waitpid(pid, wstatus, 0);
	if(pid <= 0)
		return pid;

	if(!pm->processlist)
		return pid;

	size_t length = list_length(pm->processlist);

	for(size_t i = 0; i < length; i++) {
		struct process *process = list_get_item(pm->processlist, i);

		if(process->pid == pid) {
			remove_directory_recursively(process->tmpdir);
			process_delete(process);
			list_remove(pm->processlist, i);
			break;
		}
	}

	return pid;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl -0x14(%rbp), %edi
movq -0x20(%rbp), %rsi
xorl %edx, %edx
callq 0x35e0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jg 0xba85
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xbb16
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xba97
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xbb16
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xa090
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0xbb10
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0xa430
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0xbb00
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xbe70
movq -0x38(%rbp), %rdi
callq 0xb8c0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0xa390
jmp 0xbb10
jmp 0xbb02
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xbaaf
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/xdg.c
// Function: xdg_get_config_home
int xdg_get_config_home(struct path **path)
{
	int ret = 0;
	*path = NULL;

	const char *config_home = getenv("XDG_CONFIG_HOME");
	if(config_home)
		ret = path_new_from_string(path, config_home);

	if(ret == ENOMEM)
		return ENOMEM;

	if(*path == NULL) {
		const char *home = getenv("HOME");
		if(home) {
			ret = path_new_from_string(path, home);

			if(ret == ENOMEM)
				return ENOMEM;

			if(*path == NULL)
				return ENOENT;

			if(!path_add_component(*path, ".config")) {
				path_delete(*path);
				*path = NULL;
				return ENOMEM;
			}
		} else
			return ENOENT;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
leaq 0x18ed(%rip), %rdi      # 0xd482
callq 0x3070
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xbbb5
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xb700
movl %eax, -0x14(%rbp)
cmpl $0xc, -0x14(%rbp)
jne 0xbbc7
movl $0xc, -0x4(%rbp)
jmp 0xbc69
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xbc62
leaq 0x18b1(%rip), %rdi      # 0xd48d
callq 0x3070
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xbc57
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xb700
movl %eax, -0x14(%rbp)
cmpl $0xc, -0x14(%rbp)
jne 0xbc0b
movl $0xc, -0x4(%rbp)
jmp 0xbc69
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xbc1e
movl $0x2, -0x4(%rbp)
jmp 0xbc69
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x1866(%rip), %rsi      # 0xd492
callq 0xb350
testb $0x1, %al
jne 0xbc55
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xb7f0
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movl $0xc, -0x4(%rbp)
jmp 0xbc69
jmp 0xbc60
movl $0x2, -0x4(%rbp)
jmp 0xbc69
jmp 0xbc62
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/util.c
// Function: determine_usable_config_file
struct path *determine_usable_config_file(const char *project, const char *subdir, const char *config, int flags)
{
	struct path *path = NULL;
	struct list *list = xdg_get_config_dirs(true);

	if(list == NULL)
		return NULL;

	size_t length = list_length(list);;

	for(size_t i = 0; i < length; i++) {
		struct path *curpath = list_get_item(list, i);
		if(!path_add_component(curpath, project))
			goto err;
		if(subdir) {
			if(!path_add_component(curpath, subdir))
				goto err;
		}
		if(!path_add_component(curpath, config))
			goto err;
		if(path == NULL && access(path_tocstr(curpath), flags) == 0) {
			path = curpath;
			list_set_item(list, i, NULL);
		}
	}
err:
	list_delete(list, (list_item_deallocator)path_delete);
	return path;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq $0x0, -0x30(%rbp)
movl $0x1, %edi
callq 0xbc80
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0xbf11
movq $0x0, -0x8(%rbp)
jmp 0xbfed
movq -0x38(%rbp), %rdi
callq 0xa090
movq %rax, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0xbfd3
movq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0xa430
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xb350
testb $0x1, %al
jne 0xbf58
jmp 0xbfd5
cmpq $0x0, -0x18(%rbp)
je 0xbf74
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xb350
testb $0x1, %al
jne 0xbf72
jmp 0xbfd5
jmp 0xbf74
movq -0x50(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xb350
testb $0x1, %al
jne 0xbf87
jmp 0xbfd5
cmpq $0x0, -0x30(%rbp)
jne 0xbfc0
movq -0x50(%rbp), %rdi
callq 0xb310
movq %rax, %rdi
movl -0x24(%rbp), %esi
callq 0x3610
cmpl $0x0, %eax
jne 0xbfc0
movq -0x50(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xa490
jmp 0xbfc2
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0xbf26
jmp 0xbfd5
movq -0x38(%rbp), %rdi
leaq -0x7f0(%rip), %rsi      # 0xb7f0
callq 0xa010
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/util.c
// Function: dump_string_to_file
bool dump_string_to_file(int dir_fd, const char *filename, const char *value)
{
	int fd = openat(dir_fd, filename, O_CREAT|O_WRONLY, 0700);
	if(fd < 0)
		return false;

	int ret = write(fd, value, strlen(value));

	close(fd);

	return ret < 0 ? false : true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movl $0x41, %edx
movl $0x1c0, %ecx            # imm = 0x1C0
movb $0x0, %al
callq 0x3240
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0xc03a
movb $0x0, -0x1(%rbp)
jmp 0xc086
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3230
movl -0x2c(%rbp), %edi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x31c0
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %edi
callq 0x3320
movl -0x20(%rbp), %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovll %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/util.c
// Function: dump_filelist_to_file
bool dump_filelist_to_file(int dir_fd, const char *filename, const struct list *list)
{
	int ret = 0;

	int fd = openat(dir_fd, filename, O_CREAT|O_WRONLY, 0700);
	if(fd < 0)
		return false;

	size_t length = list_length(list);;

	for(size_t i = 0; i < length; i++) {
		const char *file = list_get_item(list, i);
		if((ret = write(fd, file, strlen(file))) < 0)
			break;
		if((ret = write(fd, "\0", 1)) < 0)
			break;
	}
	close(fd);

	return ret < 0 ? false : true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movl $0x41, %edx
movl $0x1c0, %ecx            # imm = 0x1C0
movb $0x0, %al
callq 0x3240
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jge 0xc0e4
movb $0x0, -0x1(%rbp)
jmp 0xc195
movq -0x18(%rbp), %rdi
callq 0xa090
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0xc172
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xa430
movq %rax, -0x38(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x3230
movl -0x44(%rbp), %edi
movq -0x40(%rbp), %rsi
movq %rax, %rdx
callq 0x31c0
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jge 0xc144
jmp 0xc172
movl -0x20(%rbp), %edi
leaq 0x1367(%rip), %rsi      # 0xd4b5
movl $0x1, %edx
callq 0x31c0
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jge 0xc162
jmp 0xc172
jmp 0xc164
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xc0f9
movl -0x20(%rbp), %edi
callq 0x3320
movl -0x1c(%rbp), %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovll %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/util.c
// Function: run_in_foreground
bool run_in_foreground()
{
	const char *display = getenv("DISPLAY");

	if(display == NULL || strlen(display) == 0)
		return true;

	const char *foreground = getenv("DFM_FOREGROUND");

	if(foreground != NULL && strcmp(foreground, "yes") == 0)
		return true;

	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x1308(%rip), %rdi      # 0xd4b7
callq 0x3070
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xc1ce
movq -0x10(%rbp), %rdi
callq 0x3230
cmpq $0x0, %rax
jne 0xc1d4
movb $0x1, -0x1(%rbp)
jmp 0xc20a
leaq 0x12e4(%rip), %rdi      # 0xd4bf
callq 0x3070
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xc206
movq -0x18(%rbp), %rdi
leaq 0x12d8(%rip), %rsi      # 0xd4ce
callq 0x33d0
cmpl $0x0, %eax
jne 0xc206
movb $0x1, -0x1(%rbp)
jmp 0xc20a
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/main.c
// Function: init_ncurses
void init_ncurses()
{
	initscr();
	noecho();
	raw();

	start_color();
	init_pair(1, COLOR_WHITE, COLOR_BLUE);
	init_pair(2, COLOR_YELLOW, COLOR_BLACK);
	init_pair(3, COLOR_YELLOW, COLOR_BLUE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x3530
callq 0x3080
callq 0x3420
callq 0x3040
movl $0x1, %edi
movl $0x7, %esi
movl $0x4, %edx
callq 0x34c0
movl $0x2, %edi
movl $0x3, %esi
xorl %edx, %edx
callq 0x34c0
movl $0x3, %esi
movl $0x4, %edx
movl %esi, %edi
callq 0x34c0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/main.c
// Function: main
int main(void)
{
	struct application app;
	int ret = 0;

	setlocale(LC_ALL, "");
	tzset();
	init_ncurses();

	if(application_init(&app)) {
		application_run(&app);
	} else {
		endwin();
		puts("Failed to initialize the application, exiting");
	}
	application_destroy(&app);

	endwin();
	_nc_freeall();

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movl $0x0, -0x4(%rbp)
movl $0x0, -0x1e4(%rbp)
movl $0x6, %edi
leaq 0xf58(%rip), %rsi       # 0xd1f0
callq 0x3570
callq 0x3460
callq 0xc220
leaq -0x1e0(%rbp), %rdi
callq 0x4f80
testb $0x1, %al
jne 0xc2b9
jmp 0xc2c7
leaq -0x1e0(%rbp), %rdi
callq 0x46c0
jmp 0xc2d8
callq 0x36c0
leaq 0x11ff(%rip), %rdi      # 0xd4d2
callq 0x3160
leaq -0x1e0(%rbp), %rdi
callq 0x5480
callq 0x36c0
movb $0x0, %al
callq 0x32f0
movl -0x1e4(%rbp), %eax
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/dlbeer[P]dhara/ecc/crc32.c
// Function: crc32_nand
uint32_t crc32_nand(const uint8_t *block, size_t len,
		    uint32_t c)
{
	size_t i;

	for (i = 0; i < len; i++)
		c = (c >> 8) ^ reduce[(c ^ block[i]) & 0xff] ^ 0xff000000;

	return c;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movq $0x0, -0x20(%rsp)
movq -0x20(%rsp), %rax
cmpq -0x10(%rsp), %rax
jae 0x11fb
movl -0x14(%rsp), %eax
shrl $0x8, %eax
movl -0x14(%rsp), %ecx
movq -0x8(%rsp), %rdx
movq -0x20(%rsp), %rsi
movzbl (%rdx,%rsi), %edx
xorl %edx, %ecx
andl $0xff, %ecx
movl %ecx, %ecx
movl %ecx, %edx
leaq 0xe31(%rip), %rcx       # 0x2010
xorl (%rcx,%rdx,4), %eax
xorl $0xff000000, %eax       # imm = 0xFF000000
movl %eax, -0x14(%rsp)
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0x11a7
movl -0x14(%rsp), %eax
retq
// File: /workspace/github_c_makefile_star2_O0/dlbeer[P]dhara/tests/crc32.c
// Function: main
int main(void)
{
	uint8_t block[BLOCK_SIZE];
	int i;

	memset(block, 0xff, sizeof(block));
	assert(crc32_nand(block, BLOCK_SIZE, CRC32_INIT) == 0xffffffff);

	srandom(0);
	for (i = 0; i < 10; i++)
		test_random_block();

	return 0;
}

// Assembly:
subq $0x218, %rsp            # imm = 0x218
movl $0x0, 0x214(%rsp)
leaq 0x10(%rsp), %rdi
movl $0xff, %esi
movl $0x200, %edx            # imm = 0x200
callq 0x1050
leaq 0x10(%rsp), %rdi
movl $0x200, %esi            # imm = 0x200
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x1190
cmpl $-0x1, %eax
jne 0x1241
jmp 0x1260
leaq 0x11c8(%rip), %rdi      # 0x2410
leaq 0x11f9(%rip), %rsi      # 0x2448
movl $0x45, %edx
leaq 0x11fb(%rip), %rcx      # 0x2456
callq 0x1040
xorl %edi, %edi
callq 0x1030
movl $0x0, 0xc(%rsp)
cmpl $0xa, 0xc(%rsp)
jge 0x1288
callq 0x12a0
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x126f
xorl %eax, %eax
addq $0x218, %rsp            # imm = 0x218
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dlbeer[P]dhara/tests/crc32.c
// Function: test_random_block
static void test_random_block(void)
{
	uint8_t block[BLOCK_SIZE];
	uint32_t crc;
	int i;

	for (i = 0; i < BLOCK_SIZE; i++)
		block[i] = random();

	crc = crc32_nand(block, BLOCK_SIZE, CRC32_INIT);

	for (i = 0; i < 20; i++)
		test_hd(block, crc, 4);
}

// Assembly:
subq $0x218, %rsp            # imm = 0x218
movl $0x0, 0x8(%rsp)
cmpl $0x200, 0x8(%rsp)       # imm = 0x200
jge 0x12d6
callq 0x1080
movb %al, %cl
movslq 0x8(%rsp), %rax
movb %cl, 0x10(%rsp,%rax)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x12af
leaq 0x10(%rsp), %rdi
movl $0x200, %esi            # imm = 0x200
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x1190
movl %eax, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
cmpl $0x14, 0x8(%rsp)
jge 0x131d
leaq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
movl $0x4, %edx
callq 0x1330
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x12f6
addq $0x218, %rsp            # imm = 0x218
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dlbeer[P]dhara/tests/crc32.c
// Function: test_hd
static void test_hd(const uint8_t *good, uint32_t good_crc, int hd)
{
	uint8_t bad[BLOCK_SIZE];
	uint32_t bad_crc;
	int i;

	memcpy(bad, good, sizeof(bad));

	for (i = 0; i < hd; i++)
		flip_one_bit(bad, sizeof(bad));

	bad_crc = crc32_nand(bad, sizeof(bad), CRC32_INIT);
	assert(!memcmp(bad, good, BLOCK_SIZE) || (bad_crc != good_crc));
}

// Assembly:
subq $0x228, %rsp            # imm = 0x228
movq %rdi, 0x220(%rsp)
movl %esi, 0x21c(%rsp)
movl %edx, 0x218(%rsp)
leaq 0x10(%rsp), %rdi
movq 0x220(%rsp), %rsi
movl $0x200, %edx            # imm = 0x200
callq 0x1070
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0x218(%rsp), %eax
jge 0x1395
leaq 0x10(%rsp), %rdi
movl $0x200, %esi            # imm = 0x200
callq 0x1400
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x136c
leaq 0x10(%rsp), %rdi
movl $0x200, %esi            # imm = 0x200
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x1190
movl %eax, 0xc(%rsp)
leaq 0x10(%rsp), %rdi
movq 0x220(%rsp), %rsi
movl $0x200, %edx            # imm = 0x200
callq 0x1060
cmpl $0x0, %eax
je 0x13d6
movl 0xc(%rsp), %eax
cmpl 0x21c(%rsp), %eax
je 0x13d8
jmp 0x13f7
leaq 0x1086(%rip), %rdi      # 0x2465
leaq 0x1062(%rip), %rsi      # 0x2448
movl $0x2d, %edx
leaq 0x10ab(%rip), %rcx      # 0x249d
callq 0x1040
addq $0x228, %rsp            # imm = 0x228
retq
nop
// File: /workspace/github_c_makefile_star2_O0/robertdavidgraham[P]wc2/wctool.c
// Function: utf8_to_ucs4
unsigned 
utf8_to_ucs4(unsigned char *buf, size_t sizeof_buf)
{
    if (sizeof_buf >= 1 && buf[0] < 0x80) {
        return buf[0];
    } else if (sizeof_buf >= 2 && (buf[0]&0xE0) == 0xC0) {
        return  (buf[0]&0x1F)<<6 
                | (buf[1] & 0x3F) << 0;
    } else if (sizeof_buf >= 3 && (buf[0]&0xF0) == 0xE0) {
        return (buf[0]&0x0F)<<12 
                | (buf[1] & 0x3F) << 6
                | (buf[2] & 0x3F) << 0;
    } else if (sizeof_buf >= 4 && (buf[0]&0xF1) == 0xF0) {
        return (buf[0]&0x07)<<18 
                | (buf[1] & 0x3F) << 12
                | (buf[2] & 0x3F) << 6
                | (buf[3] & 0x3F) << 0;
    } else
        return 0xFFFFFFFF;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x1, -0x18(%rbp)
jb 0x11f0
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x80, %eax
jge 0x11f0
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x12de
cmpq $0x2, -0x18(%rbp)
jb 0x122f
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
andl $0xe0, %eax
cmpl $0xc0, %eax
jne 0x122f
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
andl $0x1f, %eax
shll $0x6, %eax
movq -0x10(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
andl $0x3f, %ecx
shll $0x0, %ecx
orl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x12de
cmpq $0x3, -0x18(%rbp)
jb 0x127b
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
andl $0xf0, %eax
cmpl $0xe0, %eax
jne 0x127b
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
andl $0xf, %eax
shll $0xc, %eax
movq -0x10(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
andl $0x3f, %ecx
shll $0x6, %ecx
orl %ecx, %eax
movq -0x10(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
andl $0x3f, %ecx
shll $0x0, %ecx
orl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x12de
cmpq $0x4, -0x18(%rbp)
jb 0x12d7
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
andl $0xf1, %eax
cmpl $0xf0, %eax
jne 0x12d7
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
andl $0x7, %eax
shll $0x12, %eax
movq -0x10(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
andl $0x3f, %ecx
shll $0xc, %ecx
orl %ecx, %eax
movq -0x10(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
andl $0x3f, %ecx
shll $0x6, %ecx
orl %ecx, %eax
movq -0x10(%rbp), %rcx
movzbl 0x3(%rcx), %ecx
andl $0x3f, %ecx
shll $0x0, %ecx
orl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x12de
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/robertdavidgraham[P]wc2/wctool.c
// Function: gen_utf8
void gen_utf8(void)
{
    size_t i;
    unsigned seed = 0;
    static const char *list[] = { 
        "\xe7\x9a\x84",     /* U+7684 的 */
        "\xe4\xb8\x80",     /* U+4e00 一 */
        "\xe6\x98\xaf",     /* U+662f 是 */
        "\xe6\x96\x87",     /* U+6587 文 */
        "\xe3\x81\xaa",     /* U+306a な */
        "\xf0\x9f\x98\x82", /* U+1f602 😂 */
        "\xe2\x9d\xa4\xef\xb8\x8f", /* U+2764 ❤️ */
        "\xf0\x9f\x92\xa9", /* U+1f4a9 💩 */
        "\xe2\x80\x83",     /* U+2003   */
        "\xe1\xa0\x8e",     /* U+180e ᠎ */
        "\xe3\x80\x80",     /* U+3000 　 */
        "\n",               /* U+000a */
        " ",                /* U+0020   */
        "\xef\xbb\xbf",     /* U+feff ﻿ */
        "\xe1\x9a\x80",     /* U+1680   */
        "\t",               /* U+0009   */
        0};

        
    fprintf(stderr, "[+] generating utf8 rabndom file\n");
    for (i=0; i<FILESIZE; ) {
        const char *out = list[r_rand(&seed)%16];
        printf("%s", out);
        i += strlen(out);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0xc(%rbp)
movq 0x2b72(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xbb1(%rip), %rsi       # 0x2041
movb $0x0, %al
callq 0x1080
movq $0x0, -0x8(%rbp)
cmpq $0x5805559, -0x8(%rbp)  # imm = 0x5805559
jae 0x14ed
leaq -0xc(%rbp), %rdi
callq 0x1500
andl $0xf, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x2bb0(%rip), %rax      # 0x4070
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq 0xb90(%rip), %rdi       # 0x2063
movb $0x0, %al
callq 0x1050
movq -0x18(%rbp), %rdi
callq 0x1040
addq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x149f
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/robertdavidgraham[P]wc2/wctool.c
// Function: gen_allword
void gen_allword(void)
{
    size_t i;
    char buf[1024];
    memset(buf, 'x', sizeof(buf));
    
    fprintf(stderr, "[+] generating all-word file\n");
    for (i=0; i<FILESIZE-1024; i += sizeof(buf)) {
        fwrite(buf, 1, sizeof(buf), stdout);
    }
    for (; i<FILESIZE; i++) {
        putchar('x');
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x410, %rsp            # imm = 0x410
leaq -0x410(%rbp), %rdi
movl $0x78, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x1060
movq 0x2aa0(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xb04(%rip), %rsi       # 0x2066
movb $0x0, %al
callq 0x1080
movq $0x0, -0x8(%rbp)
cmpq $0x5805159, -0x8(%rbp)  # imm = 0x5805159
jae 0x15ab
leaq -0x410(%rbp), %rdi
movq 0x2a4f(%rip), %rax      # 0x3fd8
movq (%rax), %rcx
movl $0x1, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x10b0
movq -0x8(%rbp), %rax
addq $0x400, %rax            # imm = 0x400
movq %rax, -0x8(%rbp)
jmp 0x1571
jmp 0x15ad
cmpq $0x5805559, -0x8(%rbp)  # imm = 0x5805559
jae 0x15cf
movl $0x78, %edi
callq 0x1030
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x15ad
addq $0x410, %rsp            # imm = 0x410
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/robertdavidgraham[P]wc2/wctool.c
// Function: gen_allspace
void gen_allspace(void)
{
    size_t i;
    char buf[1024];
    memset(buf, ' ', sizeof(buf));
    
    fprintf(stderr, "[+] generating all-space file\n");
    for (i=0; i<FILESIZE-1024; i += sizeof(buf)) {
        fwrite(buf, 1, sizeof(buf), stdout);
    }
    for (; i<FILESIZE; i++) {
        putchar(' ');
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x410, %rsp            # imm = 0x410
leaq -0x410(%rbp), %rdi
movl $0x20, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x1060
movq 0x29f0(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xa72(%rip), %rsi       # 0x2084
movb $0x0, %al
callq 0x1080
movq $0x0, -0x8(%rbp)
cmpq $0x5805159, -0x8(%rbp)  # imm = 0x5805159
jae 0x165b
leaq -0x410(%rbp), %rdi
movq 0x299f(%rip), %rax      # 0x3fd8
movq (%rax), %rcx
movl $0x1, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x10b0
movq -0x8(%rbp), %rax
addq $0x400, %rax            # imm = 0x400
movq %rax, -0x8(%rbp)
jmp 0x1621
jmp 0x165d
cmpq $0x5805559, -0x8(%rbp)  # imm = 0x5805559
jae 0x167f
movl $0x20, %edi
callq 0x1030
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x165d
addq $0x410, %rsp            # imm = 0x410
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/robertdavidgraham[P]wc2/wctool.c
// Function: gen_ascii
void gen_ascii(void)
{
    size_t i;
    unsigned seed = 0;

    fprintf(stderr, "[+] generating ascii random file\n");
    for (i=0; i<FILESIZE; i++) {
        putchar(" x\ty\rz\na"[r_rand(&seed)%8]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0xc(%rbp)
movq 0x2952(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x9f3(%rip), %rsi       # 0x20a3
movb $0x0, %al
callq 0x1080
movq $0x0, -0x8(%rbp)
cmpq $0x5805559, -0x8(%rbp)  # imm = 0x5805559
jae 0x16f7
leaq -0xc(%rbp), %rdi
callq 0x1500
andl $0x7, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x9e5(%rip), %rax       # 0x20c5
movsbl (%rax,%rcx), %edi
callq 0x1030
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x16bf
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/robertdavidgraham[P]wc2/wctool.c
// Function: main
int main(int argc, char *argv[])
{
    if (argc > 1 && (tolower(argv[1][0]) == 'u' || strcmp(argv[1], "-u") == 0 || strcmp(argv[1], "--utf8") == 0))
        gen_utf8();
    else if (argc > 1 && (tolower(argv[1][0]) == 'w' || strcmp(argv[1], "-w") == 0 || strcmp(argv[1], "--allword") == 0))
        gen_allword();
    else if (argc > 1 && (tolower(argv[1][0]) == 's' || strcmp(argv[1], "-s") == 0 || strcmp(argv[1], "--allspace") == 0))
        gen_allspace();
    else if (argc > 1 && (tolower(argv[1][0]) == 'a' || strcmp(argv[1], "-a") == 0 || strcmp(argv[1], "--ascii") == 0))
        gen_ascii();
    else {
        setlocale(LC_CTYPE, "");
        printf("LC_CTYPE=%s\n", setlocale(LC_CTYPE, NULL));
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jle 0x176d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %edi
callq 0x1090
cmpl $0x75, %eax
je 0x1763
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x98e(%rip), %rsi       # 0x20ce
callq 0x1070
cmpl $0x0, %eax
je 0x1763
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x978(%rip), %rsi       # 0x20d1
callq 0x1070
cmpl $0x0, %eax
jne 0x176d
callq 0x1470
jmp 0x189f
cmpl $0x1, -0x8(%rbp)
jle 0x17c4
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %edi
callq 0x1090
cmpl $0x77, %eax
je 0x17ba
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x941(%rip), %rsi       # 0x20d8
callq 0x1070
cmpl $0x0, %eax
je 0x17ba
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x92b(%rip), %rsi       # 0x20db
callq 0x1070
cmpl $0x0, %eax
jne 0x17c4
callq 0x1530
jmp 0x189d
cmpl $0x1, -0x8(%rbp)
jle 0x181b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %edi
callq 0x1090
cmpl $0x73, %eax
je 0x1811
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x8f7(%rip), %rsi       # 0x20e5
callq 0x1070
cmpl $0x0, %eax
je 0x1811
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x8e1(%rip), %rsi       # 0x20e8
callq 0x1070
cmpl $0x0, %eax
jne 0x181b
callq 0x15e0
jmp 0x189b
cmpl $0x1, -0x8(%rbp)
jle 0x186f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %edi
callq 0x1090
cmpl $0x61, %eax
je 0x1868
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x8ae(%rip), %rsi       # 0x20f3
callq 0x1070
cmpl $0x0, %eax
je 0x1868
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x898(%rip), %rsi       # 0x20f6
callq 0x1070
cmpl $0x0, %eax
jne 0x186f
callq 0x1690
jmp 0x1899
xorl %edi, %edi
leaq 0x7c8(%rip), %rsi       # 0x2040
callq 0x10a0
xorl %edi, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x10a0
movq %rax, %rsi
leaq 0x86c(%rip), %rdi       # 0x20fe
movb $0x0, %al
callq 0x1050
jmp 0x189b
jmp 0x189d
jmp 0x189f
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]scg/examples/tunnel.c
// Function: main
int main(int arcg, char *argv[]) {
    scg_config_t config = scg_config_new_default();
    config.video.title = "SCG Example: Tunnel";

    scg_app_t app;
    scg_app_init(&app, config);

    scg_image_t *image = scg_image_new_from_bmp("assets/space.bmp");
    if (image == NULL) {
        return -1;
    }

    tunnel_t tunnel;
    init(&app, &tunnel, image);

    while (scg_app_process_events(&app)) {
        draw(app.draw_target, &tunnel, app.elapsed_time);

        scg_app_present(&app);
    }

    free(tunnel.shade_buffer);
    free(tunnel.angle_buffer);
    free(tunnel.distance_buffer);

    scg_image_free(image);
    scg_app_free(&app);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4a10
leaq 0xe63(%rip), %rax       # 0x759c
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x20(%rax)
movups -0x38(%rbp), %xmm0
movups -0x28(%rbp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq -0xa0(%rbp), %rdi
callq 0x4a60
leaq 0xe46(%rip), %rdi       # 0x75b0
callq 0x2c40
movq %rax, -0xa8(%rbp)
cmpq $0x0, -0xa8(%rbp)
jne 0x678c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6821
movq -0xa8(%rbp), %rdx
leaq -0xa0(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0x6830
leaq -0xa0(%rbp), %rdi
callq 0x56e0
testb $0x1, %al
jne 0x67b8
jmp 0x67de
movq -0x68(%rbp), %rdi
movss -0x98(%rbp), %xmm0
leaq -0xc8(%rbp), %rsi
callq 0x6a50
leaq -0xa0(%rbp), %rdi
callq 0x5830
jmp 0x67a6
movq -0xb8(%rbp), %rdi
callq 0x22a0
movq -0xc0(%rbp), %rdi
callq 0x22a0
movq -0xc8(%rbp), %rdi
callq 0x22a0
movq -0xa8(%rbp), %rdi
callq 0x46a0
leaq -0xa0(%rbp), %rdi
callq 0x5ce0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xf0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vidarr[P]ringbuffer/test/../src/buffercache.c
// Function: buffer_free
static void buffer_free(void* buffer, void* additional_arg) {

    // UNUSED(additional_arg);

    if(0 == buffer) goto error;

    Buffer* db = buffer;

    if(0 != db->data) {
        free(db->data);
        db->data = 0;
    }

    free(db);

error:

    return;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x8(%rbp), %rax
jne 0x15aa
jmp 0x15e0
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq 0x10(%rcx), %rax
je 0x15d7
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1030
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rdi
callq 0x1030
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vidarr[P]ringbuffer/test/../src/buffercache.c
// Function: buffercache_get_buffer
Buffer* buffercache_get_buffer(Ringbuffer* cache, size_t min_length_bytes) {

    Buffer* db =  0;

    if(0 != cache) {
        db = cache->pop(cache);
    }

    if(0 == db) {
        db = calloc(1, sizeof(Buffer));
    }

    if(db->capacity_bytes < min_length_bytes) {
        if(0 != db->data) {
            free(db->data);
            db->data = 0;
        }
    }

    if(0 == db->data) {
        db->data = calloc(1, sizeof(min_length_bytes) * sizeof(uint8_t));
        db->capacity_bytes = min_length_bytes;
    }

    db->bytes_used = 0;

    return db;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x8(%rbp), %rax
je 0x1622
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jne 0x163d
movl $0x1, %edi
movl $0x18, %esi
callq 0x1060
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jae 0x1671
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq 0x10(%rcx), %rax
je 0x166f
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1030
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
jmp 0x1671
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq 0x10(%rcx), %rax
jne 0x16a2
movl $0x1, %edi
movl $0x8, %esi
callq 0x1060
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vidarr[P]ringbuffer/test/../src/buffercache.c
// Function: buffercache_release_buffer
bool buffercache_release_buffer(Ringbuffer* cache, Buffer* buffer) {

    if(0 == cache) goto finish;
    if(0 == buffer) goto finish;
    
    buffer->bytes_used = 0;

    return cache->add(cache, buffer);

finish:

    return false;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
jne 0x16da
jmp 0x1709
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jne 0x16e4
jmp 0x1709
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x170d
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/giometti[P]mastering_UNIX_programming/chapter_08/memalign.c
// Function: main
int main(int argc, char *argv[])
{
	size_t alignment, size;
	void *ptr;
	int ret;

	/* Parse the command line */
	if (argc < 3) {
		fprintf(stderr,
			"usage: %s <align-size> <size>\n", argv[0]);
		return -1;
	}
	alignment = atoi(argv[1]);
	size = atoi(argv[2]);

	/* Try memory allocation */
	ret = posix_memalign(&ptr, alignment, size);
	if (ret) {
		/* Set errno is such a way perror() may work correctly */
		errno = ret;
		perror("posix_memalign");
		return -1;
	}
	printf("posix_memalign(%ld, %ld) returned %p\n",
		alignment, size, ptr);
	free(ptr);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x8(%rbp)
jge 0x11e7
movq 0x2e35(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0xe30(%rip), %rsi       # 0x2004
movb $0x0, %al
callq 0x1060
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1276
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1080
cltq
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1080
cltq
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x28(%rbp), %rdi
callq 0x1090
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x124c
movl -0x2c(%rbp), %eax
movl %eax, -0x30(%rbp)
callq 0x1040
movl -0x30(%rbp), %ecx
movl %ecx, (%rax)
leaq 0xde5(%rip), %rdi       # 0x2023
callq 0x1070
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1276
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq 0xdd3(%rip), %rdi       # 0x2032
movb $0x0, %al
callq 0x1050
movq -0x28(%rbp), %rdi
callq 0x1030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/yurrriq[P]knrc/src/words.c
// Function: main
int main()
{
    int c, state;

    state = OUT;
    while ((c = getchar()) != EOF) {
        if (c == ' ' || c == '\n' || c == '\t') {
            if (state == IN)
                putchar('\n');
            state = OUT;
        } else {
            state = IN;
        }

        if (state == IN)
            putchar(c);
    }


    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl $0x0, -0xc(%rbp)
callq 0x1040
movl %eax, -0x8(%rbp)
cmpl $-0x1, %eax
je 0x11b5
cmpl $0x20, -0x8(%rbp)
je 0x1185
cmpl $0xa, -0x8(%rbp)
je 0x1185
cmpl $0x9, -0x8(%rbp)
jne 0x119e
cmpl $0x1, -0xc(%rbp)
jne 0x1195
movl $0xa, %edi
callq 0x1030
movl $0x0, -0xc(%rbp)
jmp 0x11a5
movl $0x1, -0xc(%rbp)
cmpl $0x1, -0xc(%rbp)
jne 0x11b3
movl -0x8(%rbp), %edi
callq 0x1030
jmp 0x1166
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes128poetv2aes4ni/ni/poet.c
// Function: aesfour_expand_key
static void aesfour_expand_key(__m128i userkey, AXU_KEY enc_key)
{
    __m128i temp1, temp2;
    __m128i *key = (__m128i*)enc_key;

    _mm_storeu_si128(&temp1, userkey);
    _mm_storeu_si128(&key[0], temp1);

    aes_create_round_key(temp1, temp2, 0x01, &key[1]);
    aes_create_round_key(temp1, temp2, 0x02, &key[2]);
    aes_create_round_key(temp1, temp2, 0x04, &key[3]);
    aes_create_round_key(temp1, temp2, 0x08, &key[4]);
}

// Assembly:
subq $0x108, %rsp            # imm = 0x108
vmovdqa %xmm0, 0x40(%rsp)
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
vmovdqa 0x40(%rsp), %xmm0
leaq 0x20(%rsp), %rax
movq %rax, 0x100(%rsp)
vmovdqa %xmm0, 0xf0(%rsp)
vmovdqa 0xf0(%rsp), %xmm0
movq 0x100(%rsp), %rax
vmovdqu %xmm0, (%rax)
movq 0x8(%rsp), %rax
vmovdqa 0x20(%rsp), %xmm0
movq %rax, 0xe8(%rsp)
vmovdqa %xmm0, 0xd0(%rsp)
vmovdqa 0xd0(%rsp), %xmm0
movq 0xe8(%rsp), %rax
vmovdqu %xmm0, (%rax)
vmovdqa 0x20(%rsp), %xmm0
vaeskeygenassist $0x1, %xmm0, %xmm0
vmovdqa %xmm0, 0x10(%rsp)
vmovdqa 0x20(%rsp), %xmm0
vmovdqa 0x10(%rsp), %xmm1
callq 0x9600
vmovdqa %xmm0, 0x20(%rsp)
movq 0x8(%rsp), %rax
addq $0x10, %rax
vmovdqa 0x20(%rsp), %xmm0
movq %rax, 0xc8(%rsp)
vmovdqa %xmm0, 0xb0(%rsp)
vmovdqa 0xb0(%rsp), %xmm0
movq 0xc8(%rsp), %rax
vmovdqa %xmm0, (%rax)
vmovdqa 0x20(%rsp), %xmm0
vaeskeygenassist $0x2, %xmm0, %xmm0
vmovdqa %xmm0, 0x10(%rsp)
vmovdqa 0x20(%rsp), %xmm0
vmovdqa 0x10(%rsp), %xmm1
callq 0x9600
vmovdqa %xmm0, 0x20(%rsp)
movq 0x8(%rsp), %rax
addq $0x20, %rax
vmovdqa 0x20(%rsp), %xmm0
movq %rax, 0xa8(%rsp)
vmovdqa %xmm0, 0x90(%rsp)
vmovdqa 0x90(%rsp), %xmm0
movq 0xa8(%rsp), %rax
vmovdqa %xmm0, (%rax)
vmovdqa 0x20(%rsp), %xmm0
vaeskeygenassist $0x4, %xmm0, %xmm0
vmovdqa %xmm0, 0x10(%rsp)
vmovdqa 0x20(%rsp), %xmm0
vmovdqa 0x10(%rsp), %xmm1
callq 0x9600
vmovdqa %xmm0, 0x20(%rsp)
movq 0x8(%rsp), %rax
addq $0x30, %rax
vmovdqa 0x20(%rsp), %xmm0
movq %rax, 0x88(%rsp)
vmovdqa %xmm0, 0x70(%rsp)
vmovdqa 0x70(%rsp), %xmm0
movq 0x88(%rsp), %rax
vmovdqa %xmm0, (%rax)
vmovdqa 0x20(%rsp), %xmm0
vaeskeygenassist $0x8, %xmm0, %xmm0
vmovdqa %xmm0, 0x10(%rsp)
vmovdqa 0x20(%rsp), %xmm0
vmovdqa 0x10(%rsp), %xmm1
callq 0x9600
vmovdqa %xmm0, 0x20(%rsp)
movq 0x8(%rsp), %rax
addq $0x40, %rax
vmovdqa 0x20(%rsp), %xmm0
movq %rax, 0x68(%rsp)
vmovdqa %xmm0, 0x50(%rsp)
vmovdqa 0x50(%rsp), %xmm0
movq 0x68(%rsp), %rax
vmovdqa %xmm0, (%rax)
addq $0x108, %rsp            # imm = 0x108
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes128poetv2aes4ni/ni/poet.c
// Function: aesfour_encrypt
static __m128i aesfour_encrypt(__m128i in, __m128i* k)
{
    __m128i x = _mm_xor_si128(in, k[0]);
    x = _mm_aesenc_si128(x, k[1]);
    x = _mm_aesenc_si128(x, k[2]);
    x = _mm_aesenc_si128(x, k[3]);
    return _mm_aesenc_si128(x, k[4]);
}

// Assembly:
subq $0x58, %rsp
vmovdqa %xmm0, -0x60(%rsp)
movq %rdi, -0x68(%rsp)
vmovdqa -0x60(%rsp), %xmm1
movq -0x68(%rsp), %rax
vmovdqa (%rax), %xmm0
vmovdqa %xmm1, -0x40(%rsp)
vmovdqa %xmm0, -0x50(%rsp)
vmovdqa -0x40(%rsp), %xmm0
vpxor -0x50(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, -0x80(%rsp)
vmovdqa -0x80(%rsp), %xmm1
movq -0x68(%rsp), %rax
vmovdqa 0x10(%rax), %xmm0
vmovdqa %xmm1, 0x40(%rsp)
vmovdqa %xmm0, 0x30(%rsp)
vmovdqa 0x40(%rsp), %xmm0
vmovdqa 0x30(%rsp), %xmm1
vaesenc %xmm1, %xmm0, %xmm0
vmovdqa %xmm0, -0x80(%rsp)
vmovdqa -0x80(%rsp), %xmm1
movq -0x68(%rsp), %rax
vmovdqa 0x20(%rax), %xmm0
vmovdqa %xmm1, 0x20(%rsp)
vmovdqa %xmm0, 0x10(%rsp)
vmovdqa 0x20(%rsp), %xmm0
vmovdqa 0x10(%rsp), %xmm1
vaesenc %xmm1, %xmm0, %xmm0
vmovdqa %xmm0, -0x80(%rsp)
vmovdqa -0x80(%rsp), %xmm1
movq -0x68(%rsp), %rax
vmovdqa 0x30(%rax), %xmm0
vmovdqa %xmm1, (%rsp)
vmovdqa %xmm0, -0x10(%rsp)
vmovdqa (%rsp), %xmm0
vmovdqa -0x10(%rsp), %xmm1
vaesenc %xmm1, %xmm0, %xmm0
vmovdqa %xmm0, -0x80(%rsp)
vmovdqa -0x80(%rsp), %xmm1
movq -0x68(%rsp), %rax
vmovdqa 0x40(%rax), %xmm0
vmovdqa %xmm1, -0x20(%rsp)
vmovdqa %xmm0, -0x30(%rsp)
vmovdqa -0x20(%rsp), %xmm0
vmovdqa -0x30(%rsp), %xmm1
vaesenc %xmm1, %xmm0, %xmm0
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)