LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/programs/pair_sum/../../modules/UsingADTSet/ADTMap.c
// Function: destroy_map_node
static void destroy_map_node(MapNode node) {
	if (node->owner->destroy_key != NULL)
		node->owner->destroy_key(node->key);

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

	free(node);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0x57e0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x0, 0x18(%rax)
je 0x5805
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rdi
callq 0x2270
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/programs/pair_sum/../../modules/UsingADTSet/ADTMap.c
// Function: map_insert
void map_insert(Map map, Pointer key, Pointer value) {
	struct map_node search_node = { .key = key, .owner = map };

	MapNode node = set_find(map->set, &search_node);
	if (node != NULL) {
		if (key != node->key && map->destroy_key != NULL)
			map->destroy_key(node->key);

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

		node->key = key;
		node->value = value;
		return;
	}

	node = malloc(sizeof(*node));
	node->key = key;
	node->value = value;
	node->owner = map;

	set_insert(map->set, node);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6040
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x5964
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
cmpq (%rcx), %rax
je 0x5920
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x5920
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x38(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
movq -0x18(%rbp), %rax
movq -0x38(%rbp), %rcx
cmpq 0x8(%rcx), %rax
je 0x594b
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x594b
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x38(%rbp), %rcx
movq 0x8(%rcx), %rdi
callq *%rax
movq -0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x59a5
movl $0x18, %edi
callq 0x2180
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x38(%rbp), %rsi
callq 0x5cd0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/programs/pair_sum/../../modules/UsingADTSet/ADTMap.c
// Function: map_remove
bool map_remove(Map map, Pointer key) {
	struct map_node search_node = { .key = key, .owner = map };

	MapNode node = set_find(map->set, &search_node);
	if (node == NULL)
		return false;

	set_remove(map->set, node);

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6040
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x59f9
movb $0x0, -0x1(%rbp)
jmp 0x5a0d
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x38(%rbp), %rsi
callq 0x5e30
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/programs/set_example/../../modules/UsingAVL/ADTSet.c
// Function: set_create
Set set_create(CompareFunc compare, DestroyFunc destroy_value) {
	assert(compare != NULL);	// LCOV_EXCL_LINE

	// δημιουργούμε το stuct
	Set set = malloc(sizeof(*set));
	set->root = NULL;			// κενό δέντρο
	set->size = 0;
	set->compare = compare;
	set->destroy_value = destroy_value;

	return set;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5c49
jmp 0x5c68
leaq 0x21cb(%rip), %rdi      # 0x7e1b
leaq 0x222d(%rip), %rsi      # 0x7e84
movl $0x165, %edx            # imm = 0x165
leaq 0x2241(%rip), %rcx      # 0x7ea4
callq 0x20f0
movl $0x20, %edi
callq 0x2180
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5d7c
movq -0x28(%rbp), %rax
movb $0x1, (%rax)
movq -0x20(%rbp), %rdi
callq 0x67a0
movq %rax, -0x8(%rbp)
jmp 0x5e20
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rsi
callq *%rax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x5dbb
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x5e13
cmpl $0x0, -0x34(%rbp)
jge 0x5de9
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x5d40
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x5e11
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x5d40
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x5e13
movq -0x10(%rbp), %rdi
callq 0x6800
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/programs/set_example/../../modules/UsingAVL/ADTSet.c
// Function: node_find_equal
static SetNode node_find_equal(SetNode node, CompareFunc compare, Pointer value) {
	// κενό υποδέντρο, δεν υπάρχει η τιμή
	if (node == NULL)
		return NULL;
	
	// Το πού βρίσκεται ο κόμβος που ψάχνουμε εξαρτάται από τη διάταξη της τιμής
	// value σε σχέση με την τιμή του τρέχοντος κόμβο (node->value)
	//
	int compare_res = compare(value, node->value);			// αποθήκευση για να μην καλέσουμε την compare 2 φορές
	if (compare_res == 0)									// value ισοδύναμη της node->value, βρήκαμε τον κόμβο
		return node;
	else if (compare_res < 0)								// value < node->value, ο κόμβος που ψάχνουμε είναι στο αριστερό υποδέντρο
		return node_find_equal(node->left, compare, value);
	else													// value > node->value, ο κόμβος που ψάχνουμε είνια στο δεξιό υποδέντρο
		return node_find_equal(node->right, compare, value);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x60c5
movq $0x0, -0x8(%rbp)
jmp 0x6123
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rsi
callq *%rax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x60ea
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6123
cmpl $0x0, -0x24(%rbp)
jge 0x610a
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x60a0
movq %rax, -0x8(%rbp)
jmp 0x6123
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x60a0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x61a9
jmp 0x61e8
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x6190
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x6190
cmpq $0x0, -0x10(%rbp)
je 0x61df
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rdi
callq 0x2270
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x6330
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x6280
movq %rax, -0x8(%rbp)
jmp 0x639f
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rdi
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rsi
callq *%rax
cmpl $0x0, %eax
jge 0x6365
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x6300
movq %rax, -0x8(%rbp)
jmp 0x639f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x6300
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x638f
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x6397
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x6411
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6210
movq %rax, -0x8(%rbp)
jmp 0x6480
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rdi
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rsi
callq *%rax
cmpl $0x0, %eax
jle 0x6447
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x63e0
movq %rax, -0x8(%rbp)
jmp 0x6480
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x63e0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x6470
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x6478
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/programs/set_example/../../modules/UsingAVL/ADTSet.c
// Function: node_create
static SetNode node_create(Pointer value) {
	SetNode node = malloc(sizeof(*node));
	node->left = NULL;
	node->right = NULL;
	node->value = value;
	node->height = 1;			// AVL
	return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x20, %edi
callq 0x2180
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x18(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x68a0
movq -0x10(%rbp), %rdi
callq 0x6730
movl %eax, -0x14(%rbp)
cmpl $0x1, -0x14(%rbp)
jle 0x6856
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x6730
cmpl $0x0, %eax
jl 0x6847
movq -0x10(%rbp), %rdi
callq 0x68f0
movq %rax, -0x8(%rbp)
jmp 0x6896
movq -0x10(%rbp), %rdi
callq 0x6950
movq %rax, -0x8(%rbp)
jmp 0x6896
cmpl $-0x1, -0x14(%rbp)
jge 0x688c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6730
cmpl $0x0, %eax
jg 0x687d
movq -0x10(%rbp), %rdi
callq 0x6990
movq %rax, -0x8(%rbp)
jmp 0x6896
movq -0x10(%rbp), %rdi
callq 0x69f0
movq %rax, -0x8(%rbp)
jmp 0x6896
jmp 0x688e
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x68a0
movq -0x10(%rbp), %rdi
callq 0x68a0
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x6a63
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x6a8a
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x6a30
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x6800
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, 0x14(%rsp)
cmpl $0x0, %eax
je 0x19c6
callq 0x1120
movl %eax, 0x10(%rsp)
movl %eax, %ecx
movl %ecx, 0xc(%rsp)
subl $-0x1, %eax
je 0x18d5
jmp 0x18c4
movl 0xc(%rsp), %eax
testl %eax, %eax
je 0x19ad
jmp 0x19c1
jmp 0x18d7
movq 0x271a(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x750(%rip), %rsi       # 0x2038
movb $0x0, %al
callq 0x10d0
movq 0x2702(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x73e(%rip), %rsi       # 0x203e
movb $0x0, %al
callq 0x10d0
movq 0x26ea(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x808(%rip), %rsi       # 0x2120
movb $0x0, %al
callq 0x10d0
movq 0x26d2(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x735(%rip), %rsi       # 0x2065
movb $0x0, %al
callq 0x10d0
movq 0x26ba(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x720(%rip), %rsi       # 0x2068
leaq 0x7e3(%rip), %rdx       # 0x2132
movb $0x0, %al
callq 0x10d0
movq 0x269b(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x71d(%rip), %rsi       # 0x2084
movl $0x14, %edx
movb $0x0, %al
callq 0x10d0
movq 0x267e(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x6e2(%rip), %rsi       # 0x2066
movb $0x0, %al
callq 0x10d0
movq 0x2666(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x6f5(%rip), %rsi       # 0x2091
movb $0x0, %al
callq 0x10d0
movl $0x1, %edi
callq 0x1100
movl 0x14(%rsp), %esi
leaq 0x784(%rip), %rdi       # 0x213c
movb $0x0, %al
callq 0x10a0
jmp 0x19bf
jmp 0x1898
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x2018, %rsp           # imm = 0x2018
movl $0x0, 0x2014(%rsp)
movl %edi, 0x2010(%rsp)
movq %rsi, 0x2008(%rsp)
movq %rsp, %rdi
xorl %esi, %esi
movl $0x2008, %edx           # imm = 0x2008
callq 0x10b0
movq 0x25c1(%rip), %rax      # 0x3fc8
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1090
movl 0x2010(%rsp), %edi
movq 0x2008(%rsp), %rsi
movq %rsp, %rdx
callq 0x12d0
movl (%rsp), %edi
callq 0x1890
callq 0x16d0
xorl %eax, %eax
addq $0x2018, %rsp           # imm = 0x2018
retq
// File: /workspace/github_c_makefile_star2_O0/radforddc[P]icpc_siggen/calc_signal.c
// Function: signal_calc_init
int signal_calc_init(char *config_file_name, MJD_Siggen_Setup *setup) {

  if (read_config(config_file_name, setup)) return 1;

  TELL_CHATTY("r: %.2f  z: %.2f\n", setup->xtal_radius, setup->xtal_length);
  setup->ntsteps_out = setup->time_steps_calc /
    lrintf(setup->step_time_out/setup->step_time_calc);
  TELL_NORMAL("Will use %d time steps in calculations, each %.2f ns long;\n"
	      "the output signals will have %d time steps, each %.2f ns long\n", 
	      setup->time_steps_calc, setup->step_time_calc,
	      setup->ntsteps_out, setup->step_time_out);

  TELL_NORMAL("Reading field data...\n");
  if (field_setup(setup) != 0) return -1;
  
  if ((setup->dpath_e = (point *) malloc(setup->time_steps_calc*sizeof(point))) == NULL ||
      (setup->dpath_h = (point *) malloc(setup->time_steps_calc*sizeof(point))) == NULL) {
    error("Path malloc failed\n");
    return -1;
  }

  tell("Setup of signal calculation done\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 0x91d0
cmpl $0x0, %eax
je 0x23be
movl $0x1, -0x4(%rbp)
jmp 0x2522
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
jl 0x23ef
movq -0x18(%rbp), %rax
movss 0x8(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x18(%rbp), %rax
movss 0x4(%rax), %xmm1
cvtss2sd %xmm1, %xmm1
leaq 0xacd8(%rip), %rdi      # 0xd0c0
movb $0x2, %al
callq 0x2530
movq -0x18(%rbp), %rax
movslq 0x390(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movss 0x398(%rax), %xmm0
movq -0x18(%rbp), %rax
divss 0x394(%rax), %xmm0
callq 0x2150
movq %rax, %rcx
movq -0x20(%rbp), %rax
cqto
idivq %rcx
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x3ac(%rax)
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
jl 0x247e
movq -0x18(%rbp), %rax
movl 0x390(%rax), %esi
movq -0x18(%rbp), %rax
movss 0x394(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x18(%rbp), %rax
movl 0x3ac(%rax), %edx
movq -0x18(%rbp), %rax
movss 0x398(%rax), %xmm1
cvtss2sd %xmm1, %xmm1
leaq 0xac5b(%rip), %rdi      # 0xd0d2
movb $0x2, %al
callq 0x2530
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
jl 0x2495
leaq 0xacbe(%rip), %rdi      # 0xd14c
movb $0x0, %al
callq 0x2530
movq -0x18(%rbp), %rdi
callq 0x5370
cmpl $0x0, %eax
je 0x24ac
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2522
movq -0x18(%rbp), %rax
movslq 0x390(%rax), %rax
imulq $0xc, %rax, %rdi
callq 0x20b0
movq -0x18(%rbp), %rcx
movq %rax, 0x1580(%rcx)
cmpq $0x0, %rax
je 0x24f6
movq -0x18(%rbp), %rax
movslq 0x390(%rax), %rax
imulq $0xc, %rax, %rdi
callq 0x20b0
movq -0x18(%rbp), %rcx
movq %rax, 0x1588(%rcx)
cmpq $0x0, %rax
jne 0x250d
leaq 0xac66(%rip), %rdi      # 0xd163
movb $0x0, %al
callq 0x25d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2522
leaq 0xac63(%rip), %rdi      # 0xd177
movb $0x0, %al
callq 0x2530
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/radforddc[P]icpc_siggen/calc_signal.c
// Function: tell
void tell(const char *format, ...){
  va_list ap;

  va_start(ap, format);
  vprintf(format, ap);
  va_end(ap);
  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x2565
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 -0xd0(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x30, -0x1c(%rbp)
movl $0x8, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2190
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/radforddc[P]icpc_siggen/calc_signal.c
// Function: error
void error(const char *format, ...) {
  va_list ap;

  va_start(ap, format);
  vfprintf(stderr, format, ap);
  va_end(ap);
  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x2605
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 -0xd0(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x30, -0x1c(%rbp)
movl $0x8, -0x20(%rbp)
movq 0xe99c(%rip), %rax      # 0x10ff0
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x2100
addq $0xd0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movss 0x8df8(%rip), %xmm0     # 0xd004
ucomiss -0x14(%rbp), %xmm0
jbe 0x425b
movl -0x18(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jle 0x424b
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x421b
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, (%rax)
jmp 0x42ea
movq -0x8(%rbp), %rax
movss (%rax), %xmm0
movss %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, (%rax)
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x42e8
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movss -0x20(%rbp), %xmm1
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
subss (%rax,%rcx,4), %xmm1
divss -0x14(%rbp), %xmm1
addss %xmm1, %xmm0
movss %xmm0, -0x24(%rbp)
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x20(%rbp)
movss -0x24(%rbp), %xmm0
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x427a
jmp 0x42ea
xorl %eax, %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8780
movq -0x8(%rbp), %rax
movq 0x1588(%rax), %rdi
callq 0x2110
movq -0x8(%rbp), %rax
movq 0x1580(%rax), %rdi
callq 0x2110
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movlpd %xmm0, -0x28(%rbp)
movss %xmm1, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x10(%rbp)
movss -0x18(%rbp), %xmm0
movss -0x18(%rbp), %xmm2
movss -0x14(%rbp), %xmm1
mulss -0x14(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x2250
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0xc(%rbp)
movss -0x18(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x4422
jp 0x4422
movss -0x14(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x4413
movss 0x9080(%rip), %xmm0     # 0xd48c
movss %xmm0, -0x8(%rbp)
jmp 0x4420
movss 0x906d(%rip), %xmm0     # 0xd488
movss %xmm0, -0x8(%rbp)
jmp 0x4467
movss -0x14(%rbp), %xmm0
divss -0x18(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x2120
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x8(%rbp)
xorps %xmm0, %xmm0
ucomiss -0x18(%rbp), %xmm0
jbe 0x4465
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x9028(%rip), %xmm1     # 0xd480
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x8(%rbp)
jmp 0x4467
movss -0x10(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0xc(%rbp), %rax
movq %rax, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
movss -0x30(%rbp), %xmm1
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/radforddc[P]icpc_siggen/cyl_point.c
// Function: cyl_to_cart
struct point cyl_to_cart(struct cyl_pt cyl_pt){
  struct point cart_pt;

  cart_pt.x = cyl_pt.r * cos(cyl_pt.phi);
  cart_pt.y = cyl_pt.r * sin(cyl_pt.phi);
  cart_pt.z = cyl_pt.z;

  return cart_pt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movlpd %xmm0, -0x28(%rbp)
movss %xmm1, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movss -0x18(%rbp), %xmm1
movss -0x14(%rbp), %xmm0
cvtss2sd %xmm1, %xmm1
movsd %xmm1, -0x48(%rbp)
cvtss2sd %xmm0, %xmm0
callq 0x20d0
movaps %xmm0, %xmm1
movsd -0x48(%rbp), %xmm0
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0xc(%rbp)
movss -0x18(%rbp), %xmm1
movss -0x14(%rbp), %xmm0
cvtss2sd %xmm1, %xmm1
movsd %xmm1, -0x40(%rbp)
cvtss2sd %xmm0, %xmm0
callq 0x2270
movaps %xmm0, %xmm1
movsd -0x40(%rbp), %xmm0
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x8(%rbp)
movss -0x10(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0xc(%rbp), %rax
movq %rax, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
movss -0x30(%rbp), %xmm1
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/radforddc[P]icpc_siggen/cyl_point.c
// Function: cyl_diff
struct cyl_pt cyl_diff(struct cyl_pt from, struct cyl_pt to){
  struct cyl_pt v;

  v.r = from.r - to.r;
  v.phi = from.phi - to.phi;
  v.z = from.z - to.z;

  return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movlpd %xmm0, -0x28(%rbp)
movss %xmm1, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movlpd %xmm2, -0x48(%rbp)
movss %xmm3, -0x40(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movss -0x18(%rbp), %xmm0
movss -0x38(%rbp), %xmm1
subss %xmm1, %xmm0
movss %xmm0, -0xc(%rbp)
movss -0x14(%rbp), %xmm0
movss -0x34(%rbp), %xmm1
subss %xmm1, %xmm0
movss %xmm0, -0x8(%rbp)
movss -0x10(%rbp), %xmm0
movss -0x30(%rbp), %xmm1
subss %xmm1, %xmm0
movss %xmm0, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x50(%rbp)
movq -0xc(%rbp), %rax
movq %rax, -0x58(%rbp)
movsd -0x58(%rbp), %xmm0
movss -0x50(%rbp), %xmm1
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movlpd %xmm0, -0x1c(%rbp)
movss %xmm1, -0x14(%rbp)
movq -0x1c(%rbp), %rax
movq %rax, -0xc(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movq %rdi, -0x28(%rbp)
movss -0xc(%rbp), %xmm0
movss -0xc(%rbp), %xmm2
movss -0x4(%rbp), %xmm1
mulss -0x4(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x2250
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x8(%rbp), %xmm0
movq -0x28(%rbp), %rax
movss %xmm0, 0x4(%rax)
movss -0xc(%rbp), %xmm0
divss -0x2c(%rbp), %xmm0
movq -0x28(%rbp), %rax
movss %xmm0, (%rax)
movss -0x4(%rbp), %xmm0
divss -0x2c(%rbp), %xmm0
movq -0x28(%rbp), %rax
movss %xmm0, 0x8(%rax)
movss -0x2c(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movlpd %xmm0, -0x20(%rbp)
movss %xmm1, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x8(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movss -0x10(%rbp), %xmm0
movss -0xc(%rbp), %xmm1
mulss %xmm1, %xmm1
mulss %xmm0, %xmm0
addss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x2250
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x60(%rbp)
movss -0x8(%rbp), %xmm0
movss %xmm0, -0x58(%rbp)
movq -0x30(%rbp), %rsi
movl -0x58(%rbp), %eax
movl %eax, -0x68(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x70(%rbp)
movsd -0x70(%rbp), %xmm0
movss -0x68(%rbp), %xmm1
leaq -0x54(%rbp), %rdi
callq 0x7930
cmpl $0x0, %eax
jge 0x7843
movl $0x1, -0x4(%rbp)
jmp 0x791f
leaq -0x40(%rbp), %rdx
movq -0x30(%rbp), %rcx
movl -0x58(%rbp), %eax
movl %eax, -0x78(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x80(%rbp)
movsd -0x80(%rbp), %xmm0
movss -0x78(%rbp), %xmm1
movq -0x54(%rbp), %rax
movq %rax, -0x90(%rbp)
movl -0x4c(%rbp), %eax
movl %eax, -0x88(%rbp)
movq -0x90(%rbp), %rdi
movl -0x88(%rbp), %esi
callq 0x7b90
movq -0x28(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, (%rax)
movl $0x0, -0x44(%rbp)
cmpl $0x2, -0x44(%rbp)
jge 0x7918
movl $0x0, -0x48(%rbp)
cmpl $0x2, -0x48(%rbp)
jge 0x790b
movslq -0x44(%rbp), %rcx
leaq -0x40(%rbp), %rax
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x48(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x30(%rbp), %rax
movq 0x1478(%rax), %rax
movl -0x54(%rbp), %ecx
addl -0x44(%rbp), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movl -0x4c(%rbp), %ecx
addl -0x48(%rbp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm2
movq -0x28(%rbp), %rax
movss (%rax), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, (%rax)
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x78a8
jmp 0x790d
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x789b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/radforddc[P]icpc_siggen/fields.c
// Function: grid_weights
static int grid_weights(cyl_pt pt, cyl_int_pt ipt, float out[2][2],
			MJD_Siggen_Setup *setup){
  float r, z;

  r = (pt.r - setup->rmin)/setup->rstep - ipt.r;
  z = (pt.z - setup->zmin)/setup->zstep - ipt.z;

  out[0][0] = (1.0 - r) * (1.0 - z);
  out[0][1] = (1.0 - r) *        z;
  out[1][0] =        r  * (1.0 - z);
  out[1][1] =        r  *        z;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movlpd %xmm0, -0x1c(%rbp)
movss %xmm1, -0x14(%rbp)
movq -0x1c(%rbp), %rax
movq %rax, -0xc(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movq %rdi, -0x38(%rbp)
movl %esi, -0x30(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x20(%rbp)
movq %rdx, -0x40(%rbp)
movq %rcx, -0x48(%rbp)
movss -0xc(%rbp), %xmm0
movq -0x48(%rbp), %rax
subss 0x3b0(%rax), %xmm0
movq -0x48(%rbp), %rax
divss 0x3b8(%rax), %xmm0
cvtsi2ssl -0x28(%rbp), %xmm1
subss %xmm1, %xmm0
movss %xmm0, -0x4c(%rbp)
movss -0x4(%rbp), %xmm0
movq -0x48(%rbp), %rax
subss 0x3bc(%rax), %xmm0
movq -0x48(%rbp), %rax
divss 0x3c4(%rax), %xmm0
cvtsi2ssl -0x20(%rbp), %xmm1
subss %xmm1, %xmm0
movss %xmm0, -0x50(%rbp)
movss -0x4c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x5460(%rip), %xmm0     # 0xd090
subsd %xmm1, %xmm0
movss -0x50(%rbp), %xmm1
cvtss2sd %xmm1, %xmm2
movsd 0x544b(%rip), %xmm1     # 0xd090
subsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x40(%rbp), %rax
movss %xmm0, (%rax)
movss -0x4c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x5426(%rip), %xmm0     # 0xd090
subsd %xmm1, %xmm0
movss -0x50(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x40(%rbp), %rax
movss %xmm0, 0x4(%rax)
movss -0x4c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movss -0x50(%rbp), %xmm1
cvtss2sd %xmm1, %xmm2
movsd 0x53ee(%rip), %xmm1     # 0xd090
subsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x40(%rbp), %rax
movss %xmm0, 0x8(%rax)
movss -0x4c(%rbp), %xmm0
mulss -0x50(%rbp), %xmm0
movq -0x40(%rbp), %rax
movss %xmm0, 0xc(%rax)
xorl %eax, %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/radforddc[P]icpc_siggen/fields.c
// Function: efield
static cyl_pt efield(cyl_pt pt, cyl_int_pt ipt, MJD_Siggen_Setup *setup){
  cyl_pt e = {0,0,0}, ef;
  float  w[2][2];
  int    i, j;

  grid_weights(pt, ipt, w, setup);
  for (i = 0; i < 2; i++){
    for (j = 0; j < 2; j++){
      ef = setup->efld[ipt.r + i][ipt.z + j];
      e.r += ef.r*w[i][j];
      e.z += ef.z*w[i][j];
    }
  }
  e.phi = pt.phi;
  return e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movlpd %xmm0, -0x30(%rbp)
movss %xmm1, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x50(%rbp)
movl %esi, -0x48(%rbp)
movl -0x48(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x40(%rbp)
movq %rdx, -0x58(%rbp)
movl $0x0, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
leaq -0x80(%rbp), %rdx
movq -0x58(%rbp), %rcx
movl -0x18(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x98(%rbp)
movsd -0x98(%rbp), %xmm0
movss -0x90(%rbp), %xmm1
movq -0x40(%rbp), %rax
movq %rax, -0xa8(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0xa0(%rbp)
movq -0xa8(%rbp), %rdi
movl -0xa0(%rbp), %esi
callq 0x7b90
movl $0x0, -0x84(%rbp)
cmpl $0x2, -0x84(%rbp)
jge 0x873a
movl $0x0, -0x88(%rbp)
cmpl $0x2, -0x88(%rbp)
jge 0x8724
movq -0x58(%rbp), %rax
movq 0x1470(%rax), %rax
movl -0x40(%rbp), %ecx
addl -0x84(%rbp), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movl -0x38(%rbp), %ecx
addl -0x88(%rbp), %ecx
movslq %ecx, %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0x64(%rbp)
movl 0x8(%rax), %eax
movl %eax, -0x5c(%rbp)
movss -0x64(%rbp), %xmm0
movslq -0x84(%rbp), %rcx
leaq -0x80(%rbp), %rax
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x88(%rbp), %rcx
movss (%rax,%rcx,4), %xmm2
movss -0x10(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x10(%rbp)
movss -0x5c(%rbp), %xmm0
movslq -0x84(%rbp), %rcx
leaq -0x80(%rbp), %rax
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x88(%rbp), %rcx
movss (%rax,%rcx,4), %xmm2
movss -0x8(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x8(%rbp)
movl -0x88(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x88(%rbp)
jmp 0x865e
jmp 0x8726
movl -0x84(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x84(%rbp)
jmp 0x8647
movss -0x1c(%rbp), %xmm0
movss %xmm0, -0xc(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xb0(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
movsd -0xb8(%rbp), %xmm0
movss -0xb0(%rbp), %xmm1
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movss 0x3b4(%rax), %xmm0
movq -0x8(%rbp), %rax
subss 0x3b0(%rax), %xmm0
movq -0x8(%rbp), %rax
divss 0x3b8(%rax), %xmm0
callq 0x2150
movq %rax, %rcx
movq -0x18(%rbp), %rax
addq $0x1, %rcx
cmpq %rcx, %rax
jge 0x880f
movq -0x8(%rbp), %rax
movq 0x1470(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2110
movq -0x8(%rbp), %rax
movq 0x1478(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2110
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8793
movq -0x8(%rbp), %rax
movq 0x1470(%rax), %rdi
callq 0x2110
movq -0x8(%rbp), %rax
movq 0x1478(%rax), %rdi
callq 0x2110
movq -0x8(%rbp), %rax
movq 0x3d8(%rax), %rdi
callq 0x2110
movq -0x8(%rbp), %rax
movq $0x0, 0x1470(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x1478(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x3d8(%rax)
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movss %xmm0, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movss -0x4(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x4bee(%rip), %xmm0     # 0xd490
ucomisd %xmm1, %xmm0
ja 0x88bf
movss -0x4(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x4bdf(%rip), %xmm1     # 0xd498
ucomisd %xmm1, %xmm0
jbe 0x88d8
movss -0x4(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x4d57(%rip), %rdi      # 0xd626
movb $0x1, %al
callq 0x25d0
jmp 0x8909
movss -0x4(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x388(%rax)
movss -0x4(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x4d4b(%rip), %rdi      # 0xd644
movb $0x1, %al
callq 0x25d0
movq -0x10(%rbp), %rdi
callq 0x5590
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/radforddc[P]icpc_siggen/point.c
// Function: vector_norm
float vector_norm(vector v, vector *e){
  float length;
  
  length = vector_length(v);

  e->x = v.x / length;
  e->y = v.y / length;
  e->z = v.z / length;
  
  return length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movlpd %xmm0, -0x20(%rbp)
movss %xmm1, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x8(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq %rdi, -0x28(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
movss -0x38(%rbp), %xmm1
callq 0x8c40
movss %xmm0, -0x2c(%rbp)
movss -0x10(%rbp), %xmm0
divss -0x2c(%rbp), %xmm0
movq -0x28(%rbp), %rax
movss %xmm0, (%rax)
movss -0xc(%rbp), %xmm0
divss -0x2c(%rbp), %xmm0
movq -0x28(%rbp), %rax
movss %xmm0, 0x4(%rax)
movss -0x8(%rbp), %xmm0
divss -0x2c(%rbp), %xmm0
movq -0x28(%rbp), %rax
movss %xmm0, 0x8(%rax)
movss -0x2c(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/radforddc[P]icpc_siggen/point.c
// Function: cross_prod
vector cross_prod(vector v1, vector v2){
  vector v;
  
  v.x = v1.y*v2.z - v1.z*v2.y;
  v.y = v1.z*v2.x - v1.x*v2.z;
  v.z = v1.x*v2.y - v1.y*v2.x;

  return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movlpd %xmm0, -0x28(%rbp)
movss %xmm1, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movlpd %xmm2, -0x48(%rbp)
movss %xmm3, -0x40(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movss -0x34(%rbp), %xmm3
movss -0x30(%rbp), %xmm2
movss -0x14(%rbp), %xmm0
movss -0x10(%rbp), %xmm1
mulss %xmm3, %xmm1
mulss %xmm2, %xmm0
subss %xmm1, %xmm0
movss %xmm0, -0xc(%rbp)
movss -0x18(%rbp), %xmm1
movss -0x10(%rbp), %xmm0
movss -0x38(%rbp), %xmm2
movss -0x30(%rbp), %xmm3
mulss %xmm3, %xmm1
mulss %xmm2, %xmm0
subss %xmm1, %xmm0
movss %xmm0, -0x8(%rbp)
movss -0x38(%rbp), %xmm3
movss -0x34(%rbp), %xmm2
movss -0x18(%rbp), %xmm0
movss -0x14(%rbp), %xmm1
mulss %xmm3, %xmm1
mulss %xmm2, %xmm0
subss %xmm1, %xmm0
movss %xmm0, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x50(%rbp)
movq -0xc(%rbp), %rax
movq %rax, -0x58(%rbp)
movsd -0x58(%rbp), %xmm0
movss -0x50(%rbp), %xmm1
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/radforddc[P]icpc_siggen/point.c
// Function: vector_scale
vector vector_scale(vector v, float factor){
  vector res;

  res.x = v.x*factor;
  res.y = v.y*factor;
  res.z = v.z*factor;

  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movlpd %xmm0, -0x28(%rbp)
movss %xmm1, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movss %xmm2, -0x2c(%rbp)
movss -0x18(%rbp), %xmm0
movss -0x2c(%rbp), %xmm1
mulss %xmm1, %xmm0
movss %xmm0, -0xc(%rbp)
movss -0x14(%rbp), %xmm0
movss -0x2c(%rbp), %xmm1
mulss %xmm1, %xmm0
movss %xmm0, -0x8(%rbp)
movss -0x10(%rbp), %xmm0
movss -0x2c(%rbp), %xmm1
mulss %xmm1, %xmm0
movss %xmm0, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0xc(%rbp), %rax
movq %rax, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
movss -0x38(%rbp), %xmm1
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movlpd %xmm0, -0x28(%rbp)
movss %xmm1, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movss %xmm2, -0x2c(%rbp)
movss -0x2c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x4b6a(%rip), %xmm1     # 0xdbd0
divsd %xmm1, %xmm0
movsd 0x440e(%rip), %xmm1     # 0xd480
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x30(%rbp)
movss -0x30(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x20d0
movsd %xmm0, -0x58(%rbp)
movss -0x18(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x60(%rbp)
movss -0x30(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x2270
movsd -0x60(%rbp), %xmm2
movaps %xmm0, %xmm1
movsd -0x58(%rbp), %xmm0
movss -0x14(%rbp), %xmm3
cvtss2sd %xmm3, %xmm3
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
subsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0xc(%rbp)
movss -0x30(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x2270
movsd %xmm0, -0x48(%rbp)
movss -0x18(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x50(%rbp)
movss -0x30(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x20d0
movsd -0x50(%rbp), %xmm2
movaps %xmm0, %xmm1
movsd -0x48(%rbp), %xmm0
movss -0x14(%rbp), %xmm3
cvtss2sd %xmm3, %xmm3
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x8(%rbp)
movss -0x10(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0xc(%rbp), %rax
movq %rax, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
movss -0x38(%rbp), %xmm1
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)