LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/DeforaOS[P]libSystem/src/event.c
// Function: event_register_io_read
int event_register_io_read(Event * event, int fd, EventIOFunc func,
		void * userdata)
{
	EventIO * eventio;

	assert(fd >= 0);
	if((eventio = (EventIO *)object_new(sizeof(*eventio))) == NULL)
		return 1;
	eventio->fd = fd;
	eventio->func = func;
	eventio->data = userdata;
	event->fdmax = max(event->fdmax, fd);
	if(array_append(event->reads, &eventio) != 0)
	{
		object_delete(eventio);
		return -1;
	}
	FD_SET(fd, &event->rfds);
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testl %esi, %esi
js 0x690f
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebx
movq %rdi, %r14
movl $0x18, %edi
callq 0x45e0
movq %rax, (%rsp)
testq %rax, %rax
je 0x68e8
movl %ebx, (%rax)
movq %r12, 0x8(%rax)
movq %r15, 0x10(%rax)
movl 0x4(%r14), %eax
cmpl %ebx, %eax
cmovlel %ebx, %eax
movl %eax, 0x4(%r14)
movq 0x108(%r14), %rdi
movq %rsp, %rsi
callq 0x4290
testl %eax, %eax
je 0x68ef
movq (%rsp), %rdi
callq 0x4460
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x6903
movl $0x1, %eax
jmp 0x6903
movl $0x1, %eax
movl %ebx, %ecx
shlq %cl, %rax
shrl $0x6, %ebx
orq %rax, 0x8(%r14,%rbx,8)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x47be(%rip), %rdi      # 0xb0d4
leaq 0x47bf(%rip), %rsi      # 0xb0dc
leaq 0x47c0(%rip), %rcx      # 0xb0e4
movl $0xcb, %edx
callq 0x42e0
// File: /workspace/github_c_makefile_star2_O1/DeforaOS[P]libSystem/src/event.c
// Function: event_register_io_write
int event_register_io_write(Event * event, int fd, EventIOFunc func,
		void * userdata)
{
	EventIO * eventio;

	assert(fd >= 0);
	if((eventio = (EventIO *)object_new(sizeof(*eventio))) == NULL)
		return 1;
	eventio->fd = fd;
	eventio->func = func;
	eventio->data = userdata;
	event->fdmax = max(event->fdmax, fd);
	if(array_append(event->writes, &eventio) != 0)
	{
		object_delete(eventio);
		return -1;
	}
	FD_SET(fd, &event->wfds);
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testl %esi, %esi
js 0x69c0
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebx
movq %rdi, %r14
movl $0x18, %edi
callq 0x45e0
movq %rax, (%rsp)
testq %rax, %rax
je 0x6996
movl %ebx, (%rax)
movq %r12, 0x8(%rax)
movq %r15, 0x10(%rax)
movl 0x4(%r14), %eax
cmpl %ebx, %eax
cmovlel %ebx, %eax
movl %eax, 0x4(%r14)
movq 0x110(%r14), %rdi
movq %rsp, %rsi
callq 0x4290
testl %eax, %eax
je 0x699d
movq (%rsp), %rdi
callq 0x4460
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x69b4
movl $0x1, %eax
jmp 0x69b4
movl $0x1, %eax
movl %ebx, %ecx
shlq %cl, %rax
shrl $0x6, %ebx
orq %rax, 0x88(%r14,%rbx,8)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x470d(%rip), %rdi      # 0xb0d4
leaq 0x470e(%rip), %rsi      # 0xb0dc
leaq 0x474d(%rip), %rcx      # 0xb122
movl $0xe2, %edx
callq 0x42e0
// File: /workspace/github_c_makefile_star2_O1/DeforaOS[P]libSystem/src/event.c
// Function: event_unregister_io_read
int event_unregister_io_read(Event * event, int fd)
{
	event->fdmax = _unregister_io(event->reads, &event->rfds, fd);
	event->fdmax = max(event->fdmax, _unregister_io(event->writes, NULL,
				-1));
	return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %edx
movq %rdi, %rbx
movq 0x108(%rdi), %rdi
leaq 0x8(%rbx), %rsi
callq 0x6a37
movl %eax, %ebp
movl %eax, 0x4(%rbx)
movq 0x110(%rbx), %rdi
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x6a37
cmpl %eax, %ebp
jge 0x6a28
movq 0x110(%rbx), %rdi
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x6a37
jmp 0x6a2b
movl 0x4(%rbx), %eax
movl %eax, 0x4(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/DeforaOS[P]libSystem/src/event.c
// Function: unregister_io
static int _unregister_io(eventioArray * eios, fd_set * fds, int fd)
{
	unsigned int i = 0;
	EventIO * eio;
	int fdmax = -1;

	while(i < array_count(eios))
	{
		array_get_copy(eios, i, &eio);
		if(eio->fd != fd)
		{
			fdmax = max(fdmax, eio->fd);
			i++;
			continue;
		}
		FD_CLR(fd, fds);
		array_remove_pos(eios, i);
		object_delete(eio);
	}
	return fdmax;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
callq 0x4250
testq %rax, %rax
je 0x6ad1
movq $-0x2, %rbp
movl %ebx, %ecx
rolq %cl, %rbp
leal 0x3f(%rbx), %eax
testl %ebx, %ebx
cmovnsl %ebx, %eax
sarl $0x6, %eax
movslq %eax, %r13
xorl %r12d, %r12d
movl $0xffffffff, 0xc(%rsp)  # imm = 0xFFFFFFFF
movq %r15, %rdi
movq %r12, %rsi
leaq 0x10(%rsp), %rdx
callq 0x47f0
movq 0x10(%rsp), %rax
movl (%rax), %eax
cmpl %ebx, %eax
jne 0x6abf
andq %rbp, (%r14,%r13,8)
movq %r15, %rdi
movq %r12, %rsi
callq 0x4540
movq 0x10(%rsp), %rdi
callq 0x4460
movq %r15, %rdi
callq 0x4250
cmpq %r12, %rax
ja 0x6a7c
jmp 0x6ad9
movl 0xc(%rsp), %ecx
cmpl %eax, %ecx
cmovlel %eax, %ecx
movl %ecx, 0xc(%rsp)
incl %r12d
jmp 0x6ab0
movl $0xffffffff, 0xc(%rsp)  # imm = 0xFFFFFFFF
movl 0xc(%rsp), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/DeforaOS[P]libSystem/src/event.c
// Function: event_unregister_io_write
int event_unregister_io_write(Event * event, int fd)
{
	event->fdmax = _unregister_io(event->writes, &event->wfds, fd);
	event->fdmax = max(event->fdmax, _unregister_io(event->reads, NULL,
				-1));
	return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %edx
movq %rdi, %rbx
movq 0x110(%rdi), %rdi
leaq 0x88(%rbx), %rsi
callq 0x6a37
movl %eax, %ebp
movl %eax, 0x4(%rbx)
movq 0x108(%rbx), %rdi
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x6a37
cmpl %eax, %ebp
jge 0x6b38
movq 0x108(%rbx), %rdi
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x6a37
jmp 0x6b3b
movl 0x4(%rbx), %eax
movl %eax, 0x4(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/DeforaOS[P]libSystem/src/event.c
// Function: event_unregister_timeout
int event_unregister_timeout(Event * event, EventTimeoutFunc func)
{
	unsigned int i = 0;
	EventTimeout * et;
	struct timeval now;

	while(i < array_count(event->timeouts))
	{
		array_get_copy(event->timeouts, i, &et);
		if(et->func != func)
		{
			i++;
			continue;
		}
		array_remove_pos(event->timeouts, i);
		object_delete(et);
	}
	if(gettimeofday(&now, NULL) != 0)
		return error_set_code(-errno, "%s", strerror(errno));
	/* XXX will fail in 2038 on 32-bit platforms */
	event->timeout.tv_sec = (time_t)LONG_MAX;
	event->timeout.tv_usec = (suseconds_t)LONG_MAX;
	for(i = 0; i < array_count(event->timeouts); i++)
	{
		array_get_copy(event->timeouts, i, &et);
		if(et->timeout.tv_sec < event->timeout.tv_sec
				|| (et->timeout.tv_sec == event->timeout.tv_sec
					&& et->timeout.tv_usec
					< event->timeout.tv_usec))
		{
			if((event->timeout.tv_sec = et->timeout.tv_sec
						- now.tv_sec) < 0)
			{
				event->timeout.tv_sec = 0;
				event->timeout.tv_usec = 0;
				break;
			}
			event->timeout.tv_usec = et->timeout.tv_usec
				- now.tv_usec;
			if(event->timeout.tv_usec >= 0)
				continue;
			event->timeout.tv_sec = max(0, event->timeout.tv_sec-1);
			event->timeout.tv_usec = -event->timeout.tv_usec;
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x118(%rdi), %rdi
callq 0x4250
testq %rax, %rax
je 0x6bbe
xorl %r15d, %r15d
movq %rsp, %r12
movq 0x118(%rbx), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x47f0
movq (%rsp), %rax
cmpq %r14, 0x20(%rax)
jne 0x6bb9
movq 0x118(%rbx), %rdi
movq %r15, %rsi
callq 0x4540
movq (%rsp), %rdi
callq 0x4460
movq 0x118(%rbx), %rdi
callq 0x4250
cmpq %r15, %rax
ja 0x6b72
jmp 0x6bbe
incl %r15d
jmp 0x6ba6
xorl %r14d, %r14d
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x42c0
testl %eax, %eax
je 0x6bfc
callq 0x40e0
movl (%rax), %edi
movl %edi, %ebx
negl %ebx
callq 0x4790
leaq 0x4476(%rip), %rsi      # 0xb05e
movl %ebx, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x45d0
movl %eax, %r14d
jmp 0x6cda
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movq %rax, 0x120(%rbx)
movq %rax, 0x128(%rbx)
movq 0x118(%rbx), %rdi
callq 0x4250
testq %rax, %rax
je 0x6cda
leaq 0x120(%rbx), %r12
movq 0x8(%rsp), %r13
movq 0x10(%rsp), %rbp
movl $0x1, %r14d
xorl %r15d, %r15d
movq 0x118(%rbx), %rdi
movq %r15, %rsi
movq %rsp, %rdx
callq 0x47f0
movq (%rsp), %rcx
movq 0x10(%rcx), %rax
cmpq 0x120(%rbx), %rax
jge 0x6ca3
subq %r13, %rax
movq %rax, (%r12)
js 0x6ccf
movq 0x18(%rcx), %rcx
subq %rbp, %rcx
movq %rcx, 0x128(%rbx)
jns 0x6cb2
leaq -0x1(%rax), %rdx
cmpq $0x2, %rax
movl $0x0, %eax
cmovgeq %rdx, %rax
movq %rax, 0x120(%rbx)
negq %rcx
movq %rcx, 0x128(%rbx)
jmp 0x6cb2
jne 0x6cb2
movq 0x18(%rcx), %rdx
cmpq 0x128(%rbx), %rdx
jl 0x6c66
movl %r14d, %r15d
movq 0x118(%rbx), %rdi
callq 0x4250
incl %r14d
cmpq %r15, %rax
ja 0x6c43
jmp 0x6cd7
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/DeforaOS[P]libSystem/src/event.c
// Function: loop_io
static void _loop_io(Event * event, eventioArray * eios, fd_set * fds)
{
	unsigned int i = 0;
	EventIO * eio;
	int fd;

	while(i < array_count(eios))
	{
		array_get_copy(eios, i, &eio);
		if((fd = eio->fd) <= event->fdmax && FD_ISSET(fd, fds)
				&& eio->func(fd, eio->data) != 0)
		{
			if(eios == event->reads)
				event_unregister_io_read(event, fd);
			else if(eios == event->writes)
				event_unregister_io_write(event, fd);
#ifdef DEBUG
			else
				fprintf(stderr, "DEBUG: %s%s", __func__,
						"(): should not happen\n");
#endif
		}
		else
			i++;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x4250
testq %rax, %rax
je 0x6d9d
xorl %r13d, %r13d
movq %rsp, %r12
xorl %ebp, %ebp
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x47f0
movq (%rsp), %rax
movl (%rax), %r13d
cmpl 0x4(%r15), %r13d
jg 0x6d7c
leal 0x3f(%r13), %ecx
testl %r13d, %r13d
cmovnsl %r13d, %ecx
sarl $0x6, %ecx
movslq %ecx, %rcx
movq (%rbx,%rcx,8), %rcx
btq %r13, %rcx
jae 0x6d7c
movq 0x10(%rax), %rsi
movl %r13d, %edi
callq *0x8(%rax)
testl %eax, %eax
je 0x6d7c
cmpq %r14, 0x108(%r15)
je 0x6d90
cmpq %r14, 0x110(%r15)
jne 0x6d7e
movq %r15, %rdi
movl %r13d, %esi
callq 0x4600
jmp 0x6d7e
incl %ebp
movl %ebp, %r13d
movq %r14, %rdi
callq 0x4250
cmpq %r13, %rax
ja 0x6d19
jmp 0x6d9d
movq %r15, %rdi
movl %r13d, %esi
callq 0x4420
jmp 0x6d7e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/DeforaOS[P]libSystem/src/file.c
// Function: file_new
File * file_new(String const * filename, FileMode mode)
{
	File * file;
	char const * fmode;

	if((file = (File *)object_new(sizeof(*file))) == NULL)
		return NULL;
	if((file->filename = string_new(filename)) == NULL
			|| (fmode = _file_get_fmode(file, mode)) == NULL)
	{
		object_delete(file);
		return NULL;
	}
	if((file->fp = fopen(filename, fmode)) == NULL)
	{
		file_delete(file);
		_file_error(file, errno);
		return NULL;
	}
	file->mode = mode;
	return file;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
movl $0x18, %edi
callq 0x45e0
testq %rax, %rax
je 0x6e52
movq %rax, %rbx
movq %r14, %rdi
callq 0x41f0
movq %rax, (%rbx)
testq %rax, %rax
je 0x6e4a
movq %rax, %r15
movl $0x8, %eax
leaq 0x8b22(%rip), %rcx      # 0xf910
cmpl %ebp, -0x8(%rax,%rcx)
je 0x6e28
addq $0x10, %rax
cmpq $0xa8, %rax
jne 0x6dee
movl $0x16, %edi
callq 0x4790
leaq 0x4250(%rip), %rsi      # 0xb061
xorl %r12d, %r12d
movl $0xffffffea, %edi       # imm = 0xFFFFFFEA
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x45d0
jmp 0x6e2c
movq (%rax,%rcx), %r12
testq %r12, %r12
je 0x6e4a
movq %r14, %rdi
movq %r12, %rsi
callq 0x46c0
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x6e60
movl %ebp, 0x10(%rbx)
jmp 0x6e54
movq %rbx, %rdi
callq 0x4460
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x4660
callq 0x40e0
movl (%rax), %edi
movl %edi, %ebp
negl %ebp
movq (%rbx), %r14
callq 0x4790
leaq 0x41df(%rip), %rsi      # 0xb061
xorl %ebx, %ebx
movl %ebp, %edi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x45d0
jmp 0x6e54
// File: /workspace/github_c_makefile_star2_O1/DeforaOS[P]libSystem/src/file.c
// Function: file_delete
FileError file_delete(File * file)
{
	FileError ret = 0;

	if(file->fp != NULL
			&& (ret = fclose(file->fp)) != 0)
		ret = _file_error(file, errno);
	string_delete(file->filename);
	object_delete(file);
	return ret;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
xorl %ebp, %ebp
testq %rdi, %rdi
je 0x6edb
callq 0x4240
testl %eax, %eax
je 0x6edb
callq 0x40e0
movl (%rax), %edi
movl %edi, %ebp
negl %ebp
movq (%rbx), %r14
callq 0x4790
leaq 0x4197(%rip), %rsi      # 0xb061
movl %ebp, %edi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x45d0
movl %eax, %ebp
movq (%rbx), %rdi
callq 0x4260
movq %rbx, %rdi
callq 0x4460
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/DeforaOS[P]libSystem/src/file.c
// Function: file_read
FileError file_read(File * file, void * buf, size_t size, size_t * count)
{
	size_t s;

	if((s = fread(buf, size, *count, file->fp)) < *count
			&& ferror(file->fp))
	{
		*count = s;
		return _file_error(file, errno);
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdi, %rbx
movq (%rcx), %rax
movq 0x8(%rdi), %rcx
movq %rsi, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x4190
cmpq (%r14), %rax
jae 0x6f67
movq %rax, %r15
movq 0x8(%rbx), %rdi
callq 0x4180
testl %eax, %eax
je 0x6f67
movq %r15, (%r14)
callq 0x40e0
movl (%rax), %edi
movl %edi, %ebp
negl %ebp
movq (%rbx), %rbx
callq 0x4790
leaq 0x4113(%rip), %rsi      # 0xb061
movl %ebp, %edi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x45d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/DeforaOS[P]libSystem/src/file.c
// Function: file_read_buffer
FileError file_read_buffer(File * file, Buffer * buffer)
{
	int ret;
	size_t s;

	s = buffer_get_size(buffer);
	if((ret = file_read(file, (void *)buffer_get_data(buffer),
					sizeof(BufferData), &s)) != 0)
		buffer_set_size(buffer, s);
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x4270
movq %rsp, %r15
movq %rax, (%r15)
movq %rbx, %rdi
callq 0x4500
movl $0x1, %edx
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rcx
callq 0x46b0
movl %eax, %ebp
testl %eax, %eax
je 0x6fbc
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x4120
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/DeforaOS[P]libSystem/src/file.c
// Function: file_seek
FileError file_seek(File * file, FileSeekMode mode, FileOffset offset)
{
	switch(mode)
	{
		case FILE_SEEK_MODE_CURRENT:
			return fseek(file->fp, SEEK_CUR, offset);
		case FILE_SEEK_MODE_END:
			return fseek(file->fp, SEEK_END, offset);
		case FILE_SEEK_MODE_SET:
			return fseek(file->fp, SEEK_SET, offset);
	}
	return _file_error(file, EINVAL);
}

// Assembly:
cmpl $0x2, %esi
je 0x6ff3
cmpl $0x1, %esi
je 0x6fe5
testl %esi, %esi
jne 0x6ffe
movq 0x8(%rdi), %rdi
movl $0x1, %esi
jmp 0x4580
movq 0x8(%rdi), %rdi
movl $0x2, %esi
jmp 0x4580
movq 0x8(%rdi), %rdi
xorl %esi, %esi
jmp 0x4580
pushq %rbx
movq (%rdi), %rbx
movl $0x16, %edi
callq 0x4790
leaq 0x404e(%rip), %rsi      # 0xb061
movl $0xffffffea, %edi       # imm = 0xFFFFFFEA
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
popq %rbx
jmp 0x45d0
// File: /workspace/github_c_makefile_star2_O1/DeforaOS[P]libSystem/src/file.c
// Function: file_write
FileError file_write(File * file, const void * buf, size_t size, size_t * count)
{
	size_t s;

	if((s = fwrite(buf, size, *count, file->fp)) < *count)
	{
		*count = s;
		return _file_error(file, errno);
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rdi, %rbx
movq (%rcx), %rax
movq 0x8(%rdi), %rcx
movq %rsi, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x4770
cmpq (%r14), %rax
jae 0x70c4
movq %rax, (%r14)
callq 0x40e0
movl (%rax), %edi
movl %edi, %ebp
negl %ebp
movq (%rbx), %rbx
callq 0x4790
leaq 0x3fb0(%rip), %rsi      # 0xb061
movl %ebp, %edi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x45d0
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/DeforaOS[P]libSystem/src/hash.c
// Function: hash_new
Hash * hash_new(HashFunc func, HashCompare compare)
{
	Hash * hash;

	if(compare == NULL)
	{
		error_set_code(1, "%s", "Invalid comparison function");
		return NULL;
	}
	if((hash = (Hash *)object_new(sizeof(*hash))) == NULL)
		return NULL;
	if((hash->entries = _hashentryarray_new()) == NULL)
	{
		object_delete(hash);
		return NULL;
	}
	hash->func = func;
	hash->compare = compare;
	return hash;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x714e
movq %rsi, %r14
movq %rdi, %r15
movl $0x18, %edi
callq 0x45e0
testq %rax, %rax
je 0x7174
movq %rax, %rbx
movl $0x18, %edi
callq 0x45b0
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x716c
movq %r15, (%rbx)
movq %r14, 0x8(%rbx)
jmp 0x7176
leaq 0x3f09(%rip), %rsi      # 0xb05e
leaq 0x401e(%rip), %rdx      # 0xb17a
xorl %ebx, %ebx
movl $0x1, %edi
xorl %eax, %eax
callq 0x45d0
jmp 0x7176
movq %rbx, %rdi
callq 0x4460
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/DeforaOS[P]libSystem/src/hash.c
// Function: hash_new_copy
Hash * hash_new_copy(Hash const * from)
{
	Hash * hash;

	if((hash = (Hash *)object_new(sizeof(*from))) == NULL)
		return NULL;
	if((hash->entries = array_new_copy(from->entries)) == NULL)
	{
		object_delete(hash);
		return NULL;
	}
	hash->func = from->func;
	hash->compare = from->compare;
	return hash;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x18, %edi
callq 0x45e0
testq %rax, %rax
je 0x71c2
movq %rax, %rbx
movq 0x10(%r14), %rdi
callq 0x46e0
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x71ba
movq (%r14), %rax
movq %rax, (%rbx)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
jmp 0x71c4
movq %rbx, %rdi
callq 0x4460
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/DeforaOS[P]libSystem/src/hash.c
// Function: hash_func_string
unsigned int hash_func_string(void const * key)
{
	String const * str = (String const *)key;
	size_t i;
	unsigned int hash = 0;

	for(i = 0; i < sizeof(hash) && str[i] != '\0'; i++)
		hash |= str[i] << (i << 3);
	return hash;
}

// Assembly:
xorl %ecx, %ecx
xorl %eax, %eax
movsbl (%rdi), %edx
testl %edx, %edx
je 0x7201
shll %cl, %edx
orl %edx, %eax
addq $0x8, %rcx
incq %rdi
cmpq $0x20, %rcx
jne 0x71e9
retq
// File: /workspace/github_c_makefile_star2_O1/DeforaOS[P]libSystem/src/hash.c
// Function: hash_get
void * hash_get(Hash const * hash, void const * key)
{
	Array const * entries = (Array const *)hash->entries;
	unsigned int h;
	size_t i;
	HashEntry * he;

	h = (hash->func != NULL) ? hash->func(key) : 0;
	for(i = array_count(entries); i > 0; i--)
	{
		if((he = (HashEntry *)array_get(entries, i - 1)) == NULL)
			return NULL;
		if(he->hash != h)
			continue;
		if(hash->compare(he->key, key) == 0)
			return he->value;
	}
	error_set_code(1, "%s", "Key not found");
	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq 0x10(%rdi), %r15
testq %rax, %rax
je 0x7236
movq %rbx, %rdi
callq *%rax
movl %eax, %ebp
jmp 0x7238
xorl %ebp, %ebp
movq %r15, %rdi
callq 0x4250
testq %rax, %rax
je 0x7278
movq %rax, %r13
decq %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x4590
testq %rax, %rax
je 0x7296
movq %rax, %r12
cmpl %ebp, (%rax)
jne 0x7272
movq 0x8(%r12), %rdi
movq %rbx, %rsi
callq *0x8(%r14)
testl %eax, %eax
je 0x729a
addq $-0x1, %r13
jb 0x724b
leaq 0x3ddf(%rip), %rsi      # 0xb05e
leaq 0x3f10(%rip), %rdx      # 0xb196
xorl %ebx, %ebx
movl $0x1, %edi
xorl %eax, %eax
callq 0x45d0
jmp 0x729f
xorl %ebx, %ebx
jmp 0x729f
movq 0x10(%r12), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/DeforaOS[P]libSystem/src/hash.c
// Function: hash_get_key
void const * hash_get_key(Hash const * hash, void const * key)
{
	Array const * entries = (Array const *)hash->entries;
	unsigned int h;
	size_t i;
	HashEntry const * he;

	h = (hash->func != NULL) ? hash->func(key) : 0;
	for(i = array_count(entries); i > 0; i--)
	{
		if((he = (HashEntry const *)array_get(entries, i - 1)) == NULL)
			return NULL;
		if(he->hash != h)
			continue;
		if(hash->compare(he->key, key) == 0)
			return he->key;
	}
	error_set_code(1, "%s", "Key not found");
	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq 0x10(%rdi), %r15
testq %rax, %rax
je 0x72d7
movq %rbx, %rdi
callq *%rax
movl %eax, %ebp
jmp 0x72d9
xorl %ebp, %ebp
movq %r15, %rdi
callq 0x4250
testq %rax, %rax
je 0x7319
movq %rax, %r13
decq %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x4590
testq %rax, %rax
je 0x7337
movq %rax, %r12
cmpl %ebp, (%rax)
jne 0x7313
movq 0x8(%r12), %rdi
movq %rbx, %rsi
callq *0x8(%r14)
testl %eax, %eax
je 0x733b
addq $-0x1, %r13
jb 0x72ec
leaq 0x3d3e(%rip), %rsi      # 0xb05e
leaq 0x3e6f(%rip), %rdx      # 0xb196
xorl %ebx, %ebx
movl $0x1, %edi
xorl %eax, %eax
callq 0x45d0
jmp 0x7340
xorl %ebx, %ebx
jmp 0x7340
movq 0x8(%r12), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/DeforaOS[P]libSystem/src/hash.c
// Function: hash_set
int hash_set(Hash * hash, void const * key, void * value)
{
	Array * entries = (Array *)hash->entries;
	unsigned int h;
	size_t i;
	size_t cnt;
	HashEntry he;
	HashEntry * p;

	h = (hash->func != NULL) ? hash->func(key) : 0;
	for(i = 0, cnt = array_count(entries); i < cnt; i++)
	{
		if((p = (HashEntry *)array_get(entries, i)) == NULL)
			return 1;
		if(p->hash != h)
			continue;
		if(hash->compare(p->key, key) != 0)
			continue;
		if(value == NULL)
			return (array_remove_pos(entries, i) == 0) ? 0 : 1;
		return _hashentry_set_value(p, value);
	}
	if(value == NULL)
		return 0;
	_hashentry_init(&he, hash->func, key, value);
	return (array_append(entries, &he) == 0) ? 0 : 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r12
movq 0x10(%rdi), %rbx
movq (%rdi), %rax
testq %rax, %rax
movq %rdx, (%rsp)
movq %rsi, 0x8(%rsp)
je 0x7381
movq %rsi, %rdi
callq *%rax
movl %eax, %ebp
jmp 0x7383
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x4250
testq %rax, %rax
je 0x73c7
movq %rax, %r14
xorl %r13d, %r13d
movq %rbx, %rdi
movq %r13, %rsi
callq 0x4590
testq %rax, %rax
je 0x7403
movq %rax, %r15
cmpl %ebp, (%rax)
jne 0x73bf
movq 0x8(%r15), %rdi
movq 0x8(%rsp), %rsi
callq *0x8(%r12)
testl %eax, %eax
je 0x7407
incq %r13
cmpq %r13, %r14
jne 0x7396
xorl %eax, %eax
movq (%rsp), %r14
testq %r14, %r14
je 0x7416
movq (%r12), %rcx
testq %rcx, %rcx
movq 0x8(%rsp), %r15
je 0x73e5
movq %r15, %rdi
callq *%rcx
leaq 0x10(%rsp), %rsi
movl %eax, (%rsi)
movq %r15, 0x8(%rsi)
movq %r14, 0x10(%rsi)
movq %rbx, %rdi
callq 0x4290
testl %eax, %eax
setne %al
jmp 0x7416
movb $0x1, %al
jmp 0x7416
movq (%rsp), %rax
testq %rax, %rax
je 0x7428
movq %rax, 0x10(%r15)
xorl %eax, %eax
movzbl %al, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r13, %rsi
callq 0x4540
jmp 0x73fc
// File: /workspace/github_c_makefile_star2_O1/DeforaOS[P]libSystem/src/hash.c
// Function: hash_foreach
void hash_foreach(Hash const * hash, HashForeach func, void * data)
{
	Array const * entries = (Array const *)hash->entries;
	struct funcdata fd;

	fd.hash = hash;
	fd.func = func;
	fd.data = data;
	array_foreach(entries, _hash_foreach, &fd);
}

// Assembly:
subq $0x18, %rsp
movq 0x10(%rdi), %rax
movq %rsp, %rcx
movq %rdi, (%rcx)
movq %rsi, 0x8(%rcx)
movq %rdx, 0x10(%rcx)
leaq 0x10(%rip), %rsi        # 0x7462
movq %rax, %rdi
movq %rcx, %rdx
callq 0x4040
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/DeforaOS[P]libSystem/src/mutator.c
// Function: mutator_set
int mutator_set(Mutator * mutator, String const * key, void * value)
{
	int ret;
	String * k;
	String * oldk;

	/* look for the former key */
	if((oldk = (String *)hash_get_key(mutator, key)) == NULL)
	{
		if(value == NULL)
			/* there is nothing to do */
			return 0;
		/* allocate the new key */
		if((k = string_new(key)) == NULL)
			return -1;
		key = k;
	}
	else
	{
		if(value != NULL)
			oldk = NULL;
		k = NULL;
	}
	if((ret = hash_set(mutator, key, value)) != 0)
	{
		error_set("%s: %s", key, "Could not set the value");
		string_delete(k);
	}
	else
		/* free the former key if removed */
		string_delete(oldk);
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
callq 0x41e0
testq %rax, %rax
je 0x75b9
movq %rax, %r12
xorl %r13d, %r13d
testq %r14, %r14
cmovneq %r13, %r12
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x44c0
movl %eax, %ebp
testl %eax, %eax
je 0x75a0
leaq 0x3ad5(%rip), %rdi      # 0xb061
leaq 0x3c11(%rip), %rdx      # 0xb1a4
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4570
movq %r13, %r12
movq %r12, %rdi
callq 0x4260
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testq %r14, %r14
je 0x75d6
movq %rbx, %rdi
callq 0x41f0
testq %rax, %rax
je 0x75da
movq %rax, %rbx
xorl %r12d, %r12d
movq %rax, %r13
jmp 0x7571
xorl %ebp, %ebp
jmp 0x75a8
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x75a8
// File: /workspace/github_c_makefile_star2_O1/DeforaOS[P]libSystem/src/parser.c
// Function: parser_scan_filter
int parser_scan_filter(Parser * parser)
{
	int c = parser->last;
	size_t i;
	ParserFilterData * pfd;
	int l;

#ifdef DEBUG
	fprintf(stderr, "DEBUG: %s(%p)\n", __func__, (void *)parser);
#endif
	if(parser->lookahead)
		parser->lookahead--;
	else if(parser->scanner(&c, parser) != 0)
	{
		parser->error = 1;
		return EOF;
	}
	for(i = 0; i < parser->filters_cnt; i++)
	{
		pfd = &parser->filters[i];
		if((l = pfd->filter(&c, pfd->data)) < 0)
		{
			parser->error = 1;
			return EOF;
		}
		parser->lookahead += l;
	}
	parser->last = c;
	return c;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x34(%rdi), %eax
movl %eax, 0x4(%rsp)
movl 0x38(%rdi), %eax
testl %eax, %eax
je 0x76e4
decl %eax
movl %eax, 0x38(%rbx)
cmpq $0x0, 0x50(%rbx)
je 0x76db
movl $0x8, %r15d
xorl %r12d, %r12d
leaq 0x4(%rsp), %r14
movq 0x48(%rbx), %rax
movq (%rax,%r15), %rsi
movq %r14, %rdi
callq *-0x8(%rax,%r15)
testl %eax, %eax
js 0x76f3
addl %eax, 0x38(%rbx)
incq %r12
addq $0x10, %r15
cmpq 0x50(%rbx), %r12
jb 0x76b7
movl 0x4(%rsp), %eax
movl %eax, 0x34(%rbx)
jmp 0x76ff
leaq 0x4(%rsp), %rdi
movq %rbx, %rsi
callq *0x40(%rbx)
testl %eax, %eax
je 0x76a2
movl $0x1, 0x28(%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/DeforaOS[P]libSystem/src/parser.c
// Function: parser_new
Parser * parser_new(String const * pathname)
{
	Parser * parser;

#ifdef DEBUG
	fprintf(stderr, "DEBUG: %s(\"%s\")\n", __func__, pathname);
#endif
	if((parser = _new_do(_parser_scanner_file)) == NULL)
		return NULL;
	if((parser->filename = string_new(pathname)) == NULL)
		error_set_code(-errno, "%s", strerror(errno));
	if((parser->fp = fopen(pathname, "r")) == NULL)
		error_set_code(-errno, "%s: %s", pathname, strerror(errno));
	if(parser->filename == NULL || parser->fp == NULL)
	{
		parser_delete(parser);
		return NULL;
	}
	return parser;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x68, %edi
callq 0x45e0
testq %rax, %rax
je 0x7752
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x1c(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movaps 0x3a87(%rip), %xmm1     # 0xb1c0
movups %xmm1, 0x2c(%rax)
leaq 0xa9(%rip), %rax        # 0x77ed
movq %rax, 0x40(%rbx)
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x58(%rbx)
jmp 0x7754
xorl %ebx, %ebx
testq %rbx, %rbx
je 0x77e3
movq %r14, %rdi
callq 0x41f0
movq %rax, (%rbx)
testq %rax, %rax
jne 0x7790
callq 0x40e0
movl (%rax), %edi
movl %edi, %ebp
negl %ebp
callq 0x4790
leaq 0x38da(%rip), %rsi      # 0xb05e
movl %ebp, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x45d0
leaq 0x393b(%rip), %rsi      # 0xb0d2
movq %r14, %rdi
callq 0x46c0
movq %rax, 0x8(%rbx)
testq %rax, %rax
jne 0x77ce
callq 0x40e0
movl (%rax), %edi
movl %edi, %ebp
negl %ebp
callq 0x4790
leaq 0x38a2(%rip), %rsi      # 0xb061
movl %ebp, %edi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x45d0
cmpq $0x0, (%rbx)
je 0x77db
cmpq $0x0, 0x8(%rbx)
jne 0x77e5
movq %rbx, %rdi
callq 0x47d0
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/DeforaOS[P]libSystem/src/parser.c
// Function: parser_scanner_file
static int _parser_scanner_file(int * c, void * data)
{
	Parser * parser = (Parser *)data;

#ifdef DEBUG
	fprintf(stderr, "DEBUG: %s()\n", __func__);
#endif
	if(parser->last == '\n')
	{
		parser->line++;
		parser->col = 1;
	}
	else if(parser->last != EOF)
		parser->col++;
	if((*c = fgetc(parser->fp)) == EOF
			&& !feof(parser->fp))
		return -1;
	parser->last = *c;
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x34(%rsi), %eax
cmpl $-0x1, %eax
je 0x7813
cmpl $0xa, %eax
jne 0x7810
incl 0x2c(%rbx)
movl $0x1, 0x30(%rbx)
jmp 0x7813
incl 0x30(%rbx)
movq 0x8(%rbx), %rdi
callq 0x4360
movl %eax, (%r14)
cmpl $-0x1, %eax
jne 0x7831
movq 0x8(%rbx), %rdi
callq 0x4440
testl %eax, %eax
je 0x7841
movl (%r14), %eax
movl %eax, 0x34(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x7839
// File: /workspace/github_c_makefile_star2_O1/DeforaOS[P]libSystem/src/parser.c
// Function: parser_delete
int parser_delete(Parser * parser)
{
	int ret = 0;

#ifdef DEBUG
	fprintf(stderr, "DEBUG: %s(%p) \"%s\"\n", __func__, (void *)parser,
			parser->filename);
#endif
	if(parser->fp != NULL
			&& fclose(parser->fp) != 0)
		ret = error_set_code(-errno, "%s: %s", parser->filename,
				strerror(errno));
	string_delete(parser->filename);
	free(parser->string);
	free(parser->filters);
	free(parser->callbacks);
	object_delete(parser);
	return ret;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
xorl %ebp, %ebp
testq %rdi, %rdi
je 0x788e
callq 0x4240
testl %eax, %eax
je 0x788e
callq 0x40e0
movl (%rax), %edi
movl %edi, %ebp
negl %ebp
movq (%rbx), %r14
callq 0x4790
leaq 0x37e4(%rip), %rsi      # 0xb061
movl %ebp, %edi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x45d0
movl %eax, %ebp
movq (%rbx), %rdi
callq 0x4260
movq 0x10(%rbx), %rdi
callq 0x4090
movq 0x48(%rbx), %rdi
callq 0x4090
movq 0x58(%rbx), %rdi
callq 0x4090
movq %rbx, %rdi
callq 0x4460
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/DeforaOS[P]libSystem/src/parser.c
// Function: parser_new_string
Parser * parser_new_string(String const * string, size_t length)
{
	Parser * parser;

#ifdef DEBUG
	fprintf(stderr, "DEBUG: %s(\"%s\", %lu)\n", __func__, string, length);
#endif
	if((parser = _new_do(_parser_scanner_string)) == NULL)
		return NULL;
	parser->string = (String *)malloc(length);
	parser->string_cnt = length;
	if(parser->string == NULL && length != 0)
	{
		error_set_code(-errno, "%s", strerror(errno));
		parser_delete(parser);
		return NULL;
	}
	memcpy(parser->string, string, length);
	return parser;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movl $0x68, %edi
callq 0x45e0
testq %rax, %rax
je 0x790d
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x1c(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movaps 0x38cc(%rip), %xmm1     # 0xb1c0
movups %xmm1, 0x2c(%rax)
leaq 0x80(%rip), %rax        # 0x797f
movq %rax, 0x40(%rbx)
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x58(%rbx)
jmp 0x790f
xorl %ebx, %ebx
testq %rbx, %rbx
je 0x795f
movq %r14, %rdi
callq 0x44e0
movq %rax, 0x10(%rbx)
movq %r14, 0x18(%rbx)
testq %rax, %rax
setne %cl
testq %r14, %r14
sete %dl
orb %cl, %dl
jne 0x7963
callq 0x40e0
movl (%rax), %edi
movl %edi, %ebp
negl %ebp
callq 0x4790
leaq 0x3713(%rip), %rsi      # 0xb05e
movl %ebp, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x45d0
movq %rbx, %rdi
callq 0x47d0
xorl %ebx, %ebx
jmp 0x7971
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x4470
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/DeforaOS[P]libSystem/src/parser.c
// Function: parser_scanner_string
static int _parser_scanner_string(int * c, void * data)
{
	Parser * parser = (Parser *)data;

#ifdef DEBUG
	fprintf(stderr, "DEBUG: %s()\n", __func__);
#endif
	if(parser->last == '\n')
	{
		parser->line++;
		parser->col = 1;
	}
	else if(parser->last != EOF)
		parser->col++;
	if(parser->string_pos == parser->string_cnt)
		*c = EOF;
	else
		*c = parser->string[parser->string_pos];
	parser->string_pos++;
	parser->last = *c;
	return 0;
}

// Assembly:
movl 0x34(%rsi), %eax
cmpl $-0x1, %eax
je 0x799b
cmpl $0xa, %eax
jne 0x7998
incl 0x2c(%rsi)
movl $0x1, 0x30(%rsi)
jmp 0x799b
incl 0x30(%rsi)
movq 0x20(%rsi), %rax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq 0x18(%rsi), %rax
je 0x79b2
movq 0x10(%rsi), %rcx
movsbl (%rcx,%rax), %ecx
movl %ecx, (%rdi)
incq %rax
movq %rax, 0x20(%rsi)
movl %ecx, 0x34(%rsi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/DeforaOS[P]libSystem/src/parser.c
// Function: parser_get_token
int parser_get_token(Parser * parser, Token ** token)
{
	int ret = 0; /* XXX not sure */
	size_t i;
	ParserCallbackData * pcd;

	if((*token = token_new(parser->filename, parser->line, parser->col))
			== NULL)
		return -1;
	if(parser->last == EOF
			&& parser_scan_filter(parser) == EOF
			&& parser->error != 0)
	{
		token_delete(*token);
		*token = NULL;
		return -1;
	}
#ifdef DEBUG
	fprintf(stderr, "DEBUG: %s() %c\n", __func__, parser->last);
#endif
	for(i = 0; i < parser->callbacks_cnt; i++)
	{
		pcd = &parser->callbacks[i];
		if((ret = pcd->callback(parser, *token, parser->last,
						pcd->data)) <= 0)
			break;
	}
	if(ret == 0 && i != parser->callbacks_cnt)
		return 0; /* there is a token and no error */
	token_delete(*token);
	*token = NULL;
	return (ret >= 0 && parser->last == EOF) ? 0 : -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
movl 0x2c(%rbx), %esi
movl 0x30(%rbx), %edx
callq 0x4820
movq %rax, (%r14)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x7a80
cmpl $-0x1, 0x34(%rbx)
jne 0x7a0c
movq %rbx, %rdi
callq 0x4490
cmpl $-0x1, %eax
je 0x7a91
cmpq $0x0, 0x60(%rbx)
je 0x7a48
movl $0x8, %r13d
xorl %r12d, %r12d
movq 0x58(%rbx), %rax
movq (%r14), %rsi
movl 0x34(%rbx), %edx
movq (%rax,%r13), %rcx
movq %rbx, %rdi
callq *-0x8(%rax,%r13)
movl %eax, %r15d
testl %eax, %eax
jle 0x7a4e
incq %r12
addq $0x10, %r13
cmpq 0x60(%rbx), %r12
jb 0x7a1c
jmp 0x7a4e
xorl %r12d, %r12d
xorl %r15d, %r15d
testl %r15d, %r15d
jne 0x7a5b
xorl %ebp, %ebp
cmpq 0x60(%rbx), %r12
jne 0x7a80
movq (%r14), %rdi
callq 0x40b0
movq $0x0, (%r14)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %r15d, %r15d
js 0x7a80
xorl %ebp, %ebp
cmpl $-0x1, 0x34(%rbx)
setne %bpl
negl %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x0, 0x28(%rbx)
je 0x7a0c
movq (%r14), %rdi
callq 0x40b0
movq $0x0, (%r14)
jmp 0x7a80
// File: /workspace/github_c_makefile_star2_O1/DeforaOS[P]libSystem/src/parser.c
// Function: parser_add_callback
int parser_add_callback(Parser * parser, ParserCallback callback, void * data)
{
	ParserCallbackData * p;

	if((p = (ParserCallbackData *)realloc(parser->callbacks,
					sizeof(*p) * (parser->callbacks_cnt
						+ 1))) == NULL)
		return 1;
	parser->callbacks = p;
	p = &parser->callbacks[parser->callbacks_cnt++];
	p->callback = callback;
	p->data = data;
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x58(%rdi), %rdi
movq 0x60(%r15), %rsi
shlq $0x4, %rsi
addq $0x10, %rsi
callq 0x45c0
testq %rax, %rax
je 0x7af5
movq %rax, 0x58(%r15)
movq 0x60(%r15), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x60(%r15)
shlq $0x4, %rcx
movq %r14, (%rax,%rcx)
movq %rbx, 0x8(%rax,%rcx)
xorl %eax, %eax
jmp 0x7afa
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/DeforaOS[P]libSystem/src/parser.c
// Function: parser_add_filter
int parser_add_filter(Parser * parser, ParserFilter filter, void * data)
{
	ParserFilterData * p = parser->filters;

#ifdef DEBUG
	fprintf(stderr, "DEBUG: %s(%p, %p, %p)\n", __func__, (void *)parser,
			(void *)filter, (void *)data);
#endif
	if((p = (ParserFilterData *)realloc(p, sizeof(*p) * (parser->filters_cnt
						+ 1))) == NULL)
		return 1;
	parser->filters = p;
	p = &parser->filters[parser->filters_cnt++];
	p->filter = filter;
	p->data = data;
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x48(%rdi), %rdi
movq 0x50(%r15), %rsi
shlq $0x4, %rsi
addq $0x10, %rsi
callq 0x45c0
testq %rax, %rax
je 0x7b49
movq %rax, 0x48(%r15)
movq 0x50(%r15), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x50(%r15)
shlq $0x4, %rcx
movq %r14, (%rax,%rcx)
movq %rbx, 0x8(%rax,%rcx)
xorl %eax, %eax
jmp 0x7b4e
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/DeforaOS[P]libSystem/src/parser.c
// Function: parser_remove_callback
int parser_remove_callback(Parser * parser, ParserCallback callback)
	/* XXX untested */
{
	size_t i;
	ParserCallbackData * p;

	for(i = 0; i < parser->callbacks_cnt; i++)
		if(parser->callbacks[i].callback == callback)
			break;
	if(i != parser->callbacks_cnt)
		return 1;
	p = &parser->callbacks[i];
#ifdef DEBUG
	fprintf(stderr, "DEBUG: %s(): memmove(%p, %p, %lu)\n", __func__,
			(void *)p, (void *)(p + 1),
			sizeof(*p) * (parser->callbacks_cnt - i));
#endif
	memmove(p, p + 1, sizeof(*p) * (parser->callbacks_cnt - i));
	parser->callbacks_cnt--;
	return 0;
}

// Assembly:
movq 0x60(%rdi), %rcx
testq %rcx, %rcx
je 0x7b79
movq 0x58(%rdi), %rax
xorl %edx, %edx
cmpq %rsi, (%rax)
je 0x7b7b
incq %rdx
addq $0x10, %rax
cmpq %rdx, %rcx
jne 0x7b63
movq %rcx, %rdx
jmp 0x7b7b
xorl %edx, %edx
movl $0x1, %eax
cmpq %rcx, %rdx
jne 0x7b8e
decq %rcx
movq %rcx, 0x60(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/DeforaOS[P]libSystem/src/parser.c
// Function: parser_remove_filter
int parser_remove_filter(Parser * parser, ParserFilter filter)
	/* XXX untested */
{
	size_t i;
	ParserFilterData * p;

	for(i = 0; i < parser->filters_cnt; i++)
		if(parser->filters[i].filter == filter)
			break;
	if(i != parser->filters_cnt)
		return 1;
	p = &parser->filters[i];
#ifdef DEBUG
	fprintf(stderr, "DEBUG: %s(): memmove(%p, %p, %lu)\n", __func__,
			(void *)p, (void *)(p + 1),
			sizeof(*p) * (parser->callbacks_cnt - i));
#endif
	memmove(p, p + 1, sizeof(*p) * (parser->filters_cnt - i));
	parser->filters_cnt--;
	return 0;
}

// Assembly:
movq 0x50(%rdi), %rcx
testq %rcx, %rcx
je 0x7bb4
movq 0x48(%rdi), %rax
xorl %edx, %edx
cmpq %rsi, (%rax)
je 0x7bb6
incq %rdx
addq $0x10, %rax
cmpq %rdx, %rcx
jne 0x7b9e
movq %rcx, %rdx
jmp 0x7bb6
xorl %edx, %edx
movl $0x1, %eax
cmpq %rcx, %rdx
jne 0x7bc9
decq %rcx
movq %rcx, 0x50(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/DeforaOS[P]libSystem/src/plugin.c
// Function: plugin_new
Plugin * plugin_new(String const * libdir, String const * package,
		String const * type, String const * name)
{
	Plugin * plugin;
	String * filename;
	char const ext[] = PLUGIN_EXTENSION;

	if((filename = string_new_append(libdir, "/", package, "/", type, "/",
					name, ext, NULL)) == NULL)
		return NULL;
	plugin = _plugin_open(filename);
	string_delete(filename);
	return plugin;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r10
movq %rdx, %r8
movq %rsi, %rdx
leaq 0x4(%rsp), %r11
movl $0x6f732e, (%r11)       # imm = 0x6F732E
subq $0x8, %rsp
leaq 0x3476(%rip), %rcx      # 0xb08a
xorl %ebx, %ebx
movq %rcx, %rsi
movq %rcx, %r9
xorl %eax, %eax
pushq $0x0
pushq %r11
pushq %r10
callq 0x4220
addq $0x20, %rsp
testq %rax, %rax
je 0x7c48
movq %rax, %r14
movq %rax, %rdi
callq 0x7c53
movq %rax, %rbx
movq %r14, %rdi
callq 0x4260
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/DeforaOS[P]libSystem/src/string.c
// Function: string_new
String * string_new(String const * string)
{
	String * ret = NULL;

	if(string == NULL)
	{
		error_set_code(-EINVAL, "%s", strerror(EINVAL));
		return NULL;
	}
	if(string_set(&ret, string) != 0)
		return NULL;
	return ret;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq $0x0, 0x8(%rsp)
testq %rdi, %rdi
je 0x7ceb
movq %rdi, %rsi
leaq 0x8(%rsp), %rdi
callq 0x41c0
testl %eax, %eax
jne 0x7d0f
movq 0x8(%rsp), %rbx
jmp 0x7d11
movl $0x16, %edi
callq 0x4790
leaq 0x3362(%rip), %rsi      # 0xb05e
xorl %ebx, %ebx
movl $0xffffffea, %edi       # imm = 0xFFFFFFEA
movq %rax, %rdx
xorl %eax, %eax
callq 0x45d0
jmp 0x7d11
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/DeforaOS[P]libSystem/src/string.c
// Function: string_new_appendv
String * string_new_appendv(String const * string, va_list ap)
{
	String * ret = NULL;

	if(string == NULL)
		return string_new("");
	ret = string_new(string);
	for(string = va_arg(ap, String *); string != NULL;
			string = va_arg(ap, String *))
		if(string_append(&ret, string) != 0)
		{
			string_delete(ret);
			ret = NULL;
			break;
		}
	return ret;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq $0x0, 0x8(%rsp)
testq %rdi, %rdi
je 0x7e2f
movq %rsi, %rbx
movq %rdi, %rsi
xorl %r14d, %r14d
leaq 0x10(%rsp), %rdi
movq %r14, (%rdi)
callq 0x41c0
testl %eax, %eax
jne 0x7e14
movq 0x10(%rsp), %r14
movq %r14, 0x8(%rsp)
movl (%rbx), %ecx
cmpq $0x28, %rcx
ja 0x7e50
movq %rcx, %rax
addq 0x10(%rbx), %rax
addl $0x8, %ecx
movl %ecx, (%rbx)
jmp 0x7e5c
xorl %ebx, %ebx
leaq 0x10(%rsp), %rdi
movq %rbx, (%rdi)
leaq 0x3279(%rip), %rsi      # 0xb0b9
callq 0x41c0
testl %eax, %eax
jne 0x7eb9
movq 0x10(%rsp), %rbx
jmp 0x7eb9
movq 0x8(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rbx)
movq (%rax), %rsi
testq %rsi, %rsi
je 0x7eb4
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x43b0
testl %eax, %eax
jne 0x7ea1
movl (%rbx), %ecx
cmpq $0x28, %rcx
ja 0x7e8b
movq %rcx, %rax
addq 0x10(%rbx), %rax
addl $0x8, %ecx
movl %ecx, (%rbx)
jmp 0x7e97
movq 0x8(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rbx)
movq (%rax), %rsi
testq %rsi, %rsi
jne 0x7e69
jmp 0x7eb4
movq 0x8(%rsp), %rdi
callq 0x4460
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rbx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/DeforaOS[P]libSystem/src/string.c
// Function: string_append
int string_append(String ** string, String const * append)
{
	size_t slength = (*string != NULL) ? string_get_length(*string) : 0;
	size_t alength;

	if(append == NULL)
		return error_set_code(-EINVAL, "%s", strerror(EINVAL));
	if((alength = string_get_length(append)) == 0)
		return 0;
	if(object_resize((Object**)string, slength + alength + 1) != 0)
		return 1;
	strcpy(*string + slength, append);
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
testq %rax, %rax
je 0x7eee
movq $-0x1, %rcx
leaq 0x1(%rcx), %r15
cmpb $0x0, 0x1(%rax,%rcx)
movq %r15, %rcx
jne 0x7ede
jmp 0x7ef1
xorl %r15d, %r15d
testq %rbx, %rbx
je 0x7f36
xorl %esi, %esi
cmpb $0x0, (%rbx,%rsi)
leaq 0x1(%rsi), %rsi
jne 0x7ef8
xorl %eax, %eax
cmpq $0x1, %rsi
je 0x7f30
addq %r15, %rsi
movq %r14, %rdi
callq 0x46d0
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x7f30
addq (%r14), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4140
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movl $0x16, %edi
callq 0x4790
leaq 0x3117(%rip), %rsi      # 0xb05e
movl $0xffffffea, %edi       # imm = 0xFFFFFFEA
movq %rax, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x45d0
// File: /workspace/github_c_makefile_star2_O1/DeforaOS[P]libSystem/src/string.c
// Function: string_new_formatv
String * string_new_formatv(String const * format, va_list ap)
{
	String * ret;
	va_list v;
	int len;
	size_t s;

	if(format == NULL)
	{
		error_set_code(-EINVAL, "%s", strerror(EINVAL));
		return NULL;
	}
	va_copy(v, ap);
	len = vsnprintf(NULL, 0, format, v);
	va_end(v);
	if(len < 0)
	{
		error_set_code(-errno, "%s", strerror(errno));
		return NULL;
	}
	s = (size_t)len + 1;
	if((ret = (String *)object_new(s)) == NULL)
		return NULL;
	if(vsnprintf(ret, s, format, ap) != len)
	{
		error_set_code(-errno, "%s", strerror(errno));
		object_delete(ret);
		ret = NULL;
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x8083
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rsi), %rax
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
movups (%rsi), %xmm0
movaps %xmm0, (%rcx)
xorl %edi, %edi
xorl %esi, %esi
movq %r15, %rdx
callq 0x41b0
testl %eax, %eax
js 0x809d
movl %eax, %r12d
leal 0x1(%r12), %r13d
movq %r13, %rdi
callq 0x45e0
testq %rax, %rax
je 0x807f
movq %rax, %rbx
movq %rax, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x41b0
cmpl %r12d, %eax
je 0x80c2
callq 0x40e0
movl (%rax), %edi
movl %edi, %ebp
negl %ebp
callq 0x4790
leaq 0x2ff3(%rip), %rsi      # 0xb05e
movl %ebp, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x45d0
movq %rbx, %rdi
callq 0x4460
xorl %ebx, %ebx
jmp 0x80c2
movl $0x16, %edi
callq 0x4790
leaq 0x2fca(%rip), %rsi      # 0xb05e
xorl %ebx, %ebx
movl $0xffffffea, %edi       # imm = 0xFFFFFFEA
jmp 0x80b8
callq 0x40e0
movl (%rax), %edi
movl %edi, %ebp
negl %ebp
callq 0x4790
leaq 0x2faa(%rip), %rsi      # 0xb05e
xorl %ebx, %ebx
movl %ebp, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x45d0
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/DeforaOS[P]libSystem/src/string.c
// Function: string_new_length
String * string_new_length(String const * string, size_t length)
{
	String * ret;

#ifdef DEBUG
	fprintf(stderr, "DEBUG: %s(\"%s\", %zu)\n", __func__, string, length);
#endif
	if(length + 1 == 0)
	{
		error_set_code(-ERANGE, "%s", strerror(ERANGE));
		return NULL;
	}
	if((ret = (String *)object_new(length + 1)) == NULL)
		return NULL;
	snprintf(ret, length + 1, "%s", (string != NULL) ? string : "");
	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
incq %r14
jne 0x8105
movl $0x22, %edi
callq 0x4790
leaq 0x2f6c(%rip), %rsi      # 0xb05e
xorl %ebx, %ebx
movl $0xffffffde, %edi       # imm = 0xFFFFFFDE
movq %rax, %rdx
xorl %eax, %eax
callq 0x45d0
jmp 0x813e
movq %rdi, %r15
movq %r14, %rdi
callq 0x45e0
testq %rax, %rax
je 0x813c
movq %rax, %rbx
testq %r15, %r15
leaq 0x2f97(%rip), %rcx      # 0xb0b9
cmovneq %r15, %rcx
leaq 0x2f31(%rip), %rdx      # 0xb05e
movq %rax, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x42a0
jmp 0x813e
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/DeforaOS[P]libSystem/src/string.c
// Function: string_new_replace
String * string_new_replace(String const * string, String const * what,
		String const * by)
{
	String * ret;

	if((ret = string_new(string)) == NULL)
		return NULL;
	if(string_replace(&ret, what, by) != 0)
	{
		string_delete(ret);
		return NULL;
	}
	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
callq 0x41f0
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x8189
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4050
movl %eax, %ecx
movq (%r15), %rax
testl %ecx, %ecx
je 0x818b
movq %rax, %rdi
callq 0x4460
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq