LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/../modules/UsingBTree/ADTSet.c
// Function: repair_underflow
static void repair_underflow(BTreeNode node) {
	// Εαν δοθεί κενός ή μη-ελλιπής κόμβος ή η ρίζα, το δέντρο δε χρειάζεται αναδιαμόρφωση.
	if (node == NULL || node->count >= MIN_VALUES || node->parent == NULL)
		return;

	BTreeNode left_sibling  = get_left_sibling(node);
	BTreeNode right_sibling = get_right_sibling(node);

	// Εαν υπάρχει ο δεξιός αδερφός & έχει περισσότερα δεδομένα από τα ελάχιστα δυνατά, κάνε αριστερή περιστροφή.
	if (right_sibling != NULL && right_sibling->count > MIN_VALUES)
		transfer_left(node, right_sibling);
	
	// Εαν υπάρχει ο αριστερός αδερφός & έχει περισσότερα δεδομένα από τα ελάχιστα δυνατά, κάνε δεξιά περιστροφή.
	else if (left_sibling != NULL && left_sibling->count > MIN_VALUES)
		tranfer_right(node, left_sibling);

	// Εαν υπάρχει ο αριστερός αδερφός, συγχώνευσέ τον με τον ελλιπή κόμβο, παίρνοντας μια διαχωριστική τιμή από τον πατέρα.
	else if (left_sibling != NULL) 
		merge(left_sibling, node);

	else // Εαν υπάρχει ο δεξιός αδερφός, συγχώνευσέ τον με τον ελλιπή κόμβο, παίρνοντας μια διαχωριστική τιμή από τον πατέρα.
		merge(node, right_sibling);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x6d67
movq -0x8(%rbp), %rax
cmpl $0x2, (%rax)
jge 0x6d67
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x6d69
jmp 0x6de8
movq -0x8(%rbp), %rdi
callq 0x6df0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6e80
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6da2
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
jle 0x6da2
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6f10
jmp 0x6de8
cmpq $0x0, -0x10(%rbp)
je 0x6dc1
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
jle 0x6dc1
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7060
jmp 0x6de6
cmpq $0x0, -0x10(%rbp)
je 0x6dd7
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x7150
jmp 0x6de4
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7150
jmp 0x6de6
jmp 0x6de8
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/../modules/UsingBTree/ADTSet.c
// Function: get_left_sibling
static BTreeNode get_left_sibling(BTreeNode node) {
	BTreeNode parent = node->parent;
	if (parent != NULL && parent->children[0] != node)
		for (int i = 1; i <= parent->count; i++)
			if (parent->children[i] == node)
				return parent->children[i-1];

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6e65
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x10(%rbp), %rax
je 0x6e65
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jg 0x6e63
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rax
cmpq -0x10(%rbp), %rax
jne 0x6e56
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq 0x10(%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x6e6d
jmp 0x6e58
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6e20
jmp 0x6e65
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/../modules/UsingBTree/ADTSet.c
// Function: get_right_sibling
static BTreeNode get_right_sibling(BTreeNode node) {
	BTreeNode parent = node->parent;
	if (parent != NULL && parent->children[parent->count] != node)
		for (int i = 0; i < parent->count; i++)
			if (parent->children[i] == node)
				return parent->children[i+1];

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6efd
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq 0x10(%rax,%rcx,8), %rax
cmpq -0x10(%rbp), %rax
je 0x6efd
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x6efb
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rax
cmpq -0x10(%rbp), %rax
jne 0x6eee
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq 0x10(%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x6f05
jmp 0x6ef0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6eb8
jmp 0x6efd
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/../modules/UsingBTree/ADTSet.c
// Function: transfer_left
static void transfer_left(BTreeNode node, BTreeNode right) {
	BTreeNode parent = node->parent;

	int sep_index = 0;     // Βρες τη θέση της διαχωριστικής τιμής στον πατέρα.
	while (parent->children[sep_index] != node && ++sep_index)
		;

	// Αντίγραψε τη διαχωριστική τιμή από τον πατέρα στον ελλιπή κόμβο.
	node_add_value(node, parent->set_nodes[sep_index], node->count);

	// Μετακίνησε το μικρότερο στοιχείο του δεξιού αδερφού στον πατέρα, στη θέση της διαχωριστικής τιμής που μετακινήσαμε.
	parent->set_nodes[sep_index] = right->set_nodes[0];
	parent->set_nodes[sep_index]->owner = parent;

	// Μετακίνησε το μεγαλύτερο παιδί του δεξιού αδερφού στον ελλιπή κόμβο
	if (!is_leaf(node))
		node_add_child(node, right->children[0], node->count);

	// Ολίσθησε τα δεδομένα του δεξιού αδερφού μία θέση αριστερά.
	for (int i = 0; i < right->count-1; i++)
		right->set_nodes[i] = right->set_nodes[i+1];

	for (int i = 0; i < right->count; i++)
		right->children[i] = right->children[i+1];

	// Αφαίρεσε το στοιχείο που μετακινήθηκε από τον δεξιό αδερφό στον πατέρα.
	right->count--;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rcx
xorl %eax, %eax
cmpq -0x8(%rbp), %rcx
movb %al, -0x25(%rbp)
je 0x6f5d
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
setne %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0x6f66
jmp 0x6f68
jmp 0x6f33
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq 0x40(%rax,%rcx,8), %rsi
movq -0x8(%rbp), %rax
movl (%rax), %edx
callq 0x72d0
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, 0x40(%rax,%rcx,8)
movq -0x18(%rbp), %rcx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rdx
movq 0x40(%rax,%rdx,8), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
callq 0x6d20
testb $0x1, %al
jne 0x6fd2
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x8(%rbp), %rax
movl (%rax), %edx
callq 0x7350
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x7013
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq 0x40(%rax,%rcx,8), %rdx
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq %rdx, 0x40(%rax,%rcx,8)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x6fd9
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x704f
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq 0x10(%rax,%rcx,8), %rdx
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, 0x10(%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x701a
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/../modules/UsingBTree/ADTSet.c
// Function: tranfer_right
static void tranfer_right(BTreeNode node, BTreeNode left) {
	BTreeNode parent = node->parent;

	int sep_index = 0;     // Βρες τη θέση της διαχωριστικής τιμής στον πατέρα.
	while (parent->children[sep_index+1] != node && ++sep_index)
		;

	// Αντίγραψε τη διαχωριστική τιμή από τον πατέρα στον ελλιπή κόμβο.
	node_add_value(node, parent->set_nodes[sep_index], 0);

	// Μετακίνησε το μεγαλύτερο στοιχείο του αριστερού αδερφού στον πατέρα, στη θέση της διαχωριστικής τιμής που μετακινήσαμε.
	parent->set_nodes[sep_index] = left->set_nodes[left->count-1];
	parent->set_nodes[sep_index]->owner = parent;

	// Μετακίνησε το μεγαλύτερο παιδί του αριστερού αδερφού στον ελλιπή κόμβο.
	if (!is_leaf(node))
		node_add_child(node, left->children[left->count], 0);

	// Αφαίρεσε το στοιχείο που μετακινήθηκε από τον αριστερό αδερφό στον πατέρα.
	left->count--;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq 0x10(%rax,%rcx,8), %rcx
xorl %eax, %eax
cmpq -0x8(%rbp), %rcx
movb %al, -0x1d(%rbp)
je 0x70b2
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
setne %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x70bb
jmp 0x70bd
jmp 0x7083
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq 0x40(%rax,%rcx,8), %rsi
xorl %edx, %edx
callq 0x72d0
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq 0x40(%rax,%rcx,8), %rdx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, 0x40(%rax,%rcx,8)
movq -0x18(%rbp), %rcx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rdx
movq 0x40(%rax,%rdx,8), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
callq 0x6d20
testb $0x1, %al
jne 0x7134
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq (%rcx), %rcx
movq 0x10(%rax,%rcx,8), %rsi
xorl %edx, %edx
callq 0x7350
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/../modules/UsingBTree/ADTSet.c
// Function: node_add_value
static void node_add_value(BTreeNode node, SetNode set_node, int index) {
	set_node->owner = node;

	// Ολίσθησε προς τα δεξιά όλα τα στοιχεία του φύλλου αρχίζοντας από τη θέση όπου θα γίνει η προσθήκη.
	for (int i = node->count-1; i >= index; i--)
		node->set_nodes[i+1] = node->set_nodes[i];
	
	node->set_nodes[index] = set_node;
	node->count++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl (%rax), %eax
subl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jl 0x7329
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq 0x40(%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq %rdx, 0x40(%rax,%rcx,8)
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x72f7
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, 0x40(%rax,%rcx,8)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/../modules/UsingBTree/ADTSet.c
// Function: node_add_child
static void node_add_child(BTreeNode node, BTreeNode child, int index) {
	child->parent = node;

	// Ολίσθησε προς τα δεξιά όλα τα παιδιά του φύλλου αρχίζοντας από τη θέση όπου θα γίνει η προσθήκη.
	for (int i = node->count; i >= index; i--)
		node->children[i+1] = node->children[i];
	
	node->children[index] = child;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jl 0x73a6
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq %rdx, 0x10(%rax,%rcx,8)
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x7374
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, 0x10(%rax,%rcx,8)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/../modules/UsingBTree/ADTSet.c
// Function: is_valid_parent
static bool is_valid_parent(BTreeNode node) {
	if (node == NULL || is_leaf(node))
		return true;

	for (int i = 0; i <= node->count; i++)
		if (node != node->children[i]->parent)
			return false;

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7672
movq -0x10(%rbp), %rdi
callq 0x6d20
testb $0x1, %al
jne 0x7672
jmp 0x7678
movb $0x1, -0x1(%rbp)
jmp 0x76b8
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jg 0x76b4
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movq 0x10(%rcx,%rdx,8), %rcx
cmpq 0x8(%rcx), %rax
je 0x76a7
movb $0x0, -0x1(%rbp)
jmp 0x76b8
jmp 0x76a9
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x767f
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/../modules/UsingBTree/ADTSet.c
// Function: get_height
static int get_height(BTreeNode node, bool *valid) {
	if (node == NULL)
		return 0;

	const int height = 1 + get_height(node->children[0], valid);
	
	for (int i = 1; i <= node->count; i++) {
		if (height != 1 + get_height(node->children[i], valid))
			*valid = false;
	}

	return height;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x76f0
movl $0x0, -0x4(%rbp)
jmp 0x775b
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x76d0
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl $0x1, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jg 0x7755
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
callq 0x76d0
movl %eax, %ecx
movl -0x24(%rbp), %eax
addl $0x1, %ecx
cmpl %ecx, %eax
je 0x7748
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
jmp 0x774a
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x770e
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_8/exercise_8_01/cat.c
// Function: main
int main(int argc, char *argv[])
{
  if (argc == 1)
  {
    copy_file(0, 1);
  }
  else
  {
    for (int file_index = 1; file_index < argc; ++file_index)
    {
      int file_descriptor;
      if ((file_descriptor = open(argv[file_index], O_RDONLY, 0)) == -1)
      {
        error("Error: could not open the file %s.", argv[file_index]);
        exit(EXIT_FAILURE);
      }

      copy_file(file_descriptor, 1);
    }
  }

  exit(EXIT_SUCCESS);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jne 0x11ba
xorl %edi, %edi
movl $0x1, %esi
callq 0x1230
jmp 0x1226
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x1224
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
xorl %edx, %edx
movl %edx, %esi
movb $0x0, %al
callq 0x1060
movl %eax, -0x18(%rbp)
cmpl $-0x1, %eax
jne 0x120c
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0xe09(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1290
movl $0x1, %edi
callq 0x1080
movl -0x18(%rbp), %edi
movl $0x1, %esi
callq 0x1230
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x11c1
jmp 0x1226
xorl %edi, %edi
callq 0x1080
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_8/exercise_8_01/cat.c
// Function: error
void error(char *format, ...)
{
  va_list arg_p;

  va_start(arg_p, format);
  fprintf(stderr, "Error: ");
  vfprintf(stderr, format, arg_p);
  fprintf(stderr, "\n");
  va_end(arg_p);

  exit(EXIT_FAILURE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x12c5
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x2ce1(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xd06(%rip), %rsi       # 0x2027
movb $0x0, %al
callq 0x1050
movq 0x2cc9(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x1070
movq 0x2cb2(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xcdf(%rip), %rsi       # 0x202f
movb $0x0, %al
callq 0x1050
leaq -0x20(%rbp), %rax
movl $0x1, %edi
callq 0x1080
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]rbtree/rbtree.c
// Function: rbtree_insert
int rbtree_insert(rbtree_t *tree, rbnode_t *n)
{

	if (btree_insert(tree, n) != 0)
		return -1;

	n->color = rbnode_red;

	rbtree_insert_fixup(tree, n);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x11d0
cmpl $0x0, %eax
je 0x119b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x11ba
movq -0x18(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x12d0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]rbtree/rbtree.c
// Function: btree_insert
static int btree_insert(rbtree_t *tree, rbnode_t *n)
{
	int cmp;
	rbnode_t *x, *y;

	n->left = n->right = rbnode_nil;

	y = x = tree->root;
	while (!rbnode_is_nil(x)) {
		y = x;
		cmp = tree->keycmp(n->key, x->key);
		if (cmp < 0)
			x = x->left;
		else if (cmp > 0)
			x = x->right;
		else {
			errno = EEXIST;
			return -1;
		}
	}

	n->parent = y;
	if (rbnode_is_nil(y))
		tree->root = n;
	else if (cmp < 0)
		y->left = n;
	else
		y->right = n;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1217
jmp 0x127a
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rdi
movq -0x28(%rbp), %rcx
movq (%rcx), %rsi
callq *%rax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x124e
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x1278
cmpl $0x0, -0x1c(%rbp)
jle 0x1262
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x1276
callq 0x1040
movl $0x11, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x12c3
jmp 0x1278
jmp 0x1207
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
cmpq $0x0, -0x30(%rbp)
jne 0x129a
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x12bc
cmpl $0x0, -0x1c(%rbp)
jge 0x12ae
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x12ba
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x12bc
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]rbtree/rbtree.c
// Function: rbtree_lookup
rbnode_t *rbtree_lookup(rbtree_t *tree, const void *key)
{
	rbnode_t *n = tree->root;
	int cmp;
	while (!rbnode_is_nil(n) && (cmp = tree->keycmp(n->key, key)) != 0) {
		if (cmp > 0)
			n = n->left;
		else
			n = n->right;
	}
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x1d(%rbp)
je 0x1538
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rdi
movq -0x10(%rbp), %rsi
callq *%rax
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
setne %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x1541
jmp 0x1563
cmpl $0x0, -0x1c(%rbp)
jle 0x1555
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1561
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x150b
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]rbtree/rbtree.c
// Function: rbtree_successor
static rbnode_t *rbtree_successor(rbtree_t *tree, rbnode_t *n)
{
	if (!rbnode_is_nil(n->right)) {
		n = n->right;
		while (!rbnode_is_nil(n->left))
			n = n->left;
	}
	else {
		while (!rbnode_is_root(n) && rbnode_is_right(n))
			n = n->parent;
		n = n->parent;
	}
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x17c7
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x17b7
jmp 0x17c5
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x17a3
jmp 0x1812
jmp 0x17c9
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x20(%rcx)
movb %al, -0x11(%rbp)
je 0x17ef
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x18(%rax), %rax
cmpq -0x10(%rbp), %rax
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x17f8
jmp 0x1806
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x17c9
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]rbtree/rbtree.c
// Function: preorder
static int preorder(rbtree_t *tree, rbnode_t *n,
	rbtree_iterate_func_t iteration, void *state)
{
	if (!rbnode_is_nil(n)) {
		int r;
		if ((r = (*iteration)(tree, n, state)) != 0)
			return r;
		if ((r = preorder(tree, n->left, iteration, state)) != 0)
			return r;
		if ((r = preorder(tree, n->right, iteration, state)) != 0)
			return r;
	}
	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)
cmpq $0x0, -0x18(%rbp)
je 0x1c15
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq *%rax
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
je 0x1bc1
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1c1c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x1b80
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
je 0x1bea
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1c1c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x1b80
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
je 0x1c13
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1c1c
jmp 0x1c15
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/GangZhuo[P]rbtree/rbtree.c
// Function: inorder
static int inorder(rbtree_t *tree, rbnode_t *n,
	rbtree_iterate_func_t iteration, void *state)
{
	if (!rbnode_is_nil(n)) {
		int r;
		if ((r = inorder(tree, n->left, iteration, state)) != 0)
			return r;
		if ((r = (*iteration)(tree, n, state)) != 0)
			return r;
		if ((r = inorder(tree, n->right, iteration, state)) != 0)
			return r;
	}
	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)
cmpq $0x0, -0x18(%rbp)
je 0x1d05
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x1c70
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
je 0x1cb8
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1d0c
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq *%rax
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
je 0x1cda
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1d0c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x1c70
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
je 0x1d03
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1d0c
jmp 0x1d05
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/GangZhuo[P]rbtree/rbtree.c
// Function: postorder
static int postorder(rbtree_t *tree, rbnode_t *n,
	rbtree_iterate_func_t iteration, void *state)
{
	if (!rbnode_is_nil(n)) {
		int r;
		if ((r = postorder(tree, n->left, iteration, state)) != 0)
			return r;
		if ((r = postorder(tree, n->right, iteration, state)) != 0)
			return r;
		if ((r = (*iteration)(tree, n, state)) != 0)
			return r;
	}
	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)
cmpq $0x0, -0x18(%rbp)
je 0x1df5
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x1d60
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
je 0x1da8
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1dfc
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x1d60
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
je 0x1dd1
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1dfc
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq *%rax
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
je 0x1df3
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1dfc
jmp 0x1df5
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/GangZhuo[P]rbtree/rbtree.c
// Function: rbtree_foreach_print
int rbtree_foreach_print(rbtree_t *tree,
	rbtree_iterate_func_t iteration, void *state)
{
	if (!rbnode_is_nil(tree->root)) {
		int r;
		if ((r = (*iteration)(tree, tree->root, state)) != 0)
			return r;
		return printorder(tree, tree->root, iteration, state);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1e70
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq (%rcx), %rsi
movq -0x20(%rbp), %rdx
callq *%rax
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0x1e53
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1e77
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x1e80
movl %eax, -0x4(%rbp)
jmp 0x1e77
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]rbtree/rbtree.c
// Function: printorder
static int printorder(rbtree_t *tree, rbnode_t *n,
	rbtree_iterate_func_t iteration, void *state)
{
	int r;
	if (!rbnode_is_nil(n->left)) {
		if ((r = (*iteration)(tree, n->left, state)) != 0)
			return r;
	}
	if (!rbnode_is_nil(n->right)) {
		if ((r = (*iteration)(tree, n->right, state)) != 0)
			return r;
	}
	if (!rbnode_is_nil(n->left)) {
		if ((r = printorder(tree, n->left, iteration, state)) != 0)
			return r;
	}
	if (!rbnode_is_nil(n->right)) {
		if ((r = printorder(tree, n->right, iteration, state)) != 0)
			return r;
	}
	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
cmpq $0x0, 0x10(%rax)
je 0x1ece
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rsi
movq -0x28(%rbp), %rdx
callq *%rax
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
je 0x1ecc
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1f74
jmp 0x1ece
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1f01
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rsi
movq -0x28(%rbp), %rdx
callq *%rax
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
je 0x1eff
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1f74
jmp 0x1f01
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1f37
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x1e80
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
je 0x1f35
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1f74
jmp 0x1f37
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1f6d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x1e80
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
je 0x1f6b
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1f74
jmp 0x1f6d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]rbtree/rbtree.c
// Function: inner_clear
static int inner_clear(rbnode_t *root, rbnode_free_func_t free_func, void *state)
{
    int r;
    if (!rbnode_is_nil(root->left)) {
        if ((r = inner_clear(root->left, free_func, state)) != 0)
            return r;
        root->left = rbnode_nil;
    }
    if (!rbnode_is_nil(root->right)) {
        if ((r = inner_clear(root->right, free_func, state)) != 0)
            return r;
        root->right = rbnode_nil;
    }
    free_func(root, state);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x2020
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1fd0
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0x2014
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2071
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x205c
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1fd0
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0x2050
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2071
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq *%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/GangZhuo[P]rbtree/rbtree.c
// Function: rbtree_left_rotate
static void rbtree_left_rotate(rbtree_t *tree, rbnode_t *x)
{
	rbnode_t *y;

	y = x->right;
	x->right = y->left;

	if (!rbnode_is_nil(y->left))
		y->left->parent = x;

	y->parent = x->parent;

	if (rbnode_is_root(x))
		tree->root = y;
	else if (rbnode_is_left(x))
		x->parent->left = y;
	else
		x->parent->right = y;

	y->left = x;
	x->parent = y;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x20c3
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x20eb
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x2121
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x210f
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x10(%rax)
jmp 0x211f
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x18(%rax)
jmp 0x2121
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]rbtree/rbtree.c
// Function: rbtree_right_rotate
static void rbtree_right_rotate(rbtree_t *tree, rbnode_t *y)
{
	rbnode_t *x;

	x = y->left;
	y->left = x->right;

	if (!rbnode_is_nil(x->right))
		x->right->parent = y;

	x->parent = y->parent;

	if (rbnode_is_root(y))
		tree->root = x;
	else if (rbnode_is_left(y))
		y->parent->left = x;
	else
		y->parent->right = x;

	x->right = y;
	y->parent = x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x2183
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x21ab
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x21e1
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x21cf
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x10(%rax)
jmp 0x21df
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x18(%rax)
jmp 0x21e1
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]rbtree/example/example1.c
// Function: main
int main(int argc, char **argv)
{
	rbtree_t tree = RBTREE_INIT(keycmp);
	int i;
	rbnode_t *n;
	
	/* insert */
	for(i = 0; i < 10; i++) {
		n = malloc(sizeof(rbnode_t));
		n->key = itop(i);
		rbtree_insert(&tree, n);
	}
	
	/* lookup */
	n = rbtree_lookup(&tree, itop(5));
	if (n)
		printf("Find %d.\n", ptoi(n->key));
	else
		printf("5 not exist.\n");
	
	/* delete */
	rbtree_remove(&tree, n);
	
	/* print */
	printf("parent node color   dir\n");
	rbtree_foreach_inorder(&tree, print_node, NULL);
	
	free_rbtree(&tree);
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x2bbb(%rip), %rax      # 0x4dd8
movq %rax, -0x20(%rbp)
movq 0x2bb8(%rip), %rax      # 0x4de0
movq %rax, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0xa, -0x24(%rbp)
jge 0x2271
movl $0x28, %edi
callq 0x1060
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %edi
callq 0x2350
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x1170
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2233
movl $0x5, %edi
callq 0x2350
movq %rax, %rsi
leaq -0x20(%rbp), %rdi
callq 0x14f0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x22b0
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0x2370
movl %eax, %esi
leaq 0xd5d(%rip), %rdi       # 0x3004
movb $0x0, %al
callq 0x1050
jmp 0x22be
leaq 0xd57(%rip), %rdi       # 0x300e
movb $0x0, %al
callq 0x1050
movq -0x30(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x1570
leaq 0xd4a(%rip), %rdi       # 0x301c
movb $0x0, %al
callq 0x1050
leaq -0x20(%rbp), %rdi
leaq 0xac(%rip), %rsi        # 0x2390
xorl %eax, %eax
movl %eax, %edx
callq 0x1c30
leaq -0x20(%rbp), %rdi
leaq 0x1a8(%rip), %rsi       # 0x24a0
xorl %eax, %eax
movl %eax, %edx
callq 0x1d20
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]rbtree/example/example1.c
// Function: print_node
static int print_node(rbtree_t *tree, rbnode_t *n, void *state)
{
	if (rbnode_is_root(n)) {
		printf("       %4d %5s\n",
			ptoi(n->key),
			rbnode_is_red(n) ? "red" : "black");
	}
	else {
		printf("%6d %4d %5s %5s\n",
			ptoi(n->parent->key),
			ptoi(n->key),
			rbnode_is_red(n) ? "red" : "black",
			rbnode_is_right(n) ? "right" : "left");
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x2406
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2370
movl %eax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x19(%rbp)
je 0x23d8
movq -0x10(%rbp), %rax
cmpl $0x1, 0x8(%rax)
sete %al
movb %al, -0x19(%rbp)
movl -0x20(%rbp), %esi
movb -0x19(%rbp), %cl
leaq 0xc64(%rip), %rdx       # 0x3049
leaq 0xc59(%rip), %rax       # 0x3045
testb $0x1, %cl
cmovneq %rax, %rdx
leaq 0xc3b(%rip), %rdi       # 0x3035
movb $0x0, %al
callq 0x1050
jmp 0x2495
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rdi
callq 0x2370
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2370
movl %eax, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x21(%rbp)
je 0x2442
movq -0x10(%rbp), %rax
cmpl $0x1, 0x8(%rax)
sete %al
movb %al, -0x21(%rbp)
movl -0x28(%rbp), %edx
movl -0x2c(%rbp), %esi
movb -0x21(%rbp), %dil
leaq 0xbf6(%rip), %rcx       # 0x3049
leaq 0xbeb(%rip), %rax       # 0x3045
testb $0x1, %dil
cmovneq %rax, %rcx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %r9
leaq 0xbed(%rip), %r8        # 0x3066
leaq 0xbe0(%rip), %rax       # 0x3060
cmpq %r9, %rdi
cmoveq %rax, %r8
leaq 0xbc1(%rip), %rdi       # 0x304f
movb $0x0, %al
callq 0x1050
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/begriffs[P]pthread-test/pipe.c
// Function: pipe_send
void pipe_send(struct stage *s, long data)
{
	pthread_mutex_lock(&s->mutex);
	{
		while (s->data_ready)
			pthread_cond_wait(&s->ready, &s->mutex);
		s->data = data;
		s->data_ready = true;
		pthread_cond_signal(&s->avail);
	}
	pthread_mutex_unlock(&s->mutex);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1100
movq -0x8(%rbp), %rax
testb $0x1, 0x88(%rax)
je 0x1249
movq -0x8(%rbp), %rdi
addq $0x58, %rdi
movq -0x8(%rbp), %rsi
callq 0x1040
jmp 0x1229
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x90(%rax)
movq -0x8(%rbp), %rax
movb $0x1, 0x88(%rax)
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
callq 0x1080
movq -0x8(%rbp), %rdi
callq 0x10b0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/begriffs[P]pthread-test/pipe.c
// Function: pipe_stage
void *pipe_stage(void *arg)
{
	struct stage *s = arg;
	struct stage *next = s->next;

	pthread_mutex_lock(&s->mutex);
	{
		while (1)
		{
			while (!s->data_ready)
				pthread_cond_wait(&s->avail, &s->mutex);
			/* the operation we perform is incrementing data */
			pipe_send(next, s->data + 1);
			s->data_ready = false;
			pthread_cond_signal(&s->ready);
		}
	}
	pthread_mutex_unlock(&s->mutex);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0xa0(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1100
jmp 0x12ae
movq -0x10(%rbp), %rax
movb 0x88(%rax), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x12c0
jmp 0x12d3
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
movq -0x10(%rbp), %rsi
callq 0x1040
jmp 0x12ae
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rsi
addq $0x1, %rsi
callq 0x1210
movq -0x10(%rbp), %rax
movb $0x0, 0x88(%rax)
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
callq 0x1080
jmp 0x12ac
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/begriffs[P]pthread-test/pipe.c
// Function: pipe_create
void pipe_create(struct pipe *p, int stages)
{
	struct stage **link = &p->head, *new_s, *s;

	pthread_mutex_init(&p->mutex, NULL);
	p->stages = stages;
	p->active = false;

	while (stages-- > 0)
	{
		new_s = malloc(sizeof *new_s);
		pthread_mutex_init(&new_s->mutex, NULL);
		pthread_cond_init(&new_s->avail, NULL);
		pthread_cond_init(&new_s->ready, NULL);
		new_s->data_ready = false;
		*link = new_s;
		link = &new_s->next;
	}
	
	/* end list, record tail */
	*link = NULL;
	p->tail = new_s;

	for (s = p->head; s->next; s = s->next)
		pthread_create(&s->thread, NULL, pipe_stage, s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10f0
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x38(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x3c(%rax)
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
cmpl $0x0, %eax
jle 0x13c0
movl $0xa8, %edi
callq 0x10c0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10f0
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10a0
movq -0x20(%rbp), %rdi
addq $0x58, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10a0
movq -0x20(%rbp), %rax
movb $0x0, 0x88(%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
addq $0xa0, %rax
movq %rax, -0x18(%rbp)
jmp 0x134d
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0xa0(%rax)
je 0x1421
movq -0x28(%rbp), %rdi
addq $0x98, %rdi
movq -0x28(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
leaq -0x18b(%rip), %rdx      # 0x1280
callq 0x10e0
movq -0x28(%rbp), %rax
movq 0xa0(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x13e3
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/begriffs[P]pthread-test/pipe.c
// Function: pipe_start
void pipe_start(struct pipe *p, long value)
{
	pthread_mutex_lock(&p->mutex);
	{
		p->active++;
	}
	pthread_mutex_unlock(&p->mutex);

	pipe_send(p->head, value);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1100
movq -0x8(%rbp), %rax
movl 0x3c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x3c(%rax)
movq -0x8(%rbp), %rdi
callq 0x10b0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1210
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/begriffs[P]pthread-test/pipe.c
// Function: pipe_result
bool pipe_result(struct pipe *p, long *result)
{
	struct stage *tail = p->tail;
	bool empty = false;

	pthread_mutex_lock(&p->mutex);
	{
		if (p->active <= 0)
			empty = true;
		else
			p->active--;
	}
	pthread_mutex_unlock(&p->mutex);

	if (empty)
		return false;

	pthread_mutex_lock(&tail->mutex);
	{
		while (!tail->data_ready)
			pthread_cond_wait(&tail->avail, &tail->mutex);
		*result          = tail->data;
		tail->data_ready = false;
		pthread_cond_signal(&tail->ready);
	}
	pthread_mutex_unlock(&tail->mutex);
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1100
movq -0x10(%rbp), %rax
cmpl $0x0, 0x3c(%rax)
jg 0x14b9
movb $0x1, -0x21(%rbp)
jmp 0x14c6
movq -0x10(%rbp), %rax
movl 0x3c(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x3c(%rax)
movq -0x10(%rbp), %rdi
callq 0x10b0
testb $0x1, -0x21(%rbp)
je 0x14db
movb $0x0, -0x1(%rbp)
jmp 0x1540
movq -0x20(%rbp), %rdi
callq 0x1100
movq -0x20(%rbp), %rax
movb 0x88(%rax), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x14f6
jmp 0x1509
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
movq -0x20(%rbp), %rsi
callq 0x1040
jmp 0x14e4
movq -0x20(%rbp), %rax
movq 0x90(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movb $0x0, 0x88(%rax)
movq -0x20(%rbp), %rdi
addq $0x58, %rdi
callq 0x1080
movq -0x20(%rbp), %rdi
callq 0x10b0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/begriffs[P]pthread-test/pipe.c
// Function: main
int main(void)
{
	struct pipe p;
	long value, result;
	char line[128];

	pipe_create(&p, 10);
	puts("Enter integer values, or '=' for next result");

	while (1)
	{
		printf("Data> ");
		if (fgets(line, sizeof line, stdin) == NULL)
			return 0;
		if (strlen(line) <= 1)
			continue;
		if (strlen(line) == 2 && *line == '=')
		{
			if (pipe_result(&p, &result))
				printf("Result is %ld\n", result);
			else
				puts("Pipe is empty");
		}
		else
		{
			if (sscanf(line, "%ld", &value) < 1)
				fprintf(stderr, "Enter an inter value\n");
			else
				pipe_start(&p, value);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x48(%rbp), %rdi
movl $0xa, %esi
callq 0x1310
leaq 0xa8d(%rip), %rdi       # 0x2004
callq 0x1030
leaq 0xaae(%rip), %rdi       # 0x2031
movb $0x0, %al
callq 0x1060
leaq -0xe0(%rbp), %rdi
movq 0x2a40(%rip), %rax      # 0x3fd8
movq (%rax), %rdx
movl $0x80, %esi
callq 0x1070
cmpq $0x0, %rax
jne 0x15b6
xorl %eax, %eax
addq $0xe0, %rsp
popq %rbp
retq
leaq -0xe0(%rbp), %rdi
callq 0x1050
cmpq $0x1, %rax
ja 0x15ca
jmp 0x157c
leaq -0xe0(%rbp), %rdi
callq 0x1050
cmpq $0x2, %rax
jne 0x161d
movsbl -0xe0(%rbp), %eax
cmpl $0x3d, %eax
jne 0x161d
leaq -0x48(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x1480
testb $0x1, %al
jne 0x15fb
jmp 0x160f
movq -0x58(%rbp), %rsi
leaq 0xa32(%rip), %rdi       # 0x2038
movb $0x0, %al
callq 0x1060
jmp 0x161b
leaq 0xa31(%rip), %rdi       # 0x2047
callq 0x1030
jmp 0x1664
leaq -0xe0(%rbp), %rdi
leaq 0xa2a(%rip), %rsi       # 0x2055
leaq -0x50(%rbp), %rdx
movb $0x0, %al
callq 0x10d0
cmpl $0x1, %eax
jge 0x1655
movq 0x29b6(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xa0d(%rip), %rsi       # 0x2059
movb $0x0, %al
callq 0x1090
jmp 0x1662
movq -0x50(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x1430
jmp 0x1664
jmp 0x157c
// File: /workspace/github_c_makefile_star2_O0/Cyan4973[P]FiniteStateEntropy/programs/probaGenerator.c
// Function: createSampleFile
void createSampleFile(char* filename, double p)
{
    FILE* const foutput = fopen( filename, "wb" );
    if (foutput==NULL) {
        perror("dataGenerator:");
        exit(1);
    }
    {   void* const buffer = malloc(BUFFERSIZE);
        generate(buffer, BUFFERSIZE, p);
        fwrite(buffer, 1, BUFFERSIZE, foutput);
        free(buffer);
    }
    fclose(foutput);
    DISPLAY("File %s generated\n", filename);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xe34(%rip), %rsi       # 0x2020
callq 0x1090
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1212
leaq 0xe20(%rip), %rdi       # 0x2023
callq 0x10a0
movl $0x1, %edi
callq 0x10b0
movl $0xfffff, %edi          # imm = 0xFFFFF
callq 0x1080
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
movl $0xfffff, %esi          # imm = 0xFFFFF
callq 0x1280
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rcx
movl $0x1, %esi
movl $0xfffff, %edx          # imm = 0xFFFFF
callq 0x10c0
movq -0x20(%rbp), %rdi
callq 0x1030
movq -0x18(%rbp), %rdi
callq 0x1040
movq 0x2d95(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0xdc1(%rip), %rsi       # 0x2032
movb $0x0, %al
callq 0x1070
addq $0x20, %rsp
popq %rbp
retq
nop