LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/kisom[P]kam/queue.c
// Function: enqueue8
void
enqueue8(queue8 q, uint8_t val)
{
	struct node8	*node;

	node = malloc(sizeof(struct node8));

	/* memory problems can only lead to more memory problems. */
	if (NULL == node)
		abort();

	node->val = val;

	/*
	 * If queue is empty, head will be NULL and tail will be NULL.
	 * In this case, we assign both to node.
	 */
	if (NULL == q->head) {
		if (NULL != q->tail) {
			abort();
		}
		q->head = node;
		q->tail = node;
		node->next = NULL;
	} else {
		node->next = NULL;
		q->tail->next = node;
		q->tail = node;
	}
	q->nodes++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl $0x10, %edi
callq 0x1080
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jne 0x121d
callq 0x1040
movb -0x9(%rbp), %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
jne 0x1267
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq 0x8(%rcx), %rax
je 0x1242
callq 0x1040
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
jmp 0x128f
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kisom[P]kam/queue.c
// Function: dequeue8
uint8_t
dequeue8(queue8 q)
{
	struct node8	*node;
	uint8_t	val;

	if (NULL == q->head)
		abort();

	node = q->head;
	val = node->val;

	q->head = node->next;
	free(node);
	q->nodes--;
	if (0 == q->nodes)
		q->tail = NULL;
	return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
jne 0x12cc
callq 0x1040
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb (%rax), %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq 0x10(%rcx), %rax
jne 0x1320
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movb -0x11(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/kisom[P]kam/qtest.c
// Function: test_queue8
static void
test_queue8(void)
{
	uint8_t val;
	queue8	st;

	st = new_queue8();
	if (st == NULL) {
		errx(EX_OSERR, "FAILED: malloc failure");
	}

	enqueue8(st, 1);
	enqueue8(st, 2);
	if (1 != (val = dequeue8(st))) {
		fprintf(stderr,
		    "FAILED: should have received 2 from the queue.\n");
		fprintf(stderr,
		    "        (received %d)\n", val);
		exit(EXIT_FAILURE);
	}

	enqueue8(st, 3);
	if (2 != (val = dequeue8(st))) {
		fprintf(stderr,
		    "FAILED: should have received 3 from the queue.\n");
		fprintf(stderr,
		    "        (received %d)\n", val);
		exit(EXIT_FAILURE);
	}
	if (3 != (val = dequeue8(st)))
		errx(EX_SOFTWARE,
		    "FAILED: should have received 1 from the queue.");
	if (!empty_queue8(st))
		errx(EX_SOFTWARE,
		    "FAILED: queue should report empty.");
	enqueue8(st, 5);
	enqueue8(st, 5);
	destroy_queue8(st);
	printf("queue8: OK\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x11a0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x16db
movl $0x47, %edi
leaq 0x930(%rip), %rsi       # 0x2004
movb $0x0, %al
callq 0x1050
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x11f0
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x11f0
movq -0x10(%rbp), %rdi
callq 0x12b0
movb %al, -0x1(%rbp)
movzbl %al, %ecx
movl $0x1, %eax
cmpl %ecx, %eax
je 0x174d
movq 0x28e2(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x8fb(%rip), %rsi       # 0x201b
movb $0x0, %al
callq 0x1070
movq 0x28ca(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movzbl -0x1(%rbp), %edx
leaq 0x90f(%rip), %rsi       # 0x204b
movb $0x0, %al
callq 0x1070
movl $0x1, %edi
callq 0x1090
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0x11f0
movq -0x10(%rbp), %rdi
callq 0x12b0
movb %al, -0x1(%rbp)
movzbl %al, %ecx
movl $0x2, %eax
cmpl %ecx, %eax
je 0x17b1
movq 0x287e(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x8de(%rip), %rsi       # 0x2062
movb $0x0, %al
callq 0x1070
movq 0x2866(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movzbl -0x1(%rbp), %edx
leaq 0x8ab(%rip), %rsi       # 0x204b
movb $0x0, %al
callq 0x1070
movl $0x1, %edi
callq 0x1090
movq -0x10(%rbp), %rdi
callq 0x12b0
movb %al, -0x1(%rbp)
movzbl %al, %ecx
movl $0x3, %eax
cmpl %ecx, %eax
je 0x17dc
movl $0x46, %edi
leaq 0x8bd(%rip), %rsi       # 0x2092
movb $0x0, %al
callq 0x1050
movq -0x10(%rbp), %rdi
callq 0x1330
cmpl $0x0, %eax
jne 0x17fd
movl $0x46, %edi
leaq 0x8cb(%rip), %rsi       # 0x20c1
movb $0x0, %al
callq 0x1050
movq -0x10(%rbp), %rdi
movl $0x5, %esi
callq 0x11f0
movq -0x10(%rbp), %rdi
movl $0x5, %esi
callq 0x11f0
movq -0x10(%rbp), %rdi
callq 0x1350
leaq 0x8bb(%rip), %rdi       # 0x20e4
movb $0x0, %al
callq 0x1060
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/minkcv[P]vm/assembler.c
// Function: countInstructions
int countInstructions(FILE* src)
{
    char* line = NULL;
    size_t toRead = 0; // Read until \n
    ssize_t charsRead;
    uint16_t instrCount = 0;
    while ((charsRead = getline(&line, &toRead, src)) != -1)
    {
        if (line[0] != '\n' && line[0] != '@' && line[0] != ';')
        {
            char* token = strtok(line, " ");
            if (!strcmp(token, "LRL"))
                instrCount++;
            instrCount++;
        }
        free(line);
        line = NULL; // Causes getline to keep reading
    }
    rewind(src);
    return instrCount;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movw $0x0, -0x22(%rbp)
movq -0x8(%rbp), %rdx
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1140
movq %rax, -0x20(%rbp)
cmpq $-0x1, %rax
je 0x2068
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
je 0x2052
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x40, %eax
je 0x2052
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3b, %eax
je 0x2052
movq -0x10(%rbp), %rdi
leaq 0x1068(%rip), %rsi      # 0x3084
callq 0x1120
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
leaq 0x1050(%rip), %rsi      # 0x3080
callq 0x10b0
cmpl $0x0, %eax
jne 0x2046
movw -0x22(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x22(%rbp)
movw -0x22(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x22(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1030
movq $0x0, -0x10(%rbp)
jmp 0x1fd2
movq -0x8(%rbp), %rdi
callq 0x10a0
movzwl -0x22(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/minkcv[P]vm/assembler.c
// Function: getAddressesOfLabel
void getAddressesOfLabel(char* label, LabelAddress* labelMap[MAX_LABELS], uint8_t* segAddr, uint8_t* offsetAddr)
{
    int i;
    for (i = 0; i < MAX_LABELS; i++)
    {
        LabelAddress* current = labelMap[i];
        if (current != NULL && current->label != NULL)
        {
            if (!strcmp(current->label, label))
            {
                *segAddr = current->segAddr;
                *offsetAddr = current->offsetAddr;
                return;
            }
        }
    }
    printf("Error: Label \"%s\" not defined\n", label);
    exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x400, -0x24(%rbp)     # imm = 0x400
jge 0x22ee
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x22e1
movq -0x30(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x22e1
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x10b0
cmpl $0x0, %eax
jne 0x22df
movq -0x30(%rbp), %rax
movb (%rax), %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x30(%rbp), %rax
movb 0x1(%rax), %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
addq $0x30, %rsp
popq %rbp
retq
jmp 0x22e1
jmp 0x22e3
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x227f
movq -0x8(%rbp), %rsi
leaq 0xe59(%rip), %rdi       # 0x3152
movb $0x0, %al
callq 0x1090
movl $0x1, %edi
callq 0x1160
// File: /workspace/github_c_makefile_star2_O0/giometti[P]mastering_UNIX_programming/chapter_08/atexit.c
// Function: main
int main(void)
{
	long atexit_max;
	int ret;

#ifdef ATEXIT_MAX
	atexit_max = ATEXIT_MAX;
#else
	errno = 0;
	atexit_max = sysconf(_SC_ATEXIT_MAX);
	if (atexit_max < 0) {
		if (errno == 0) {
			fprintf(stderr, "_SC_ATEXIT_MAX limit not supported\n");
		} else {
			perror("sysconf");
			return -1;
		}
	}
#endif
	printf("ATEXIT_MAX = %ld\n", atexit_max);

	ret = atexit(func1);
	if (ret) {
		fprintf(stderr, "cannot set atexit func1\n");
		return -1;
	}

	ret = atexit(func2);
	if (ret) {
		fprintf(stderr, "cannot set atexit func2\n");
		return -1;
	}

	printf("press ENTER to continue >");
	getchar();

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
callq 0x1030
movl $0x0, (%rax)
movl $0x57, %edi
callq 0x1080
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jge 0x124d
callq 0x1030
cmpl $0x0, (%rax)
jne 0x1233
movq 0x2dd8(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xdda(%rip), %rsi       # 0x2004
movb $0x0, %al
callq 0x1060
jmp 0x124b
leaq 0xdee(%rip), %rdi       # 0x2028
callq 0x1070
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x12e5
jmp 0x124d
movq -0x10(%rbp), %rsi
leaq 0xdd8(%rip), %rdi       # 0x2030
movb $0x0, %al
callq 0x1040
leaq -0xc6(%rip), %rdi       # 0x11a0
callq 0x12f0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x1295
movq 0x2d7d(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xdbd(%rip), %rsi       # 0x2042
movb $0x0, %al
callq 0x1060
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x12e5
leaq -0xdc(%rip), %rdi       # 0x11c0
callq 0x12f0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x12cb
movq 0x2d47(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xda0(%rip), %rsi       # 0x205b
movb $0x0, %al
callq 0x1060
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x12e5
leaq 0xda2(%rip), %rdi       # 0x2074
movb $0x0, %al
callq 0x1040
callq 0x1050
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/src/array.c
// Function: array_new
Array * array_new(size_t size)
{
	Array * array;

	/* check for overflows */
	if(UINT32_MAX < SIZE_MAX && size > UINT32_MAX)
	{
		error_set_code(-ERANGE, "%s", strerror(ERANGE));
		return NULL;
	}
	if((array = (Array *)object_new(sizeof(*array))) == NULL)
		return NULL;
	array->count = 0;
	array->size = size;
	array->value = NULL;
	return array;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, -0x10(%rbp)
jbe 0x49f1
movl $0x22, %edi
callq 0x4840
movq %rax, %rdx
movl $0xffffffde, %edi       # imm = 0xFFFFFFDE
leaq 0xb67e(%rip), %rsi      # 0x1005e
movb $0x0, %al
callq 0x4630
movq $0x0, -0x8(%rbp)
jmp 0x4a3a
movl $0x10, %edi
callq 0x4640
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x4a0f
movq $0x0, -0x8(%rbp)
jmp 0x4a3a
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
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/array.c
// Function: array_new_copy
Array * array_new_copy(Array const * from)
{
	Array * array;

	if((array = (Array *)object_new(sizeof(*array))) == NULL)
		return NULL;
	array->value = NULL;
	if(array_copy(array, from) != 0)
	{
		array_delete(array);
		return NULL;
	}
	return array;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x10, %edi
callq 0x4640
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x4a7a
movq $0x0, -0x8(%rbp)
jmp 0x4ab3
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4360
cmpl $0x0, %eax
je 0x4aab
movq -0x18(%rbp), %rdi
callq 0x44c0
movq $0x0, -0x8(%rbp)
jmp 0x4ab3
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/src/array.c
// Function: array_copy
ArrayError array_copy(Array * array, Array const * from)
{
	char * p;

	if((p = (char *)realloc(array->value, from->count * from->size)) == NULL
			&& from->count != 0 && from->size != 0)
		return error_set_code(-errno, "%s", strerror(errno));
	array->count = from->count;
	array->size = from->size;
	array->value = p;
	memcpy(array->value, from->value, array->count * array->size);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
imull 0x4(%rcx), %eax
movl %eax, %eax
movl %eax, %esi
callq 0x4620
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x4b40
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4b40
movq -0x18(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x4b40
callq 0x40d0
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl %eax, -0x24(%rbp)
callq 0x40d0
movl (%rax), %edi
callq 0x4840
movl -0x24(%rbp), %edi
movq %rax, %rdx
leaq 0xb52a(%rip), %rsi      # 0x1005e
movb $0x0, %al
callq 0x4630
movl %eax, -0x4(%rbp)
jmp 0x4b94
movq -0x18(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
imull 0x4(%rcx), %eax
movl %eax, %eax
movl %eax, %edx
callq 0x44b0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/src/array.c
// Function: array_new_filter
Array * array_new_filter(Array const * from, ArrayFilter func, UserData * data)
{
	Array * array;
	size_t i;
	char * value;

	if((array = array_new(from->size)) == NULL)
		return NULL;
	for(i = 0; i < from->count; i++)
	{
		value = from->value + (from->size * i);
		if(func(value, data) == true)
			if(array_append(array, value) != 0)
			{
				array_delete(array);
				return NULL;
			}
	}
	return array;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, %edi
callq 0x4600
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x4c09
movq $0x0, -0x8(%rbp)
jmp 0x4c92
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
cmpq %rcx, %rax
jae 0x4c8a
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
imulq -0x30(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq *%rax
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x4c7a
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x4290
cmpl $0x0, %eax
je 0x4c78
movq -0x28(%rbp), %rdi
callq 0x44c0
movq $0x0, -0x8(%rbp)
jmp 0x4c92
jmp 0x4c7a
jmp 0x4c7c
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x4c11
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/src/array.c
// Function: array_append
ArrayError array_append(Array * array, ArrayData * value)
{
	char * p;
	uint64_t offset = array->size * array->count;

	/* check for overflows */
	if(UINT64_MAX - offset < array->size
			|| offset + array->size > SIZE_MAX)
		return error_set_code(-ERANGE, "%s", strerror(ERANGE));
	if((p = (char *)realloc(array->value, offset + array->size)) == NULL)
		return error_set_code(-errno, "%s", strerror(errno));
	array->value = p;
	memcpy(&p[offset], value, array->size);
	array->count++;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
imull (%rcx), %eax
movl %eax, %eax
movq %rax, -0x28(%rbp)
movq $-0x1, %rax
subq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
cmpq %rcx, %rax
jb 0x4cef
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
addq %rcx, %rax
cmpq $-0x1, %rax
jbe 0x4d17
movl $0x22, %edi
callq 0x4840
movq %rax, %rdx
movl $0xffffffde, %edi       # imm = 0xFFFFFFDE
leaq 0xb356(%rip), %rsi      # 0x1005e
movb $0x0, %al
callq 0x4630
movl %eax, -0x4(%rbp)
jmp 0x4da8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
addq %rax, %rsi
callq 0x4620
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x4d70
callq 0x40d0
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl %eax, -0x2c(%rbp)
callq 0x40d0
movl (%rax), %edi
callq 0x4840
movl -0x2c(%rbp), %edi
movq %rax, %rdx
leaq 0xb2fa(%rip), %rsi      # 0x1005e
movb $0x0, %al
callq 0x4630
movl %eax, -0x4(%rbp)
jmp 0x4da8
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rdi
addq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, %edx
callq 0x44b0
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/src/array.c
// Function: array_new_filter_swap
Array * array_new_filter_swap(Array const * from, ArrayFilterSwap func,
		UserData * data)
{
	Array * array;
	size_t i;
	char * value;

	if((array = array_new(from->size)) == NULL)
		return NULL;
	for(i = 0; i < from->count; i++)
	{
		value = from->value + (from->size * i);
		if(func(data, value) == true)
			if(array_append(array, value) != 0)
			{
				array_delete(array);
				return NULL;
			}
	}
	return array;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, %edi
callq 0x4600
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x4df9
movq $0x0, -0x8(%rbp)
jmp 0x4e82
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
cmpq %rcx, %rax
jae 0x4e7a
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
imulq -0x30(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq *%rax
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x4e6a
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x4290
cmpl $0x0, %eax
je 0x4e68
movq -0x28(%rbp), %rdi
callq 0x44c0
movq $0x0, -0x8(%rbp)
jmp 0x4e82
jmp 0x4e6a
jmp 0x4e6c
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x4e01
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/src/array.c
// Function: array_get
void * array_get(Array const * array, size_t pos)
{
	uint64_t offset;

	if(pos >= array->count)
		return NULL;
	offset = pos * array->size;
	return &array->value[offset];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
cmpq %rcx, %rax
jb 0x4ec5
movq $0x0, -0x8(%rbp)
jmp 0x4ee8
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
imulq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/src/array.c
// Function: array_get_copy
ArrayError array_get_copy(Array const * array, size_t pos, ArrayData * value)
{
	uint64_t offset;

	if(pos >= array->count)
		return error_set_code(-ERANGE, "%s", strerror(ERANGE));
	offset = pos * array->size;
	memcpy(value, &array->value[offset], array->size);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
cmpq %rcx, %rax
jb 0x4f38
movl $0x22, %edi
callq 0x4840
movq %rax, %rdx
movl $0xffffffde, %edi       # imm = 0xFFFFFFDE
leaq 0xb132(%rip), %rsi      # 0x1005e
movb $0x0, %al
callq 0x4630
movl %eax, -0x4(%rbp)
jmp 0x4f70
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
imulq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
addq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, %edx
callq 0x44b0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/src/array.c
// Function: array_set
ArrayError array_set(Array * array, size_t pos, ArrayData * value)
{
	uint32_t p = pos + 1;
	uint64_t offset;
	uint64_t curpos;
	void * q;

	/* check for overflows */
	if(pos >= UINT32_MAX)
		return error_set_code(-ERANGE, "%s", strerror(ERANGE));
	offset = pos * array->size;
	if(array->count < p)
	{
		/* grow the array */
		if(UINT64_MAX - offset < array->size
				|| offset + array->size > SIZE_MAX)
			return error_set_code(-ERANGE, "%s", strerror(ERANGE));
		if((q = realloc(array->value, offset + array->size)) == NULL)
			return error_set_code(-errno, "%s", strerror(errno));
		array->value = (char *)q;
		curpos = array->count * array->size;
		memset(&array->value[curpos], 0, offset - curpos);
		array->count = pos + 1;
	}
	/* set the value */
	memcpy(&array->value[offset], value, array->size);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movl %eax, -0x24(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, -0x18(%rbp)
jb 0x4ff2
movl $0x22, %edi
callq 0x4840
movq %rax, %rdx
movl $0xffffffde, %edi       # imm = 0xFFFFFFDE
leaq 0xb07b(%rip), %rsi      # 0x1005e
movb $0x0, %al
callq 0x4630
movl %eax, -0x4(%rbp)
jmp 0x5130
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
imulq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
cmpl -0x24(%rbp), %eax
jae 0x510b
movq $-0x1, %rax
subq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
cmpq %rcx, %rax
jb 0x503f
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
addq %rcx, %rax
cmpq $-0x1, %rax
jbe 0x5067
movl $0x22, %edi
callq 0x4840
movq %rax, %rdx
movl $0xffffffde, %edi       # imm = 0xFFFFFFDE
leaq 0xb006(%rip), %rsi      # 0x1005e
movb $0x0, %al
callq 0x4630
movl %eax, -0x4(%rbp)
jmp 0x5130
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
addq %rax, %rsi
callq 0x4620
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
jne 0x50c0
callq 0x40d0
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl %eax, -0x44(%rbp)
callq 0x40d0
movl (%rax), %edi
callq 0x4840
movl -0x44(%rbp), %edi
movq %rax, %rdx
leaq 0xafaa(%rip), %rsi      # 0x1005e
movb $0x0, %al
callq 0x4630
movl %eax, -0x4(%rbp)
jmp 0x5130
movq -0x40(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
imull 0x4(%rcx), %eax
movl %eax, %eax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
addq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rdx
subq -0x38(%rbp), %rdx
xorl %esi, %esi
callq 0x4320
movq -0x18(%rbp), %rax
addq $0x1, %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
addq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, %edx
callq 0x44b0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/src/array.c
// Function: array_insert
ArrayError array_insert(Array * array, size_t pos, ArrayData * value)
{
	char * p;
	uint64_t offset = array->size * pos;
	uint64_t size = array->size * (array->count + 1);

	/* check for errors */
	if(pos > array->count)
		return error_set_code(-ERANGE, "%s", strerror(ERANGE));
	/* check for overflows */
	if(UINT64_MAX - offset < array->size
			|| offset + array->size > SIZE_MAX)
		return error_set_code(-ERANGE, "%s", strerror(ERANGE));
	if((p = (char *)realloc(array->value, size)) == NULL)
		return error_set_code(-errno, "%s", strerror(errno));
	array->value = p;
	memmove(&p[offset + array->size], &p[offset], array->size
			* (array->count - pos));
	memcpy(&p[offset], value, array->size);
	array->count++;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
imulq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
addl $0x1, %ecx
imull %ecx, %eax
movl %eax, %eax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
cmpq %rcx, %rax
jbe 0x51b4
movl $0x22, %edi
callq 0x4840
movq %rax, %rdx
movl $0xffffffde, %edi       # imm = 0xFFFFFFDE
leaq 0xaeb9(%rip), %rsi      # 0x1005e
movb $0x0, %al
callq 0x4630
movl %eax, -0x4(%rbp)
jmp 0x52c7
movq $-0x1, %rax
subq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
cmpq %rcx, %rax
jb 0x51df
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
addq %rcx, %rax
cmpq $-0x1, %rax
jbe 0x5207
movl $0x22, %edi
callq 0x4840
movq %rax, %rdx
movl $0xffffffde, %edi       # imm = 0xFFFFFFDE
leaq 0xae66(%rip), %rsi      # 0x1005e
movb $0x0, %al
callq 0x4630
movl %eax, -0x4(%rbp)
jmp 0x52c7
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x38(%rbp), %rsi
callq 0x4620
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x5256
callq 0x40d0
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl %eax, -0x3c(%rbp)
callq 0x40d0
movl (%rax), %edi
callq 0x4840
movl -0x3c(%rbp), %edi
movq %rax, %rdx
leaq 0xae14(%rip), %rsi      # 0x1005e
movb $0x0, %al
callq 0x4630
movl %eax, -0x4(%rbp)
jmp 0x52c7
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
addq %rcx, %rax
addq %rax, %rdi
movq -0x28(%rbp), %rsi
addq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, %edx
movq -0x10(%rbp), %rax
movl (%rax), %eax
subq -0x18(%rbp), %rax
imulq %rax, %rdx
callq 0x46a0
movq -0x28(%rbp), %rdi
addq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, %edx
callq 0x44b0
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/src/array.c
// Function: array_remove_pos
ArrayError array_remove_pos(Array * array, size_t pos)
{
	void * p;

	if(pos >= array->count)
		return error_set_code(-ERANGE, "%s", strerror(ERANGE));
	array->count--;
	memmove(&array->value[pos * array->size],
			&array->value[(pos + 1) * array->size],
			(array->count - pos) * array->size);
	if((p = realloc(array->value, array->size * array->count)) == NULL
			&& array->count != 0)
		/* XXX ignore the error */
		return 0;
	array->value = (char *)p;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
cmpq %rcx, %rax
jb 0x5347
movl $0x22, %edi
callq 0x4840
movq %rax, %rdx
movl $0xffffffde, %edi       # imm = 0xFFFFFFDE
leaq 0xad26(%rip), %rsi      # 0x1005e
movb $0x0, %al
callq 0x4630
movl %eax, -0x4(%rbp)
jmp 0x53f4
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
imulq %rcx, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
imulq %rcx, %rax
addq %rax, %rsi
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, %edx
subq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
imulq %rax, %rdx
callq 0x46a0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
imull (%rcx), %eax
movl %eax, %eax
movl %eax, %esi
callq 0x4620
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x53e1
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x53e1
movl $0x0, -0x4(%rbp)
jmp 0x53f4
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
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/array.c
// Function: array_filter
void array_filter(Array * array, ArrayFilter func, UserData * data)
{
	uint32_t i;
	uint64_t offset;

	for(i = 0, offset = 0; i < array->count;)
		if(func(array->value + offset, data) == false)
			/* cannot fail */
			array_remove_pos(array, i);
		else
		{
			i++;
			offset += array->size;
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x5478
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdi
addq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x545e
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x4590
jmp 0x5476
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x5423
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/src/array.c
// Function: array_filter_swap
void array_filter_swap(Array * array, ArrayFilterSwap func, UserData * data)
{
	uint32_t i;
	uint64_t offset;

	for(i = 0, offset = 0; i < array->count;)
		if(func(data, array->value + offset) == false)
			/* cannot fail */
			array_remove_pos(array, i);
		else
		{
			i++;
			offset += array->size;
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x54f8
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rsi
addq -0x28(%rbp), %rsi
callq *%rax
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x54de
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x4590
jmp 0x54f6
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x54a3
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/src/buffer.c
// Function: buffer_new
Buffer * buffer_new(size_t size, BufferData const * data)
{
	Buffer * buffer;

	if((buffer = (Buffer *)object_new(sizeof(*buffer))) == NULL)
		return NULL;
	if((buffer->data = (BufferData *)object_new(size)) == NULL && size != 0)
	{
		object_delete(buffer);
		return NULL;
	}
	if(data == NULL)
		memset(buffer->data, 0, size);
	else
		memcpy(buffer->data, data, size);
	buffer->size = size;
	return buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x10, %edi
callq 0x4640
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x560e
movq $0x0, -0x8(%rbp)
jmp 0x5683
movq -0x10(%rbp), %rdi
callq 0x4640
movq -0x20(%rbp), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
jne 0x563f
cmpq $0x0, -0x10(%rbp)
je 0x563f
movq -0x20(%rbp), %rdi
callq 0x44a0
movq $0x0, -0x8(%rbp)
jmp 0x5683
cmpq $0x0, -0x18(%rbp)
jne 0x565b
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rdx
xorl %esi, %esi
callq 0x4320
jmp 0x5670
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x44b0
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/src/buffer.c
// Function: buffer_set
int buffer_set(Buffer * buffer, size_t size, BufferData const * data)
{
	if(buffer_set_size(buffer, size) != 0)
		return -1;
	if(data == NULL)
		memset(buffer->data, 0, size);
	else
		memcpy(buffer->data, data, size);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4110
cmpl $0x0, %eax
je 0x575f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5797
cmpq $0x0, -0x20(%rbp)
jne 0x577b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rdx
xorl %esi, %esi
callq 0x4320
jmp 0x5790
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x44b0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/src/buffer.c
// Function: buffer_set_size
int buffer_set_size(Buffer * buffer, size_t size)
{
	BufferData * p;

	if(size == buffer->size)
		return 0;
	if((p = (BufferData *)realloc(buffer->data, size)) == NULL && size != 0)
		return error_set_code(-errno, "%s", strerror(errno));
	buffer->data = p;
	if(size > buffer->size)
		memset(&buffer->data[buffer->size], 0, size - buffer->size);
	buffer->size = size;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x57c9
movl $0x0, -0x4(%rbp)
jmp 0x586b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x4620
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x581f
cmpq $0x0, -0x18(%rbp)
je 0x581f
callq 0x40d0
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl %eax, -0x24(%rbp)
callq 0x40d0
movl (%rax), %edi
callq 0x4840
movl -0x24(%rbp), %edi
movq %rax, %rdx
leaq 0xa84b(%rip), %rsi      # 0x1005e
movb $0x0, %al
callq 0x4630
movl %eax, -0x4(%rbp)
jmp 0x586b
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jbe 0x5859
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
addq (%rax), %rdi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
subq (%rax), %rdx
xorl %esi, %esi
callq 0x4320
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/src/buffer.c
// Function: buffer_set_data
int buffer_set_data(Buffer * buffer, size_t offset, BufferData const * data,
		size_t size)
{
	size_t s = offset + size;

	if(s < offset && s < size)
		return error_set_code(-ERANGE, "%s", strerror(ERANGE));
	if(offset + size > buffer->size)
		if(buffer_set_size(buffer, offset + size) != 0)
			return -1;
	memcpy(&buffer->data[offset], data, size);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x58dd
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x58dd
movl $0x22, %edi
callq 0x4840
movq %rax, %rdx
movl $0xffffffde, %edi       # imm = 0xFFFFFFDE
leaq 0xa78d(%rip), %rsi      # 0x1005e
movb $0x0, %al
callq 0x4630
movl %eax, -0x4(%rbp)
jmp 0x592f
movq -0x18(%rbp), %rax
addq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jbe 0x590f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq -0x28(%rbp), %rsi
callq 0x4110
cmpl $0x0, %eax
je 0x590d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x592f
jmp 0x590f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
addq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x44b0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/src/config.c
// Function: config_new_copy
Config * config_new_copy(Config const * from)
{
	ConfigError ce;

	if((ce.config = mutator_new()) == NULL)
		return NULL;
	ce.code = 0;
	config_foreach(from, _new_copy_foreach, &ce);
	if(ce.code != 0)
	{
		config_delete(ce.config);
		return NULL;
	}
	return ce.config;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
callq 0x4390
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x5975
movq $0x0, -0x8(%rbp)
jmp 0x59b1
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x79(%rip), %rsi        # 0x5a00
leaq -0x20(%rbp), %rdx
callq 0x4310
cmpl $0x0, -0x18(%rbp)
je 0x59a9
movq -0x20(%rbp), %rdi
callq 0x4400
movq $0x0, -0x8(%rbp)
jmp 0x59b1
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/src/config.c
// Function: new_copy_foreach
static void _new_copy_foreach(Config const * from, String const * section,
		void * priv)
{
	ConfigError * ce = (ConfigError *)priv;

	if(ce->code == 0)
		config_foreach_section(from, section, _new_copy_foreach_section,
				ce);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x5a3e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rcx
leaq 0x13f7(%rip), %rdx      # 0x6e30
callq 0x4140
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/src/config.c
// Function: config_new_load
Config * config_new_load(String const * filename)
{
	Config * config;

	if(filename == NULL)
		return config_new();
	if((config = config_new()) == NULL)
		return NULL;
	if(config_load(config, filename) != 0)
	{
		config_delete(config);
		return NULL;
	}
	return config;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5a9e
callq 0x4830
movq %rax, -0x8(%rbp)
jmp 0x5ae4
callq 0x4830
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x5ab7
movq $0x0, -0x8(%rbp)
jmp 0x5ae4
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x41a0
cmpl $0x0, %eax
je 0x5adc
movq -0x18(%rbp), %rdi
callq 0x4400
movq $0x0, -0x8(%rbp)
jmp 0x5ae4
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/src/config.c
// Function: config_get
String const * config_get(Config const * config, String const * section,
		String const * variable)
{
	Mutator * mutator;
	String const * value;

	if(section == NULL)
		section = "";
	if((mutator = (Mutator *)mutator_get(config, section)) == NULL)
	{
		/* the section does not exist */
		if(section[0] == '\0')
			error_set_code(1, "%s", "No default section");
		else
			error_set_code(1, "%s%s", section, ": No such section");
		return NULL;
	}
	if((value = (String const *)mutator_get(mutator, variable)) == NULL)
	{
		/* the variable is not defined */
		error_set_code(1, "%s%s%s%s%s", variable, ": Not defined in",
				(section[0] == '\0') ? " default" : "",
				" section ",
				(section[0] != '\0') ? section : "");
		return NULL;
	}
	return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5da6
leaq 0xa317(%rip), %rax      # 0x100b9
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x45b0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x5e10
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x5de5
movl $0x1, %edi
leaq 0xa289(%rip), %rsi      # 0x1005e
leaq 0xa224(%rip), %rdx      # 0x10000
movb $0x0, %al
callq 0x4630
jmp 0x5e03
movq -0x18(%rbp), %rdx
movl $0x1, %edi
leaq 0xa236(%rip), %rsi      # 0x1002b
leaq 0xa217(%rip), %rcx      # 0x10013
movb $0x0, %al
callq 0x4630
movq $0x0, -0x8(%rbp)
jmp 0x5eb9
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x45b0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x5eb1
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %edx
leaq 0xa278(%rip), %rax      # 0x100b9
leaq 0xa1f9(%rip), %rcx      # 0x10041
cmpl $0x0, %edx
cmoveq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x5e69
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x5e76
leaq 0xa249(%rip), %rax      # 0x100b9
movq %rax, -0x48(%rbp)
jmp 0x5e76
movq -0x38(%rbp), %r8
movq -0x40(%rbp), %rdx
movq -0x48(%rbp), %rax
movl $0x1, %edi
leaq 0xa197(%rip), %rsi      # 0x10025
leaq 0xa19b(%rip), %rcx      # 0x10030
leaq 0xa1ae(%rip), %r9       # 0x1004a
movq %rax, (%rsp)
movb $0x0, %al
callq 0x4630
movq $0x0, -0x8(%rbp)
jmp 0x5eb9
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/config.c
// Function: config_set
int config_set(Config * config, String const * section, String const * variable,
		String const * value)
{
	Mutator * mutator;
	String * p;
	String * newvalue = NULL;

#ifdef DEBUG
	fprintf(stderr, "DEBUG: %s(\"%s\", \"%s\", \"%s\")\n", __func__,
			section, variable, value);
#endif
	if(section == NULL)
		section = "";
	if(variable == NULL || string_get_length(variable) == 0)
		return error_set_code(-EINVAL, "variable: %s",
				strerror(EINVAL));
	if((mutator = (Mutator *)mutator_get(config, section)) == NULL)
	{
		/* create a new section */
		if((mutator = mutator_new()) == NULL)
			return -1;
		if(mutator_set(config, section, mutator) != 0)
		{
			mutator_delete(mutator);
			return -1;
		}
		p = NULL;
	}
	else if((p = (String *)mutator_get(mutator, variable)) == NULL
			&& value == NULL)
		/* there is nothing to do */
		return 0;
	if(value != NULL && (newvalue = string_new(value)) == NULL)
		return -1;
	if(mutator_set(mutator, variable, newvalue) != 0)
	{
		string_delete(newvalue);
		return -1;
	}
	/* free the former value */
	string_delete(p);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq $0x0, -0x40(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5f02
leaq 0xa1bb(%rip), %rax      # 0x100b9
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5f18
movq -0x20(%rbp), %rdi
callq 0x4350
cmpq $0x0, %rax
jne 0x5f40
movl $0x16, %edi
callq 0x4840
movq %rax, %rdx
movl $0xffffffea, %edi       # imm = 0xFFFFFFEA
leaq 0xa123(%rip), %rsi      # 0x10054
movb $0x0, %al
callq 0x4630
movl %eax, -0x4(%rbp)
jmp 0x602b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x45b0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x5fa7
callq 0x4390
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x5f72
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x602b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x44e0
cmpl $0x0, %eax
je 0x5f9d
movq -0x30(%rbp), %rdi
callq 0x47f0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x602b
movq $0x0, -0x38(%rbp)
jmp 0x5fd0
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x45b0
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0x5fce
cmpq $0x0, -0x28(%rbp)
jne 0x5fce
movl $0x0, -0x4(%rbp)
jmp 0x602b
jmp 0x5fd0
cmpq $0x0, -0x28(%rbp)
je 0x5ff3
movq -0x28(%rbp), %rdi
callq 0x41f0
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
jne 0x5ff3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x602b
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x44e0
cmpl $0x0, %eax
je 0x601b
movq -0x40(%rbp), %rdi
callq 0x4260
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x602b
movq -0x38(%rbp), %rdi
callq 0x4260
movl $0x0, -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/config.c
// Function: config_foreach_section
void config_foreach_section(Config const * config, String const * section,
		ConfigForeachSectionCallback callback, void * priv)
{
	Mutator * mutator;
	ConfigForeachSectionData data;

	if((mutator = (Mutator *)mutator_get(config, section)) == NULL)
		return; /* could not find section */
	data.callback = callback;
	data.section = section;
	data.priv = priv;
	mutator_foreach(mutator, _foreach_section_callback, &data);
}

// 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 -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x45b0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x60b1
jmp 0x60dd
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
leaq 0x1c(%rip), %rsi        # 0x60f0
leaq -0x40(%rbp), %rdx
callq 0x43a0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/src/config.c
// Function: load_section
static String * _load_section(FILE * fp)
{
	int c;
	String * str;
	String buf[2] = "\0";

	if((str = string_new("")) == NULL)
		return NULL;
	while((c = fgetc(fp)) != EOF && c != ']' && _load_isprint(c))
	{
		buf[0] = c;
		if(string_append(&str, buf) != 0)
			break;
	}
	if(c != ']')
	{
		string_delete(str);
		return NULL;
	}
	return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x22(%rbp), %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x4320
leaq 0x9f56(%rip), %rdi      # 0x100b9
callq 0x41f0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x617c
movq $0x0, -0x8(%rbp)
jmp 0x61f8
jmp 0x617e
movq -0x10(%rbp), %rdi
callq 0x4380
movl %eax, %ecx
movl %ecx, -0x14(%rbp)
xorl %eax, %eax
cmpl $-0x1, %ecx
movb %al, -0x23(%rbp)
je 0x61b2
xorl %eax, %eax
cmpl $0x5d, -0x14(%rbp)
movb %al, -0x23(%rbp)
je 0x61b2
movl -0x14(%rbp), %edi
callq 0x6210
cmpl $0x0, %eax
setne %al
movb %al, -0x23(%rbp)
movb -0x23(%rbp), %al
testb $0x1, %al
jne 0x61bb
jmp 0x61d7
movl -0x14(%rbp), %eax
movb %al, -0x22(%rbp)
leaq -0x22(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x43d0
cmpl $0x0, %eax
je 0x61d5
jmp 0x61d7
jmp 0x617e
cmpl $0x5d, -0x14(%rbp)
je 0x61f0
movq -0x20(%rbp), %rdi
callq 0x4260
movq $0x0, -0x8(%rbp)
jmp 0x61f8
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)