LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/chatziko-k08[P]lecture-code/programs/set_example/../../modules/UsingAVL/ADTSet.c
// Function: node_insert
static SetNode node_insert(SetNode node, CompareFunc compare, Pointer value, bool* inserted, Pointer* old_value) {
	// Αν το υποδέντρο είναι κενό, δημιουργούμε νέο κόμβο ο οποίος γίνεται ρίζα του υποδέντρου
	if (node == NULL) {
		*inserted = true;			// κάναμε προσθήκη
		return node_create(value);
	}

	// Το πού θα γίνει η προσθήκη εξαρτάται από τη διάταξη της τιμής
	// value σε σχέση με την τιμή του τρέχοντος κόμβου (node->value)
	//
	int compare_res = compare(value, node->value);
	if (compare_res == 0) {
		// βρήκαμε ισοδύναμη τιμή, κάνουμε update
		*inserted = false;
		*old_value = node->value;
		node->value = value;

	} else if (compare_res < 0) {
		// value < node->value, συνεχίζουμε αριστερά.
		node->left = node_insert(node->left, compare, value, inserted, old_value);

	} else {
		// value > node->value, συνεχίζουμε δεξιά
		node->right = node_insert(node->right, compare, value, inserted, old_value);
	}

	return node_repair_balance(node);	// AVL
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r12
movq %rdx, %r14
testq %rdi, %rdi
je 0x49f2
movq %r8, %r15
movq %rsi, %r13
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
movq %r14, %rdi
callq *%r13
testl %eax, %eax
je 0x4a1c
js 0x4a2e
movq 0x8(%rbx), %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %r12, %rcx
movq %r15, %r8
callq 0x49aa
movq %rax, 0x8(%rbx)
jmp 0x4a45
movb $0x1, (%r12)
movl $0x20, %edi
callq 0x21a0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %r14, 0x10(%rax)
movl $0x1, 0x18(%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movb $0x0, (%r12)
movq 0x10(%rbx), %rax
movq %rax, (%r15)
movq %r14, 0x10(%rbx)
jmp 0x4a45
movq (%rbx), %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %r12, %rcx
movq %r15, %r8
callq 0x49aa
movq %rax, (%rbx)
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4eae
// File: /workspace/github_c_makefile_star2_O3/chatziko-k08[P]lecture-code/programs/set_example/../../modules/UsingAVL/ADTSet.c
// Function: node_remove
static SetNode node_remove(SetNode node, CompareFunc compare, Pointer value, bool* removed, Pointer* old_value) {
	if (node == NULL) {
		*removed = false;		// κενό υποδέντρο, δεν υπάρχει η τιμή
		return NULL;
	}

	int compare_res = compare(value, node->value);
	if (compare_res == 0) {
		// Βρέθηκε ισοδύναμη τιμή στον node, οπότε τον διαγράφουμε. Το πώς θα γίνει αυτό εξαρτάται από το αν έχει παιδιά.
		*removed = true;
		*old_value = node->value;

		if (node->left == NULL) {
			// Δεν υπάρχει αριστερό υποδέντρο, οπότε διαγράφεται απλά ο κόμβος και νέα ρίζα μπαίνει το δεξί παιδί
			SetNode right = node->right;	// αποθήκευση πριν το free!
			free(node);
			return right;

		} else if (node->right == NULL) {
			// Δεν υπάρχει δεξί υποδέντρο, οπότε διαγράφεται απλά ο κόμβος και νέα ρίζα μπαίνει το αριστερό παιδί
			SetNode left = node->left;		// αποθήκευση πριν το free!
			free(node);
			return left;

		} else {
			// Υπάρχουν και τα δύο παιδιά. Αντικαθιστούμε την τιμή του node με την μικρότερη του δεξιού υποδέντρου, η οποία
			// αφαιρείται. Η συνάρτηση node_remove_min κάνει ακριβώς αυτή τη δουλειά.

			SetNode min_right;
			node->right = node_remove_min(node->right, &min_right);

			// Σύνδεση του min_right στη θέση του node
			min_right->left = node->left;
			min_right->right = node->right;

			free(node);

			return node_repair_balance(min_right);	// AVL
		}
	}

	// compare_res != 0, συνεχίζουμε στο αριστερό ή δεξί υποδέντρο, η ρίζα δεν αλλάζει.
	if (compare_res < 0)
		node->left  = node_remove(node->left,  compare, value, removed, old_value);
	else
		node->right = node_remove(node->right, compare, value, removed, old_value);

	return node_repair_balance(node);	// AVL
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
testq %rdi, %rdi
je 0x4b11
movq %r8, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
movq %rdx, %rdi
callq *%r13
testl %eax, %eax
je 0x4b2a
movl %eax, %ebp
notl %ebp
shrl $0x1f, %ebp
movq (%rbx,%rbp,8), %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x4aae
movq %rax, (%rbx,%rbp,8)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4eae
movb $0x0, (%r15)
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, (%r15)
movq 0x10(%rbx), %rax
movq %rax, (%r14)
movq (%rbx), %r15
movq 0x8(%rbx), %r14
testq %r15, %r15
je 0x4b72
testq %r14, %r14
je 0x4b7c
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x5001
movq %rax, 0x8(%rbx)
movq (%rbx), %rcx
movq (%r15), %r14
movq %rcx, (%r14)
movq %rax, 0x8(%r14)
movq %rbx, %rdi
callq 0x22a0
movq %r14, %rdi
jmp 0x4afe
movq %rbx, %rdi
callq 0x22a0
jmp 0x4b18
movq %rbx, %rdi
callq 0x22a0
movq %r15, %r14
jmp 0x4b18
// File: /workspace/github_c_makefile_star2_O3/chatziko-k08[P]lecture-code/programs/set_example/../../modules/UsingAVL/ADTSet.c
// Function: node_destroy
static void node_destroy(SetNode node, DestroyFunc destroy_value) {
	if (node == NULL)
		return;
	
	// πρώτα destroy τα παιδιά, μετά free το node
	node_destroy(node->left, destroy_value);
	node_destroy(node->right, destroy_value);

	if (destroy_value != NULL)
		destroy_value(node->value);

	free(node);
}

// Assembly:
testq %rdi, %rdi
je 0x4c37
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x4bf9
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x4bf9
testq %r14, %r14
je 0x4c28
movq 0x10(%rbx), %rdi
callq *%r14
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x22a0
retq
// File: /workspace/github_c_makefile_star2_O3/chatziko-k08[P]lecture-code/programs/set_example/../../modules/UsingAVL/ADTSet.c
// Function: node_find_previous
static SetNode node_find_previous(SetNode node, CompareFunc compare, SetNode target) {
	if (node == target) {
		// Ο target είναι η ρίζα του υποδέντρου, o προηγούμενός του είναι ο μεγαλύτερος του αριστερού υποδέντρου.
		// (Aν δεν υπάρχει αριστερό παιδί, τότε ο κόμβος με τιμή value είναι ο μικρότερος του υποδέντρου, οπότε
		// η node_find_max θα επιστρέψει NULL όπως θέλουμε.)
		return node_find_max(node->left);

	} else if (compare(target->value, node->value) < 0) {
		// Ο target είναι στο αριστερό υποδέντρο, οπότε και ο προηγούμενός του είναι εκεί.
		return node_find_previous(node->left, compare, target);

	} else {
		// Ο target είναι στο δεξί υποδέντρο, ο προηγούμενός του μπορεί να είναι επίσης εκεί, διαφορετικά
		// ο προηγούμενός του είναι ο ίδιος ο node.
		SetNode res = node_find_previous(node->right, compare, target);
		return res != NULL ? res : node;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rdx, %rdi
je 0x4c9a
movq %rdx, %r14
movq %rsi, %r15
movq 0x10(%r14), %rdi
movq 0x10(%rbx), %rsi
callq *%r15
testl %eax, %eax
jns 0x4cb4
movq (%rbx), %rbx
cmpq %r14, %rbx
jne 0x4c83
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x4cb0
movq %rcx, %rax
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
jne 0x4c9d
jmp 0x4cca
xorl %eax, %eax
jmp 0x4cca
movq 0x8(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x4c70
testq %rax, %rax
cmoveq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/chatziko-k08[P]lecture-code/programs/set_example/../../modules/UsingAVL/ADTSet.c
// Function: node_find_next
static SetNode node_find_next(SetNode node, CompareFunc compare, SetNode target) {
	if (node == target) {
		// Ο target είναι η ρίζα του υποδέντρου, o προηγούμενός του είναι ο μεγαλύτερος του αριστερού υποδέντρου.
		// (Aν δεν υπάρχει αριστερό παιδί, τότε ο κόμβος με τιμή value είναι ο μικρότερος του υποδέντρου, οπότε
		// η node_find_max θα επιστρέψει NULL όπως θέλουμε.)
		return node_find_min(node->right);

	} else if (compare(target->value, node->value) > 0) {
		// Ο target είναι στο αριστερό υποδέντρο, οπότε και ο προηγούμενός του είναι εκεί.
		return node_find_next(node->right, compare, target);

	} else {
		// Ο target είναι στο δεξί υποδέντρο, ο προηγούμενός του μπορεί να είναι επίσης εκεί, διαφορετικά
		// ο προηγούμενός του είναι ο ίδιος ο node.
		SetNode res = node_find_next(node->left, compare, target);
		return res != NULL ? res : node;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rdx, %rdi
je 0x4d0a
movq %rdx, %r14
movq %rsi, %r15
movq 0x10(%r14), %rdi
movq 0x10(%rbx), %rsi
callq *%r15
testl %eax, %eax
jle 0x4d24
movq 0x8(%rbx), %rbx
cmpq %r14, %rbx
jne 0x4cf2
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
je 0x4d20
movq %rcx, %rax
movq (%rcx), %rcx
testq %rcx, %rcx
jne 0x4d0e
jmp 0x4d39
xorl %eax, %eax
jmp 0x4d39
movq (%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x4cdf
testq %rax, %rax
cmoveq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/chatziko-k08[P]lecture-code/programs/set_example/../../modules/UsingAVL/ADTSet.c
// Function: node_is_avl
bool node_is_avl(SetNode node, CompareFunc compare) {
	if (node == NULL)
		return true;

	// Ελέγχουμε την ιδιότητα:
	// κάθε κόμβος είναι > αριστερό παιδί, > δεξιότερο κόμβο του αριστερού υποδέντρου, < δεξί παιδί, < αριστερότερο κόμβο του δεξιού υποδέντρου.
	// Είναι ισοδύναμη με την BST ιδιότητα (κάθε κόμβος είναι > αριστερό υποδέντρο και < δεξί υποδέντρο) αλλά ευκολότερο να ελεγθεί.
	bool res = true;
	if(node->left != NULL)
		res = res && compare(node->left->value, node->value) < 0 && compare(node_find_max(node->left)->value, node->value) < 0;
	if(node->right != NULL)
		res = res && compare(node->right->value, node->value) > 0 && compare(node_find_min(node->right)->value, node->value) > 0;

	// Το ύψος είναι σωστό
	res = res && node->height == 1 + int_max(node_height(node->left), node_height(node->right));

	// Ο κόμβος έχει την AVL ιδιότητα
	int balance = node_balance(node);
	res = res && balance >= -1 && balance <= 1;

	// Τα υποδέντρα είναι σωστά
	res = res &&
		node_is_avl(node->left, compare) &&
		node_is_avl(node->right, compare);

	return res;
}

// Assembly:
testq %rdi, %rdi
je 0x4e9c
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%r14), %rax
testq %rax, %rax
je 0x4dac
movq 0x10(%rax), %rdi
movq 0x10(%r14), %rsi
callq *%rbx
testl %eax, %eax
js 0x4db0
xorl %eax, %eax
jmp 0x4dd1
movb $0x1, %al
jmp 0x4dd1
movq (%r14), %rcx
movq %rcx, %rax
testq %rcx, %rcx
je 0x4dc4
movq 0x8(%rax), %rcx
testq %rcx, %rcx
jne 0x4db3
movq 0x10(%rax), %rdi
movq 0x10(%r14), %rsi
callq *%rbx
shrl $0x1f, %eax
movq 0x8(%r14), %rcx
testq %rcx, %rcx
je 0x4e0f
testb %al, %al
je 0x4e2e
movq 0x10(%rcx), %rdi
movq 0x10(%r14), %rsi
callq *%rbx
testl %eax, %eax
jle 0x4e2e
movq 0x8(%r14), %rcx
movq %rcx, %rax
testq %rcx, %rcx
je 0x4e00
movq (%rax), %rcx
testq %rcx, %rcx
jne 0x4df0
movq 0x10(%rax), %rdi
movq 0x10(%r14), %rsi
callq *%rbx
testl %eax, %eax
setg %al
xorl %ecx, %ecx
testb %al, %al
je 0x4e42
movq (%r14), %rax
testq %rax, %rax
je 0x4e20
movl 0x18(%rax), %ecx
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x4e32
movl 0x18(%rax), %eax
jmp 0x4e34
xorl %ecx, %ecx
jmp 0x4e42
xorl %eax, %eax
cmpl %eax, %ecx
cmovgl %ecx, %eax
incl %eax
cmpl %eax, 0x18(%r14)
sete %cl
movq (%r14), %rdi
testq %rdi, %rdi
je 0x4e51
movl 0x18(%rdi), %eax
incl %eax
jmp 0x4e56
movl $0x1, %eax
movq 0x8(%r14), %rdx
testq %rdx, %rdx
je 0x4e64
movl 0x18(%rdx), %edx
jmp 0x4e66
xorl %edx, %edx
subl %edx, %eax
cmpl $0x3, %eax
setb %al
andb %al, %cl
cmpb $0x1, %cl
jne 0x4e92
movq %rbx, %rsi
callq 0x4d7f
testb %al, %al
je 0x4e92
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x4d92
movb $0x1, %al
jmp 0x4e94
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O3/chatziko-k08[P]lecture-code/programs/set_example/../../modules/UsingAVL/ADTSet.c
// Function: node_repair_balance
static SetNode node_repair_balance(SetNode node) {
	node_update_height(node);

	int balance = node_balance(node);
	if (balance > 1) {
		// το αριστερό υπόδεντρο είναι unbalanced
		if (node_balance(node->left) >= 0) 
			return node_rotate_right(node);
		else 
			return node_rotate_left_right(node);

	} else if (balance < -1) {
		// το δεξί υπόδεντρο είναι unbalanced
		if (node_balance(node->right) <= 0)
			return node_rotate_left(node);
		else
			return node_rotate_right_left(node);
	}

	// δεν χρειάστηκε να πραγματοποιηθεί rotation
	return node;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
xorl %ecx, %ecx
movl $0x0, %edx
testq %rdi, %rdi
je 0x4ec4
movl 0x18(%rdi), %edx
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x4ed0
movl 0x18(%rax), %ecx
cmpl %ecx, %edx
cmovgl %edx, %ecx
incl %ecx
xorl %edx, %edx
movl %ecx, 0x18(%rbx)
movl $0x0, %ecx
testq %rdi, %rdi
je 0x4ee9
movl 0x18(%rdi), %ecx
testq %rax, %rax
je 0x4ef1
movl 0x18(%rax), %edx
subl %edx, %ecx
cmpl $0x2, %ecx
jl 0x4f28
movq (%rdi), %rdx
xorl %eax, %eax
movl $0x0, %ecx
testq %rdx, %rdx
je 0x4f0a
movl 0x18(%rdx), %ecx
movq 0x8(%rdi), %rdx
testq %rdx, %rdx
je 0x4f16
movl 0x18(%rdx), %eax
cmpl %eax, %ecx
jge 0x4f22
callq 0x4fb3
movq %rax, (%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x4f66
cmpl $-0x2, %ecx
jg 0x4f61
movq (%rax), %rsi
xorl %ecx, %ecx
movl $0x0, %edx
testq %rsi, %rsi
je 0x4f3f
movl 0x18(%rsi), %edx
movq 0x8(%rax), %rsi
testq %rsi, %rsi
je 0x4f4b
movl 0x18(%rsi), %ecx
cmpl %ecx, %edx
jle 0x4f5b
movq %rax, %rdi
callq 0x4f66
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x4fb3
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/chatziko-k08[P]lecture-code/programs/set_example/../../modules/UsingAVL/ADTSet.c
// Function: node_rotate_right
static SetNode node_rotate_right(SetNode node) {
	SetNode left_node = node->left;
	SetNode left_right = left_node->right;

	left_node->right = node;
	node->left = left_right;

	node_update_height(node);
	node_update_height(left_node);
	
	return left_node;
}

// Assembly:
movq (%rdi), %rax
movq 0x8(%rax), %rsi
movq %rdi, 0x8(%rax)
movq %rsi, (%rdi)
xorl %ecx, %ecx
movl $0x0, %edx
testq %rsi, %rsi
je 0x4f83
movl 0x18(%rsi), %edx
movq 0x8(%rdi), %rsi
testq %rsi, %rsi
je 0x4f8f
movl 0x18(%rsi), %ecx
cmpl %ecx, %edx
cmovgl %edx, %ecx
incl %ecx
movl %ecx, 0x18(%rdi)
movq (%rax), %rdx
testq %rdx, %rdx
je 0x4fa6
movl 0x18(%rdx), %edx
jmp 0x4fa8
xorl %edx, %edx
cmpl %ecx, %edx
cmovgl %edx, %ecx
incl %ecx
movl %ecx, 0x18(%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/chatziko-k08[P]lecture-code/programs/set_example/../../modules/UsingAVL/ADTSet.c
// Function: node_rotate_left
static SetNode node_rotate_left(SetNode node) {
	SetNode right_node = node->right;
	SetNode left_subtree = right_node->left;

	right_node->left = node;
	node->right = left_subtree;

	node_update_height(node);
	node_update_height(right_node);
	
	return right_node;
}

// Assembly:
movq 0x8(%rdi), %rax
movq (%rax), %rdx
movq %rdi, (%rax)
movq %rdx, 0x8(%rdi)
movq (%rdi), %r8
xorl %ecx, %ecx
movl $0x0, %esi
testq %r8, %r8
je 0x4fd4
movl 0x18(%r8), %esi
testq %rdx, %rdx
je 0x4fdc
movl 0x18(%rdx), %ecx
cmpl %ecx, %esi
cmovgl %esi, %ecx
incl %ecx
movl %ecx, 0x18(%rdi)
movq 0x8(%rax), %rdx
testq %rdx, %rdx
je 0x4ff4
movl 0x18(%rdx), %edx
jmp 0x4ff6
xorl %edx, %edx
cmpl %edx, %ecx
cmovgl %ecx, %edx
incl %edx
movl %edx, 0x18(%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/chatziko-k08[P]lecture-code/programs/set_example/../../modules/UsingAVL/ADTSet.c
// Function: node_remove_min
static SetNode node_remove_min(SetNode node, SetNode* min_node) {
	if (node->left == NULL) {
		// Δεν έχουμε αριστερό υποδέντρο, οπότε ο μικρότερος είναι ο ίδιος ο node
		*min_node = node;
		return node->right;		// νέα ρίζα είναι το δεξιό παιδί

	} else {
		// Εχουμε αριστερό υποδέντρο, οπότε η μικρότερη τιμή είναι εκεί. Συνεχίζουμε αναδρομικά
		// και ενημερώνουμε το node->left με τη νέα ρίζα του υποδέντρου.
		node->left = node_remove_min(node->left, min_node);

		return node_repair_balance(node);	// AVL
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x501e
callq 0x5001
movq %rax, (%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x4eae
movq %rbx, (%rsi)
movq 0x8(%rbx), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/cirocosta[P]stress/src/cpu.c
// Function: start_workers
void
start_workers(int n)
{
	int pid;

	while (n--) {
		switch (pid = fork()) {
			case -1:
				_STRESS_MUST(0, "Fork returned -1.");
				break;
			case 0:
				printf("[%d] - child started\n", n);
				while (1) {
				}
				break;
		}
	}
}

// Assembly:
pushq %rbx
movl %edi, %ebx
subl $0x1, %ebx
jb 0x17f9
callq 0x1140
testl %eax, %eax
je 0x17fb
cmpl $-0x1, %eax
jne 0x17e1
callq 0x139c
popq %rbx
retq
leaq 0x922(%rip), %rdi       # 0x2124
movl %ebx, %esi
xorl %eax, %eax
callq 0x10a0
jmp 0x180b
// File: /workspace/github_c_makefile_star2_O3/cirocosta[P]stress/src/cpu.c
// Function: main
int
main(int argc, char** argv)
{
	stress_args_t args = { 0 };

	setbuf(stdout, NULL);
	stress_parse_args(argc, argv, &args);
	start_workers(args.n);
	stress_wait_until_signalized();

	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x2010, %rsp           # imm = 0x2010
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x8(%rsp), %r14
movl $0x2008, %edx           # imm = 0x2008
movq %r14, %rdi
xorl %esi, %esi
callq 0x10b0
movq 0x2790(%rip), %rax      # 0x3fc8
movq (%rax), %rdi
xorl %esi, %esi
callq 0x1090
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x15a9
movl (%r14), %edi
callq 0x17de
callq 0x16d2
xorl %eax, %eax
addq $0x2010, %rsp           # imm = 0x2010
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/radforddc[P]icpc_siggen/calc_signal.c
// Function: rc_integrate
int rc_integrate(float *s_in, float *s_out, float tau, int time_steps){
  int   j;
  float s_in_old, s;  /* DCR: added so that it's okay to
			 call this function with s_out == s_in */
  
  if (tau < 1.0f) {
    for (j = time_steps-1; j > 0; j--) s_out[j] = s_in[j-1];
    s_out[0] = 0.0;
  } else {
    s_in_old = s_in[0];
    s_out[0] = 0.0;
    for (j = 1; j < time_steps; j++) {
      s = s_out[j-1] + (s_in_old - s_out[j-1])/tau;
      s_in_old = s_in[j];
      s_out[j] = s;
    }
  }
  return 0;
}

// Assembly:
movss 0x48e7(%rip), %xmm1     # 0x8008
ucomiss %xmm0, %xmm1
jbe 0x374d
cmpl $0x2, %edx
jl 0x3745
movl %edx, %eax
incq %rax
movss -0xc(%rdi,%rax,4), %xmm0
movss %xmm0, -0x8(%rsi,%rax,4)
decq %rax
cmpq $0x2, %rax
ja 0x3730
movl $0x0, (%rsi)
jmp 0x3785
movss (%rdi), %xmm1
movl $0x0, (%rsi)
cmpl $0x2, %edx
jl 0x3785
movl %edx, %eax
movss (%rsi), %xmm2
movl $0x1, %ecx
subss %xmm2, %xmm1
divss %xmm0, %xmm1
addss %xmm1, %xmm2
movss (%rdi,%rcx,4), %xmm1
movss %xmm2, (%rsi,%rcx,4)
incq %rcx
cmpq %rcx, %rax
jne 0x3767
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/radforddc[P]icpc_siggen/calc_signal.c
// Function: signal_calc_finalize
int signal_calc_finalize(MJD_Siggen_Setup *setup){
  fields_finalize(setup);
  free(setup->dpath_h);
  free(setup->dpath_e);
  return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x5d0f
movq 0x1588(%rbx), %rdi
callq 0x2140
movq 0x1580(%rbx), %rdi
callq 0x2140
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/radforddc[P]icpc_siggen/cyl_point.c
// Function: cart_to_cyl
struct cyl_pt cart_to_cyl(struct point cart_pt){
  struct cyl_pt cyl_pt;

  cyl_pt.r = sqrt(cart_pt.x*cart_pt.x + cart_pt.y*cart_pt.y);
  if (cart_pt.x == 0.0){
    if (cart_pt.y > 0.0) cyl_pt.phi = M_PI/2;
    else cyl_pt.phi = -M_PI/2;
  }else{
    cyl_pt.phi = atan(cart_pt.y/cart_pt.x);
    if (cart_pt.x < 0) cyl_pt.phi += M_PI;
  }
  cyl_pt.z = cart_pt.z;
  
  return cyl_pt;
}

// Assembly:
subq $0x38, %rsp
movaps %xmm0, %xmm4
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movaps %xmm0, %xmm3
mulss %xmm0, %xmm3
movaps %xmm4, %xmm2
mulss %xmm4, %xmm2
addss %xmm3, %xmm2
sqrtss %xmm2, %xmm2
xorps %xmm3, %xmm3
ucomiss %xmm3, %xmm4
jne 0x3809
jp 0x3809
ucomiss %xmm3, %xmm0
jbe 0x3868
movaps 0x4cb9(%rip), %xmm0     # 0x84c0
jmp 0x386f
movss %xmm1, 0xc(%rsp)
divss %xmm4, %xmm0
cvtss2sd %xmm0, %xmm0
movaps %xmm4, 0x20(%rsp)
movaps %xmm2, 0x10(%rsp)
callq 0x2150
xorps %xmm1, %xmm1
cvtsd2ss %xmm0, %xmm1
movaps %xmm1, %xmm0
movaps 0x10(%rsp), %xmm2
movlhps %xmm2, %xmm0            # xmm0 = xmm0[0],xmm2[0]
shufps $0xe2, %xmm2, %xmm0     # xmm0 = xmm0[2,0],xmm2[2,3]
xorps %xmm2, %xmm2
ucomiss 0x20(%rsp), %xmm2
jbe 0x3860
cvtss2sd %xmm1, %xmm1
addsd 0x4c4e(%rip), %xmm1     # 0x84a0
cvtsd2ss %xmm1, %xmm1
movlhps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
shufps $0xe2, %xmm0, %xmm1     # xmm1 = xmm1[2,0],xmm0[2,3]
movaps %xmm1, %xmm0
movss 0xc(%rsp), %xmm1
jmp 0x3873
movaps 0x4c41(%rip), %xmm0     # 0x84b0
movss %xmm2, %xmm0            # xmm0 = xmm2[0],xmm0[1,2,3]
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/radforddc[P]icpc_siggen/cyl_point.c
// Function: vector_norm_cyl
float vector_norm_cyl(struct cyl_pt pt, struct cyl_pt *e){
  float norm;

  norm = sqrt(pt.r*pt.r + pt.z*pt.z);
  e->phi = pt.phi;
  e->r = pt.r/norm;
  e->z = pt.z/norm;

  return norm;
}

// Assembly:
movaps %xmm1, %xmm2
mulss %xmm1, %xmm2
movaps %xmm0, %xmm3
mulss %xmm0, %xmm3
addss %xmm2, %xmm3
xorps %xmm2, %xmm2
sqrtss %xmm3, %xmm2
movaps %xmm0, %xmm3
shufps $0x55, %xmm0, %xmm3     # xmm3 = xmm3[1,1],xmm0[1,1]
movss %xmm3, 0x4(%rdi)
divss %xmm2, %xmm0
movss %xmm0, (%rdi)
divss %xmm2, %xmm1
movss %xmm1, 0x8(%rdi)
movaps %xmm2, %xmm0
retq
nop
// File: /workspace/github_c_makefile_star2_O3/radforddc[P]icpc_siggen/fields.c
// Function: wpotential
int wpotential(point pt, float *wp, MJD_Siggen_Setup *setup){
  float w[2][2];
  int   i, j;
  cyl_int_pt ipt;
  cyl_pt cyl;

  // cyl = cart_to_cyl(pt);  // do not need to know phi, so save call to atan
  cyl.r = sqrt(pt.x*pt.x + pt.y*pt.y);
  cyl.z = pt.z;

  if (nearest_field_grid_index(cyl, &ipt, setup) < 0) return 1;
  grid_weights(cyl, ipt, w, setup);
  *wp = 0.0;
  for (i = 0; i < 2; i++){
    for (j = 0; j < 2; j++){
      *wp += w[i][j]*setup->wpot[ipt.r+i][ipt.z+j];
    }
  }

  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movaps %xmm0, %xmm2
mulps %xmm0, %xmm2
shufps $0x55, %xmm2, %xmm2     # xmm2 = xmm2[1,1,1,1]
mulss %xmm0, %xmm0
addss %xmm2, %xmm0
sqrtss %xmm0, %xmm0
leaq 0x20(%rsp), %rdi
movaps %xmm0, 0x30(%rsp)
movss %xmm1, 0xc(%rsp)
callq 0x551b
testl %eax, %eax
js 0x550e
movq 0x20(%rsp), %rax
movslq 0x28(%rsp), %rcx
movaps 0x30(%rsp), %xmm6
subss 0x3b0(%r14), %xmm6
divss 0x3b8(%r14), %xmm6
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
subss %xmm0, %xmm6
movss 0xc(%rsp), %xmm5
subss 0x3bc(%r14), %xmm5
divss 0x3c4(%r14), %xmm5
xorps %xmm0, %xmm0
cvtsi2ss %ecx, %xmm0
subss %xmm0, %xmm5
xorps %xmm0, %xmm0
cvtss2sd %xmm6, %xmm0
movsd 0x2c40(%rip), %xmm1     # 0x8098
movapd %xmm1, %xmm2
subsd %xmm0, %xmm2
cvtss2sd %xmm5, %xmm3
subsd %xmm3, %xmm1
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
movapd %xmm1, %xmm4
unpcklpd %xmm3, %xmm4            # xmm4 = xmm4[0],xmm3[0]
mulpd %xmm2, %xmm4
cvtpd2ps %xmm4, %xmm2
movlpd %xmm2, 0x10(%rsp)
mulsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
movss %xmm0, 0x18(%rsp)
mulss %xmm6, %xmm5
movss %xmm5, 0x1c(%rsp)
movl $0x0, (%rbx)
movslq %eax, %rdx
shlq $0x3, %rdx
addq 0x1478(%r14), %rdx
xorps %xmm0, %xmm0
movb $0x1, %sil
xorl %r8d, %r8d
shlq $0x2, %rcx
xorl %eax, %eax
movq (%rdx,%r8,8), %rdi
addq %rcx, %rdi
leaq (%rsp,%r8,8), %r8
addq $0x10, %r8
movb $0x1, %r9b
xorl %r10d, %r10d
movss (%r8,%r10,4), %xmm1
mulss (%rdi,%r10,4), %xmm1
addss %xmm1, %xmm0
movss %xmm0, (%rbx)
movl $0x1, %r10d
testb $0x1, %r9b
movl $0x0, %r9d
jne 0x54d5
movl $0x1, %r8d
testb $0x1, %sil
movl $0x0, %esi
jne 0x54c0
jmp 0x5513
movl $0x1, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/radforddc[P]icpc_siggen/fields.c
// Function: fields_finalize
int fields_finalize(MJD_Siggen_Setup *setup){
  int i;

  for (i = 0; i < lrintf((setup->rmax - setup->rmin)/setup->rstep) + 1; i++){
    free(setup->efld[i]);
    free(setup->wpot[i]);
  }
  free(setup->efld);
  free(setup->wpot);
  free(setup->v_lookup);
  setup->efld = NULL;
  setup->wpot = NULL;
  setup->v_lookup = NULL;

  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movss 0x3b4(%rdi), %xmm0
subss 0x3b0(%rdi), %xmm0
divss 0x3b8(%rdi), %xmm0
callq 0x2180
testq %rax, %rax
js 0x5d86
movq $-0x1, %r14
movq 0x1470(%rbx), %rax
movq 0x8(%rax,%r14,8), %rdi
callq 0x2140
movq 0x1478(%rbx), %rax
movq 0x8(%rax,%r14,8), %rdi
callq 0x2140
movss 0x3b4(%rbx), %xmm0
subss 0x3b0(%rbx), %xmm0
divss 0x3b8(%rbx), %xmm0
callq 0x2180
incq %r14
cmpq %r14, %rax
jg 0x5d3f
movq 0x1470(%rbx), %rdi
callq 0x2140
movq 0x1478(%rbx), %rdi
callq 0x2140
movq 0x3d8(%rbx), %rdi
callq 0x2140
movq $0x0, 0x3d8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x1470(%rbx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/radforddc[P]icpc_siggen/fields.c
// Function: set_temp
void set_temp(float temp, MJD_Siggen_Setup *setup){
  if (temp < MIN_TEMP || temp > MAX_TEMP){
    error("temperature out of range: %f\n", temp);
  }else{
    setup->xtal_temp = temp;
    error("temperature set to %f\n", temp);
    /* re-read velocities and correct them to the new temperature value */
    setup_velo(setup);
  }
}

// Assembly:
movaps %xmm0, %xmm1
cvtss2sd %xmm0, %xmm0
movss 0x26f5(%rip), %xmm2     # 0x84d0
ucomiss %xmm1, %xmm2
ja 0x5e0c
ucomiss 0x26ed(%rip), %xmm1     # 0x84d4
ja 0x5e0c
pushq %rbx
movq %rdi, %rbx
movss %xmm1, 0x388(%rdi)
leaq 0x2894(%rip), %rdi      # 0x8690
movb $0x1, %al
callq 0x22e0
movq %rbx, %rdi
popq %rbx
jmp 0x4847
leaq 0x285f(%rip), %rdi      # 0x8672
movb $0x1, %al
jmp 0x22e0
nop
// File: /workspace/github_c_makefile_star2_O3/radforddc[P]icpc_siggen/point.c
// Function: vector_rotate_z
vector vector_rotate_z(vector v, float angle_deg){
  float angle_rad;
  vector res;
  angle_rad = angle_deg/180.0*M_PI;

  res.x = cos(angle_rad)*v.x - sin(angle_rad)*v.y;
  res.y = sin(angle_rad)*v.x + cos(angle_rad)*v.y;
  res.z = v.z;

  return res;
}

// Assembly:
subq $0x68, %rsp
movss %xmm1, 0xc(%rsp)
xorps %xmm1, %xmm1
cvtss2sd %xmm2, %xmm1
divsd 0x2ce0(%rip), %xmm1     # 0x8c18
mulsd 0x2560(%rip), %xmm1     # 0x84a0
movaps %xmm0, 0x10(%rsp)
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, (%rsp)
callq 0x20f0
movaps %xmm0, 0x40(%rsp)
xorps %xmm0, %xmm0
cvtss2sd 0x10(%rsp), %xmm0
movaps %xmm0, 0x50(%rsp)
movsd (%rsp), %xmm0
callq 0x22b0
movaps 0x10(%rsp), %xmm1
shufps $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
cvtss2sd %xmm1, %xmm1
movaps %xmm1, 0x10(%rsp)
xorps 0x2580(%rip), %xmm0     # 0x8510
movaps %xmm0, 0x20(%rsp)
movsd (%rsp), %xmm0
callq 0x22b0
movaps %xmm0, 0x30(%rsp)
movsd (%rsp), %xmm0
callq 0x20f0
movapd 0x10(%rsp), %xmm2
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
movapd 0x20(%rsp), %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
mulpd %xmm2, %xmm1
movapd %xmm1, %xmm2
movapd 0x40(%rsp), %xmm1
unpcklpd 0x30(%rsp), %xmm1       # xmm1 = xmm1[0],mem[0]
movapd 0x50(%rsp), %xmm0
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
mulpd %xmm1, %xmm0
addpd %xmm2, %xmm0
cvtpd2ps %xmm0, %xmm0
movss 0xc(%rsp), %xmm1
addq $0x68, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/radforddc[P]icpc_siggen/signal_tester.c
// Function: main
int main(int argc, char **argv) {

  MJD_Siggen_Setup setup;

  char  ans[MAX_LINE], *cp;
  int   i, ncmds;

  
  /* read config file and initialize */
  if (argc < 2) {
    printf("Usage: %s <config_file_name>\n", argv[0]);
    return 1;
  }
  if (signal_calc_init(argv[1], &setup) != 0) return 1;
  setup.coord_type = CYL;

  ncmds = sizeof(cmds)/sizeof(cmds[0]);
  while (1) {
    rl_gets(ans, MAX_LINE);
    for (cp = ans; isspace(*cp); cp++);
    if (strlen(cp) == 0) continue;
    if (strncmp(cp, "quit", 4) == 0) return 0;
    for (i = 0; i < ncmds; i++){
      if (strncmp(cp, cmds[i].cmd, strlen(cmds[i].cmd)) == 0){
	cp += strlen(cmds[i].cmd);
	cmds[i].f(cp, &setup);
	break;
      }
    } 
    if (i == ncmds){
      printf("unknown command: %s\n", ans);
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x17b8, %rsp           # imm = 0x17B8
cmpl $0x1, %edi
jg 0x6ec5
movq (%rsi), %rsi
leaq 0x28ac(%rip), %rdi      # 0x9760
xorl %eax, %eax
callq 0x2030
movl $0x1, %eax
jmp 0x7015
movq 0x8(%rsi), %rdi
leaq 0x208(%rsp), %rsi
callq 0x249c
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x7015
leaq 0x208(%rsp), %rax
movl $0x0, 0x3a8(%rax)
movq %rsp, %r15
leaq 0x528f(%rip), %r12      # 0xc190
movq 0x8338(%rip), %rdi      # 0xf240
testq %rdi, %rdi
je 0x6f1d
callq 0x2140
movq $0x0, 0x8323(%rip) # 0xf240
leaq 0x2b59(%rip), %rdi      # 0x9a7d
callq 0x21f0
movq %rax, %rbp
movq %rax, 0x830d(%rip)      # 0xf240
cmpb $0x0, (%rax)
je 0x6f47
movq %rbp, %rdi
callq 0x2270
movq 0x82f9(%rip), %rbp      # 0xf240
movl $0x200, %edx            # imm = 0x200
movq %r15, %rdi
movq %rbp, %rsi
callq 0x2230
movb $0x0, 0x1ff(%rsp)
movq %rbp, %rdi
callq 0x2140
movq $0x0, 0x82ce(%rip) # 0xf240
callq 0x2170
movq (%rax), %rax
leaq -0x1(%rsp), %rbp
movsbq 0x1(%rbp), %rcx
incq %rbp
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x6f7f
testb %cl, %cl
je 0x6f01
movl $0x4, %edx
movq %rbp, %rdi
leaq 0x27d9(%rip), %rsi      # 0x977e
callq 0x20c0
testl %eax, %eax
je 0x7013
xorl %r14d, %r14d
leaq (%r12,%r14), %rbx
movq %rbx, %rdi
callq 0x2160
movq %rax, %r13
movq %rbp, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x20c0
testl %eax, %eax
je 0x6ff8
addq $0x408, %r14            # imm = 0x408
cmpq $0x3060, %r14           # imm = 0x3060
jne 0x6fb1
leaq 0x279a(%rip), %rdi      # 0x9783
movq %r15, %rsi
xorl %eax, %eax
callq 0x2030
jmp 0x6f01
addq %r13, %rbp
movq %rbp, %rdi
leaq 0x208(%rsp), %rsi
callq *0x200(%r14,%r12)
jmp 0x6f01
xorl %eax, %eax
addq $0x17b8, %rsp           # imm = 0x17B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/radforddc[P]icpc_siggen/signal_tester.c
// Function: print_signal
static int print_signal(char *cmd, MJD_Siggen_Setup *setup){
  struct point cart;
  int    i;
  static float *s;

  if (s == NULL){//first call
    if ((s = (float *) malloc(setup->ntsteps_out*sizeof(*s))) == NULL) {
      printf("Malloc failed\n");
      return 1;
    }
  }

  if (get_cart(cmd, &cart, setup->coord_type) <= 0) return 1;

  if (get_signal(cart, s, setup) < 0) {
    printf("point not in crystal or has no field: (x = %.1f, y = %.1f, z = %.1f)\n",
	   cart.x, cart.y, cart.z);
    return 1;
  }

  printf("signal: \n");
  for (i = 0; i < setup->ntsteps_out; i++){
    printf("%.3f ", s[i]);
    if (i%10 == 9) printf("\n");
  }
  printf("\n");
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x7dd6(%rip)      # 0xf238
jne 0x7484
movslq 0x3ac(%rbx), %rdi
shlq $0x2, %rdi
callq 0x20d0
movq %rax, 0x7dbd(%rip)      # 0xf238
testq %rax, %rax
je 0x757f
movl 0x3a8(%rbx), %edx
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x7acd
movl $0x1, %ebp
testl %eax, %eax
jle 0x7590
movq 0x7d8d(%rip), %rdi      # 0xf238
movsd 0x10(%rsp), %xmm0
movss 0x18(%rsp), %xmm1
movaps %xmm0, 0x20(%rsp)
movss %xmm1, 0xc(%rsp)
movq %rbx, %rsi
callq 0x263a
testl %eax, %eax
js 0x7555
leaq 0x25e4(%rip), %rdi      # 0x9abd
callq 0x2090
cmpl $0x0, 0x3ac(%rbx)
jle 0x7547
xorl %r14d, %r14d
movabsq $-0x3333333333333333, %r12 # imm = 0xCCCCCCCCCCCCCCCD
leaq 0x23cc(%rip), %r15      # 0x98c7
movq %r14, %rax
mulq %r12
shrq $0x3, %rdx
leal (%rdx,%rdx,4), %eax
leal 0x9(,%rax,2), %ebp
movq 0x7d22(%rip), %rax      # 0xf238
xorps %xmm0, %xmm0
cvtss2sd (%rax,%r14,4), %xmm0
movq %r15, %rdi
movb $0x1, %al
callq 0x2030
cmpl %r14d, %ebp
jne 0x7538
movl $0xa, %edi
callq 0x20b0
incq %r14
movslq 0x3ac(%rbx), %rax
cmpq %rax, %r14
jl 0x74fb
movl $0xa, %edi
callq 0x20b0
xorl %ebp, %ebp
jmp 0x7590
movaps 0x20(%rsp), %xmm1
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
shufps $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
cvtss2sd %xmm1, %xmm1
cvtss2sd 0xc(%rsp), %xmm2
leaq 0x2239(%rip), %rdi      # 0x97af
movb $0x3, %al
callq 0x2030
jmp 0x7590
leaq 0x2540(%rip), %rdi      # 0x9ac6
callq 0x2090
movl $0x1, %ebp
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/radforddc[P]icpc_siggen/signal_tester.c
// Function: set_temp_local
static int set_temp_local(char *cmd, MJD_Siggen_Setup *setup){
  float t;
  char *endp;
  
  t = strtod(cmd, &endp);
  if (endp == cmd){
    printf("cannot parse temperature: %s\n", cmd);
    return 1;
  }
  set_temp(t, setup);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0x22c0
cmpq %rbx, (%r15)
je 0x7852
cvtsd2ss %xmm0, %xmm0
movq %r14, %rdi
callq 0x5dcc
xorl %eax, %eax
jmp 0x7868
leaq 0x20e2(%rip), %rdi      # 0x993b
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2030
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/radforddc[P]icpc_siggen/signal_tester.c
// Function: set_tau
static int set_tau(char *cmd, MJD_Siggen_Setup *setup){
  float t;
  char *endp;

  t = strtod(cmd, &endp);
  if (endp == cmd){
    printf("cannot parse tau: %s\n", cmd);
    return 1;
  }
  if (t < 0) t = 0;
  setup->preamp_tau = t;
  printf("Signals will be integrated with tau = %f ns\n", setup->preamp_tau);

  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0x22c0
cmpq %rbx, (%r15)
je 0x78c0
cvtsd2ss %xmm0, %xmm0
xorps %xmm1, %xmm1
maxss %xmm0, %xmm1
movss %xmm1, 0x38c(%r14)
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
leaq 0x20ba(%rip), %rdi      # 0x996f
movb $0x1, %al
callq 0x2030
xorl %eax, %eax
jmp 0x78d6
leaq 0x2092(%rip), %rdi      # 0x9959
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2030
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/radforddc[P]icpc_siggen/signal_tester.c
// Function: set_charge_size
static int set_charge_size(char *cmd, MJD_Siggen_Setup *setup){
  float cs;
  char *endp;

  cs = strtod(cmd, &endp);
  if (endp == cmd){
    printf("cannot parse charge_cloud_size: %s\n", cmd);
    return 1;
  }
  if (cs < 0) cs = 0;
  setup->charge_cloud_size = cs;
  printf("Charge cloud size set to %f mm\n", setup->charge_cloud_size);

  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0x22c0
cmpq %rbx, (%r15)
je 0x792e
cvtsd2ss %xmm0, %xmm0
xorps %xmm1, %xmm1
maxss %xmm0, %xmm1
movss %xmm1, 0x39c(%r14)
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
leaq 0x209d(%rip), %rdi      # 0x99c0
movb $0x1, %al
callq 0x2030
xorl %eax, %eax
jmp 0x7944
leaq 0x2067(%rip), %rdi      # 0x999c
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2030
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/radforddc[P]icpc_siggen/signal_tester.c
// Function: set_diffusion
static int set_diffusion(char *cmd, MJD_Siggen_Setup *setup){
  int  d;
  char *endp;

  d = (int) strtol(cmd, &endp, 0);
  if (endp == cmd){
    printf("cannot parse diffusion option: %s\n", cmd);
    return 1;
  }
  if (d < 0) d = 0;
  setup->use_diffusion = d;
  if (d > 0) {
    printf("Diffusion turned on\n");
  } else {
    printf("Diffusion turned off\n");
  }

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
xorl %ebp, %ebp
movq %r15, %rsi
xorl %edx, %edx
callq 0x21d0
cmpq %r14, (%r15)
je 0x7985
testl %eax, %eax
cmovgl %eax, %ebp
movl %ebp, 0x3a0(%rbx)
jle 0x799d
leaq 0x2166(%rip), %rdi      # 0x9ae9
jmp 0x79a4
leaq 0x2054(%rip), %rdi      # 0x99e0
movq %r14, %rsi
xorl %eax, %eax
callq 0x2030
movl $0x1, %eax
jmp 0x79ab
leaq 0x2130(%rip), %rdi      # 0x9ad4
callq 0x2090
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/radforddc[P]icpc_siggen/signal_tester.c
// Function: set_energy
static int set_energy(char *cmd, MJD_Siggen_Setup *setup){
  float e;
  char *endp;

  e = strtod(cmd, &endp);
  if (endp == cmd){
    printf("cannot parse energy: %s\n", cmd);
    return 1;
  }
  if (e < 0) e = 0;
  setup->energy = e;
  printf("Interaction energy set to %.1f keV\n", e);

  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0x22c0
cmpq %rbx, (%r15)
je 0x7a04
cvtsd2ss %xmm0, %xmm0
xorps %xmm1, %xmm1
maxss %xmm0, %xmm1
movss %xmm1, 0x3a4(%r14)
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
leaq 0x2023(%rip), %rdi      # 0x9a1c
movb $0x1, %al
callq 0x2030
xorl %eax, %eax
jmp 0x7a1a
leaq 0x1ff8(%rip), %rdi      # 0x9a03
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2030
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/radforddc[P]icpc_siggen/signal_tester.c
// Function: set_verbosity
static int set_verbosity(char *cmd, MJD_Siggen_Setup *setup) {
  int i;
  char *endp;

  i = strtol(cmd, &endp, 0);
  if (endp == cmd) {
    printf("cannot parse verbosity level: %s\n", cmd);
    return 1;
  }
  if (i < 0) i = 0;
  if (i > 2) i = 2;
  setup->verbosity = i;
  printf("Verbosity level set to %d\n", i);

  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movq %rsp, %r12
xorl %ebx, %ebx
movq %r12, %rsi
xorl %edx, %edx
callq 0x21d0
cmpq %r15, (%r12)
je 0x7a6a
testl %eax, %eax
cmovlel %ebx, %eax
cmpl $0x2, %eax
movl $0x2, %esi
cmovll %eax, %esi
movl %esi, (%r14)
leaq 0x2001(%rip), %rdi      # 0x9a62
xorl %eax, %eax
callq 0x2030
jmp 0x7a80
leaq 0x1fcf(%rip), %rdi      # 0x9a40
movq %r15, %rsi
xorl %eax, %eax
callq 0x2030
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/radforddc[P]icpc_siggen/signal_tester.c
// Function: print_help
static int print_help(char *cmd, MJD_Siggen_Setup *setup){
  int i;

  printf("available commands:\n");
  for (i = 0; i < (int) (sizeof(cmds)/sizeof(cmds[0])); i++){
    printf("%s\n",cmds[i].help_str);
  }
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x2064(%rip), %rdi      # 0x9afd
callq 0x2090
movl $0x208, %ebx            # imm = 0x208
leaq 0x46e6(%rip), %r14      # 0xc190
leaq (%r14,%rbx), %rdi
callq 0x2090
addq $0x408, %rbx            # imm = 0x408
cmpq $0x3268, %rbx           # imm = 0x3268
jne 0x7aaa
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/icepole128v2/ref/encrypt.c
// Function: crypto_aead_encrypt
int crypto_aead_encrypt(
	unsigned char *c,unsigned long long *clen,
	const unsigned char *m,unsigned long long mlen,
	const unsigned char *ad,unsigned long long adlen,
	const unsigned char *nsec,
	const unsigned char *npub,
	const unsigned char *k )
{
    ICESTATE S;
    unsigned int frameBit;
    
    /* initialize the state with secret key and nonce */
    initState(S, k, npub);

    /* ciphertext length is plaintext len + size of tag and nsec */
    *clen = mlen + ICEPOLETAGLEN + ICEPOLENSECLEN; 
    
    /* absorb and encrypt 128-bit secret message number */
    processDataBlock(S, nsec, &c, ICEPOLENSECLEN, 0);
    
    /* process auth-only associated data blocks */
    do {
        unsigned long long blocklen = ICEPOLEDATABLOCKLEN;
        frameBit = (adlen <= blocklen ? 1 : 0); /* is it the last block? */
        if (adlen < blocklen) {
            blocklen = adlen;
        }
        /* apply the permutation to the state */
        P6(S,S);
        /* absorb a data block */
        processDataBlock(S, ad, NULL, blocklen, frameBit);
        ad += blocklen;
        adlen -= blocklen;
    } while (adlen > 0);

    /* process plaintext blocks to get the ciphertext */
    do {
        unsigned long long blocklen = ICEPOLEDATABLOCKLEN;
        frameBit = (mlen <=blocklen ? 0 : 1);
        if (mlen < blocklen) {
            blocklen = mlen;
        }
        /* apply the permutation to the state */
        P6(S,S);
        /* absorb a data block and produce a ciphertext block */
        processDataBlock(S, m, &c, blocklen, frameBit);
        m += blocklen;
        mlen -= blocklen;    
    } while (mlen > 0);

    /* store authentication tag at the end of the ciphertext */
    generateTag(S, c);    
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %r9, %r15
movq %r8, %r12
movq %rcx, %rbx
movq %rdx, 0x8(%rsp)
movq %rsi, %rbp
movq 0x100(%rsp), %rsi
movq 0xf8(%rsp), %rdx
movq %rsp, %r13
movq %rdi, (%r13)
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x10b0
leaq 0x20(%rbx), %rax
movq %rax, (%rbp)
movl $0x10, %ecx
movq %r14, %rdi
movq 0xf0(%rsp), %rsi
movq %r13, %rdx
xorl %r8d, %r8d
callq 0x1040
xorl %ebp, %ebp
cmpq $0x81, %r15
setb %bpl
movl $0x80, %eax
cmpq %rax, %r15
movl $0x80, %r13d
cmovbq %r15, %r13
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %r14, %rsi
callq 0x1100
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
movq %r13, %rcx
movl %ebp, %r8d
callq 0x1040
addq %r13, %r12
subq %r13, %r15
jne 0x1275
leaq 0x10(%rsp), %r15
movq %rsp, %r12
movq 0x8(%rsp), %r14
xorl %ebp, %ebp
cmpq $0x81, %rbx
setae %bpl
movl $0x80, %eax
cmpq %rax, %rbx
movl $0x80, %r13d
cmovbq %rbx, %r13
movq %r15, %rdi
movq %r15, %rsi
callq 0x1100
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %r13, %rcx
movl %ebp, %r8d
callq 0x1040
addq %r13, %r14
subq %r13, %rbx
jne 0x12cc
movq (%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x10e0
xorl %eax, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/icepole128v2/ref/icepole.c
// Function: load64
uint64_t load64(const unsigned char * p, unsigned int len)
{
    uint64_t v = 0;
    unsigned int i;
    assert(len <= 8);
    for(i=0; i<len; ++i) {
        v = v ^ (((uint64_t)p[i]) << (8*i));
    }
    return v;
}

// Assembly:
cmpl $0x8, %esi
ja 0x1535
testl %esi, %esi
je 0x1532
movl %esi, %eax
addl $0x3, %esi
andl $0x1c, %esi
decq %rax
vpbroadcastq %rax, %ymm0
vpxor %xmm4, %xmm4, %xmm4
vpmovsxbq 0x1cb5(%rip), %ymm1 # 0x3188
xorl %eax, %eax
vpbroadcastq 0x1ca2(%rip), %ymm3 # 0x3180
vmovdqa %ymm4, %ymm2
vpcmpleuq %ymm0, %ymm1, %k1
vmovdqu8 (%rdi,%rax), %xmm4 {%k1} {z}
vpmovzxbq %xmm4, %ymm4    # ymm4 = xmm4[0],zero,zero,zero,zero,zero,zero,zero,xmm4[1],zero,zero,zero,zero,zero,zero,zero,xmm4[2],zero,zero,zero,zero,zero,zero,zero,xmm4[3],zero,zero,zero,zero,zero,zero,zero
vpsllq $0x3, %ymm1, %ymm5
vpsllvq %ymm5, %ymm4, %ymm4
vpxor %ymm2, %ymm4, %ymm4
addq $0x4, %rax
vpaddq %ymm3, %ymm1, %ymm1
cmpq %rax, %rsi
jne 0x14de
vmovdqa64 %ymm4, %ymm2 {%k1}
vextracti128 $0x1, %ymm2, %xmm0
vpxor %xmm0, %xmm2, %xmm0
vpshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
vpxor %xmm1, %xmm0, %xmm0
vmovq %xmm0, %rax
vzeroupper
retq
xorl %eax, %eax
retq
pushq %rax
leaq 0x1c73(%rip), %rdi      # 0x31b0
leaq 0x1c75(%rip), %rsi      # 0x31b9
leaq 0x1c95(%rip), %rcx      # 0x31e0
movl $0x8, %edx
callq 0x1030
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/icepole128v2/ref/icepole.c
// Function: store64
void store64(unsigned char * p, uint64_t v, unsigned int len)
{
    unsigned int i;
    assert(len <= 8);
    for (i=0; i<len; ++i) {
        p[i] = (unsigned char) (v >> (8*i));
    }
}

// Assembly:
cmpl $0x8, %edx
ja 0x15b2
testl %edx, %edx
je 0x15ae
movl %edx, %eax
addl $0x3, %edx
andl $0x1c, %edx
decq %rax
vpbroadcastq %rax, %ymm0
vpbroadcastq %rsi, %ymm1
vpmovsxbq 0x1c0a(%rip), %ymm2 # 0x3188
xorl %eax, %eax
vpbroadcastq 0x1bf7(%rip), %ymm3 # 0x3180
vpcmpleuq %ymm0, %ymm2, %k1
vpsllq $0x3, %ymm2, %ymm4
vpsrlvq %ymm4, %ymm1, %ymm4
vpmovqb %ymm4, (%rdi,%rax) {%k1}
addq $0x4, %rax
vpaddq %ymm3, %ymm2, %ymm2
cmpq %rax, %rdx
jne 0x1589
vzeroupper
retq
pushq %rax
leaq 0x1bf6(%rip), %rdi      # 0x31b0
leaq 0x1bf8(%rip), %rsi      # 0x31b9
leaq 0x1c4d(%rip), %rcx      # 0x3215
movl $0x13, %edx
callq 0x1030
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/icepole128v2/ref/icepole.c
// Function: Pi
void Pi(ICESTATE SS, ICESTATE S)
{
    unsigned int x,y;
    for(x = 0; x < 4; ++x) {
        for (y = 0; y < 5; ++y) {
            unsigned int xx = (x + y) % 4;
            unsigned int yy = (xx + y + 1) % 5;
            SS[xx][yy] = S[x][y];
        }
    }
}

// Assembly:
xorl %eax, %eax
movq %rax, %rcx
xorl %edx, %edx
xorl %r8d, %r8d
movl %ecx, %r9d
andl $0x3, %r9d
leal (%rdx,%r9), %r10d
incl %r10d
leal (%rdx,%r9), %r11d
addl $-0x4, %r11d
cmpl $0x5, %r10d
cmovbl %r10d, %r11d
movq (%rsi,%r8), %r10
leaq (%r9,%r9,4), %r9
leaq (%rdi,%r9,8), %r9
movq %r10, (%r9,%r11,8)
addq $0x8, %r8
incl %edx
incq %rcx
cmpq $0x28, %r8
jne 0x18b3
incq %rax
addq $0x28, %rsi
cmpq $0x4, %rax
jne 0x18ab
retq
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/icepole128v2/ref/icepole.c
// Function: Kappa
void Kappa(ICESTATE SS, ICESTATE S, int roundNo)
{
    const uint64_t constant[MAXROUND] = {
    0x0091A2B3C4D5E6F7ULL, 0x0048D159E26AF37BULL, 0x002468ACF13579BDULL, 0x00123456F89ABCDEULL,
    0x00091A2BFC4D5E6FULL, 0x00048D15FE26AF37ULL, 0x0002468AFF13579BULL, 0x000123457F89ABCDULL,
    0x000091A2BFC4D5E6ULL, 0x000048D1DFE26AF3ULL, 0x00002468EFF13579ULL, 0x00001234F7F89ABC };
    unsigned int x,y;
    for(x = 0; x < 4; ++x) {
        for(y = 0; y < 5; ++y) {
            SS[x][y] = S[x][y];
        }
    }

    SS[0][0] = SS[0][0] ^ constant[roundNo];
}

// Assembly:
xorl %eax, %eax
movq %rdi, %rcx
xorl %r8d, %r8d
movq (%rsi,%r8,8), %r9
movq %r9, (%rcx,%r8,8)
incq %r8
cmpq $0x5, %r8
jne 0x19d0
incq %rax
addq $0x28, %rsi
addq $0x28, %rcx
cmpq $0x4, %rax
jne 0x19cd
movslq %edx, %rax
leaq 0x1964(%rip), %rcx      # 0x3360
movq (%rcx,%rax,8), %rax
xorq %rax, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/icepole128v2/ref/icepole.c
// Function: oneround
void oneround(ICESTATE SS, ICESTATE S, int roundNo)
{
    ICESTATE B;
    ICESTATE C;
    ICESTATE D;
    ICESTATE E;

    Mu(B, S);
    Rho(C, B);
    Pi(D, C);
    Psi(E, D);
    Kappa(SS, E, roundNo);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x280, %rsp            # imm = 0x280
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x1e0(%rsp), %r14
movq %r14, %rdi
callq 0x1070
movq (%r14), %rax
leaq 0x140(%rsp), %rsi
movq %rax, (%rsi)
vmovdqu 0x8(%r14), %ymm0
vprolvq 0x15de(%rip), %ymm0, %ymm0 # 0x3020
vmovdqu %ymm0, 0x8(%rsi)
vmovdqu 0x28(%r14), %ymm0
vprolvq 0x15e9(%rip), %ymm0, %ymm0 # 0x3040
vmovdqu %ymm0, 0x28(%rsi)
vmovdqu 0x48(%r14), %ymm0
vprolvq 0x15f4(%rip), %ymm0, %ymm0 # 0x3060
vmovdqu %ymm0, 0x48(%rsi)
vmovdqu 0x68(%r14), %ymm0
vprolvq 0x15ff(%rip), %ymm0, %ymm0 # 0x3080
vmovdqu %ymm0, 0x68(%rsi)
vmovdqu 0x88(%r14), %xmm0
vprolvq 0x1707(%rip), %xmm0, %xmm0 # 0x31a0
vmovdqu %xmm0, 0x88(%rsi)
rorxq $0x8, 0x98(%r14), %rax
movq %rax, 0x98(%rsi)
leaq 0xa0(%rsp), %r14
movq %r14, %rdi
vzeroupper
callq 0x10d0
movq %rsp, %rdi
movq %r14, %rsi
callq 0x10c0
xorl %eax, %eax
movq 0x20(%rsp,%rax), %rcx
movq %rcx, 0x20(%rbx,%rax)
vmovdqu (%rsp,%rax), %ymm0
vmovdqu %ymm0, (%rbx,%rax)
addq $0x28, %rax
cmpq $0xa0, %rax
jne 0x1ad2
movslq %ebp, %rax
leaq 0x1864(%rip), %rcx      # 0x3360
movq (%rcx,%rax,8), %rax
xorq %rax, (%rbx)
addq $0x280, %rsp            # imm = 0x280
popq %rbx
popq %r14
popq %rbp
vzeroupper
retq
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/icepole128v2/ref/icepole.c
// Function: P6
void P6(ICESTATE SS, ICESTATE S)
{
    ICESTATE A;
    ICESTATE B;

    oneround(A,S,0);
    oneround(B,A,1);
    oneround(A,B,2);
    oneround(B,A,3);
    oneround(A,B,4);
    oneround(SS,A,5);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x140, %rsp            # imm = 0x140
movq %rdi, %rbx
leaq 0xa0(%rsp), %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0x10f0
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x10f0
movq %r14, %rdi
movq %r15, %rsi
movl $0x2, %edx
callq 0x10f0
movq %r15, %rdi
movq %r14, %rsi
movl $0x3, %edx
callq 0x10f0
movq %r14, %rdi
movq %r15, %rsi
movl $0x4, %edx
callq 0x10f0
movq %rbx, %rdi
movq %r14, %rsi
movl $0x5, %edx
callq 0x10f0
addq $0x140, %rsp            # imm = 0x140
popq %rbx
popq %r14
popq %r15
retq