LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4350
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4150
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
jl 0xaadf
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x41d0
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0xaaa6
movq -0x48(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x43d0
cmpl $0x0, %eax
jne 0xaaa6
movq -0x20(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x43d0
cmpl $0x0, %eax
je 0xaac1
movq -0x48(%rbp), %rdi
callq 0x4260
movq -0x28(%rbp), %rdi
callq 0x4260
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xab28
movq -0x48(%rbp), %rdi
callq 0x4260
movq -0x40(%rbp), %rax
addq -0x38(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0xaa54
cmpq $0x0, -0x28(%rbp)
je 0xab21
movq -0x30(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x43d0
cmpl $0x0, %eax
je 0xab0a
movq -0x28(%rbp), %rdi
callq 0x4260
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xab28
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x4260
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xac93
movl $0x16, %edi
callq 0x4840
movq %rax, %rdx
movl $0xffffffea, %edi       # imm = 0xFFFFFFEA
leaq 0x53da(%rip), %rsi      # 0x1005e
movb $0x0, %al
callq 0x4630
movl %eax, -0x4(%rbp)
jmp 0xad9c
leaq -0x40(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movups (%rcx), %xmm0
movups %xmm0, (%rax)
movq -0x18(%rbp), %rdx
leaq -0x40(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x41b0
movl %eax, -0x44(%rbp)
leaq -0x40(%rbp), %rax
cmpl $0x0, -0x44(%rbp)
jge 0xad01
callq 0x40d0
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl %eax, -0x5c(%rbp)
callq 0x40d0
movl (%rax), %edi
callq 0x4840
movl -0x5c(%rbp), %edi
movq %rax, %rdx
leaq 0x536c(%rip), %rsi      # 0x1005e
movb $0x0, %al
callq 0x4630
movl %eax, -0x4(%rbp)
jmp 0xad9c
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x4350
movq %rax, -0x50(%rbp)
movslq -0x44(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
movq -0x50(%rbp), %rsi
addq -0x58(%rbp), %rsi
callq 0x4750
cmpl $0x0, %eax
je 0xad3c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xad9c
movq -0x10(%rbp), %rax
movq (%rax), %rdi
addq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x41b0
cmpl -0x44(%rbp), %eax
je 0xad95
callq 0x40d0
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl %eax, -0x60(%rbp)
callq 0x40d0
movl (%rax), %edi
callq 0x4840
movl -0x60(%rbp), %edi
movq %rax, %rdx
leaq 0x52d9(%rip), %rsi      # 0x1005e
movb $0x0, %al
callq 0x4630
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xad9c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movzbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x29(%rbp)
je 0xae44
movq -0x28(%rbp), %rax
movzbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x29(%rbp)
je 0xae44
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
movq -0x28(%rbp), %rcx
movzbl (%rcx), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0xae4d
jmp 0xae67
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xae0c
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
movq -0x28(%rbp), %rcx
movzbl (%rcx), %ecx
subl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xaea3
movl $0x0, -0x4(%rbp)
jmp 0xaf3e
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rcx
addq $-0x1, %rcx
movq %rcx, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x39(%rbp)
je 0xaf02
movq -0x30(%rbp), %rax
movzbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x39(%rbp)
je 0xaf02
movq -0x38(%rbp), %rax
movzbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x39(%rbp)
je 0xaf02
movq -0x30(%rbp), %rax
movzbl (%rax), %eax
movq -0x38(%rbp), %rcx
movzbl (%rcx), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0xaf0b
jmp 0xaf25
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0xaeb3
movq -0x30(%rbp), %rax
movzbl (%rax), %eax
movq -0x38(%rbp), %rcx
movzbl (%rcx), %ecx
subl %ecx, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
callq 0xb0b0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xaf7c
movq $0x0, -0x8(%rbp)
jmp 0xb0a2
cmpq $0x0, -0x18(%rbp)
je 0xaf96
movq -0x18(%rbp), %rdi
callq 0x4350
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
jne 0xafcc
movl $0x16, %edi
callq 0x4840
movq %rax, %rdx
movl $0xffffffea, %edi       # imm = 0xFFFFFFEA
leaq 0x50af(%rip), %rsi      # 0x1005e
movb $0x0, %al
callq 0x4630
movq -0x20(%rbp), %rdi
callq 0x44c0
movq $0x0, -0x8(%rbp)
jmp 0xb0a2
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4150
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jge 0xb032
movq -0x38(%rbp), %rdi
callq 0x41f0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xb01d
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x4290
cmpl $0x0, %eax
je 0xb028
movq -0x28(%rbp), %rdi
callq 0x4260
jmp 0xb07d
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb0a2
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x41d0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xb05b
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x4290
cmpl $0x0, %eax
je 0xb066
movq -0x28(%rbp), %rdi
callq 0x4260
jmp 0xb07d
jmp 0xb068
movq -0x40(%rbp), %rax
addq -0x48(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0xafd4
movq -0x20(%rbp), %rdi
leaq 0xe8(%rip), %rsi        # 0xb170
xorl %eax, %eax
movl %eax, %edx
callq 0x4030
movq -0x20(%rbp), %rdi
callq 0x44c0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4350
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4350
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0xb0fa
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb163
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0xb10e
movq $-0x1, -0x8(%rbp)
jmp 0xb163
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
subq -0x28(%rbp), %rcx
cmpq %rcx, %rax
ja 0xb15b
movq -0x10(%rbp), %rdi
addq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x44f0
cmpl $0x0, %eax
jne 0xb14b
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb163
jmp 0xb14d
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xb116
movq $-0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0xb2cf
cmpq $0x0, -0x10(%rbp)
jne 0xb250
callq 0x48b0
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
jne 0xb24e
jmp 0xb2cf
jmp 0xb2bc
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x21(%rbp)
je 0xb28e
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0xb297
jmp 0xb2a7
jmp 0xb299
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xb258
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0xb2ba
jmp 0xb2cf
jmp 0xb2bc
jmp 0xb2be
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xb208
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0xb310
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
subq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xb2d7
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
subq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/src/string.c
// Function: string_rindex
ssize_t string_rindex(String const * string, String const * key)
{
	size_t len;
	size_t keylen;
	ssize_t i;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4350
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4350
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0xb36a
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb3cd
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0xb37e
movq $-0x1, -0x8(%rbp)
jmp 0xb3cd
movq -0x20(%rbp), %rax
subq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jl 0xb3c5
movq -0x10(%rbp), %rdi
addq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x44f0
cmpl $0x0, %eax
jne 0xb3b5
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb3cd
jmp 0xb3b7
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xb38a
movq $-0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/src/string.c
// Function: string_rtrim
size_t string_rtrim(String * string, String const * which)
{
	size_t ret = 0;
	size_t i;
	size_t j;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4350
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jbe 0xb4fa
cmpq $0x0, -0x18(%rbp)
jne 0xb46b
callq 0x48b0
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rdx
subq $0x1, %rdx
movzbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
jne 0xb44d
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb502
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xb4e7
movq $0x0, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0xb4d2
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0xb4c2
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xb4d2
jmp 0xb4c4
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xb473
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0xb4e5
jmp 0xb4fa
jmp 0xb4e7
jmp 0xb4e9
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xb405
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/src/token.c
// Function: token_new
Token * token_new(String const * filename, unsigned int line, unsigned int col)
{
	Token * token;

#ifdef DEBUG
	fprintf(stderr, "DEBUG: %s(%u, %u)\n", __func__, line, col);
#endif
	if((token = (Token *)object_new(sizeof(*token))) == NULL)
		return NULL;
	token->code = 0;
	token->string = NULL;
	token->filename = (filename != NULL) ? string_new(filename) : NULL;
	token->line = line;
	token->col = col;
	token->data = NULL;
	if(filename != NULL && token->filename == NULL)
	{
		error_set_code(1, "%s", strerror(errno));
		object_delete(token);
		return NULL;
	}
	return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl $0x28, %edi
callq 0x4640
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xb643
movq $0x0, -0x8(%rbp)
jmp 0xb6f2
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
cmpq $0x0, -0x10(%rbp)
je 0xb66f
movq -0x10(%rbp), %rdi
callq 0x41f0
movq %rax, -0x28(%rbp)
jmp 0xb677
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0xb677
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x18(%rax)
movl -0x18(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x20(%rax)
cmpq $0x0, -0x10(%rbp)
je 0xb6ea
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xb6ea
callq 0x40d0
movl (%rax), %edi
callq 0x4840
movq %rax, %rdx
movl $0x1, %edi
leaq 0x498e(%rip), %rsi      # 0x1005e
movb $0x0, %al
callq 0x4630
movq -0x20(%rbp), %rdi
callq 0x44a0
movq $0x0, -0x8(%rbp)
jmp 0xb6f2
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/src/token.c
// Function: token_set_filename
int token_set_filename(Token * token, String const * filename)
{
	string_delete(token->filename);
	if((token->filename = string_new(filename)) == NULL)
		return 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x4260
movq -0x18(%rbp), %rdi
callq 0x41f0
movq -0x10(%rbp), %rcx
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
jne 0xb88d
movl $0x1, -0x4(%rbp)
jmp 0xb894
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/src/token.c
// Function: token_set_string
int token_set_string(Token * token, String const * string)
{
#ifdef DEBUG
	fprintf(stderr, "DEBUG: %s(%p, \"%s\")\n", __func__, token, string);
#endif
	string_delete(token->string);
	if((token->string = string_new(string)) == NULL)
		return 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4260
movq -0x18(%rbp), %rdi
callq 0x41f0
movq -0x10(%rbp), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
jne 0xb8fd
movl $0x1, -0x4(%rbp)
jmp 0xb904
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/src/token.c
// Function: token_in_set
int token_in_set(Token * token, TokenSet set)
{
	TokenCode * code;

	for(code = set; *code != TC_NULL; code++)
		if(token->code == *code)
			return 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xb954
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jne 0xb944
movl $0x1, -0x4(%rbp)
jmp 0xb95b
jmp 0xb946
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
jmp 0xb924
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/src/variable.c
// Function: variable_newv
Variable * variable_newv(VariableType type, va_list ap)
{
	Variable * variable;

	if((variable = (Variable *)object_new(sizeof(*variable))) == NULL)
		return NULL;
	variable->type = VT_NULL;
	if(variable_set_typev(variable, type, ap) != 0)
	{
		object_delete(variable);
		return NULL;
	}
	return variable;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x20, %edi
callq 0x4640
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xba2d
movq $0x0, -0x8(%rbp)
jmp 0xba67
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x4120
cmpl $0x0, %eax
je 0xba5f
movq -0x20(%rbp), %rdi
callq 0x44a0
movq $0x0, -0x8(%rbp)
jmp 0xba67
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/src/variable.c
// Function: variable_new_arrayv
Variable * variable_new_arrayv(VariableType type, size_t size, va_list ap)
{
	Variable * variable;
	size_t i;
	void * p;

	if((variable = variable_new(VT_ARRAY, type, size)) == NULL)
		return NULL;
	for(i = 0; i < size; i++)
	{
		p = va_arg(ap, void *);
		if(array_set(variable->u.array.array, i, p) != 0)
		{
			variable_delete(variable);
			return NULL;
		}
	}
	return variable;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl $0xe, %edi
movb $0x0, %al
callq 0x46e0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0xc43d
movq $0x0, -0x8(%rbp)
jmp 0xc4e8
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xc4e0
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
cmpl $0x28, %eax
ja 0xc47e
movq -0x48(%rbp), %rcx
movl -0x3c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x50(%rbp)
jmp 0xc495
movq -0x48(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x4540
cmpl $0x0, %eax
je 0xc4cd
movq -0x28(%rbp), %rdi
callq 0x4330
movq $0x0, -0x8(%rbp)
jmp 0xc4e8
jmp 0xc4cf
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xc445
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/src/variable.c
// Function: variable_delete
void variable_delete(Variable * variable)
{
	if(variable == NULL)
		return;
	_variable_destroy(variable);
	object_delete(variable);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xc515
jmp 0xc527
movq -0x8(%rbp), %rdi
callq 0xd1a0
movq -0x8(%rbp), %rdi
callq 0x44a0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/src/variable.c
// Function: variable_new_compoundv
Variable * variable_new_compoundv(String const * name, va_list ap)
{
	Variable * variable;
	VariableType type;
	Mutator * m;
	Variable * v;

	if((variable = variable_new(VT_COMPOUND, name)) == NULL)
		return NULL;
	m = variable->u.compound.members;
	for(;;)
	{
		type = (VariableType)va_arg(ap, unsigned int);
		if(type == VT_NULL)
			return variable;
		name = va_arg(ap, String const *);
		if(name == NULL)
			break;
		if((v = (Variable *)mutator_get(m, name)) != NULL)
			variable_delete(v);
		if((v = variable_newv(type, ap)) == NULL
				|| mutator_set(m, name, v) != 0)
		{
			variable_delete(v);
			break;
		}
	}
	variable_delete(variable);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movl $0xf, %edi
movb $0x0, %al
callq 0x46e0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xc607
movq $0x0, -0x8(%rbp)
jmp 0xc734
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
cmpl $0x28, %eax
ja 0xc63e
movq -0x48(%rbp), %rcx
movl -0x3c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x50(%rbp)
jmp 0xc655
movq -0x48(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0xc671
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xc734
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movl (%rax), %eax
movl %eax, -0x54(%rbp)
cmpl $0x28, %eax
ja 0xc69c
movq -0x60(%rbp), %rcx
movl -0x54(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x68(%rbp)
jmp 0xc6b3
movq -0x60(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xc6c7
jmp 0xc723
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x45b0
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xc6e7
movq -0x38(%rbp), %rdi
callq 0x4330
movl -0x24(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x4370
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xc713
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x44e0
cmpl $0x0, %eax
je 0xc71e
movq -0x38(%rbp), %rdi
callq 0x4330
jmp 0xc723
jmp 0xc613
movq -0x20(%rbp), %rdi
callq 0x4330
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/src/variable.c
// Function: variable_new_compound_variables
Variable * variable_new_compound_variables(String const * name, size_t members,
		String const ** names, Variable const ** variables)
{
	Variable * variable;
	Mutator * m;
	size_t i;
	Variable * v;

	if((variable = variable_new(VT_COMPOUND, name)) == NULL)
		return NULL;
	m = variable->u.compound.members;
	for(i = 0; i < members; i++)
	{
		if(names[i] == NULL)
		{
			error_set_code(-EINVAL, "%s", strerror(EINVAL));
			break;
		}
		if((v = (Variable *)mutator_get(m, names[i])) != NULL)
		{
			mutator_set(m, names[i], NULL);
			variable_delete(v);
		}
		if((v = variable_new_copy(variables[i])) == NULL
				|| mutator_set(m, names[i], v) != 0)
			break;
	}
	if(i != members)
	{
		variable_delete(variable);
		return NULL;
	}
	return variable;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rsi
movl $0xf, %edi
movb $0x0, %al
callq 0x46e0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0xc77f
movq $0x0, -0x8(%rbp)
jmp 0xc889
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xc864
movq -0x20(%rbp), %rax
movq -0x40(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0xc7d5
movl $0x16, %edi
callq 0x4840
movq %rax, %rdx
movl $0xffffffea, %edi       # imm = 0xFFFFFFEA
leaq 0x3895(%rip), %rsi      # 0x1005e
movb $0x0, %al
callq 0x4630
jmp 0xc864
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x45b0
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0xc816
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x44e0
movq -0x48(%rbp), %rdi
callq 0x4330
movq -0x28(%rbp), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x4090
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0xc84f
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x48(%rbp), %rdx
callq 0x44e0
cmpl $0x0, %eax
je 0xc851
jmp 0xc864
jmp 0xc853
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0xc793
movq -0x40(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0xc881
movq -0x30(%rbp), %rdi
callq 0x4330
movq $0x0, -0x8(%rbp)
jmp 0xc889
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/src/variable.c
// Function: new_copy_array
static Variable * _new_copy_array(Variable const * from)
{
	Variable * variable;
	size_t size;

	size = array_get_size(from->u.array.array);
	if((variable = variable_new_array(from->u.array.type, size)) == NULL)
		return NULL;
	if(array_copy(variable->u.array.array, from->u.array.array) != 0)
	{
		variable_delete(variable);
		return NULL;
	}
	return variable;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x4340
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edi
movq -0x20(%rbp), %rsi
movb $0x0, %al
callq 0x46c0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0xcb33
movq $0x0, -0x8(%rbp)
jmp 0xcb68
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x4360
cmpl $0x0, %eax
je 0xcb60
movq -0x18(%rbp), %rdi
callq 0x4330
movq $0x0, -0x8(%rbp)
jmp 0xcb68
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/src/variable.c
// Function: new_copy_compound
static Variable * _new_copy_compound(Variable const * from)
{
	Variable * variable;
	Mutator * m;

	if((variable = variable_new_compound(from->u.compound.name, VT_NULL))
			== NULL)
		return NULL;
	m = variable->u.compound.members;
	mutator_foreach(from->u.compound.members, _new_copy_compound_foreach,
			&m);
	if(m == NULL)
	{
		variable_delete(variable);
		return NULL;
	}
	return variable;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x4670
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0xcbb1
movq $0x0, -0x8(%rbp)
jmp 0xcbf7
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
leaq 0x1f44(%rip), %rsi      # 0xeb10
leaq -0x20(%rbp), %rdx
callq 0x43a0
cmpq $0x0, -0x20(%rbp)
jne 0xcbef
movq -0x18(%rbp), %rdi
callq 0x4330
movq $0x0, -0x8(%rbp)
jmp 0xcbf7
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/src/variable.c
// Function: variable_new_deserialize
Variable * variable_new_deserialize(size_t * size, char const * data)
{
	Variable * variable;
	uint8_t u8;
	VariableType type;
	size_t s;

	/* check the arguments */
	if(size == NULL || *size < sizeof(u8) || data == NULL)
	{
		error_set_code(-EINVAL, "%s", strerror(EINVAL));
		return NULL;
	}
	/* obtain the type from the data */
	u8 = data[0];
	type = (VariableType)u8;
	s = *size - sizeof(u8);
	/* deserialize according to the type */
	variable = variable_new_deserialize_type(type, &s, &data[sizeof(u8)]);
	*size = s + sizeof(u8);
	return variable;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xcc38
movq -0x10(%rbp), %rax
cmpq $0x1, (%rax)
jb 0xcc38
cmpq $0x0, -0x18(%rbp)
jne 0xcc62
movl $0x16, %edi
callq 0x4840
movq %rax, %rdx
movl $0xffffffea, %edi       # imm = 0xFFFFFFEA
leaq 0x340d(%rip), %rsi      # 0x1005e
movb $0x0, %al
callq 0x4630
movq $0x0, -0x8(%rbp)
jmp 0xccb0
movq -0x18(%rbp), %rax
movb (%rax), %al
movb %al, -0x21(%rbp)
movzbl -0x21(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
subq $0x1, %rax
movq %rax, -0x30(%rbp)
movl -0x28(%rbp), %edi
movq -0x18(%rbp), %rdx
addq $0x1, %rdx
leaq -0x30(%rbp), %rsi
callq 0x40e0
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rcx
addq $0x1, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/src/variable.c
// Function: variable_destroy
static void _variable_destroy(Variable * variable)
{
	switch(variable->type)
	{
		case VT_NULL:
		case VT_BOOL:
		case VT_INT8:
		case VT_UINT8:
		case VT_INT16:
		case VT_UINT16:
		case VT_INT32:
		case VT_UINT32:
		case VT_INT64:
		case VT_UINT64:
		case VT_FLOAT:
		case VT_DOUBLE:
		case VT_POINTER:
			break;
		case VT_BUFFER:
			buffer_delete(variable->u.buffer);
			break;
		case VT_STRING:
			string_delete(variable->u.string);
			break;
		case VT_ARRAY:
			array_delete(variable->u.array.array);
			break;
		case VT_COMPOUND:
			_variable_destroy_compound(variable);
			break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x10(%rbp)
subq $0x10, %rax
ja 0xd208
movq -0x10(%rbp), %rax
leaq 0x30b9(%rip), %rcx      # 0x10280
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0xd208
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4690
jmp 0xd208
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4260
jmp 0xd208
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x44c0
jmp 0xd208
movq -0x8(%rbp), %rdi
callq 0xf150
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/src/variable.c
// Function: variable_get_pointer
void const * variable_get_pointer(Variable const * variable)
{
	switch(variable->type)
	{
		case VT_NULL:
			return NULL;
		case VT_BOOL:
			return &variable->u.b;
		case VT_INT8:
			return &variable->u.int8;
		case VT_UINT8:
			return &variable->u.uint8;
		case VT_INT16:
			return &variable->u.int16;
		case VT_UINT16:
			return &variable->u.uint16;
		case VT_INT32:
			return &variable->u.int32;
		case VT_UINT32:
			return &variable->u.uint32;
		case VT_INT64:
			return &variable->u.int64;
		case VT_UINT64:
			return &variable->u.uint64;
		case VT_FLOAT:
			return &variable->u.f;
		case VT_DOUBLE:
			return &variable->u.d;
		case VT_BUFFER:
			return variable->u.buffer;
		case VT_STRING:
			/* XXX because of String operations */
			return &variable->u.string;
		case VT_ARRAY:
			return variable->u.array.array;
		case VT_COMPOUND:
			return NULL;
		case VT_POINTER:
			return &variable->u.pointer;
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x18(%rbp)
subq $0x10, %rax
ja 0xde3e
movq -0x18(%rbp), %rax
leaq 0x2615(%rip), %rcx      # 0x1034c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq $0x0, -0x8(%rbp)
jmp 0xde46
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0xde46
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0xde46
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0xde46
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0xde46
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0xde46
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0xde46
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0xde46
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0xde46
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0xde46
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0xde46
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0xde46
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xde46
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0xde46
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xde46
movq $0x0, -0x8(%rbp)
jmp 0xde46
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0xde46
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/src/variable.c
// Function: get_as_pointer
static int _get_as_pointer(size_t * size)
{
	size_t sz;

	sz = _variable_sizes[VT_POINTER];
	if(size != NULL)
	{
		if(sz > *size)
			return error_set_code(-ENOSPC, "%s", strerror(ENOSPC));
		*size = sz;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0x267d(%rip), %rax      # 0x104e0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xdeab
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jbe 0xdea0
movl $0x1c, %edi
callq 0x4840
movq %rax, %rdx
movl $0xffffffe4, %edi       # imm = 0xFFFFFFE4
leaq 0x21ca(%rip), %rsi      # 0x1005e
movb $0x0, %al
callq 0x4630
movl %eax, -0x4(%rbp)
jmp 0xdeb2
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/src/variable.c
// Function: get_as_compound
static VariableError _get_as_compound(Variable const * variable, void * result,
		size_t * size)
{
	VariableCompoundCallbackData data;

	if(size == NULL)
		return error_set_code(-EINVAL, "%s", strerror(EINVAL));
	data.size = size;
	data.pos = 0;
	data.result = result;
	data.ret = 0;
	/* XXX there is no warranty on the right order */
	mutator_foreach(variable->u.compound.members,
			_get_as_compound_callback, &data);
	return data.ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xdf00
movl $0x16, %edi
callq 0x4840
movq %rax, %rdx
movl $0xffffffea, %edi       # imm = 0xFFFFFFEA
leaq 0x216a(%rip), %rsi      # 0x1005e
movb $0x0, %al
callq 0x4630
movl %eax, -0x4(%rbp)
jmp 0xdf3d
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
leaq 0xca2(%rip), %rsi       # 0xebd0
leaq -0x40(%rbp), %rdx
callq 0x43a0
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/src/variable.c
// Function: variable_is_class
bool variable_is_class(Variable const * variable, VariableClass _class)
{
	if(!variable_is_type(variable, VT_COMPOUND)
			|| variable->u.compound.name == NULL)
		return false;
	return (variable->u.compound._class == _class) ? true : false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl $0xf, %esi
callq 0x47c0
testb $0x1, %al
jne 0xdff3
jmp 0xdffe
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xe004
movb $0x0, -0x1(%rbp)
jmp 0xe025
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edx
movl -0x14(%rbp), %esi
xorl %eax, %eax
movl $0x1, %ecx
cmpl %esi, %edx
cmovel %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/src/variable.c
// Function: variable_is_instance
bool variable_is_instance(Variable const * variable, String const * name)
{
	if(!variable_is_type(variable, VT_COMPOUND)
			|| variable->u.compound.name == NULL)
		return false;
	return (string_compare(variable->u.compound.name, name) == 0)
		? true : false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0xf, %esi
callq 0x47c0
testb $0x1, %al
jne 0xe0b4
jmp 0xe0bf
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xe0c5
movb $0x0, -0x1(%rbp)
jmp 0xe0f0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x4230
movl %eax, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/src/variable.c
// Function: variable_is_scalar
bool variable_is_scalar(Variable const * variable)
{
	VariableType type;

	type = variable_get_type(variable);
	if(type >= VT_BOOL && type <= VT_DOUBLE)
		return true;
	if(type == VT_STRING || type == VT_POINTER)
		return true;
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4820
movl %eax, -0x14(%rbp)
cmpl $0x1, -0x14(%rbp)
jb 0xe12a
cmpl $0xb, -0x14(%rbp)
ja 0xe12a
movb $0x1, -0x1(%rbp)
jmp 0xe140
cmpl $0xd, -0x14(%rbp)
je 0xe136
cmpl $0x10, -0x14(%rbp)
jne 0xe13c
movb $0x1, -0x1(%rbp)
jmp 0xe140
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/src/variable.c
// Function: copy_compound
static VariableError _copy_compound(Variable * variable, Variable const * from)
{
	String * s;
	Mutator * m;
	Mutator * n;

	if(from->u.compound.name == NULL)
		s = NULL;
	else if((s = string_new(from->u.compound.name)) == NULL)
		return -1;
	if((n = m = mutator_new()) == NULL)
	{
		string_delete(s);
		return -1;
	}
	mutator_foreach(from->u.compound.members, _copy_compound_foreach, &n);
	if(n == NULL)
	{
		_variable_destroy_compound_members(m);
		string_delete(s);
		return -1;
	}
	_variable_destroy(variable);
	variable->u.compound.name = s;
	variable->u.compound.members = m;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xe465
movq $0x0, -0x20(%rbp)
jmp 0xe48a
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x41f0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xe488
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe511
jmp 0xe48a
callq 0x4390
movq %rax, -0x28(%rbp)
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0xe4af
movq -0x20(%rbp), %rdi
callq 0x4260
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe511
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
leaq 0xba2(%rip), %rsi       # 0xf060
leaq -0x30(%rbp), %rdx
callq 0x43a0
cmpq $0x0, -0x30(%rbp)
jne 0xe4e9
movq -0x28(%rbp), %rdi
callq 0xf0f0
movq -0x20(%rbp), %rdi
callq 0x4260
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe511
movq -0x10(%rbp), %rdi
callq 0xd1a0
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/src/variable.c
// Function: bswap64
static uint64_t _bswap64(uint64_t u)
{
	return ((u & 0xff) << 56) | ((u & 0xff00) << 40)
		| ((u & 0xff0000) << 24) | ((u & 0xff000000) << 8)
		| ((u & 0xff00000000) >> 8) | ((u & 0xff0000000000) >> 24)
		| ((u & 0xff000000000000) >> 40)
		| ((u & 0xff00000000000000) >> 56);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
andq $0xff, %rax
shlq $0x38, %rax
movq -0x8(%rbp), %rcx
andq $0xff00, %rcx           # imm = 0xFF00
shlq $0x28, %rcx
orq %rcx, %rax
movq -0x8(%rbp), %rcx
andq $0xff0000, %rcx         # imm = 0xFF0000
shlq $0x18, %rcx
orq %rcx, %rax
movabsq $0xff000000, %rcx       # imm = 0xFF000000
andq -0x8(%rbp), %rcx
shlq $0x8, %rcx
orq %rcx, %rax
movabsq $0xff00000000, %rcx     # imm = 0xFF00000000
andq -0x8(%rbp), %rcx
shrq $0x8, %rcx
orq %rcx, %rax
movabsq $0xff0000000000, %rcx   # imm = 0xFF0000000000
andq -0x8(%rbp), %rcx
shrq $0x18, %rcx
orq %rcx, %rax
movabsq $0xff000000000000, %rcx # imm = 0xFF000000000000
andq -0x8(%rbp), %rcx
shrq $0x28, %rcx
orq %rcx, %rax
movabsq $-0x100000000000000, %rcx # imm = 0xFF00000000000000
andq -0x8(%rbp), %rcx
shrq $0x38, %rcx
orq %rcx, %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/src/variable.c
// Function: new_copy_compound_foreach
static void _new_copy_compound_foreach(Mutator const * mutator,
		String const * key, void * value, void * data)
{
	Mutator ** m = (Mutator **)data;
	Variable const * from = (Variable const *)value;
	Variable * v;
	(void) mutator;

	if(*m == NULL)
		return;
	if((v = (Variable *)mutator_get(*m, key)) != NULL)
	{
		mutator_set(*m, key, NULL);
		variable_delete(v);
	}
	if((v = variable_new_copy(from)) == NULL
			|| mutator_set(*m, key, v) != 0)
	{
		variable_delete(v);
		*m = NULL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xeb44
jmp 0xebbb
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x45b0
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xeb7b
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x44e0
movq -0x38(%rbp), %rdi
callq 0x4330
movq -0x30(%rbp), %rdi
callq 0x4090
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xeba7
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x44e0
cmpl $0x0, %eax
je 0xebbb
movq -0x38(%rbp), %rdi
callq 0x4330
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)