LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/ADTQueue_test.c
// Function: test_remove
void test_remove(void) {
	Queue queue = queue_create(NULL);
	int N = 1000;
	int* array = malloc(N * sizeof(*array));

	// insert για προσθήκη δεδομένων, χωρίς ελέγχους (έχουμε ξεχωριστό test για το insert)
	for (int i = 0; i < 1000; i++)
		queue_insert_back(queue, &array[i]);

	// Διαδοχικά remove, πρέπει να βγουν με την ίδια σειρά που είναι στο array
	for (int i = 0; i < 1000; i++) {
		TEST_ASSERT(queue_front(queue) == &array[i]);
		queue_remove_front(queue);
		TEST_ASSERT(queue_size(queue) == 999-i);
	}

	queue_destroy(queue);
	free(array);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
xorl %eax, %eax
movl %eax, %edi
callq 0x51f0
movq %rax, -0x8(%rbp)
movl $0x3e8, -0xc(%rbp)      # imm = 0x3E8
movslq -0xc(%rbp), %rdi
shlq $0x2, %rdi
callq 0x2190
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x3e8, -0x1c(%rbp)     # imm = 0x3E8
jge 0x4610
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
callq 0x52d0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x45e4
movl $0x0, -0x20(%rbp)
cmpl $0x3e8, -0x20(%rbp)     # imm = 0x3E8
jge 0x46d7
jmp 0x4626
movq -0x8(%rbp), %rdi
callq 0x5250
movq -0x18(%rbp), %rcx
movslq -0x20(%rbp), %rdx
shlq $0x2, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x1c91(%rip), %rsi      # 0x62e1
movl $0x33, %edx
leaq 0x1df0(%rip), %rcx      # 0x644c
leaq 0x1d0b(%rip), %r8       # 0x636e
movb $0x0, %al
callq 0x2370
cmpl $0x0, %eax
jne 0x4674
callq 0x2e50
jmp 0x4676
movq -0x8(%rbp), %rdi
callq 0x5310
movq -0x8(%rbp), %rdi
callq 0x5230
movl $0x3e7, %ecx            # imm = 0x3E7
subl -0x20(%rbp), %ecx
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x1c40(%rip), %rsi      # 0x62e1
movl $0x35, %edx
leaq 0x1d9f(%rip), %rcx      # 0x644c
leaq 0x1cda(%rip), %r8       # 0x638e
movb $0x0, %al
callq 0x2370
cmpl $0x0, %eax
jne 0x46c5
callq 0x2e50
jmp 0x46c7
jmp 0x46c9
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x4617
movq -0x8(%rbp), %rdi
callq 0x5370
movq -0x18(%rbp), %rdi
callq 0x2030
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/lib/../modules/UsingADTList/ADTQueue.c
// Function: queue_create
Queue queue_create(DestroyFunc destroy_value) {
	// Φτιάχνουμε ένα struct και αποθηκεύουμε μέσα μια νέα λίστα
	//
	Queue queue = malloc(sizeof(*queue));
	queue->list = list_create(destroy_value);
	return queue;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x8, %edi
callq 0x2190
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x53a0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/lib/../modules/UsingLinkedList/ADTList.c
// Function: list_create
List list_create(DestroyFunc destroy_value) {
	// Πρώτα δημιουργούμε το stuct
	List list = malloc(sizeof(*list));
	list->size = 0;
	list->destroy_value = destroy_value;

	// Χρησιμοποιούμε dummy κόμβο, ώστε ακόμα και μια άδεια λίστα να έχει ένα κόμβο
	// (απλοποιεί τους αλγορίθμους). Οπότε πρέπει να τον δημιουργήσουμε.
	//
	list->dummy = malloc(sizeof(*list->dummy));
	list->dummy->next = NULL;		// άδεια λίστα, ο dummy δεν έχει επόμενο

	// Σε μια κενή λίστα, τελευταίος κόμβος είναι επίσης ο dummy
	list->last = list->dummy;

	return list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x20, %edi
callq 0x2190
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movl $0x10, %edi
callq 0x2190
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/lib/../modules/UsingLinkedList/ADTList.c
// Function: list_insert_next
void list_insert_next(List list, ListNode node, Pointer value) {
	// Αν το node είναι NULL απλά εισάγουμε μετά τον dummy κόμβο!
	// Αυτή ακριβώς είναι η αξία του dummy, δε χρειαζόμαστε ξεχωριστή υλοποίηση.
	if (node == NULL)
		node = list->dummy;

	// Δημιουργία του νέου κόμβου
	ListNode new = malloc(sizeof(*new));
	new->value = value;

	// Σύνδεση του new ανάμεσα στο node και το node->next
	new->next = node->next;
	node->next = new;

	// Ενημέρωση των size & last
	list->size++;
	if (list->last == node)
		list->last = new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5456
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x10, %edi
callq 0x2190
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x54b0
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/lib/../modules/UsingLinkedList/ADTList.c
// Function: list_remove_next
void list_remove_next(List list, ListNode node) {
	// Αν το node είναι NULL απλά διαγράφουμε μετά τον dummy κόμβο!
	// Αυτή ακριβώς είναι η αξία του dummy, δε χρειαζόμαστε ξεχωριστή υλοποίηση.
	if (node == NULL)
		node = list->dummy;

	// Ο κόμβος προς διαγραφή είναι ο επόμενος του node, ο οποίος πρέπει να υπάρχει
	ListNode removed = node->next;
	assert(removed != NULL);		// LCOV_EXCL_LINE

	if (list->destroy_value != NULL)
		list->destroy_value(removed->value);

	// Σύνδεση του node με τον επόμενο του removed
	node->next = removed->next;		// πριν το free!

	free(removed);

	// Ενημέρωση των size & last
	list->size--;
	if (list->last == removed)
		list->last = node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x54e2
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x54f6
jmp 0x5515
leaq 0x18f3(%rip), %rdi      # 0x6df0
leaq 0x18fc(%rip), %rsi      # 0x6e00
movl $0x4d, %edx
leaq 0x1915(%rip), %rcx      # 0x6e25
callq 0x2100
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x5532
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rdi
callq *%rax
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x5570
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/lib/../modules/UsingLinkedList/ADTList.c
// Function: list_find_node
ListNode list_find_node(List list, Pointer value, CompareFunc compare) {
	// διάσχιση όλης της λίστας, καλούμε την compare μέχρι να επιστρέψει 0
	//
	for (ListNode node = list->dummy->next; node != NULL; node = node->next)
		if (compare(value, node->value) == 0)
			return node;		// βρέθηκε

	return NULL;	// δεν υπάρχει
}

// 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
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x5629
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rsi
callq *%rax
cmpl $0x0, %eax
jne 0x561a
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5631
jmp 0x561c
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x55f2
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/lib/../modules/UsingLinkedList/ADTList.c
// Function: list_destroy
void list_destroy(List list) {
	// Διασχίζουμε όλη τη λίστα και κάνουμε free όλους τους κόμβους,
	// συμπεριλαμβανομένου και του dummy!
	//
	ListNode node = list->dummy;
	while (node != NULL) {				// while αντί για for, γιατί θέλουμε να διαβάσουμε
		ListNode next = node->next;		// το node->next _πριν_ κάνουμε free!

		// Καλούμε τη destroy_value, αν υπάρχει (προσοχή, όχι στον dummy!)
		if (node != list->dummy && list->destroy_value != NULL)
			list->destroy_value(node->value);

		free(node);
		node = next;
	}

	// Τέλος free το ίδιο το struct
	free(list);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x56d6
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
je 0x56c3
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x56c3
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdi
callq *%rax
movq -0x10(%rbp), %rdi
callq 0x2030
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x5687
movq -0x8(%rbp), %rdi
callq 0x2030
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/lib/../modules/UsingLinkedList/ADTList.c
// Function: list_last
ListNode list_last(List list) {
	// Προσοχή, αν η λίστα είναι κενή το last δείχνει στον dummy, εμείς όμως θέλουμε να επιστρέψουμε NULL, όχι τον dummy!
	//
	if (list->last == list->dummy)
		return LIST_EOF;		// κενή λίστα
	else
		return list->last;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x5733
movq $0x0, -0x8(%rbp)
jmp 0x573f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: memalloc
void* memalloc(size_t size) {
  void* ans = malloc(size);
  if (ans == NULL)
    exit(error("", ERRMEM));
  return ans;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2230
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x28c8
leaq 0x1d4bb(%rip), %rdi     # 0x1fd72
movl $0x4, %esi
callq 0x2840
movl %eax, %edi
callq 0x22b0
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: memrealloc
void* memrealloc(void* ptr, size_t size) {
  void* ans = realloc(ptr, size);
  if (ans == NULL)
    exit(error("", ERRMEM));
  return ans;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x2250
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x2920
leaq 0x1d463(%rip), %rdi     # 0x1fd72
movl $0x4, %esi
callq 0x2840
movl %eax, %edi
callq 0x22b0
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: getFloat
float getFloat(char* in) {
  char* endptr;
  float ans = strtof(in, &endptr);
  if (*endptr != '\0')
    exit(error(in, ERRFLOAT));
  return ans;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2130
movss %xmm0, 0x4(%rsp)
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x2971
movq 0x10(%rsp), %rdi
movl $0x6, %esi
callq 0x2840
movl %eax, %edi
callq 0x22b0
movss 0x4(%rsp), %xmm0
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: getInt
int getInt(char* in) {
  char* endptr;
  int ans = (int) strtol(in, &endptr, 10);
  if (*endptr != '\0')
    exit(error(in, ERRINT));
  return ans;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl $0xa, %edx
callq 0x21f0
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x29c4
movq 0x10(%rsp), %rdi
movl $0x5, %esi
callq 0x2840
movl %eax, %edi
callq 0x22b0
movl 0x4(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: getLong
uint64_t getLong(char* in) {
  char* endptr;
  uint64_t ans = (uint64_t) strtol(in, &endptr, 10);
  if (*endptr != '\0')
    exit(error(in, ERRINT));
  return ans;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl $0xa, %edx
callq 0x21f0
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x2a14
movq 0x10(%rsp), %rdi
movl $0x5, %esi
callq 0x2840
movl %eax, %edi
callq 0x22b0
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: getLine
char* getLine(char* line, int size, File in, bool gz) {
  if (gz)
    return gzgets(in.gzf, line, size);
  else
    return fgets(line, size, in.f);
}

// Assembly:
subq $0x28, %rsp
movb %cl, %al
movq %rdx, 0x18(%rsp)
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
andb $0x1, %al
movb %al, 0xb(%rsp)
testb $0x1, 0xb(%rsp)
je 0x2a5b
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0xc(%rsp), %edx
callq 0x2090
movq %rax, 0x20(%rsp)
jmp 0x2a73
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
movq 0x18(%rsp), %rdx
callq 0x2190
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: partition
int64_t partition(float* pVal, uint64_t* pEnd,
    int64_t low, int64_t high) {
  float pivot = pVal[high];  // pivot value: last elt
  int64_t idx = low - 1;

  for (int64_t j = low; j < high; j++) {
    if (pVal[j] < pivot) {
      idx++;
      swapFloat(pVal + idx, pVal + j);
      swapInt(pEnd + idx, pEnd + j);  // swap int values too
    }
  }
  idx++;
  swapFloat(pVal + idx, pVal + high);
  swapInt(pEnd + idx, pEnd + high);
  return idx;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq 0x18(%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, 0x14(%rsp)
movq 0x20(%rsp), %rax
subq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
cmpq 0x18(%rsp), %rax
jge 0x2bd9
movq 0x30(%rsp), %rax
movq (%rsp), %rcx
movss (%rax,%rcx,4), %xmm1
movss 0x14(%rsp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x2bc6
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq 0x30(%rsp), %rsi
movq (%rsp), %rax
shlq $0x2, %rax
addq %rax, %rsi
callq 0x2a80
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq 0x28(%rsp), %rsi
movq (%rsp), %rax
shlq $0x3, %rax
addq %rax, %rsi
callq 0x2ac0
jmp 0x2bc8
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x2b44
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq 0x30(%rsp), %rsi
movq 0x18(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rsi
callq 0x2a80
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq 0x28(%rsp), %rsi
movq 0x18(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rsi
callq 0x2ac0
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: quickSort
void quickSort(float* pVal, uint64_t* pEnd,
    int64_t low, int64_t high) {
  if (low < high) {
    int64_t idx = partition(pVal, pEnd, low, high);
    quickSort(pVal, pEnd, low, idx - 1);
    quickSort(pVal, pEnd, idx + 1, high);
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jge 0x2cb9
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x2b00
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq (%rsp), %rcx
subq $0x1, %rcx
callq 0x2c40
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq (%rsp), %rdx
addq $0x1, %rdx
movq 0x8(%rsp), %rcx
callq 0x2c40
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: lookup
float lookup(float* pVal, uint64_t low, uint64_t high,
    float* qVal, float p) {
  if (low == high)
    return qVal[low];
  uint64_t idx = (low + high) / 2;
  if (pVal[idx] == p)
    return qVal[idx];
  if (pVal[idx] > p)
    return lookup(pVal, low, idx - 1, qVal, p);
  return lookup(pVal, idx + 1, high, qVal, p);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movss %xmm0, 0xc(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
jne 0x2d04
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, 0x34(%rsp)
jmp 0x2da9
movq 0x20(%rsp), %rax
addq 0x18(%rsp), %rax
shrq %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rax
movq (%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
ucomiss 0xc(%rsp), %xmm0
jne 0x2d42
jp 0x2d42
movq 0x10(%rsp), %rax
movq (%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, 0x34(%rsp)
jmp 0x2da9
movq 0x28(%rsp), %rax
movq (%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
ucomiss 0xc(%rsp), %xmm0
jbe 0x2d81
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq (%rsp), %rdx
subq $0x1, %rdx
movq 0x10(%rsp), %rcx
movss 0xc(%rsp), %xmm0
callq 0x2cc0
movss %xmm0, 0x34(%rsp)
jmp 0x2da9
movq 0x28(%rsp), %rdi
movq (%rsp), %rsi
addq $0x1, %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
movss 0xc(%rsp), %xmm0
callq 0x2cc0
movss %xmm0, 0x34(%rsp)
movss 0x34(%rsp), %xmm0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: jenkins_one_at_a_time_hash
uint32_t jenkins_one_at_a_time_hash(float f) {
  uint32_t hash = 0;
  unsigned char* p = (unsigned char*) &f;
  for (int i = 0; i < sizeof(float); i++) {
    hash += p[i];
    hash += hash << 10;
    hash ^= hash >> 6;
  }
  hash += hash << 3;
  hash ^= hash >> 11;
  hash += hash << 15;
  return hash % HASH_SIZE;
}

// Assembly:
movss %xmm0, -0x4(%rsp)
movl $0x0, -0x8(%rsp)
leaq -0x4(%rsp), %rax
movq %rax, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
movslq -0x14(%rsp), %rax
cmpq $0x4, %rax
jae 0x33ac
movq -0x10(%rsp), %rax
movslq -0x14(%rsp), %rcx
movzbl (%rax,%rcx), %eax
addl -0x8(%rsp), %eax
movl %eax, -0x8(%rsp)
movl -0x8(%rsp), %eax
shll $0xa, %eax
addl -0x8(%rsp), %eax
movl %eax, -0x8(%rsp)
movl -0x8(%rsp), %eax
shrl $0x6, %eax
xorl -0x8(%rsp), %eax
movl %eax, -0x8(%rsp)
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x3360
movl -0x8(%rsp), %eax
shll $0x3, %eax
addl -0x8(%rsp), %eax
movl %eax, -0x8(%rsp)
movl -0x8(%rsp), %eax
shrl $0xb, %eax
xorl -0x8(%rsp), %eax
movl %eax, -0x8(%rsp)
movl -0x8(%rsp), %eax
shll $0xf, %eax
addl -0x8(%rsp), %eax
movl %eax, -0x8(%rsp)
movl -0x8(%rsp), %eax
movl $0x13fed1, %ecx         # imm = 0x13FED1
xorl %edx, %edx
divl %ecx
movl %edx, %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: recordPval
int recordPval(Hash** table, float p, uint32_t length) {

  // check hashtable for matching p-value
  uint32_t idx = jenkins_one_at_a_time_hash(p);
  for (Hash* h = table[idx]; h != NULL; h = h->next)
    if (p == h->val) {
      // match: add length to bucket
      h->len += length;
      return 0;
    }

  // no match: add info into bucket
  Hash* newVal = (Hash*) memalloc(sizeof(Hash));
  newVal->val = p;
  newVal->len = length;
  newVal->next = table[idx];
  table[idx] = newVal;
  return 1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movss %xmm0, 0x24(%rsp)
movl %esi, 0x20(%rsp)
movss 0x24(%rsp), %xmm0
callq 0x3340
movl %eax, 0x1c(%rsp)
movq 0x28(%rsp), %rax
movl 0x1c(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x346d
movss 0x24(%rsp), %xmm0
movq 0x10(%rsp), %rax
ucomiss (%rax), %xmm0
jne 0x345b
jp 0x345b
movl 0x20(%rsp), %eax
movl %eax, %ecx
movq 0x10(%rsp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movl $0x0, 0x34(%rsp)
jmp 0x34ca
jmp 0x345d
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x3424
movl $0x18, %edi
callq 0x2890
movq %rax, 0x8(%rsp)
movss 0x24(%rsp), %xmm0
movq 0x8(%rsp), %rax
movss %xmm0, (%rax)
movl 0x20(%rsp), %eax
movl %eax, %ecx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x28(%rsp), %rax
movl 0x1c(%rsp), %ecx
movq (%rax,%rcx,8), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rdx
movq 0x28(%rsp), %rax
movl 0x1c(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: hashPval
Hash** hashPval(Chrom* chrom, int chromLen, int n,
    int64_t* pLen) {

  // create hashtable for conversion of p-values to q-values
  Hash** table = (Hash**) memalloc(HASH_SIZE * sizeof(Hash*));
  for (int i = 0; i < HASH_SIZE; i++)
    table[i] = NULL;

  // loop through chroms
  for (int i = 0; i < chromLen; i++) {
    Chrom* chr = chrom + i;
    if (chr->skip || chr->pval[n] == NULL)
      continue;

    // populate hashtable
    Pileup* p = chr->pval[n]; // use the last p-value array
    uint32_t start = 0;
    for (uint32_t m = 0; m < chr->pvalLen[n]; m++) {
      // record p-value and length in hashtable
      if (p->cov[m] != SKIP)
        *pLen += recordPval(table, p->cov[m],
          p->end[m] - start);
      start = p->end[m];
    }
  }

  return table;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movl %edx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movl $0x9ff688, %edi         # imm = 0x9FF688
callq 0x2890
movq %rax, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
cmpl $0x13fed1, 0x24(%rsp)   # imm = 0x13FED1
jge 0x3536
movq 0x28(%rsp), %rax
movslq 0x24(%rsp), %rcx
movq $0x0, (%rax,%rcx,8)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x350d
movl $0x0, 0x20(%rsp)
movl 0x20(%rsp), %eax
cmpl 0x3c(%rsp), %eax
jge 0x365e
movq 0x40(%rsp), %rax
movslq 0x20(%rsp), %rcx
imulq $0x68, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
testb $0x1, 0xc(%rax)
jne 0x3582
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rax
movslq 0x38(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x3587
jmp 0x364e
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rax
movslq 0x38(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x18(%rsp), %rcx
movq 0x50(%rcx), %rcx
movslq 0x38(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
jae 0x364c
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x8(%rsp), %ecx
movss (%rax,%rcx,4), %xmm0
movss 0x1abb1(%rip), %xmm1    # 0x1e194
ucomiss %xmm1, %xmm0
jne 0x35ec
jp 0x35ec
jmp 0x3629
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x8(%rsp), %ecx
movss (%rax,%rcx,4), %xmm0
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl 0x8(%rsp), %ecx
movl (%rax,%rcx,4), %esi
subl 0xc(%rsp), %esi
callq 0x33f0
movslq %eax, %rcx
movq 0x30(%rsp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl 0x8(%rsp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, 0xc(%rsp)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x35ae
jmp 0x364e
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x353e
movq 0x28(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: collectPval
float* collectPval(Hash** table, uint64_t** pEnd,
    int64_t pLen, uint64_t* checkLen) {
  float* pVal = (float*) memalloc(pLen * sizeof(float));
  int64_t idx = 0;
  for (int i = 0; i < HASH_SIZE; i++)
    for (Hash* h = table[i]; h != NULL; h = h->next) {
      pVal[idx] = h->val;
      (*pEnd)[idx] = h->len;
      *checkLen += h->len;
      idx++;
    }
  if (idx != pLen)
    exit(error(errMsg[ERRPVAL], ERRISSUE));
  return pVal;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x30(%rsp), %rdi
shlq $0x2, %rdi
callq 0x2890
movq %rax, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
cmpl $0x13fed1, 0x14(%rsp)   # imm = 0x13FED1
jge 0x374b
movq 0x40(%rsp), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x3739
movq 0x8(%rsp), %rax
movss (%rax), %xmm0
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
movss %xmm0, (%rax,%rcx,4)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdx
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x28(%rsp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x36cd
jmp 0x373b
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x36ac
movq 0x18(%rsp), %rax
cmpq 0x30(%rsp), %rax
je 0x376f
movq 0x1fb42(%rip), %rdi     # 0x232a0
movl $0x21, %esi
callq 0x2840
movl %eax, %edi
callq 0x22b0
movq 0x20(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: bd0
double bd0(double x, double np) {
  double ej, s, s1, v;
  if (fabs(x-np) < 0.1*(x+np)) {
    v = (x-np)/(x+np);
    s = (x-np)*v;
    if (fabs(s) < DBL_MIN)
      return s;
    ej = 2*x*v;
    v = v*v;
    for (int j = 1; j < 1000; j++) {
      ej *= v;
      s1 = s+ej/((j<<1)+1);
      if (s1 == s)
        return s1;
      s = s1;
    }
  }
  return x * log(x / np) + np - x;
}

// Assembly:
subq $0x48, %rsp
movsd %xmm0, 0x38(%rsp)
movsd %xmm1, 0x30(%rsp)
movsd 0x38(%rsp), %xmm1
subsd 0x30(%rsp), %xmm1
movaps 0x1a72d(%rip), %xmm0    # 0x1e1d0
pand %xmm0, %xmm1
movsd 0x38(%rsp), %xmm2
addsd 0x30(%rsp), %xmm2
movsd 0x1a55d(%rip), %xmm0    # 0x1e018
mulsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x3be3
movsd 0x38(%rsp), %xmm0
subsd 0x30(%rsp), %xmm0
movsd 0x38(%rsp), %xmm1
addsd 0x30(%rsp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x38(%rsp), %xmm0
subsd 0x30(%rsp), %xmm0
mulsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm1
movaps 0x1a6c0(%rip), %xmm0    # 0x1e1d0
pand %xmm0, %xmm1
movsd 0x1a504(%rip), %xmm0    # 0x1e020
ucomisd %xmm1, %xmm0
jbe 0x3b33
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x40(%rsp)
jmp 0x3c21
movsd 0x1a4ed(%rip), %xmm0    # 0x1e028
mulsd 0x38(%rsp), %xmm0
mulsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x10(%rsp), %xmm0
mulsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movl $0x1, 0xc(%rsp)
cmpl $0x3e8, 0xc(%rsp)       # imm = 0x3E8
jge 0x3be1
movsd 0x10(%rsp), %xmm0
mulsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x20(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
movl 0xc(%rsp), %eax
shll %eax
addl $0x1, %eax
cvtsi2sd %eax, %xmm2
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
ucomisd 0x20(%rsp), %xmm0
jne 0x3bc8
jp 0x3bc8
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x40(%rsp)
jmp 0x3c21
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x3b67
jmp 0x3be3
movsd 0x38(%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x38(%rsp), %xmm0
divsd 0x30(%rsp), %xmm0
callq 0x2170
movaps %xmm0, %xmm2
movsd (%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
subsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x40(%rsp)
movsd 0x40(%rsp), %xmm0
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: stirlerr
double stirlerr(double n) {
  double S0 = 1.0 / 12;
  double S1 = 1.0 / 360;
  double S2 = 1.0 / 1260;
  double S3 = 1.0 / 1680;
  double S4 = 1.0 / 1188;
  double sferr[16] = {
    0.0,
    0.0810614667953272582196702,
    0.0413406959554092940938221,
    0.02767792568499833914878929,
    0.02079067210376509311152277,
    0.01664469118982119216319487,
    0.01387612882307074799874573,
    0.01189670994589177009505572,
    0.010411265261972096497478567,
    0.009255462182712732917728637,
    0.008330563433362871256469318,
    0.007573675487951840794972024,
    0.006942840107209529865664152,
    0.006408994188004207068439631,
    0.005951370112758847735624416,
    0.005554733551962801371038690
  };

  double nn = n * n;
  if (n > 80.0)
    return (S0-(S1-S2/nn)/nn)/n;
  if (n > 35.0)
    return (S0-(S1-(S2-S3/nn)/nn)/nn)/n;
  if (n > 15.0)
    return (S0-(S1-(S2-(S3-S4/nn)/nn)/nn)/nn)/n;
  return sferr[(int) n];
}

// Assembly:
subq $0xc8, %rsp
movsd %xmm0, 0xb8(%rsp)
movsd 0x1a410(%rip), %xmm0    # 0x1e058
movsd %xmm0, 0xb0(%rsp)
movsd 0x1a3f7(%rip), %xmm0    # 0x1e050
movsd %xmm0, 0xa8(%rsp)
movsd 0x1a3de(%rip), %xmm0    # 0x1e048
movsd %xmm0, 0xa0(%rsp)
movsd 0x1a3c5(%rip), %xmm0    # 0x1e040
movsd %xmm0, 0x98(%rsp)
movsd 0x1a3ac(%rip), %xmm0    # 0x1e038
movsd %xmm0, 0x90(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x1a96f(%rip), %rsi     # 0x1e610
movl $0x80, %edx
callq 0x2200
movsd 0xb8(%rsp), %xmm0
mulsd 0xb8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0xb8(%rsp), %xmm0
movsd 0x1a35c(%rip), %xmm1    # 0x1e030
ucomisd %xmm1, %xmm0
jbe 0x3d20
movsd 0xb0(%rsp), %xmm0
movsd 0xa8(%rsp), %xmm1
movsd 0xa0(%rsp), %xmm2
divsd 0x8(%rsp), %xmm2
subsd %xmm2, %xmm1
divsd 0x8(%rsp), %xmm1
subsd %xmm1, %xmm0
divsd 0xb8(%rsp), %xmm0
movsd %xmm0, 0xc0(%rsp)
jmp 0x3e2a
movsd 0xb8(%rsp), %xmm0
movsd 0x1a32f(%rip), %xmm1    # 0x1e060
ucomisd %xmm1, %xmm0
jbe 0x3d90
movsd 0xb0(%rsp), %xmm0
movsd 0xa8(%rsp), %xmm1
movsd 0xa0(%rsp), %xmm2
movsd 0x98(%rsp), %xmm3
divsd 0x8(%rsp), %xmm3
subsd %xmm3, %xmm2
divsd 0x8(%rsp), %xmm2
subsd %xmm2, %xmm1
divsd 0x8(%rsp), %xmm1
subsd %xmm1, %xmm0
divsd 0xb8(%rsp), %xmm0
movsd %xmm0, 0xc0(%rsp)
jmp 0x3e2a
movsd 0xb8(%rsp), %xmm0
movsd 0x1a2c7(%rip), %xmm1    # 0x1e068
ucomisd %xmm1, %xmm0
jbe 0x3e10
movsd 0xb0(%rsp), %xmm0
movsd 0xa8(%rsp), %xmm1
movsd 0xa0(%rsp), %xmm2
movsd 0x98(%rsp), %xmm3
movsd 0x90(%rsp), %xmm4
divsd 0x8(%rsp), %xmm4
subsd %xmm4, %xmm3
divsd 0x8(%rsp), %xmm3
subsd %xmm3, %xmm2
divsd 0x8(%rsp), %xmm2
subsd %xmm2, %xmm1
divsd 0x8(%rsp), %xmm1
subsd %xmm1, %xmm0
divsd 0xb8(%rsp), %xmm0
movsd %xmm0, 0xc0(%rsp)
jmp 0x3e2a
cvttsd2si 0xb8(%rsp), %eax
cltq
movsd 0x10(%rsp,%rax,8), %xmm0
movsd %xmm0, 0xc0(%rsp)
movsd 0xc0(%rsp), %xmm0
addq $0xc8, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: pd_upper_series
double pd_upper_series(double x, double alph) {
  double term = x / alph;
  double sum = term;
  do {
    alph++;
    term *= x / alph;
    sum += term;
  } while (term > sum * DBL_EPSILON);
  return log(sum);
}

// Assembly:
subq $0x28, %rsp
movsd %xmm0, 0x20(%rsp)
movsd %xmm1, 0x18(%rsp)
movsd 0x20(%rsp), %xmm0
divsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x1a17a(%rip), %xmm0    # 0x1e080
addsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x20(%rsp), %xmm0
divsd 0x18(%rsp), %xmm0
mulsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
addsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
movsd 0x1a13e(%rip), %xmm1    # 0x1e088
mulsd 0x8(%rsp), %xmm1
ucomisd %xmm1, %xmm0
ja 0x3efe
movsd 0x8(%rsp), %xmm0
callq 0x2170
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: pd_lower_series
double pd_lower_series(double lambda, double y) {
  double term = 1, sum = 0;
  while (y >= 1 && term > sum * DBL_EPSILON) {
    term *= y / lambda;
    sum += term;
    y--;
  }
  return log1p(sum);
}

// Assembly:
subq $0x28, %rsp
movsd %xmm0, 0x20(%rsp)
movsd %xmm1, 0x18(%rsp)
movsd 0x1a0f8(%rip), %xmm0    # 0x1e080
movsd %xmm0, 0x10(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x18(%rsp), %xmm0
xorl %eax, %eax
movsd 0x1a0d9(%rip), %xmm1    # 0x1e080
ucomisd %xmm1, %xmm0
movb %al, 0x7(%rsp)
jb 0x3fd0
movsd 0x10(%rsp), %xmm0
movsd 0x1a0c9(%rip), %xmm1    # 0x1e088
mulsd 0x8(%rsp), %xmm1
ucomisd %xmm1, %xmm0
seta %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x3fda
jmp 0x401d
movsd 0x18(%rsp), %xmm0
divsd 0x20(%rsp), %xmm0
mulsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
addsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x1a084(%rip), %xmm0    # 0x1e090
addsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
jmp 0x3f97
movsd 0x8(%rsp), %xmm0
callq 0x2160
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: pgamma_smallx
double pgamma_smallx(double x, double alph) {
  double sum = 0.0;
  double c = alph;
  double n = 0.0;
  double term;
  do {
    n++;
    c *= -x / n;
    term = c / (alph + n);
    sum += term;
  } while (fabs(term) > DBL_EPSILON * fabs(sum));
  double lf2 = alph * log(x) - lgamma(alph + 1);
  return R_Log1_Exp(log1p(sum) + lf2);
}

// Assembly:
subq $0x58, %rsp
movsd %xmm0, 0x50(%rsp)
movsd %xmm1, 0x48(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x40(%rsp)
movsd 0x48(%rsp), %xmm0
movsd %xmm0, 0x38(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x1a01a(%rip), %xmm0    # 0x1e080
addsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x50(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
divsd 0x30(%rsp), %xmm0
mulsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x38(%rsp)
movsd 0x38(%rsp), %xmm0
movsd 0x48(%rsp), %xmm1
addsd 0x30(%rsp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x28(%rsp), %xmm0
addsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x40(%rsp)
movsd 0x28(%rsp), %xmm0
movaps 0x1a0f4(%rip), %xmm1    # 0x1e1d0
pand %xmm1, %xmm0
movsd 0x40(%rsp), %xmm2
movaps 0x1a0e3(%rip), %xmm1    # 0x1e1d0
pand %xmm1, %xmm2
movsd 0x19f8f(%rip), %xmm1    # 0x1e088
mulsd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
ja 0x405e
movsd 0x48(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x50(%rsp), %xmm0
callq 0x2170
movsd %xmm0, 0x10(%rsp)
movsd 0x19f54(%rip), %xmm0    # 0x1e080
addsd 0x48(%rsp), %xmm0
callq 0x21e0
movsd 0x10(%rsp), %xmm2
movaps %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x40(%rsp), %xmm0
callq 0x2160
addsd 0x20(%rsp), %xmm0
movsd 0x19f14(%rip), %xmm1    # 0x1e098
ucomisd %xmm1, %xmm0
jbe 0x41c4
movsd 0x40(%rsp), %xmm0
callq 0x2160
addsd 0x20(%rsp), %xmm0
callq 0x2210
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
callq 0x2170
movsd %xmm0, 0x8(%rsp)
jmp 0x41fc
movsd 0x40(%rsp), %xmm0
callq 0x2160
addsd 0x20(%rsp), %xmm0
callq 0x22d0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
callq 0x2160
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: pgamma
double pgamma(double x, double alph) {

  if (x < 1)
    // small values of x
    return pgamma_smallx(x, alph);

  else if (x <= alph - 1) {
    // larger alph than x
    double sum = pd_upper_series(x, alph);
    double d = dpois(alph - 1, x);
    return R_Log1_Exp(sum + d);
  }

  // x > alph - 1
  double sum = pd_lower_series(x, alph - 1);
  double d = dpois(alph - 1, x);
  return sum + d;
}

// Assembly:
subq $0x48, %rsp
movsd %xmm0, 0x38(%rsp)
movsd %xmm1, 0x30(%rsp)
movsd 0x19e58(%rip), %xmm0    # 0x1e080
ucomisd 0x38(%rsp), %xmm0
jbe 0x424c
movsd 0x38(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
callq 0x4030
movsd %xmm0, 0x40(%rsp)
jmp 0x4392
movsd 0x38(%rsp), %xmm1
movsd 0x30(%rsp), %xmm0
movsd 0x19e20(%rip), %xmm2    # 0x1e080
subsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jb 0x4338
movsd 0x38(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
callq 0x3ed0
movsd %xmm0, 0x28(%rsp)
movsd 0x30(%rsp), %xmm0
movsd 0x19ded(%rip), %xmm1    # 0x1e080
subsd %xmm1, %xmm0
movsd 0x38(%rsp), %xmm1
callq 0x3e40
movsd %xmm0, 0x20(%rsp)
movsd 0x28(%rsp), %xmm0
addsd 0x20(%rsp), %xmm0
movsd 0x19ddc(%rip), %xmm1    # 0x1e098
ucomisd %xmm1, %xmm0
jbe 0x42f7
movsd 0x28(%rsp), %xmm0
addsd 0x20(%rsp), %xmm0
callq 0x2210
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
callq 0x2170
movsd %xmm0, 0x8(%rsp)
jmp 0x432a
movsd 0x28(%rsp), %xmm0
addsd 0x20(%rsp), %xmm0
callq 0x22d0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
callq 0x2160
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x40(%rsp)
jmp 0x4392
jmp 0x433a
movsd 0x38(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
movsd 0x19d32(%rip), %xmm2    # 0x1e080
subsd %xmm2, %xmm1
callq 0x3f70
movsd %xmm0, 0x18(%rsp)
movsd 0x30(%rsp), %xmm0
movsd 0x19d15(%rip), %xmm1    # 0x1e080
subsd %xmm1, %xmm0
movsd 0x38(%rsp), %xmm1
callq 0x3e40
movsd %xmm0, 0x10(%rsp)
movsd 0x18(%rsp), %xmm0
addsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x40(%rsp)
movsd 0x40(%rsp), %xmm0
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: multPval
float multPval(Pileup** pval, int n, uint32_t idx[]) {
  double sum = 0.0;
  int df = 0;
  for (int j = 0; j < n; j++)
    if (pval[j] != NULL && pval[j]->cov[idx[j]] != SKIP) {
      sum += pval[j]->cov[idx[j]];
      df += 2;
    }
  if (df == 0)
    return SKIP;
  if (df == 2 || ! sum)
    return (float) sum;

  // calculate p-value using chi-squared dist.
  double p = pchisq(2.0 * sum / M_LOG10E, df);
  return p > FLT_MAX ? FLT_MAX : (float) p;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq %rdx, 0x28(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x34(%rsp), %eax
jge 0x4530
movq 0x38(%rsp), %rax
movslq 0x18(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x451e
movq 0x38(%rsp), %rax
movslq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq 0x28(%rsp), %rcx
movslq 0x18(%rsp), %rdx
movl (%rcx,%rdx,4), %ecx
movss (%rax,%rcx,4), %xmm0
movss 0x19cbe(%rip), %xmm1    # 0x1e194
ucomiss %xmm1, %xmm0
jne 0x44df
jp 0x44df
jmp 0x451e
movq 0x38(%rsp), %rax
movslq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq 0x28(%rsp), %rcx
movslq 0x18(%rsp), %rdx
movl (%rcx,%rdx,4), %ecx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
addsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movl 0x1c(%rsp), %eax
addl $0x2, %eax
movl %eax, 0x1c(%rsp)
jmp 0x4520
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x448b
cmpl $0x0, 0x1c(%rsp)
jne 0x454a
movss 0x19c55(%rip), %xmm0    # 0x1e194
movss %xmm0, 0x44(%rsp)
jmp 0x45dd
cmpl $0x2, 0x1c(%rsp)
je 0x4562
movsd 0x20(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x4574
jp 0x4574
movsd 0x20(%rsp), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x44(%rsp)
jmp 0x45dd
movsd 0x19aac(%rip), %xmm0    # 0x1e028
mulsd 0x20(%rsp), %xmm0
movsd 0x19b26(%rip), %xmm1    # 0x1e0b0
divsd %xmm1, %xmm0
movl 0x1c(%rsp), %edi
callq 0x43a0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
movsd 0x19afd(%rip), %xmm1    # 0x1e0a8
ucomisd %xmm1, %xmm0
jbe 0x45c1
movss 0x19bd7(%rip), %xmm0    # 0x1e190
movss %xmm0, 0xc(%rsp)
jmp 0x45d1
movsd 0x10(%rsp), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
movss 0xc(%rsp), %xmm0
movss %xmm0, 0x44(%rsp)
movss 0x44(%rsp), %xmm0
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: countIntervals2
uint32_t countIntervals2(Chrom* c, int n) {
  uint32_t num = 1;
  uint32_t idx[n];  // indexes into each pval array
  for (int j = 0; j < n; j++)
    idx[j] = 0;
  for (uint32_t k = 1; k < c->len; k++) {
    bool add = false;
    for (int j = 0; j < n; j++)
      if (c->pval[j] != NULL
          && c->pval[j]->end[idx[j]] == k) {
        if (! add) {
          num++;
          add = true;
        }
        idx[j]++;
      }
  }
  return num;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x1, -0x10(%rbp)
movl -0xc(%rbp), %eax
movq %rsp, %rcx
movq %rcx, -0x18(%rbp)
leaq 0xf(,%rax,4), %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x38(%rbp)
movq %rcx, %rsp
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x4656
movq -0x38(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x4634
movl $0x1, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jae 0x46fa
movb $0x0, -0x29(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x46ea
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0x30(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x46dd
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0x30(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movq (%rax), %rax
movslq -0x30(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
movl (%rax,%rcx,4), %eax
cmpl -0x28(%rbp), %eax
jne 0x46dd
testb $0x1, -0x29(%rbp)
jne 0x46cc
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movb $0x1, -0x29(%rbp)
movq -0x38(%rbp), %rax
movslq -0x30(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
jmp 0x46df
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x4678
jmp 0x46ec
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x465d
movl -0x10(%rbp), %eax
movq -0x18(%rbp), %rcx
movq %rcx, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: checkPeak
void checkPeak(File out, bool gzOut, char* name,
    int64_t start, int64_t end, int* count, float auc,
    float pval, float qval, uint32_t pos, float minAUC,
    int minLen, uint64_t* peakBP) {
  if (start != -1 && auc >= minAUC
      && end - start >= minLen) {
    printPeak(out, gzOut, name, start, end, *count,
      auc, pval, qval, pos);
    (*peakBP) += end - start;
    (*count)++;
  }
}

// Assembly:
subq $0x48, %rsp
movb %sil, %al
movq 0x60(%rsp), %rsi
movl 0x58(%rsp), %esi
movl 0x50(%rsp), %esi
movq %rdi, 0x40(%rsp)
andb $0x1, %al
movb %al, 0x3f(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x18(%rsp)
movss %xmm0, 0x14(%rsp)
movss %xmm1, 0x10(%rsp)
movss %xmm2, 0xc(%rsp)
movss %xmm3, 0x8(%rsp)
cmpq $-0x1, 0x28(%rsp)
je 0x5d90
movss 0x14(%rsp), %xmm0
ucomiss 0x8(%rsp), %xmm0
jb 0x5d90
movq 0x20(%rsp), %rax
subq 0x28(%rsp), %rax
movslq 0x58(%rsp), %rcx
cmpq %rcx, %rax
jl 0x5d90
movb 0x3f(%rsp), %sil
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %r8
movq 0x18(%rsp), %rax
movl (%rax), %r9d
movss 0x14(%rsp), %xmm0
movss 0x10(%rsp), %xmm1
movss 0xc(%rsp), %xmm2
movl 0x50(%rsp), %eax
movq 0x40(%rsp), %rdi
andb $0x1, %sil
movzbl %sil, %esi
movl %eax, (%rsp)
callq 0x59a0
movq 0x20(%rsp), %rcx
subq 0x28(%rsp), %rcx
movq 0x60(%rsp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: resetVars
void resetVars(int64_t* peakStart, float* summitVal,
    uint32_t* summitLen, float* auc) {
  *peakStart = -1;
  *summitVal = -1.0f;
  *summitLen = 0;
  *auc = 0.0f;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq -0x8(%rsp), %rax
movq $-0x1, (%rax)
movq -0x10(%rsp), %rax
movss 0x183c7(%rip), %xmm0    # 0x1e194
movss %xmm0, (%rax)
movq -0x18(%rsp), %rax
movl $0x0, (%rax)
movq -0x20(%rsp), %rax
xorps %xmm0, %xmm0
movss %xmm0, (%rax)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: updatePeak
void updatePeak(int64_t* peakStart, int64_t* peakEnd,
    uint32_t start, uint32_t end, float* auc, float pqval,
    float minPQval, float pval, float qval,
    float* summitVal, float* summitPval, float* summitQval,
    uint32_t* summitPos, uint32_t* summitLen) {
  // update peak AUC, coordinates
  uint32_t len = end - start;
  *auc += len * (pqval - minPQval); // sum AUC
  if (*peakStart == -1)
    *peakStart = start; // start new potential peak
  *peakEnd = end;       // end of potential peak (for now)

  // check if interval is summit for this peak
  if (pqval > *summitVal) {
    *summitVal = pqval;
    *summitPval = pval;
    *summitQval = qval;
    *summitPos = (end + start)/2 - *peakStart; // midpoint of interval
    *summitLen = len;
  } else if (pqval == *summitVal) {
    // update summitPos only if interval is longer
    if (len > *summitLen) {
      *summitPos = (end + start)/2 - *peakStart; // midpoint of interval
      *summitLen = len;
      // assume summitPval, summitQval remain the same
    }
  }
}

// Assembly:
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rax
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl %ecx, -0x18(%rsp)
movq %r8, -0x20(%rsp)
movss %xmm0, -0x24(%rsp)
movss %xmm1, -0x28(%rsp)
movss %xmm2, -0x2c(%rsp)
movss %xmm3, -0x30(%rsp)
movq %r9, -0x38(%rsp)
movl -0x18(%rsp), %eax
movl -0x14(%rsp), %ecx
subl %ecx, %eax
movl %eax, -0x3c(%rsp)
movl -0x3c(%rsp), %eax
cvtsi2ss %rax, %xmm0
movss -0x24(%rsp), %xmm2
subss -0x28(%rsp), %xmm2
movq -0x20(%rsp), %rax
movss (%rax), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, (%rax)
movq -0x8(%rsp), %rax
cmpq $-0x1, (%rax)
jne 0x5e89
movl -0x14(%rsp), %eax
movl %eax, %ecx
movq -0x8(%rsp), %rax
movq %rcx, (%rax)
movl -0x18(%rsp), %eax
movl %eax, %ecx
movq -0x10(%rsp), %rax
movq %rcx, (%rax)
movss -0x24(%rsp), %xmm0
movq -0x38(%rsp), %rax
ucomiss (%rax), %xmm0
jbe 0x5efe
movss -0x24(%rsp), %xmm0
movq -0x38(%rsp), %rax
movss %xmm0, (%rax)
movss -0x2c(%rsp), %xmm0
movq 0x8(%rsp), %rax
movss %xmm0, (%rax)
movss -0x30(%rsp), %xmm0
movq 0x10(%rsp), %rax
movss %xmm0, (%rax)
movl -0x18(%rsp), %eax
addl -0x14(%rsp), %eax
shrl %eax
movl %eax, %eax
movq -0x8(%rsp), %rcx
subq (%rcx), %rax
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movl -0x3c(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
jmp 0x5f49
movss -0x24(%rsp), %xmm0
movq -0x38(%rsp), %rax
ucomiss (%rax), %xmm0
jne 0x5f47
jp 0x5f47
movl -0x3c(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl (%rcx), %eax
jbe 0x5f45
movl -0x18(%rsp), %eax
addl -0x14(%rsp), %eax
shrl %eax
movl %eax, %eax
movq -0x8(%rsp), %rcx
subq (%rcx), %rax
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movl -0x3c(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
jmp 0x5f47
jmp 0x5f49
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: checkChrom
bool checkChrom(char* chr, int xcount, char** xchrList) {
  for (int i = 0; i < xcount; i++)
    if (!strcmp(xchrList[i], chr))
      return true;
  return false;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq %rdx, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0x6d77
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x18(%rsp), %rsi
callq 0x21a0
cmpl $0x0, %eax
jne 0x6d68
movb $0x1, 0x27(%rsp)
jmp 0x6d7c
jmp 0x6d6a
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x6d3a
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw (%rax,%rax)