LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r14
movl $0x18, %edi
callq 0x45e0
testq %rax, %rax
je 0x6eaf
movq %rax, %rbx
movq %r14, %rdi
callq 0x41f0
movq %rax, (%rbx)
testq %rax, %rax
je 0x6ea7
movq %rax, %r15
movl $0x8, %eax
leaq 0x8aaf(%rip), %rcx      # 0xf900
cmpl %ebp, -0x8(%rax,%rcx)
je 0x6e88
addq $0x10, %rax
cmpq $0xa8, %rax
jne 0x6e51
movl $0x16, %edi
callq 0x47a0
leaq 0x41ed(%rip), %rsi      # 0xb061
movl $0xffffffea, %edi       # imm = 0xFFFFFFEA
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x45d0
jmp 0x6ea7
movq (%rax,%rcx), %rsi
testq %rsi, %rsi
je 0x6ea7
movq %r14, %rdi
callq 0x46d0
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x6ebf
movl %ebp, 0x10(%rbx)
jmp 0x6eb1
movq %rbx, %rdi
callq 0x4460
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x4660
callq 0x40e0
movl (%rax), %edi
movq (%rbx), %r14
movl %edi, %ebp
negl %ebp
callq 0x47a0
leaq 0x4180(%rip), %rsi      # 0xb061
xorl %ebx, %ebx
movl %ebp, %edi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x45d0
jmp 0x6eb1
// File: /workspace/github_c_makefile_star2_O3/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 0x6f3a
callq 0x4240
testl %eax, %eax
je 0x6f3a
callq 0x40e0
movl (%rax), %edi
movq (%rbx), %r14
movl %edi, %ebp
negl %ebp
callq 0x47a0
leaq 0x4138(%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_O3/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 0x6fc6
movq %rax, %r15
movq 0x8(%rbx), %rdi
callq 0x4180
testl %eax, %eax
je 0x6fc6
movq %r15, (%r14)
callq 0x40e0
movl (%rax), %edi
movq (%rbx), %rbx
movl %edi, %ebp
negl %ebp
callq 0x47a0
leaq 0x40b4(%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_O3/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 0x46c0
movl %eax, %ebp
testl %eax, %eax
je 0x701b
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_O3/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 0x7052
cmpl $0x1, %esi
je 0x7044
testl %esi, %esi
jne 0x705d
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 0x47a0
leaq 0x3fef(%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_O3/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 0x4780
cmpq (%r14), %rax
jae 0x7123
movq %rax, (%r14)
callq 0x40e0
movl (%rax), %edi
movq (%rbx), %rbx
movl %edi, %ebp
negl %ebp
callq 0x47a0
leaq 0x3f51(%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_O3/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 0x71ae
movq %rsi, %r14
movq %rdi, %r15
movl $0x18, %edi
callq 0x45e0
testq %rax, %rax
je 0x71d4
movq %rax, %rbx
movl $0x18, %edi
callq 0x45b0
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x71cc
movq %r15, (%rbx)
movq %r14, 0x8(%rbx)
jmp 0x71d6
leaq 0x3ea9(%rip), %rsi      # 0xb05e
leaq 0x3fbe(%rip), %rdx      # 0xb17a
xorl %ebx, %ebx
movl $0x1, %edi
xorl %eax, %eax
callq 0x45d0
jmp 0x71d6
movq %rbx, %rdi
callq 0x4460
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x721b
movq %rax, %rbx
movq 0x10(%r14), %rdi
callq 0x46f0
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x7213
movups (%r14), %xmm0
movups %xmm0, (%rbx)
jmp 0x721d
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_O3/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 0x725a
shll %cl, %edx
orl %edx, %eax
addq $0x8, %rcx
incq %rdi
cmpq $0x20, %rcx
jne 0x7242
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x728f
movq %rbx, %rdi
callq *%rax
movl %eax, %ebp
jmp 0x7291
xorl %ebp, %ebp
movq %r15, %rdi
callq 0x4250
testq %rax, %rax
je 0x72d1
movq %rax, %r13
decq %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x4590
testq %rax, %rax
je 0x72ef
movq %rax, %r12
cmpl %ebp, (%rax)
jne 0x72cb
movq 0x8(%r12), %rdi
movq %rbx, %rsi
callq *0x8(%r14)
testl %eax, %eax
je 0x72f3
addq $-0x1, %r13
jb 0x72a4
leaq 0x3d86(%rip), %rsi      # 0xb05e
leaq 0x3eb7(%rip), %rdx      # 0xb196
xorl %ebx, %ebx
movl $0x1, %edi
xorl %eax, %eax
callq 0x45d0
jmp 0x72f8
xorl %ebx, %ebx
jmp 0x72f8
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_O3/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 0x7330
movq %rbx, %rdi
callq *%rax
movl %eax, %ebp
jmp 0x7332
xorl %ebp, %ebp
movq %r15, %rdi
callq 0x4250
testq %rax, %rax
je 0x7372
movq %rax, %r13
decq %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x4590
testq %rax, %rax
je 0x7390
movq %rax, %r12
cmpl %ebp, (%rax)
jne 0x736c
movq 0x8(%r12), %rdi
movq %rbx, %rsi
callq *0x8(%r14)
testl %eax, %eax
je 0x7394
addq $-0x1, %r13
jb 0x7345
leaq 0x3ce5(%rip), %rsi      # 0xb05e
leaq 0x3e16(%rip), %rdx      # 0xb196
xorl %ebx, %ebx
movl $0x1, %edi
xorl %eax, %eax
callq 0x45d0
jmp 0x7399
xorl %ebx, %ebx
jmp 0x7399
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_O3/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 0x73da
movq %rsi, %rdi
callq *%rax
movl %eax, %ebp
jmp 0x73dc
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x4250
testq %rax, %rax
je 0x7420
movq %rax, %r14
xorl %r13d, %r13d
movq %rbx, %rdi
movq %r13, %rsi
callq 0x4590
testq %rax, %rax
je 0x745c
movq %rax, %r15
cmpl %ebp, (%rax)
jne 0x7418
movq 0x8(%r15), %rdi
movq 0x8(%rsp), %rsi
callq *0x8(%r12)
testl %eax, %eax
je 0x7460
incq %r13
cmpq %r13, %r14
jne 0x73ef
xorl %eax, %eax
movq (%rsp), %r14
testq %r14, %r14
je 0x746f
movq (%r12), %rcx
testq %rcx, %rcx
movq 0x8(%rsp), %r15
je 0x743e
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 0x746f
movb $0x1, %al
jmp 0x746f
movq (%rsp), %rax
testq %rax, %rax
je 0x7481
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 0x7455
// File: /workspace/github_c_makefile_star2_O3/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 0x75fa
movq %rax, %r12
xorl %r13d, %r13d
testq %r14, %r14
cmovneq %r13, %r12
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x44c0
testl %eax, %eax
je 0x7617
movl %eax, %ebp
leaq 0x3a7d(%rip), %rdi      # 0xb061
leaq 0x3bb9(%rip), %rdx      # 0xb1a4
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4570
movq %r13, %r12
jmp 0x7619
testq %r14, %r14
je 0x7632
movq %rbx, %rdi
callq 0x41f0
testq %rax, %rax
je 0x7636
movq %rax, %rbx
xorl %r12d, %r12d
movq %rax, %r13
jmp 0x75c9
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 0x7621
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x7621
// File: /workspace/github_c_makefile_star2_O3/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 0x7740
decl %eax
movl %eax, 0x38(%rbx)
cmpq $0x0, 0x50(%rbx)
je 0x7737
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 0x774f
addl %eax, 0x38(%rbx)
incq %r12
addq $0x10, %r15
cmpq 0x50(%rbx), %r12
jb 0x7713
movl 0x4(%rsp), %eax
movl %eax, 0x34(%rbx)
jmp 0x775b
leaq 0x4(%rsp), %rdi
movq %rbx, %rsi
callq *0x40(%rbx)
testl %eax, %eax
je 0x76fe
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_O3/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 0x7836
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x1c(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movaps 0x3a27(%rip), %xmm1     # 0xb1c0
movups %xmm1, 0x2c(%rax)
leaq 0x9c(%rip), %rax        # 0x7840
movq %rax, 0x40(%rbx)
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x58(%rbx)
movq %r14, %rdi
callq 0x41f0
movq %rax, (%rbx)
testq %rax, %rax
jne 0x77e3
callq 0x40e0
movl (%rax), %edi
movl %edi, %ebp
negl %ebp
callq 0x47a0
leaq 0x3887(%rip), %rsi      # 0xb05e
movl %ebp, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x45d0
leaq 0x38e8(%rip), %rsi      # 0xb0d2
movq %r14, %rdi
callq 0x46d0
movq %rax, 0x8(%rbx)
testq %rax, %rax
jne 0x7821
callq 0x40e0
movl (%rax), %edi
movl %edi, %ebp
negl %ebp
callq 0x47a0
leaq 0x384f(%rip), %rsi      # 0xb061
movl %ebp, %edi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x45d0
cmpq $0x0, (%rbx)
je 0x782e
cmpq $0x0, 0x8(%rbx)
jne 0x7838
movq %rbx, %rdi
callq 0x47e0
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7866
cmpl $0xa, %eax
jne 0x7863
incl 0x2c(%rbx)
movl $0x1, 0x30(%rbx)
jmp 0x7866
incl 0x30(%rbx)
movq 0x8(%rbx), %rdi
callq 0x4360
movl %eax, (%r14)
cmpl $-0x1, %eax
jne 0x7887
movq 0x8(%rbx), %rdi
callq 0x4440
testl %eax, %eax
je 0x7894
movl (%r14), %eax
movl %eax, 0x34(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x788c
// File: /workspace/github_c_makefile_star2_O3/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 0x78e1
callq 0x4240
testl %eax, %eax
je 0x78e1
callq 0x40e0
movl (%rax), %edi
movl %edi, %ebp
negl %ebp
movq (%rbx), %r14
callq 0x47a0
leaq 0x3791(%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_O3/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 0x79a9
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x1c(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movaps 0x3879(%rip), %xmm1     # 0xb1c0
movups %xmm1, 0x2c(%rax)
leaq 0x77(%rip), %rax        # 0x79c9
movq %rax, 0x40(%rbx)
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x58(%rbx)
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 0x79ad
callq 0x40e0
movl (%rax), %edi
movl %edi, %ebp
negl %ebp
callq 0x47a0
leaq 0x36c9(%rip), %rsi      # 0xb05e
movl %ebp, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x45d0
movq %rbx, %rdi
callq 0x47e0
xorl %ebx, %ebx
jmp 0x79bb
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_O3/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 0x79e5
cmpl $0xa, %eax
jne 0x79e2
incl 0x2c(%rsi)
movl $0x1, 0x30(%rsi)
jmp 0x79e5
incl 0x30(%rsi)
movq 0x20(%rsi), %rax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq 0x18(%rsi), %rax
je 0x79fc
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_O3/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 0x4830
movq %rax, (%r14)
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x7ace
cmpl $-0x1, 0x34(%rbx)
jne 0x7a57
movq %rbx, %rdi
callq 0x4490
cmpl $-0x1, %eax
je 0x7ae0
xorl %r15d, %r15d
cmpq $0x0, 0x60(%rbx)
je 0x7a95
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, %ebp
testl %eax, %eax
jle 0x7a9a
incq %r12
addq $0x10, %r13
cmpq 0x60(%rbx), %r12
jb 0x7a6a
jmp 0x7aa7
xorl %r12d, %r12d
jmp 0x7a9c
jne 0x7aa7
movl $0x0, %ebp
cmpq 0x60(%rbx), %r12
jne 0x7ace
movq (%r14), %rdi
callq 0x40b0
movq $0x0, (%r14)
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
testl %ebp, %ebp
js 0x7ace
xorl %r15d, %r15d
cmpl $-0x1, 0x34(%rbx)
setne %r15b
negl %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x0, 0x28(%rbx)
je 0x7a57
movq (%r14), %rdi
callq 0x40b0
movq $0x0, (%r14)
jmp 0x7ace
// File: /workspace/github_c_makefile_star2_O3/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 0x7b44
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 0x7b49
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7b98
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 0x7b9d
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7bc5
movq 0x58(%rdi), %rax
xorl %edx, %edx
cmpq %rsi, (%rax)
je 0x7bc7
incq %rdx
addq $0x10, %rax
cmpq %rdx, %rcx
jne 0x7bb2
jmp 0x7bd1
xorl %edx, %edx
movl $0x1, %eax
cmpq %rcx, %rdx
jne 0x7bda
decq %rcx
movq %rcx, 0x60(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7bfd
movq 0x48(%rdi), %rax
xorl %edx, %edx
cmpq %rsi, (%rax)
je 0x7bff
incq %rdx
addq $0x10, %rax
cmpq %rdx, %rcx
jne 0x7bea
jmp 0x7c09
xorl %edx, %edx
movl $0x1, %eax
cmpq %rcx, %rdx
jne 0x7c12
decq %rcx
movq %rcx, 0x50(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x342e(%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 0x7c90
movq %rax, %r14
movq %rax, %rdi
callq 0x7c9b
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_O3/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 0x7d33
movq %rdi, %rsi
leaq 0x8(%rsp), %rdi
callq 0x41c0
testl %eax, %eax
jne 0x7d57
movq 0x8(%rsp), %rbx
jmp 0x7d59
movl $0x16, %edi
callq 0x47a0
leaq 0x331a(%rip), %rsi      # 0xb05e
xorl %ebx, %ebx
movl $0xffffffea, %edi       # imm = 0xFFFFFFEA
movq %rax, %rdx
xorl %eax, %eax
callq 0x45d0
jmp 0x7d59
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7e67
movq %rsi, %rbx
movq %rdi, %rsi
xorl %r14d, %r14d
movq %rsp, %rdi
movq %r14, (%rdi)
callq 0x41c0
testl %eax, %eax
jne 0x7e4d
movq (%rsp), %r14
movq %r14, (%rsp)
movl (%rbx), %ecx
cmpq $0x28, %rcx
ja 0x7e82
movq %rcx, %rax
addq 0x10(%rbx), %rax
addl $0x8, %ecx
movl %ecx, (%rbx)
jmp 0x7e8e
xorl %r14d, %r14d
movq %rsp, %rdi
movq %r14, (%rdi)
leaq 0x3242(%rip), %rsi      # 0xb0b9
callq 0x41c0
testl %eax, %eax
je 0x7ecf
jmp 0x7ee1
movq 0x8(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rbx)
movq (%rax), %rsi
testq %rsi, %rsi
je 0x7ee1
movq %rsp, %r14
movq %r14, %rdi
callq 0x43b0
testl %eax, %eax
jne 0x7ed5
movl (%rbx), %ecx
cmpq $0x28, %rcx
ja 0x7ebb
movq %rcx, %rax
addq 0x10(%rbx), %rax
addl $0x8, %ecx
movl %ecx, (%rbx)
jmp 0x7ec7
movq 0x8(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rbx)
movq (%rax), %rsi
testq %rsi, %rsi
jne 0x7e99
movq (%rsp), %r14
jmp 0x7ee1
movq (%rsp), %rdi
callq 0x4460
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7f16
movq $-0x1, %rcx
leaq 0x1(%rcx), %r15
cmpb $0x0, 0x1(%rax,%rcx)
movq %r15, %rcx
jne 0x7f06
jmp 0x7f19
xorl %r15d, %r15d
testq %rbx, %rbx
je 0x7f5e
xorl %esi, %esi
cmpb $0x0, (%rbx,%rsi)
leaq 0x1(%rsi), %rsi
jne 0x7f20
xorl %eax, %eax
cmpq $0x1, %rsi
je 0x7f58
addq %r15, %rsi
movq %r14, %rdi
callq 0x46e0
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x7f58
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 0x47a0
leaq 0x30ef(%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_O3/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 0x80ab
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 0x80c5
movl %eax, %r12d
leal 0x1(%r12), %r13d
movq %r13, %rdi
callq 0x45e0
testq %rax, %rax
je 0x80a7
movq %rax, %rbx
movq %rax, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x41b0
cmpl %r12d, %eax
je 0x80ea
callq 0x40e0
movl (%rax), %edi
movl %edi, %ebp
negl %ebp
callq 0x47a0
leaq 0x2fcb(%rip), %rsi      # 0xb05e
movl %ebp, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x45d0
movq %rbx, %rdi
callq 0x4460
xorl %ebx, %ebx
jmp 0x80ea
movl $0x16, %edi
callq 0x47a0
leaq 0x2fa2(%rip), %rsi      # 0xb05e
xorl %ebx, %ebx
movl $0xffffffea, %edi       # imm = 0xFFFFFFEA
jmp 0x80e0
callq 0x40e0
movl (%rax), %edi
movl %edi, %ebp
negl %ebp
callq 0x47a0
leaq 0x2f82(%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_O3/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 0x812d
movl $0x22, %edi
callq 0x47a0
leaq 0x2f44(%rip), %rsi      # 0xb05e
xorl %ebx, %ebx
movl $0xffffffde, %edi       # imm = 0xFFFFFFDE
movq %rax, %rdx
xorl %eax, %eax
callq 0x45d0
jmp 0x8166
movq %rdi, %r15
movq %r14, %rdi
callq 0x45e0
testq %rax, %rax
je 0x8164
movq %rax, %rbx
testq %r15, %r15
leaq 0x2f6f(%rip), %rcx      # 0xb0b9
cmovneq %r15, %rcx
leaq 0x2f09(%rip), %rdx      # 0xb05e
movq %rax, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x42a0
jmp 0x8166
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x81b1
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 0x81b3
movq %rax, %rdi
callq 0x4460
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r13
movq $0x0, (%rsp)
movq $-0x1, %r14
cmpb $0x0, 0x1(%r15,%r14)
leaq 0x1(%r14), %r14
jne 0x81e5
movq (%r13), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x4160
movq %rax, %rbx
xorl %eax, %eax
testq %rbx, %rbx
js 0x82b5
movq %r13, 0x8(%rsp)
movq %rsp, %r13
movq %r12, %rdi
movq %rbx, %rsi
callq 0x41d0
movq %rax, %rbp
testq %rax, %rax
je 0x829f
movq %r13, %rdi
movq %rbp, %rsi
callq 0x43b0
testl %eax, %eax
jne 0x829f
movq %r13, %rdi
movq 0x10(%rsp), %rsi
callq 0x43b0
testl %eax, %eax
jne 0x829f
movq %rbp, %rdi
callq 0x4460
movq %r12, %rbp
addq %rbx, %rbp
leaq (%r14,%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x4160
movq %rax, %rbx
testq %rax, %rax
jns 0x8216
cmpq $0x0, (%rsp)
je 0x829b
addq %r14, %rbp
movq %rsp, %rdi
movq %rbp, %rsi
callq 0x43b0
testl %eax, %eax
jne 0x82a7
movq 0x8(%rsp), %rbx
movq (%rbx), %rdi
callq 0x4460
movq (%rsp), %rax
movq %rax, (%rbx)
xorl %eax, %eax
jmp 0x82b5
movq %rbp, %rdi
callq 0x4460
movq (%rsp), %rdi
callq 0x4460
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x8434
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 0x8462
movl %eax, %ebp
movq (%r15), %rax
movq $-0x1, %r12
cmpb $0x0, 0x1(%rax,%r12)
leaq 0x1(%r12), %r12
jne 0x83bd
movl %ebp, %r13d
leaq (%r12,%r13), %rsi
incq %rsi
movq %r15, %rdi
callq 0x46e0
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x8485
incq %r13
addq (%r15), %r12
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x41b0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ebp, %ecx
je 0x8485
callq 0x40e0
movl (%rax), %edi
movl %edi, %ebx
negl %ebx
callq 0x47a0
leaq 0x2c3d(%rip), %rsi      # 0xb05e
movl %ebx, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x45d0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x8485
movl $0x16, %edi
callq 0x47a0
leaq 0x2c19(%rip), %rsi      # 0xb05e
movl $0xffffffea, %edi       # imm = 0xFFFFFFEA
movq %rax, %rdx
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x45d0
callq 0x40e0
movl (%rax), %edi
movl %edi, %ebx
negl %ebx
callq 0x47a0
leaq 0x2be5(%rip), %rsi      # 0xb05e
movl %ebx, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x45d0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/DeforaOS[P]libSystem/src/string.c
// Function: string_compare
int string_compare(String const * string, String const * string2)
{
	int ret;
	unsigned char const * u1;
	unsigned char const * u2;

#ifdef DEBUG
	fprintf(stderr, "DEBUG: %s(%s, %s)\n", __func__, string, string2);
#endif
	u1 = (unsigned char const *)string;
	u2 = (unsigned char const *)string2;
	while(*u1 && *u2 && *u1 == *u2)
	{
		u1++;
		u2++;
	}
	ret = *u1 - *u2;
	return ret;
}

// Assembly:
movb (%rdi), %al
testb %al, %al
je 0x84ca
incq %rdi
cmpb (%rsi), %al
jne 0x84c5
incq %rsi
movb (%rdi), %al
incq %rdi
testb %al, %al
jne 0x84b3
xorl %eax, %eax
movzbl %al, %eax
jmp 0x84cc
xorl %eax, %eax
movzbl (%rsi), %ecx
subl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/DeforaOS[P]libSystem/src/string.c
// Function: string_compare_length
int string_compare_length(String const * string, String const * string2,
		size_t length)
{
	int ret;
	unsigned char const * u1;
	unsigned char const * u2;

	if(length == 0)
		return 0;
	u1 = (unsigned char const *)string;
	u2 = (unsigned char const *)string2;
	while(--length && *u1 && *u2 && *u1 == *u2)
	{
		u1++;
		u2++;
	}
	ret = *u1 - *u2;
	return ret;
}

// Assembly:
testq %rdx, %rdx
je 0x850b
decq %rdx
je 0x8502
leaq (%rdi,%rdx), %rax
leaq (%rsi,%rdx), %rcx
movb (%rdi), %r8b
testb %r8b, %r8b
je 0x8502
cmpb (%rsi), %r8b
jne 0x8502
incq %rdi
incq %rsi
decq %rdx
jne 0x84e4
movq %rax, %rdi
movq %rcx, %rsi
movzbl (%rdi), %eax
movzbl (%rsi), %ecx
subl %ecx, %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/DeforaOS[P]libSystem/src/string.c
// Function: string_explode
StringArray * string_explode(String const * string, String const * separator)
{
	StringArray * ret;
	String * p;			/* temporary pointer */
	size_t i;			/* current position */
	String const * s;		/* &string[i] */
	ssize_t j;			/* position of the next separator */
	ssize_t l;

#ifdef DEBUG
	fprintf(stderr, "DEBUG: %s(\"%s\", \"%s\")\n", __func__, string,
			separator);
#endif
	if((ret = stringarray_new()) == NULL)
		return NULL;
	if(separator == NULL || (l = string_get_length(separator)) == 0)
	{
		error_set_code(-EINVAL, "%s", strerror(EINVAL));
		array_delete(ret);
		return NULL;
	}
	for(i = 0;; i += j + l)
	{
		s = &string[i];
		j = string_index(s, separator);
#ifdef DEBUG
		fprintf(stderr, "DEBUG: %s(): i=%zu, j=%zd\n", __func__, i, j);
#endif
		if(j < 0)
		{
			if((p = string_new(s)) == NULL
					|| array_append(ret, p) != 0)
			{
				string_delete(p);
				break;
			}
#ifdef DEBUG
			fprintf(stderr, "DEBUG: %s(): \"%s\"\n", __func__,
					ret[ret_cnt - 1]);
#endif
			return ret;
		}
		if((p = string_new_length(s, j)) == NULL
				|| array_append(ret, p) != 0)
		{
			string_delete(p);
			break;
		}
#ifdef DEBUG
		fprintf(stderr, "DEBUG: %s(): \"%s\"\n", __func__,
				ret[ret_cnt - 1]);
#endif
	}
	/* free everything */
	array_foreach(ret, _explose_foreach_delete, NULL);
	array_delete(ret);
	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %r13
movl $0x8, %edi
callq 0x45b0
testq %rax, %rax
je 0x867b
movq %rax, %r12
testq %r15, %r15
je 0x8626
movl $0x1, %ebp
movq %r15, %rax
decq %rbp
cmpb $0x0, (%rax)
leaq 0x1(%rax), %rax
jne 0x8549
testq %rbp, %rbp
je 0x8626
movq %r13, %rdi
movq %r15, %rsi
callq 0x4160
testq %rax, %rax
js 0x8602
movq %rax, %rbx
movq %r12, 0x8(%rsp)
movq %rbp, %rax
negq %rax
movq %rax, 0x20(%rsp)
movq %r13, %rax
subq %rbp, %rax
movq %rax, 0x18(%rsp)
xorl %r14d, %r14d
movq %r13, 0x10(%rsp)
movq %r13, %rdi
movq %rbx, %rsi
callq 0x41d0
testq %rax, %rax
je 0x864c
movq %rax, %r13
movq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x4290
testl %eax, %eax
jne 0x865a
movq %rbx, %r12
addq %r14, %r12
movq 0x20(%rsp), %rax
leaq (%rax,%r12), %r14
movq 0x18(%rsp), %rax
leaq (%rax,%r12), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x4160
movq %rax, %rbx
testq %rax, %rax
jns 0x8598
movq 0x10(%rsp), %r13
addq %r12, %r13
subq %rbp, %r13
movq 0x8(%rsp), %r12
movq %r13, %rdi
callq 0x41f0
testq %rax, %rax
je 0x8648
movq %rax, %r14
movq %r12, %rdi
movq %rax, %rsi
callq 0x4290
testl %eax, %eax
je 0x867e
movq %r14, %rdi
jmp 0x865d
movl $0x16, %edi
callq 0x47a0
leaq 0x2a27(%rip), %rsi      # 0xb05e
movl $0xffffffea, %edi       # imm = 0xFFFFFFEA
movq %rax, %rdx
xorl %eax, %eax
callq 0x45d0
jmp 0x8673
xorl %edi, %edi
jmp 0x865d
xorl %edi, %edi
callq 0x4460
movq 0x8(%rsp), %r12
jmp 0x8662
movq %r13, %rdi
callq 0x4460
leaq 0xe6(%rip), %rsi        # 0x874f
movq %r12, %rdi
xorl %edx, %edx
callq 0x4040
movq %r12, %rdi
callq 0x4480
xorl %r12d, %r12d
movq %r12, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/DeforaOS[P]libSystem/src/string.c
// Function: string_index
ssize_t string_index(String const * string, String const * key)
{
	size_t len;
	size_t keylen;
	size_t i;

	len = string_get_length(string);
	if((keylen = string_get_length(key)) == 0)
		return len;
	if(keylen > len)
		return -1;
	for(i = 0; i <= len - keylen; i++)
		if(string_compare_length(&string[i], key, keylen) == 0)
			return i;
	return -1;
}

// Assembly:
xorl %ecx, %ecx
movq %rcx, %rax
incq %rcx
cmpb $0x0, (%rdi,%rax)
jne 0x8692
xorl %edx, %edx
cmpb $0x0, (%rsi,%rdx)
leaq 0x1(%rdx), %rdx
jne 0x86a0
cmpq $0x1, %rdx
je 0x86c0
leaq -0x1(%rdx), %r8
cmpq %rax, %r8
jbe 0x86c1
movq $-0x1, %rax
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq %rdx, %rcx
leaq (%rdx,%rsi), %r8
addq $-0x2, %r8
leaq -0x2(%rdx), %r9
leaq (%rdx,%rdi), %r10
addq $-0x2, %r10
xorl %eax, %eax
movq %rdi, %r11
leaq (%rdi,%rax), %rbx
cmpq $0x2, %rdx
jne 0x86f4
movq %rsi, %r14
jmp 0x872d
leaq (%r10,%rax), %r12
xorl %r15d, %r15d
movq %rsi, %r14
movb (%r11,%r15), %bpl
testb %bpl, %bpl
je 0x872d
cmpb (%rsi,%r15), %bpl
jne 0x8723
incq %rbx
incq %r14
incq %r15
cmpq %r15, %r9
jne 0x86fe
movq %r12, %rbx
movq %r8, %r14
jmp 0x872d
leaq (%rsi,%r15), %r14
addq %r11, %r15
movq %r15, %rbx
movb (%rbx), %bl
cmpb (%r14), %bl
je 0x8746
incq %rax
incq %r11
cmpq %rcx, %rax
jbe 0x86e5
movq $-0x1, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/DeforaOS[P]libSystem/src/string.c
// Function: string_ltrim
size_t string_ltrim(String * string, String const * which)
{
	size_t i;
	size_t j;

	for(i = 0; string[i] != '\0'; i++)
		if(which == NULL)
		{
			if(!isspace((unsigned char)string[i]))
				break;
		}
		else
		{
			for(j = 0; which[j] != '\0' && string[i] != which[j];
					j++);
			if(which[j] == '\0')
				break;
		}
	for(j = i; string[j] != '\0'; j++)
		string[j - i] = string[j];
	string[j - i] = '\0';
	return i;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movb (%rdi), %bpl
testb %bpl, %bpl
je 0x87c8
movq %rsi, %r15
leaq 0x1(%rsi), %r12
xorl %r14d, %r14d
testq %r15, %r15
je 0x87a6
movb (%r15), %cl
movq %r12, %rax
testb %cl, %cl
je 0x87cb
cmpb %cl, %bpl
je 0x87b9
movb (%rax), %cl
incq %rax
jmp 0x8796
callq 0x4810
movq (%rax), %rax
movzbl %bpl, %ecx
testb $0x20, 0x1(%rax,%rcx,2)
je 0x87cb
movb 0x1(%rbx,%r14), %bpl
incq %r14
testb %bpl, %bpl
jne 0x878b
jmp 0x87cb
xorl %r14d, %r14d
movb (%rbx,%r14), %cl
movq %r14, %rax
testb %cl, %cl
je 0x87ed
leaq (%rbx,%r14), %rdx
xorl %eax, %eax
movb %cl, (%rbx,%rax)
movb 0x1(%rdx,%rax), %cl
incq %rax
testb %cl, %cl
jne 0x87dc
addq %r14, %rax
subq %r14, %rax
movb $0x0, (%rbx,%rax)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq