LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x6930
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebx
movq %rdi, %r14
pushq $0x18
popq %rdi
callq 0x4620
movq %rax, (%rsp)
testq %rax, %rax
je 0x690a
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 0x690f
movq (%rsp), %rdi
callq 0x44a0
pushq $-0x1
jmp 0x690c
pushq $0x1
popq %rax
jmp 0x6924
pushq $0x1
popq %rax
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 0x479d(%rip), %rdi      # 0xb0d4
leaq 0x479e(%rip), %rsi      # 0xb0dc
leaq 0x47dd(%rip), %rcx      # 0xb122
movl $0xe2, %edx
callq 0x42e0
// File: /workspace/github_c_makefile_star2_O2/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 0x69a3
movl %eax, %ebp
movl %eax, 0x4(%rbx)
movq 0x110(%rbx), %rdi
pushq $-0x1
popq %rdx
xorl %esi, %esi
callq 0x69a3
cmpl %eax, %ebp
jge 0x6994
movq 0x110(%rbx), %rdi
pushq $-0x1
popq %rdx
xorl %esi, %esi
callq 0x69a3
jmp 0x6997
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_O2/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
pushq $-0x2
popq %rbp
movl %ebx, %ecx
rolq %cl, %rbp
pushq $0x40
popq %rcx
movl %edx, %eax
cltd
idivl %ecx
movslq %eax, %r13
pushq $-0x1
popq %rax
movl %eax, 0xc(%rsp)
xorl %r12d, %r12d
movl %r12d, %r12d
movq %r15, %rdi
callq 0x4250
cmpq %r12, %rax
jbe 0x6a2e
movq %r15, %rdi
movq %r12, %rsi
leaq 0x10(%rsp), %rdx
callq 0x4860
movq 0x10(%rsp), %rax
movl (%rax), %eax
cmpl %ebx, %eax
jne 0x6a1c
andq %rbp, (%r14,%r13,8)
movq %r15, %rdi
movq %r12, %rsi
callq 0x4580
movq 0x10(%rsp), %rdi
callq 0x44a0
jmp 0x69d9
movl 0xc(%rsp), %ecx
cmpl %eax, %ecx
cmovlel %eax, %ecx
movl %ecx, 0xc(%rsp)
incl %r12d
jmp 0x69d6
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_O2/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 0x69a3
movl %eax, %ebp
movl %eax, 0x4(%rbx)
movq 0x108(%rbx), %rdi
pushq $-0x1
popq %rdx
xorl %esi, %esi
callq 0x69a3
cmpl %eax, %ebp
jge 0x6a89
movq 0x108(%rbx), %rdi
pushq $-0x1
popq %rdx
xorl %esi, %esi
callq 0x69a3
jmp 0x6a8c
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_O2/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
xorl %r15d, %r15d
movq %rsp, %r12
movl %r15d, %r15d
movq 0x118(%rbx), %rdi
callq 0x4250
cmpq %r15, %rax
jbe 0x6b01
movq 0x118(%rbx), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x4860
movq (%rsp), %rax
cmpq %r14, 0x20(%rax)
jne 0x6afc
movq 0x118(%rbx), %rdi
movq %r15, %rsi
callq 0x4580
movq (%rsp), %rdi
callq 0x44a0
jmp 0x6ab5
incl %r15d
jmp 0x6ab2
xorl %r14d, %r14d
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x42c0
testl %eax, %eax
je 0x6b4a
callq 0x40e0
movl (%rax), %edi
movl %edi, %ebx
negl %ebx
callq 0x47f0
leaq 0x4533(%rip), %rsi      # 0xb05e
movl %ebx, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4610
movl %eax, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x120(%rbx), %r12
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movq %rax, 0x120(%rbx)
movq %rax, 0x128(%rbx)
movq 0x8(%rsp), %r13
movq 0x10(%rsp), %r15
xorl %ebp, %ebp
movl %r14d, %r14d
movq 0x118(%rbx), %rdi
callq 0x4250
cmpq %r14, %rax
jbe 0x6b39
movq 0x118(%rbx), %rdi
movq %r14, %rsi
movq %rsp, %rdx
callq 0x4860
movq (%rsp), %rcx
movq 0x10(%rcx), %rax
cmpq 0x120(%rbx), %rax
jge 0x6be9
subq %r13, %rax
movq %rax, (%r12)
js 0x6c00
movq 0x18(%rcx), %rcx
subq %r15, %rcx
movq %rcx, 0x128(%rbx)
jns 0x6bf8
leaq -0x1(%rax), %rdx
cmpq $0x2, %rax
movl $0x0, %eax
cmovaeq %rdx, %rax
movq %rax, 0x120(%rbx)
negq %rcx
movq %rcx, 0x128(%rbx)
jmp 0x6bf8
jne 0x6bf8
movq 0x18(%rcx), %rdx
cmpq 0x128(%rbx), %rdx
jl 0x6bac
incl %r14d
jmp 0x6b75
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
jmp 0x6b39
// File: /workspace/github_c_makefile_star2_O2/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
xorl %r12d, %r12d
movq %rsp, %r13
movl %r12d, %r12d
movq %r14, %rdi
callq 0x4250
cmpq %r12, %rax
jbe 0x6ca1
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x4860
movq (%rsp), %rcx
movl (%rcx), %ebp
cmpl 0x4(%r15), %ebp
jg 0x6c9c
movl %ebp, %eax
cltd
pushq $0x40
popq %rsi
idivl %esi
cltq
movq (%rbx,%rax,8), %rax
btq %rdx, %rax
jae 0x6c9c
movq 0x10(%rcx), %rsi
movl %ebp, %edi
callq *0x8(%rcx)
testl %eax, %eax
je 0x6c9c
cmpq %r14, 0x108(%r15)
je 0x6c90
cmpq %r14, 0x110(%r15)
jne 0x6c2a
movq %r15, %rdi
movl %ebp, %esi
callq 0x4640
jmp 0x6c2a
movq %r15, %rdi
movl %ebp, %esi
callq 0x4450
jmp 0x6c2a
incl %r12d
jmp 0x6c27
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
pushq $0x18
popq %rdi
callq 0x4620
testq %rax, %rax
je 0x6d2a
movq %rax, %rbx
movq %r14, %rdi
callq 0x41f0
movq %rax, (%rbx)
testq %rax, %rax
je 0x6d22
xorl %ecx, %ecx
leaq 0x8bee(%rip), %rax      # 0xf8d0
leaq 0x10(%rcx), %rdx
cmpq $0xb0, %rdx
je 0x6d17
cmpl %ebp, (%rcx,%rax)
movq %rdx, %rcx
jne 0x6ce2
movq -0x8(%rdx,%rax), %rsi
testq %rsi, %rsi
je 0x6d22
movq %r14, %rdi
callq 0x4720
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x6d34
movl %ebp, 0x10(%rbx)
jmp 0x6d2c
pushq $0x16
popq %rsi
movq %rbx, %rdi
callq 0x6d91
movq %rbx, %rdi
callq 0x44a0
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
callq 0x46b0
callq 0x40e0
movl (%rax), %esi
movq %rbx, %rdi
callq 0x6d91
jmp 0x6d2a
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
xorl %ebp, %ebp
testq %rdi, %rdi
je 0x6d78
callq 0x4240
testl %eax, %eax
je 0x6d78
callq 0x40e0
movl (%rax), %esi
movq %rbx, %rdi
callq 0x6d91
movl %eax, %ebp
movq (%rbx), %rdi
callq 0x4260
movq %rbx, %rdi
callq 0x44a0
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
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 0x4190
cmpq (%r14), %rax
jae 0x6e11
movq %rax, %r15
movq 0x8(%rbx), %rdi
callq 0x4180
testl %eax, %eax
je 0x6e11
movq %r15, (%r14)
callq 0x40e0
movl (%rax), %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x6d91
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4540
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rcx
callq 0x4710
movl %eax, %ebp
testl %eax, %eax
je 0x6e5f
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_O2/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 0x6e8e
cmpl $0x1, %esi
je 0x6e82
testl %esi, %esi
jne 0x6e99
movq 0x8(%rdi), %rdi
pushq $0x1
jmp 0x6e88
movq 0x8(%rdi), %rdi
pushq $0x2
popq %rsi
jmp 0x45c0
movq 0x8(%rdi), %rdi
xorl %esi, %esi
jmp 0x45c0
pushq $0x16
popq %rsi
jmp 0x6d91
// File: /workspace/github_c_makefile_star2_O2/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 0x6f8a
movq %rsi, %r14
movq %rdi, %r15
pushq $0x18
popq %rdi
callq 0x4620
testq %rax, %rax
je 0x6fae
movq %rax, %rbx
pushq $0x18
popq %rdi
callq 0x45f0
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x6fa6
movq %r15, (%rbx)
movq %r14, 0x8(%rbx)
jmp 0x6fb0
leaq 0x40cd(%rip), %rsi      # 0xb05e
leaq 0x41e2(%rip), %rdx      # 0xb17a
xorl %ebx, %ebx
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x4610
jmp 0x6fb0
movq %rbx, %rdi
callq 0x44a0
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x18
popq %rdi
callq 0x4620
testq %rax, %rax
je 0x6ff3
movq %rax, %rbx
movq 0x10(%r14), %rdi
callq 0x4740
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x6feb
movups (%r14), %xmm0
movups %xmm0, (%rbx)
jmp 0x6ff5
movq %rbx, %rdi
callq 0x44a0
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
cmpq $0x20, %rcx
je 0x7034
movsbl (%rdi), %edx
testl %edx, %edx
je 0x7034
shll %cl, %edx
orl %edx, %eax
addq $0x8, %rcx
incq %rdi
jmp 0x701a
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7069
movq %rbx, %rdi
callq *%rax
movl %eax, %ebp
jmp 0x706b
xorl %ebp, %ebp
movq %r15, %rdi
callq 0x4250
movq %rax, %r13
decq %r13
cmpq $-0x1, %r13
je 0x70ad
movq %r15, %rdi
movq %r13, %rsi
callq 0x45d0
testq %rax, %rax
je 0x70c9
movq %rax, %r12
cmpl %ebp, (%rax)
jne 0x7076
movq 0x8(%r12), %rdi
movq %rbx, %rsi
callq *0x8(%r14)
testl %eax, %eax
jne 0x7076
movq 0x10(%r12), %rbx
jmp 0x70cb
leaq 0x3faa(%rip), %rsi      # 0xb05e
leaq 0x40db(%rip), %rdx      # 0xb196
xorl %ebx, %ebx
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x4610
jmp 0x70cb
xorl %ebx, %ebx
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_O2/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 0x7103
movq %rbx, %rdi
callq *%rax
movl %eax, %ebp
jmp 0x7105
xorl %ebp, %ebp
movq %r15, %rdi
callq 0x4250
movq %rax, %r13
decq %r13
cmpq $-0x1, %r13
je 0x7147
movq %r15, %rdi
movq %r13, %rsi
callq 0x45d0
testq %rax, %rax
je 0x7163
movq %rax, %r12
cmpl %ebp, (%rax)
jne 0x7110
movq 0x8(%r12), %rdi
movq %rbx, %rsi
callq *0x8(%r14)
testl %eax, %eax
jne 0x7110
movq 0x8(%r12), %rbx
jmp 0x7165
leaq 0x3f10(%rip), %rsi      # 0xb05e
leaq 0x4041(%rip), %rdx      # 0xb196
xorl %ebx, %ebx
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x4610
jmp 0x7165
xorl %ebx, %ebx
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_O2/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 0x71a6
movq %rsi, %rdi
callq *%rax
movl %eax, %ebp
jmp 0x71a8
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x4250
movq %rax, %r14
xorl %r13d, %r13d
cmpq %r13, %r14
je 0x71e9
movq %rbx, %rdi
movq %r13, %rsi
callq 0x45d0
testq %rax, %rax
je 0x7220
movq %rax, %r15
cmpl %ebp, (%rax)
jne 0x71e4
movq 0x8(%r15), %rdi
movq 0x8(%rsp), %rsi
callq *0x8(%r12)
testl %eax, %eax
je 0x7224
incq %r13
jmp 0x71b6
xorl %eax, %eax
movq (%rsp), %r14
testq %r14, %r14
je 0x7245
movq (%r12), %rcx
testq %rcx, %rcx
movq 0x8(%rsp), %r15
je 0x7207
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
jmp 0x7240
movb $0x1, %al
jmp 0x7245
movq (%rsp), %rax
testq %rax, %rax
je 0x7235
movq %rax, 0x10(%r15)
xorl %eax, %eax
jmp 0x7245
movq %rbx, %rdi
movq %r13, %rsi
callq 0x4580
testl %eax, %eax
setne %al
movzbl %al, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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        # 0x7284
movq %rax, %rdi
movq %rcx, %rdx
callq 0x4040
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x73b1
movq %rax, %r12
xorl %r13d, %r13d
testq %r14, %r14
cmovneq %r13, %r12
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x4500
testl %eax, %eax
je 0x73ce
movl %eax, %ebp
leaq 0x3cc6(%rip), %rdi      # 0xb061
leaq 0x3e02(%rip), %rdx      # 0xb1a4
movq %rbx, %rsi
xorl %eax, %eax
callq 0x45b0
movq %r13, %r12
jmp 0x73d0
testq %r14, %r14
je 0x73e9
movq %rbx, %rdi
callq 0x41f0
testq %rax, %rax
je 0x73ed
movq %rax, %rbx
xorl %r12d, %r12d
movq %rax, %r13
jmp 0x7380
xorl %ebp, %ebp
movq %r12, %rdi
callq 0x4260
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %ebp, %ebp
jmp 0x73d8
pushq $-0x1
popq %rbp
jmp 0x73d8
// File: /workspace/github_c_makefile_star2_O2/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 0x74e9
decl %eax
movl %eax, 0x38(%rbx)
pushq $0x8
popq %r15
xorl %r12d, %r12d
leaq 0x4(%rsp), %r14
cmpq 0x50(%rbx), %r12
jae 0x74e0
movq 0x48(%rbx), %rax
movq (%rax,%r15), %rsi
movq %r14, %rdi
callq *-0x8(%rax,%r15)
testl %eax, %eax
js 0x74f8
addl %eax, 0x38(%rbx)
incq %r12
addq $0x10, %r15
jmp 0x74ba
movl 0x4(%rsp), %eax
movl %eax, 0x34(%rbx)
jmp 0x7502
leaq 0x4(%rsp), %rdi
movq %rbx, %rsi
callq *0x40(%rbx)
testl %eax, %eax
je 0x74ae
movl $0x1, 0x28(%rbx)
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
leaq 0xd9(%rip), %rdi        # 0x75f5
callq 0x75bd
testq %rax, %rax
je 0x75b3
movq %rax, %rbx
movq %r14, %rdi
callq 0x41f0
movq %rax, (%rbx)
testq %rax, %rax
jne 0x7560
callq 0x40e0
movl (%rax), %edi
movl %edi, %ebp
negl %ebp
callq 0x47f0
leaq 0x3b0a(%rip), %rsi      # 0xb05e
movl %ebp, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4610
leaq 0x3b6b(%rip), %rsi      # 0xb0d2
movq %r14, %rdi
callq 0x4720
movq %rax, 0x8(%rbx)
testq %rax, %rax
jne 0x759e
callq 0x40e0
movl (%rax), %edi
movl %edi, %ebp
negl %ebp
callq 0x47f0
leaq 0x3ad2(%rip), %rsi      # 0xb061
movl %ebp, %edi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x4610
cmpq $0x0, (%rbx)
je 0x75ab
cmpq $0x0, 0x8(%rbx)
jne 0x75b5
movq %rbx, %rdi
callq 0x4840
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x761b
cmpl $0xa, %eax
jne 0x7618
incl 0x2c(%rbx)
movl $0x1, 0x30(%rbx)
jmp 0x761b
incl 0x30(%rbx)
movq 0x8(%rbx), %rdi
callq 0x4380
movl %eax, (%r14)
cmpl $-0x1, %eax
jne 0x763c
movq 0x8(%rbx), %rdi
callq 0x4470
testl %eax, %eax
je 0x7649
movl (%r14), %eax
movl %eax, 0x34(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $-0x1
popq %rax
jmp 0x7641
// File: /workspace/github_c_makefile_star2_O2/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 0x7694
callq 0x4240
testl %eax, %eax
je 0x7694
callq 0x40e0
movl (%rax), %edi
movl %edi, %ebp
negl %ebp
movq (%rbx), %r14
callq 0x47f0
leaq 0x39de(%rip), %rsi      # 0xb061
movl %ebp, %edi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x4610
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 0x44a0
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
leaq 0x78(%rip), %rdi        # 0x7752
callq 0x75bd
testq %rax, %rax
je 0x7732
movq %rax, %rbx
movq %r14, %rdi
callq 0x4520
movq %rax, 0x10(%rbx)
movq %r14, 0x18(%rbx)
testq %rax, %rax
setne %cl
testq %r14, %r14
sete %dl
orb %cl, %dl
jne 0x7736
callq 0x40e0
movl (%rax), %edi
movl %edi, %ebp
negl %ebp
callq 0x47f0
leaq 0x3940(%rip), %rsi      # 0xb05e
movl %ebp, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4610
movq %rbx, %rdi
callq 0x4840
xorl %ebx, %ebx
jmp 0x7744
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x44b0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x776e
cmpl $0xa, %eax
jne 0x776b
incl 0x2c(%rsi)
movl $0x1, 0x30(%rsi)
jmp 0x776e
incl 0x30(%rsi)
movq 0x20(%rsi), %rax
cmpq 0x18(%rsi), %rax
jne 0x777d
pushq $-0x1
popq %rcx
jmp 0x7785
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_O2/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 0x4890
movq %rax, (%r14)
pushq $-0x1
popq %rbp
testq %rax, %rax
je 0x784e
cmpl $-0x1, 0x34(%rbx)
jne 0x77d9
movq %rbx, %rdi
callq 0x44d0
cmpl $-0x1, %eax
je 0x783c
xorl %r15d, %r15d
pushq $0x8
popq %r13
xorl %r12d, %r12d
cmpq 0x60(%rbx), %r12
jae 0x780f
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 0x780f
incq %r12
addq $0x10, %r13
jmp 0x77e3
testl %r15d, %r15d
jne 0x781c
xorl %eax, %eax
cmpq %r12, 0x60(%rbx)
jne 0x7850
movq (%r14), %rdi
callq 0x40b0
andq $0x0, (%r14)
movl %ebp, %eax
testl %r15d, %r15d
js 0x7850
xorl %eax, %eax
cmpl $-0x1, 0x34(%rbx)
setne %al
negl %eax
jmp 0x7850
cmpl $0x0, 0x28(%rbx)
je 0x77d9
movq (%r14), %rdi
callq 0x40b0
andq $0x0, (%r14)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4600
testq %rax, %rax
je 0x78a8
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 0x78ab
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4600
testq %rax, %rax
je 0x78fa
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 0x78fd
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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), %rax
xorl %ecx, %ecx
movq %rax, %r8
movq %rax, %rdx
subq $0x1, %rdx
jb 0x7931
movq 0x58(%rdi), %r9
cmpq %rsi, (%r9,%rcx)
je 0x7928
addq $0x10, %rcx
movq %rdx, %r8
jmp 0x790f
testq %r8, %r8
je 0x7931
pushq $0x1
popq %rax
retq
decq %rax
movq %rax, 0x60(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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), %rax
xorl %ecx, %ecx
movq %rax, %r8
movq %rax, %rdx
subq $0x1, %rdx
jb 0x7969
movq 0x48(%rdi), %r9
cmpq %rsi, (%r9,%rcx)
je 0x7960
addq $0x10, %rcx
movq %rdx, %r8
jmp 0x7947
testq %r8, %r8
je 0x7969
pushq $0x1
popq %rax
retq
decq %rax
movq %rax, 0x50(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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
subq $0x28, %rsp
movq %rdx, %r8
movq %rsi, %rdx
leaq 0x24(%rsp), %rax
movl $0x6f732e, (%rax)       # imm = 0x6F732E
movq %rax, 0x8(%rsp)
movq %rcx, (%rsp)
andq $0x0, 0x10(%rsp)
leaq 0x36c4(%rip), %rcx      # 0xb08a
xorl %ebx, %ebx
movq %rcx, %rsi
movq %rcx, %r9
xorl %eax, %eax
callq 0x4220
testq %rax, %rax
je 0x79f0
movq %rax, %r14
movq %rax, %rdi
callq 0x79fb
movq %rax, %rbx
movq %r14, %rdi
callq 0x4260
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, 0x8(%rsp)
testq %rdi, %rdi
je 0x7a8c
movq %rdi, %rsi
leaq 0x8(%rsp), %rdi
callq 0x41c0
testl %eax, %eax
jne 0x7aac
movq 0x8(%rsp), %rbx
jmp 0x7aae
pushq $0x16
popq %rdi
callq 0x47f0
leaq 0x35c3(%rip), %rsi      # 0xb05e
xorl %ebx, %ebx
pushq $-0x16
popq %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4610
jmp 0x7aae
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/DeforaOS[P]libSystem/src/string.c
// Function: string_set
int string_set(String ** string, String const * string2)
{
	size_t len = string_get_length(string2);

	if(object_resize((Object **)string, len + 1) != 0)
		return 1;
	strcpy(*string, string2);
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x4350
leaq 0x1(%rax), %rsi
movq %r14, %rdi
callq 0x4730
testl %eax, %eax
je 0x7ade
pushq $0x1
popq %rax
jmp 0x7aeb
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x4140
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rax
testq %rdi, %rdi
je 0x7ba6
movq %rsi, %rbx
callq 0x41f0
movq %rax, (%rsp)
movl (%rbx), %ecx
cmpq $0x28, %rcx
ja 0x7bb9
movq %rcx, %rax
addq 0x10(%rbx), %rax
addl $0x8, %ecx
movl %ecx, (%rbx)
jmp 0x7bc5
leaq 0x350c(%rip), %rdi      # 0xb0b9
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x41f0
movq 0x8(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rbx)
movq %rsp, %r14
movq (%rax), %rsi
testq %rsi, %rsi
je 0x7c00
movq %r14, %rdi
callq 0x43d0
testl %eax, %eax
jne 0x7c06
movl (%rbx), %ecx
cmpq $0x28, %rcx
ja 0x7bf2
movq %rcx, %rax
addq 0x10(%rbx), %rax
addl $0x8, %ecx
movl %ecx, (%rbx)
jmp 0x7bc8
movq 0x8(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rbx)
jmp 0x7bc8
movq (%rsp), %rax
jmp 0x7c11
movq (%rsp), %rdi
callq 0x44a0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x7c38
callq 0x4350
movq %rax, %r15
jmp 0x7c3b
xorl %r15d, %r15d
testq %rbx, %rbx
je 0x7c67
movq %rbx, %rdi
callq 0x4350
xorl %ebp, %ebp
testq %rax, %rax
je 0x7c9b
leaq (%r15,%rax), %rsi
incq %rsi
movq %r14, %rdi
callq 0x4730
testl %eax, %eax
je 0x7c8d
pushq $0x1
popq %rbp
jmp 0x7c9b
pushq $0x16
popq %rdi
callq 0x47f0
leaq 0x33e8(%rip), %rsi      # 0xb05e
pushq $-0x16
popq %rdi
movq %rax, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4610
addq (%r14), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4140
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7dd0
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 0x7de6
movl %eax, %r12d
leal 0x1(%r12), %r13d
movq %r13, %rdi
callq 0x4620
testq %rax, %rax
je 0x7dcc
movq %rax, %rbx
movq %rax, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x41b0
cmpl %r12d, %eax
je 0x7e0b
callq 0x40e0
movl (%rax), %edi
movl %edi, %ebp
negl %ebp
callq 0x47f0
leaq 0x32a6(%rip), %rsi      # 0xb05e
movl %ebp, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4610
movq %rbx, %rdi
callq 0x44a0
xorl %ebx, %ebx
jmp 0x7e0b
pushq $0x16
popq %rdi
callq 0x47f0
leaq 0x327f(%rip), %rsi      # 0xb05e
xorl %ebx, %ebx
pushq $-0x16
popq %rdi
jmp 0x7e01
callq 0x40e0
movl (%rax), %edi
movl %edi, %ebp
negl %ebp
callq 0x47f0
leaq 0x3261(%rip), %rsi      # 0xb05e
xorl %ebx, %ebx
movl %ebp, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4610
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_O2/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 0x7e4a
pushq $0x22
popq %rdi
callq 0x47f0
leaq 0x3225(%rip), %rsi      # 0xb05e
xorl %ebx, %ebx
pushq $-0x22
popq %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4610
jmp 0x7e83
movq %rdi, %r15
movq %r14, %rdi
callq 0x4620
testq %rax, %rax
je 0x7e81
movq %rax, %rbx
testq %r15, %r15
leaq 0x3252(%rip), %rcx      # 0xb0b9
cmovneq %r15, %rcx
leaq 0x31ec(%rip), %rdx      # 0xb05e
movq %rax, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x42a0
jmp 0x7e83
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7ece
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 0x7ed0
movq %rax, %rdi
callq 0x44a0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/DeforaOS[P]libSystem/src/string.c
// Function: string_replace
int string_replace(String ** string, String const * what, String const * by)
{
	String * ret = NULL;
	String const * p;
	size_t len = string_get_length(what);
	ssize_t index;
	String * q;

	for(p = *string; (index = string_index(p, what)) >= 0; p += index + len)
	{
		if((q = string_new_length(p, index)) == NULL
				|| string_append(&ret, q) != 0
				|| string_append(&ret, by) != 0)
		{
			string_delete(q);
			string_delete(ret);
			return -1;
		}
		string_delete(q);
	}
	if(ret != NULL)
	{
		if(string_append(&ret, p) != 0)
		{
			string_delete(ret);
			return -1;
		}
		string_delete(*string);
		*string = ret;
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %r13
andq $0x0, (%r13)
movq %rsi, %rdi
callq 0x4350
movq %rax, %rbp
movq %rbx, 0x8(%rsp)
movq (%rbx), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x4160
testq %rax, %rax
js 0x7f89
movq %rax, %rbx
movq %r12, %rdi
movq %rax, %rsi
callq 0x41d0
movq %rax, %r14
testq %rax, %rax
je 0x7f64
movq %r13, %rdi
movq %r14, %rsi
callq 0x43d0
testl %eax, %eax
jne 0x7f64
movq %r13, %rdi
movq 0x10(%rsp), %rsi
callq 0x43d0
testl %eax, %eax
jne 0x7f64
movq %r14, %rdi
callq 0x44a0
addq %rbp, %rbx
addq %rbx, %r12
jmp 0x7f0e
movq %r14, %rdi
callq 0x44a0
movq (%rsp), %rdi
callq 0x44a0
pushq $-0x1
popq %rbx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %ebx, %ebx
cmpq $0x0, (%rsp)
je 0x7f78
movq %rsp, %rdi
movq %r12, %rsi
callq 0x43d0
testl %eax, %eax
jne 0x7f6c
movq 0x8(%rsp), %r14
movq (%r14), %rdi
callq 0x44a0
movq (%rsp), %rax
movq %rax, (%r14)
jmp 0x7f78
// File: /workspace/github_c_makefile_star2_O2/DeforaOS[P]libSystem/src/string.c
// Function: string_append_formatv
int string_append_formatv(String ** string, String const * format, va_list ap)
{
	va_list v;
	int alen;
	size_t len;
	size_t s;

	if(format == NULL)
		return error_set_code(-EINVAL, "%s", strerror(EINVAL));
	va_copy(v, ap);
	alen = vsnprintf(NULL, 0, format, v);
	va_end(v);
	if(alen < 0)
		return error_set_code(-errno, "%s", strerror(errno));
	len = string_get_length(*string);
	s = (size_t)alen + 1;
	if(object_resize((Object **)string, len + s) != 0)
		return -1;
	if(vsnprintf(&(*string)[len], s, format, ap) != alen)
	{
		error_set_code(-errno, "%s", strerror(errno));
		return -1;
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rsi, %rsi
je 0x80c3
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rdx), %rax
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
movups (%rdx), %xmm0
movaps %xmm0, (%rcx)
xorl %edi, %edi
xorl %esi, %esi
movq %r14, %rdx
callq 0x41b0
testl %eax, %eax
js 0x80ed
movl %eax, %ebp
movq (%r15), %rdi
callq 0x4350
movq %rax, %r13
movl %ebp, %r12d
leaq (%rax,%r12), %rsi
incq %rsi
movq %r15, %rdi
callq 0x4730
pushq $-0x1
popq %rcx
testl %eax, %eax
je 0x8112
movl %ecx, %eax
jmp 0x8157
pushq $0x16
popq %rdi
callq 0x47f0
leaq 0x2f8c(%rip), %rsi      # 0xb05e
pushq $-0x16
popq %rdi
movq %rax, %rdx
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4610
callq 0x40e0
movl (%rax), %edi
movl %edi, %ebx
negl %ebx
callq 0x47f0
leaq 0x2f5a(%rip), %rsi      # 0xb05e
movl %ebx, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4610
jmp 0x8157
incq %r12
addq (%r15), %r13
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x41b0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ebp, %ecx
je 0x8157
callq 0x40e0
movl (%rax), %edi
movl %edi, %ebx
negl %ebx
callq 0x47f0
leaq 0x2f16(%rip), %rsi      # 0xb05e
movl %ebx, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4610
pushq $-0x1
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq