LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/raemarks[P]SuffixTree/src/SuffixTree.cpp
// Function: suffixtree::Tree::DisplayChildren(suffixtree::Node*)
void
Tree::DisplayChildren(
	Node *node
	)
{
	Node *child = node->child;

	while (child != nullptr) {
		std::cout << "Node id: " << child->id << "Edge label: '";
		for (int i = child->beg; i < child->len + child->beg; i++) {
			std::cout << input[i];
		}
		std::cout << "'" << std::endl;

		child = child->sibling;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rsi), %r15
testq %r15, %r15
je 0x2665
movq %rdi, %rbx
movq 0x3a34(%rip), %r14      # 0x5fd8
leaq 0x7(%rsp), %r13
leaq 0x1ad0(%rip), %rbp      # 0x4080
movl $0x9, %edx
movq %r14, %rdi
leaq 0x1aab(%rip), %rsi      # 0x406a
callq 0x2140
movl 0x50(%r15), %esi
movq %r14, %rdi
callq 0x21b0
movl $0xd, %edx
movq %rax, %rdi
leaq 0x1a95(%rip), %rsi      # 0x4074
callq 0x2140
cmpl $0x0, 0x4c(%r15)
jle 0x2621
movslq 0x48(%r15), %r12
movq 0x40(%rbx), %rax
movq (%rax), %rax
movb (%rax,%r12), %al
movb %al, 0x7(%rsp)
movl $0x1, %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x2140
incq %r12
movslq 0x4c(%r15), %rax
movslq 0x48(%r15), %rcx
addq %rax, %rcx
cmpq %rcx, %r12
jl 0x25ef
movl $0x1, %edx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x2140
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2100
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20b0
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0x25b0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/raemarks[P]SuffixTree/src/SuffixTree.cpp
// Function: suffixtree::Tree::findPathAndInsert(suffixtree::Node*, int, int, int)
Node *
Tree::findPathAndInsert(
	Node *node,
	int suffix,
	int beg,
	int len
	)
{
	/*
	printf("= findPathAndInsert: ");
	PrintSegment(beg, len);
	printf(" -> ");
	PrintNodeLabel(node);
	printf("\n");
	*/

	if (len == 0) {
		printf("len is zero. why?\n");
	}

	Node *child = getChildByLabelBeginning(node, input[beg]);

	// No child by that label
	if (child == nullptr) {
		Node *nchild = newNode(suffix, node, beg, len);
		addChildToNode(node, nchild);

		return nchild;
	}

	for (int i = 1; i < len; i++) {
		if (i >= child->len) {
			return findPathAndInsert(child, suffix, beg + i, len - i);
		}
		if (input[beg + i] != input[child->beg + i]) {
			// SPLIT
			Node *mid = breakEdge(child, i);
			//printf("= splitting: ");
			//PrintNodeLabel(mid);
			//printf("\n");
			return findPathAndInsert(mid, suffix, (beg + i), (len - i));
		}
	}

	panic("shouldnt actually happen");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movl %ecx, %r15d
movl %edx, %ebp
movq %rsi, %r13
movq %rdi, %r14
movl $0x1, %r12d
testl %ebx, %ebx
jne 0x26a3
leaq 0x1add(%rip), %rdi      # 0x417b
callq 0x21a0
movq 0x8(%r13), %rax
testq %rax, %rax
je 0x2740
movq 0x40(%r14), %rcx
movslq %r15d, %rdx
movq (%rcx), %rsi
movb (%rsi,%rdx), %cl
movslq 0x48(%rax), %rdi
cmpb %cl, (%rsi,%rdi)
je 0x26d1
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0x26bd
jmp 0x2740
cmpl $0x2, %ebx
jl 0x2795
movl 0x4c(%rax), %r13d
movl %ebx, %ecx
cmpl $0x2, %r13d
cmovll %r12d, %r13d
addq %rsi, %rdi
incq %rdi
leaq -0x1(%r13), %r8
addq %rdx, %rsi
incq %rsi
decq %rcx
xorl %edx, %edx
cmpq %rdx, %r8
je 0x2716
movb (%rsi,%rdx), %r9b
cmpb (%rdi,%rdx), %r9b
jne 0x271b
incq %rdx
cmpq %rdx, %rcx
jne 0x26fd
jmp 0x2795
addl %r13d, %r15d
jmp 0x2735
movl %edx, %r13d
incl %r13d
addl %edx, %r15d
incl %r15d
movq %r14, %rdi
movq %rax, %rsi
movl %r13d, %edx
callq 0x287e
subl %r13d, %ebx
movq %rax, %r13
jmp 0x2693
movq (%r14), %rax
movslq 0x8(%r14), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x8(%r14)
imulq $0x58, %rcx, %rcx
leaq (%rax,%rcx), %r12
movl %ebp, 0x50(%rax,%rcx)
movq %r13, (%rax,%rcx)
movl %r15d, 0x48(%rax,%rcx)
movl %ebx, 0x4c(%rax,%rcx)
testq %r13, %r13
je 0x2775
addl 0x54(%r13), %ebx
movl %ebx, 0x54(%r12)
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x27e0
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1868(%rip), %rdi      # 0x4004
leaq 0x1881(%rip), %rsi      # 0x4024
movl $0x57, %edx
xorl %eax, %eax
callq 0x2040
movl $0x1, %edi
callq 0x2150
nop
// File: /workspace/github_cpp_makefile_star2_O3/raemarks[P]SuffixTree/src/SuffixTree.cpp
// Function: suffixtree::Tree::addChildToNode(suffixtree::Node*, suffixtree::Node*)
void 
Tree::addChildToNode(
	Node *parent,
	Node *child
	)
{
	Node *cur = parent->child;
	if (cur == nullptr) {
		parent->child = child;
		return;
	}

	char k = input[child->beg];
	if (k == '$') {
		if (cur != nullptr && input[cur->beg] == '$') {
			panic("shouldnt already have child with this label");
		}

		child->sibling = cur;
		parent->child = child;
		return;
	}

	Node *prev = nullptr;
	while(cur != nullptr) {
		if (k < input[cur->beg]) {
			child->sibling = cur;
			if (prev == nullptr) {
				parent->child = child;
			} else {
				prev->sibling = child;
			}
			return;
		}

		prev = cur;
		cur = cur->sibling;
	}
	prev->sibling = child;
}

// Assembly:
pushq %rax
movq 0x8(%rsi), %rax
addq $0x8, %rsi
testq %rax, %rax
je 0x2855
movq 0x40(%rdi), %rcx
movslq 0x48(%rdx), %rdi
movq (%rcx), %rcx
movb (%rcx,%rdi), %dil
movslq 0x48(%rax), %r8
movb (%rcx,%r8), %r8b
cmpb $0x24, %dil
jne 0x2817
cmpb $0x24, %r8b
je 0x285a
movq %rax, 0x10(%rdx)
jmp 0x2855
cmpb %r8b, %dil
jge 0x2821
xorl %r9d, %r9d
jmp 0x283d
movq %rax, %r8
movq 0x10(%r8), %rax
testq %rax, %rax
je 0x284e
movslq 0x48(%rax), %r10
movq %r8, %r9
movq %rax, %r8
cmpb (%rcx,%r10), %dil
jge 0x2824
movq %rax, 0x10(%rdx)
leaq 0x10(%r9), %rax
testq %r9, %r9
cmovneq %rax, %rsi
jmp 0x2855
addq $0x10, %r8
movq %r8, %rsi
movq %rdx, (%rsi)
popq %rax
retq
leaq 0x17d6(%rip), %rdi      # 0x4037
leaq 0x17bc(%rip), %rsi      # 0x4024
movl $0x101, %edx            # imm = 0x101
xorl %eax, %eax
callq 0x2040
movl $0x1, %edi
callq 0x2150
// File: /workspace/github_cpp_makefile_star2_O3/raemarks[P]SuffixTree/src/SuffixTree.cpp
// Function: suffixtree::Tree::breakEdge(suffixtree::Node*, int)
Node *
Tree::breakEdge(
	Node *n,
	int i
	)
{
	//printf("= breakEdge(%d)\n", i);
	Node *parent = nullptr, *nNode = nullptr;

	parent = n->parent;

	//Make new node
	nNode = newNode(assignId(), parent, n->beg, i);
	//Remove n from parent's children, replace with new node.
	replaceChild(parent, nNode);

	n->sibling = nullptr;

	//Insert n under new node
	addChildToNode(nNode, n);

	//Alter n
	n->beg = n->beg + i;
	n->parent = nNode;
	n->len = n->len - i;

	//We have a new internal node
	nIntNodes++;
	if (lowestIntNode == nullptr ||
		nNode->stringDepth > lowestIntNode->stringDepth) {
		lowestIntNode = nNode;
	}

	return nNode;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
movl 0x48(%rdi), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x48(%rdi)
movl 0x48(%r14), %ecx
movq (%rdi), %rdx
movslq 0x8(%rdi), %rdi
leal 0x1(%rdi), %r8d
movl %r8d, 0x8(%rbx)
imulq $0x58, %rdi, %rdi
leaq (%rdx,%rdi), %r15
movl %eax, 0x50(%rdx,%rdi)
movq %rsi, (%rdx,%rdi)
movl %ecx, 0x48(%rdx,%rdi)
movl %ebp, 0x4c(%rdx,%rdi)
testq %rsi, %rsi
je 0x28d2
movl 0x54(%rsi), %eax
addl %ebp, %eax
movl %eax, 0x54(%r15)
movq %rbx, %rdi
movq %r15, %rdx
callq 0x2990
movq $0x0, 0x10(%r14)
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x27e0
addl %ebp, 0x48(%r14)
movq %r15, (%r14)
subl %ebp, 0x4c(%r14)
incl 0x58(%rbx)
movq 0x60(%rbx), %rax
testq %rax, %rax
je 0x2913
movl 0x54(%r15), %ecx
cmpl 0x54(%rax), %ecx
jle 0x2917
movq %r15, 0x60(%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/raemarks[P]SuffixTree/src/SuffixTree.cpp
// Function: suffixtree::Tree::replaceChild(suffixtree::Node*, suffixtree::Node*)
void Tree::replaceChild(Node *parent, Node *node) {
	Node *prev = nullptr;
	Node *cur = parent->child;
	char k = input[node->beg];

	while (cur != nullptr) {
		if (k == input[cur->beg]) {
			node->sibling = cur->sibling;
			if (prev == nullptr) {
				parent->child = node;
			} else {
				prev->sibling = node;
			}
			return;
		}

		prev = cur;
		cur = cur->sibling;
	}
}

// Assembly:
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x29ed
movq 0x40(%rdi), %rcx
movslq 0x48(%rdx), %rdi
movq (%rcx), %rcx
movb (%rcx,%rdi), %dil
movslq 0x48(%rax), %r8
cmpb (%rcx,%r8), %dil
jne 0x29b7
xorl %r8d, %r8d
jmp 0x29d3
movq %rax, %r9
movq 0x10(%r9), %rax
testq %rax, %rax
je 0x29ed
movslq 0x48(%rax), %r10
movq %r9, %r8
movq %rax, %r9
cmpb (%rcx,%r10), %dil
jne 0x29ba
addq $0x8, %rsi
movq 0x10(%rax), %rax
movq %rax, 0x10(%rdx)
leaq 0x10(%r8), %rax
testq %r8, %r8
cmoveq %rsi, %rax
movq %rdx, (%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O3/raemarks[P]SuffixTree/src/SuffixTree.cpp
// Function: suffixtree::Tree::EnumerateNodesDFS()
void
Tree::EnumerateNodesDFS()
{
	printCount = 0;
	recursiveEnumerateNodesDFS(root);
	std::cout << std::endl;
	printCount = 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %ebp, %ebp
movl %ebp, 0x4c(%rdi)
movq 0x10(%rdi), %rsi
callq 0x2a3a
movq 0x35ce(%rip), %r14      # 0x5fd8
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2100
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20b0
movl %ebp, 0x4c(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/raemarks[P]SuffixTree/src/SuffixTree.cpp
// Function: suffixtree::Tree::recursiveEnumerateNodesDFS(suffixtree::Node*)
void
Tree::recursiveEnumerateNodesDFS(
	Node *n
	)
{
	//After 10 enumerations, print a newline
	if (printCount == 10) {
		std::cout << std::endl;
		printCount = 0;
	}

	std::cout << n->stringDepth;

	if (printCount != 9)
		std::cout << " ";

	printCount++;
	Node *child = n->child;

	while (child != nullptr) {
		recursiveEnumerateNodesDFS(child);
		child = child->sibling;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0xa, 0x4c(%rdi)
jne 0x2a80
movq 0x3586(%rip), %r15      # 0x5fd8
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2100
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20b0
movl $0x0, 0x4c(%rbx)
movl 0x54(%r14), %esi
movq 0x354d(%rip), %rdi      # 0x5fd8
callq 0x21b0
movl $0xa, %eax
cmpl $0x9, 0x4c(%rbx)
je 0x2ab8
movq 0x3536(%rip), %rdi      # 0x5fd8
leaq 0x15c9(%rip), %rsi      # 0x4072
movl $0x1, %edx
callq 0x2140
movl 0x4c(%rbx), %eax
incl %eax
movl %eax, 0x4c(%rbx)
movq 0x8(%r14), %r14
testq %r14, %r14
je 0x2ad5
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2a3a
movq 0x10(%r14), %r14
jmp 0x2abf
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/raemarks[P]SuffixTree/src/SuffixTree.cpp
// Function: suffixtree::Tree::recursiveEnumerateBWT(suffixtree::Node*)
void Tree::recursiveEnumerateBWT(
	Node *n
	)
{
	//Must be a leaf node.
	if (n->child == nullptr) {
		if (n->id == 0) {
			B[B_i++] = input[input.length() - 1];
		} else {
			B[B_i++] = input[n->id - 1];
		}
		return;
	}

	Node *child = n->child;
	while (child != nullptr) {
		recursiveEnumerateBWT(child);
		child = child->sibling;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rsi), %r14
testq %r14, %r14
je 0x2b02
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2adc
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x2aec
jmp 0x2b2f
movslq 0x50(%rsi), %rax
movq 0x40(%rbx), %rcx
testq %rax, %rax
je 0x2b14
addq (%rcx), %rax
jmp 0x2b1b
movq (%rcx), %rax
addq 0x8(%rcx), %rax
movb -0x1(%rax), %al
movslq 0x50(%rbx), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x50(%rbx)
movq 0x68(%rbx), %rdx
movb %al, (%rdx,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/raemarks[P]SuffixTree/src/SuffixTree.cpp
// Function: suffixtree::Tree::EnumerateBWT()
void Tree::EnumerateBWT()
{
	recursiveEnumerateBWT(root);
	for (auto v : B) {
		std::cout << v << std::endl;
	}
	//printf("NNODES = %d\n", assignId());
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
callq 0x2adc
movq 0x68(%rbx), %r12
movq 0x70(%rbx), %r13
cmpq %r13, %r12
je 0x2bb4
movq 0x3473(%rip), %rbx      # 0x5fd8
leaq 0xf(%rsp), %r14
movb (%r12), %al
movb %al, 0xf(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2140
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2100
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20b0
incq %r12
cmpq %r13, %r12
jne 0x2b6a
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/raemarks[P]SuffixTree/src/SuffixTree.cpp
// Function: suffixtree::Tree::printTreeRec(suffixtree::Node*, int)
void Tree::printTreeRec(Node *nd, int depth) {
	writeTabs(depth);
	printf("[");
	PrintNodeLabel(nd);
	printf("]");
	printf("{");
	
	Node *cur = nd->child;
	if (cur != nullptr) {
		printf("\n");
	}

	while(cur != nullptr) {
		printTreeRec(cur, depth + 1);
		cur = cur->sibling;
	}
	if (nd->child != nullptr) {
		writeTabs(depth);
	}
	printf("}\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
testl %edx, %edx
jle 0x2bf5
movl %ebx, %ebp
movl $0x2b, %edi
callq 0x2180
decl %ebp
jne 0x2be7
movl $0x5b, %edi
callq 0x2180
movslq 0x4c(%r14), %r12
testq %r12, %r12
jle 0x2c25
movslq 0x48(%r14), %r13
movq 0x40(%r15), %rax
movq (%rax), %rax
movsbl (%rax,%r13), %edi
callq 0x2180
incq %r13
decq %r12
jne 0x2c0c
movl $0x5d, %edi
callq 0x2180
movl $0x7b, %edi
callq 0x2180
movq 0x8(%r14), %r12
testq %r12, %r12
je 0x2c7f
movl $0xa, %edi
callq 0x2180
leal 0x1(%rbx), %ebp
movq %r15, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x2bce
movq 0x10(%r12), %r12
testq %r12, %r12
jne 0x2c4f
testl %ebx, %ebx
jle 0x2c7f
cmpq $0x0, 0x8(%r14)
je 0x2c7f
movl $0x2b, %edi
callq 0x2180
decl %ebx
jne 0x2c71
leaq 0x1507(%rip), %rdi      # 0x418d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21a0
// File: /workspace/github_cpp_makefile_star2_O3/raemarks[P]SuffixTree/src/SuffixTree.cpp
// Function: suffixtree::Tree::PrintLongestRepeatSeqInfo()
void
Tree::PrintLongestRepeatSeqInfo() {
	std::cout << "Length of longest repeating sequence: " <<
	  lowestIntNode->stringDepth << std::endl;
	std::cout << "Starting indeces of longest repeating sequence: " << std::endl;

	Node *child = lowestIntNode->child;

	while (child != nullptr) {
		std::cout << child->id << " ";
		child = child->sibling;
	}
	std::cout << std::endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x31be(%rip), %rbx      # 0x5fd8
leaq 0x12a7(%rip), %rsi      # 0x40c8
movl $0x26, %edx
movq %rbx, %rdi
callq 0x2140
movq 0x60(%r14), %rax
movl 0x54(%rax), %esi
movq %rbx, %rdi
callq 0x21b0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2100
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20b0
leaq 0x1281(%rip), %rsi      # 0x40ef
movl $0x30, %edx
movq %rbx, %rdi
callq 0x2140
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2100
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20b0
movq 0x60(%r14), %rax
movq 0x8(%rax), %r12
testq %r12, %r12
je 0x2ee4
movq 0x3122(%rip), %r14      # 0x5fd8
leaq 0x11b5(%rip), %r15      # 0x4072
movl 0x50(%r12), %esi
movq %r14, %rdi
callq 0x21b0
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2140
movq 0x10(%r12), %r12
testq %r12, %r12
jne 0x2ebd
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2100
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/raemarks[P]SuffixTree/src/io.cpp
// Function: ReadInputFasta(std::basic_ifstream<char, std::char_traits<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void
ReadInputFasta(
	std::ifstream &in,
	std::string& str,
	std::string& name
	)
{
	int BUFSIZE = 4 * MB;
	char buf[BUFSIZE], _name[MB/2], c = '\0';
	int i = 0;
	memset(buf, 0, BUFSIZE);

	// Skip over '>'
	while (c != '>' && !in.eof()) {
		in >> c;
	}

	in.getline(buf, BUFSIZE);
	// Get unique identifier of sequence, up to first whitespace
	sscanf(buf, "%s", _name);
	// Allocate and copy
	name = std::string(_name);

	i = 0;
	c = '\0';
	memset(buf, 0, BUFSIZE);

	in >> c;
	while (c != '>' && !in.eof()) {
		if (notLineEnd(c)) {
			buf[i++] = c;
		}
		in >> c;
	}
	str = std::string(buf);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x480038, %rsp         # imm = 0x480038
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xf(%rsp), %r12
movb $0x0, (%r12)
leaq 0x80030(%rsp), %rdi
movl $0x400000, %edx         # imm = 0x400000
xorl %esi, %esi
callq 0x2090
movq (%r14), %rax
movq -0x18(%rax), %rdi
testb $0x2, 0x20(%r14,%rdi)
jne 0x30d0
movq %r14, %rdi
movq %r12, %rsi
callq 0x2170
cmpb $0x3e, 0xf(%rsp)
jne 0x30a8
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2100
movsbl %al, %ecx
leaq 0x80030(%rsp), %r12
movl $0x400000, %edx         # imm = 0x400000
movq %r14, %rdi
movq %r12, %rsi
callq 0x21f0
leaq 0x1090(%rip), %rsi      # 0x418f
leaq 0x30(%rsp), %r13
movq %r12, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x2110
leaq 0x20(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq %r13, %rdi
callq 0x2070
leaq (%rsp,%rax), %rdx
addq $0x30, %rdx
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x322e
movq %r15, %rdi
movq %r12, %rsi
callq 0x2160
movq (%r12), %rdi
cmpq %rbp, %rdi
je 0x315b
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2130
leaq 0xf(%rsp), %r15
movb $0x0, (%r15)
leaq 0x80030(%rsp), %rdi
xorl %r12d, %r12d
movl $0x400000, %edx         # imm = 0x400000
xorl %esi, %esi
callq 0x2090
movq %r14, %rdi
movq %r15, %rsi
callq 0x2170
movb (%r15), %al
cmpb $0x3e, %al
je 0x31cd
leaq 0xf(%rsp), %r15
movq (%r14), %rcx
movq -0x18(%rcx), %rcx
testb $0x2, 0x20(%r14,%rcx)
jne 0x31cd
cmpb $0xa, %al
je 0x31ba
movzbl %al, %ecx
cmpl $0xd, %ecx
je 0x31ba
movslq %r12d, %rcx
incl %r12d
movb %al, 0x80030(%rsp,%rcx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x2170
movb 0xf(%rsp), %al
cmpb $0x3e, %al
jne 0x3192
leaq 0x10(%rsp), %r14
movq %rbp, (%r14)
leaq 0x80030(%rsp), %r15
movq %r15, %rdi
callq 0x2070
leaq (%rsp,%rax), %rdx
addq $0x80030, %rdx          # imm = 0x80030
movq %r14, %rdi
movq %r15, %rsi
callq 0x322e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2160
movq (%r14), %rdi
cmpq %rbp, %rdi
je 0x321b
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2130
addq $0x480038, %rsp         # imm = 0x480038
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/raemarks[P]SuffixTree/src/main.cpp
// Function: main
int main(int argc, char *argv[])
{
	//TODO: append $ to input string!
	//suffixtree::SuffixTree tree = new suffixtree::SuffixTree(params);

	if (argc < 3) {
		printf("Error, not enough arguments.\n");
		printf("Usage: '%s <input fasta file> {<alphabet>}'\n", argv[0]);
		return 1;
	}

	std::ifstream in(argv[1], std::ifstream::in);
	if (!in.good()) {
		printf("Error: file '%s' not valid.\n", argv[1]);
		return 2;
	}

	std::string name, input;
	ReadInputFasta(in, input, name);

	/*
	std::cout << "Name: " << name << std::endl;
	std::cout << "Input: " << input << std::endl;
	*/

	suffixtree::Tree *t = new suffixtree::Tree(input, "$ACGT");

	t->Build();
	//t->EnumerateNodesDFS();
	t->PrintTreeInfo();
	t->PrintLongestRepeatSeqInfo();
	//t->EnumerateBWT();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x270, %rsp            # imm = 0x270
movq %rsi, %rbx
cmpl $0x2, %edi
jg 0x3303
leaq 0xeff(%rip), %rdi       # 0x41e2
callq 0x21a0
movq (%rbx), %rsi
leaq 0xea0(%rip), %rdi       # 0x4192
xorl %eax, %eax
callq 0x2040
movl $0x1, %ebx
jmp 0x3428
movq 0x8(%rbx), %rsi
leaq 0x68(%rsp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x21e0
movq (%r14), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x88(%rsp,%rax)
je 0x3346
movq 0x8(%rbx), %rsi
leaq 0xe8a(%rip), %rdi       # 0x41bf
xorl %eax, %eax
callq 0x2040
movl $0x2, %ebx
jmp 0x341e
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
xorl %eax, %eax
movq %rax, -0x8(%r15)
movb %al, (%r15)
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq %rax, -0x8(%r12)
movb %al, (%r12)
leaq 0x68(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x3070
movl $0x80, %edi
callq 0x2120
movq %rax, %rbx
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0xe40(%rip), %rsi       # 0x41dc
leaq 0xe3e(%rip), %rdx       # 0x41e1
leaq 0x8(%rsp), %rdi
callq 0x322e
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x237c
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x33d6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2130
movq %rbx, %rdi
callq 0x24b2
movq %rbx, %rdi
callq 0x2d16
movq %rbx, %rdi
callq 0x2e08
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x3405
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2130
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x341c
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2130
xorl %ebx, %ebx
leaq 0x68(%rsp), %rdi
callq 0x2050
movl %ebx, %eax
addq $0x270, %rsp            # imm = 0x270
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x345a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2130
jmp 0x345a
movq %rax, %r14
movl $0x80, %esi
movq %rbx, %rdi
callq 0x2130
jmp 0x346e
jmp 0x346b
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x3485
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2130
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x349c
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2130
leaq 0x68(%rsp), %rdi
callq 0x2050
movq %r14, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O3/billDrett[P]Bulletin-Boards/boardPost.cpp
// Function: BoardPost::BoardPost(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
BoardPost::BoardPost(std::string BP2S, std::string S2BP)
{//anoigoume ta pipes
    if((pipeBoardPost2Server = open(BP2S.c_str(), O_WRONLY)) < 0)
    {
        perror("fifo BP2S not found");
    }

    if((pipeServer2BoardPost = open(S2BP.c_str(), O_RDWR)) < 0)
    {
        perror("fifo S2BP not found");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
movl $0x1, %esi
xorl %eax, %eax
callq 0x2120
movl %eax, (%rbx)
testl %eax, %eax
js 0x2c61
movq (%r14), %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x2120
movl %eax, 0x4(%rbx)
testl %eax, %eax
js 0x2c6f
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x13fd(%rip), %rdi      # 0x4065
callq 0x2140
jmp 0x2c46
leaq 0x1403(%rip), %rdi      # 0x4079
popq %rbx
popq %r14
popq %rbp
jmp 0x2140
nop
// File: /workspace/github_cpp_makefile_star2_O3/billDrett[P]Bulletin-Boards/boardPost.cpp
// Function: BoardPost::sendMessage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
void BoardPost::sendMessage(string message, int Id)
{
    int nwrite;
    char convert[24];
    string name;
    if((nwrite = write(pipeBoardPost2Server, "<Message><start>", 16))== -1) //eisagwgika tag gia message
    {
        perror("Cant write to pipe BP2S");
    }

    sprintf(convert, "%d", Id); //metatrepw to Id se string
    name = "*";
    name.append(convert); //stelnw to chanel mesa se *ID*
    name.append("*");

    if((nwrite = write(pipeBoardPost2Server, name.c_str(), name.size()))== -1) //grafw to chanelID
    {
        perror("Cant write to pipe BP2S");
    }

    if((nwrite = write(pipeBoardPost2Server, message.c_str(), message.size()))== -1) // grafw to message
    {
        perror("Cant write to pipe BP2S");
    }

    if((nwrite = write(pipeBoardPost2Server, "<end><Message>", 14))== -1) //telos message tags
    {
        perror("Cant write to pipe BP2S");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movl (%rdi), %edi
leaq 0x110e(%rip), %rsi      # 0x40c0
movl $0x10, %edx
callq 0x20a0
cmpl $-0x1, %eax
je 0x3074
leaq 0x111d(%rip), %rsi      # 0x40e9
leaq -0x60(%rbp), %rdi
movl %r15d, %edx
xorl %eax, %eax
callq 0x2040
leaq -0x40(%rbp), %rdi
movq 0x8(%rdi), %rdx
leaq 0x1103(%rip), %rcx      # 0x40ec
movl $0x1, %r8d
xorl %esi, %esi
callq 0x2220
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x2280
leaq 0x10e2(%rip), %rsi      # 0x40ec
leaq -0x40(%rbp), %rdi
callq 0x2280
movl (%rbx), %edi
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x20a0
cmpl $-0x1, %eax
je 0x3085
movl (%rbx), %edi
movq (%r14), %rsi
movq 0x8(%r14), %rdx
callq 0x20a0
cmpl $-0x1, %eax
je 0x3093
movl (%rbx), %edi
leaq 0x10ab(%rip), %rsi      # 0x40ee
movl $0xe, %edx
callq 0x20a0
cmpl $-0x1, %eax
je 0x30a1
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x3067
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x2180
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1056(%rip), %rdi      # 0x40d1
callq 0x2140
jmp 0x2fc5
leaq 0x1045(%rip), %rdi      # 0x40d1
callq 0x2140
jmp 0x3027
leaq 0x1037(%rip), %rdi      # 0x40d1
callq 0x2140
jmp 0x303a
leaq 0x1029(%rip), %rdi      # 0x40d1
callq 0x2140
jmp 0x3052
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x30c7
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x2180
movq %rbx, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O3/ef-gy[P]libefgy/src/test-case/range.cpp
// Function: testRange(std::ostream&)
bool testRange(std::ostream &log) {
  std::array<int, 5> a5{0, 1, 2, 3, 4};
  std::array<int, 5> b5{1000, 1001, 1002, 1003, 1004};
  std::array<int, 8> a8n{49, 48, 47, 46, 45, 44, 43, 42};

  for (int i : range<int>(0, 4)) {
    std::cerr << i << "\n";
  }

  std::array<int, 8> a1{42, 43, 44, 45, 46, 47, 48, 49};
  std::size_t p = 0;

  for (int i : range<int, 8>(42)) {
    if (i != a1[p]) {
      log << "range<int, 8>(42) did not produce the expected results.\n";
      return false;
    }

    p++;
  }

  if (!std::equal(a1.begin(), a1.end(), range<int, 8>(42).begin())) {
    log << "range iterator did not produce the expected results.\n";
    return false;
  }

  std::array<int, 8> a2{49, 48, 47, 46, 45, 44, 43, 42};

  if (!std::equal(a2.begin(), a2.end(), range<int, 8>(49, 42).begin())) {
    log << "range iterator did not produce the expected results.\n";
    return false;
  }

  if (!std::equal(a2.begin(), a2.end(), range<int>(49, 42, 8, true).begin())) {
    log << "range iterator did not produce the expected results.\n";
    return false;
  }

  return true;
}

// Assembly:
pushq %rax
movl $0x2a, %ecx
xorl %edx, %edx
leaq 0x10093(%rip), %rax     # 0x14b30
cmpl (%rdx,%rax), %ecx
jne 0x4b01
incl %ecx
addq $0x4, %rdx
cmpq $0x20, %rdx
jne 0x4a9d
movl $0x2a, %ecx
xorl %edx, %edx
cmpl (%rdx,%rax), %ecx
jne 0x4b0f
addq $0x4, %rdx
incl %ecx
cmpq $0x20, %rdx
jne 0x4ab5
movl $0x31, %ecx
xorl %edx, %edx
leaq 0x1007c(%rip), %rax     # 0x14b50
cmpl (%rdx,%rax), %ecx
jne 0x4b0f
addq $0x4, %rdx
decl %ecx
cmpq $0x20, %rdx
jne 0x4ad4
movl $0x31, %ecx
xorl %edx, %edx
cmpl (%rdx,%rax), %ecx
jne 0x4b0f
addq $0x4, %rdx
decl %ecx
cmpq $0x20, %rdx
jne 0x4aec
movb $0x1, %al
jmp 0x4b22
leaq 0xf612(%rip), %rsi      # 0x1411a
movl $0x38, %edx
jmp 0x4b1b
leaq 0xf63d(%rip), %rsi      # 0x14153
movl $0x35, %edx
callq 0x42a0
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O3/killwing[P]underscore/test.cpp
// Function: main
int main() {
    test_each();
    test_map();
    test_reduce();
    test_reduceRight();
    test_find();
    test_filter();
    test_reject();
    test_every();
    test_some();
    test_contains();
    test_invoke();
    test_pluck();
    test_max();
    test_min();
    test_sortBy();
    test_groupBy();
    test_countBy();
    test_shuffle();
    test_toArray();
    test_size();

    cout << "All tests passed." << endl;
    return 0;
}

// Assembly:
pushq %rbx
callq 0x3f40
callq 0x6855
callq 0xac2e
callq 0xe416
callq 0x10e3b
callq 0x1251a
callq 0x14d2a
callq 0x1753a
callq 0x18caa
callq 0x1a3f4
callq 0x1bb59
callq 0x1ce1f
callq 0x1dab1
callq 0x1f304
callq 0x20af7
callq 0x21bee
callq 0x259bc
callq 0x28446
callq 0x28d87
callq 0x2b71e
movq 0x1a491(%rip), %rbx     # 0x46fd8
leaq 0xca8d(%rip), %rsi      # 0x395db
movl $0x11, %edx
movq %rbx, %rdi
callq 0x2230
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/killwing[P]underscore/test.cpp
// Function: Tracer::~Tracer()
~Tracer() {
        if (supported_) {
            cout << "[ok]" << endl;
        } else {
            cout << "[not supported]" << endl;
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xbc65(%rip), %rax      # 0x39621
leaq 0xbc63(%rip), %rsi      # 0x39626
cmpb $0x0, 0x20(%rdi)
cmovneq %rax, %rsi
movl $0x4, %eax
movl $0xf, %edx
cmovneq %rax, %rdx
movq 0x195f8(%rip), %r14     # 0x46fd8
movq %r14, %rdi
callq 0x2230
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq 0x195d2(%rip), %rdi     # 0x46fd8
callq 0x2030
movq %rax, %rdi
callq 0x2140
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x2da31
movq (%rbx), %rsi
incq %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21f0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x2f0d3
nop
// File: /workspace/github_cpp_makefile_star2_O3/killwing[P]underscore/./underscore.h
// Function: std::enable_if<!std::is_void<decltype(*std::begin(fp).*fp0(fp1...))>::value, std::__cxx11::list<std::decay<decltype(*std::begin(fp).*fp0(fp1...))>::type>>::type _::invoke<std::__cxx11::list, std::__cxx11::list<Data, std::allocator<Data>>, int (Data::*)() const>(std::__cxx11::list<Data, std::allocator<Data>>&, int (Data::*)() const)
auto
invoke(Collection& obj, Function method, Argument&&... args)
    -> typename std::enable_if<!std::is_void<decltype(((*std::begin(obj)).*method)(args...))>::value,
       RetCollection<typename std::decay<decltype(((*std::begin(obj)).*method)(args...))>::type>>::type {

    using R = typename std::decay<decltype(((*std::begin(obj)).*method)(args...))>::type;
    RetCollection<R> result;
    for (auto& i : obj) {
        util::add(result, (i.*method)(std::forward<Argument>(args)...));
    }
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %r13
cmpq %rsi, %r13
je 0x2e28c
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
leaq (%r14,%r13), %rdi
addq $0x10, %rdi
movq %r15, %rax
testb $0x1, %r15b
je 0x2e263
movq (%rdi), %rax
movq -0x1(%rax,%r15), %rax
callq *%rax
movl %eax, %ebp
movl $0x18, %edi
callq 0x21e0
movl %ebp, 0x10(%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2050
incq 0x10(%rbx)
movq (%r13), %r13
cmpq %r12, %r13
jne 0x2e24a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %rbx, %rdi
je 0x2e2be
movq (%rdi), %r15
movl $0x18, %esi
callq 0x21f0
movq %r15, %rdi
cmpq %rbx, %r15
jne 0x2e2a9
movq %r14, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O3/killwing[P]underscore/./underscore.h
// Function: std::deque<std::decay<decltype(*std::begin(fp).*fp0)>::type> _::pluck<std::deque, std::deque<Data, std::allocator<Data>>, int Data::*>(std::deque<Data, std::allocator<Data>> const&, int Data::*)
auto
pluck(const Collection& obj, Function member)
    -> RetCollection<typename std::decay<decltype((*std::begin(obj)).*member)>::type> {

    using R = typename std::decay<decltype((*std::begin(obj)).*member)>::type;
    RetCollection<R> result;
    for (auto& i : obj) {
        util::add(result, i.*member);
    }
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %esi, %esi
callq 0x2fab2
movq 0x10(%r15), %r13
movq 0x30(%r15), %r12
cmpq %r12, %r13
je 0x2e627
movq 0x20(%r15), %rbp
movq 0x28(%r15), %r15
leaq (%r14,%r13), %rsi
movq 0x30(%rbx), %rax
movq 0x40(%rbx), %rcx
addq $-0x4, %rcx
cmpq %rcx, %rax
je 0x2e602
movl (%rsi), %ecx
movl %ecx, (%rax)
addq $0x4, %rax
movq %rax, 0x30(%rbx)
jmp 0x2e60a
movq %rbx, %rdi
callq 0x3411a
addq $0x4, %r13
cmpq %rbp, %r13
jne 0x2e622
movq 0x8(%r15), %r13
addq $0x8, %r15
leaq 0x200(%r13), %rbp
cmpq %r12, %r13
jne 0x2e5df
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2fa5a
movq %r14, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O3/killwing[P]underscore/./underscore.h
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> _::shuffle<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Collection
shuffle(const Collection& obj) {
    Collection result = obj;
    std::random_device rd;
    std::shuffle(std::begin(result), std::end(result), std::mt19937(rd()));
    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2718, %rsp           # imm = 0x2718
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x2f03e
leaq 0x8(%rsp), %rdi
callq 0x37444
movq (%rbx), %r14
movq 0x8(%rbx), %r15
addq %r14, %r15
leaq 0x8(%rsp), %rdi
callq 0x2290
movl %eax, %eax
movq %rax, 0x1390(%rsp)
movl $0x1, %ecx
movq %rax, %rdx
shrq $0x1e, %rdx
xorl %eax, %edx
imull $0x6c078965, %edx, %eax # imm = 0x6C078965
addl %ecx, %eax
movq %rax, 0x1390(%rsp,%rcx,8)
incq %rcx
cmpq $0x270, %rcx            # imm = 0x270
jne 0x2ecc7
leaq 0x1390(%rsp), %rdx
movq $0x270, 0x1380(%rdx) # imm = 0x270
movq %r14, %rdi
movq %r15, %rsi
callq 0x37890
leaq 0x8(%rsp), %rdi
callq 0x21c0
movq %rbx, %rax
addq $0x2718, %rsp           # imm = 0x2718
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x2ed56
movq %rax, %r14
jmp 0x2ed3a
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x21c0
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x2ed4e
movq (%r12), %rsi
incq %rsi
callq 0x21f0
movq %r14, %rdi
callq 0x2320
movq %rax, %rdi
callq 0x2f0d3
// File: /workspace/github_cpp_makefile_star2_O3/killwing[P]underscore/./underscore.h
// Function: std::enable_if<HasInsertAfter<std::forward_list<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::value, void>::type _::util::add<std::forward_list<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::forward_list<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&)
typename std::enable_if<HasInsertAfter<T>::value, void>::type
add(T& c, U&& v) {
    // get to the end of the list, which is O(N) and not fast at all
    auto before_end = c.before_begin();
    for (auto& _ : c) {
        ++before_end;
    }
    c.insert_after(before_end, std::forward<U>(v));
}

// Assembly:
pushq %rbx
movq (%rdi), %rax
movq %rdi, %rbx
testq %rax, %rax
je 0x32a34
movq %rdi, %rbx
movq (%rbx), %rbx
movq (%rax), %rax
testq %rax, %rax
jne 0x32a29
callq 0x32a44
movq (%rbx), %rcx
movq %rcx, (%rax)
movq %rax, (%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/stevedonovan[P]outstreams/./outstream.h
// Function: stream::Writer& stream::Writer::operator()<char const*, int>(std::pair<char const*, int>, char const*)
Writer& operator() (std::pair<T,S> pp, const char *fmt=nullptr) {
        sep_out();
        char osep = reset_sep();
        (*this)(pp.first,fmt)(':')(pp.second,fmt);
        return restore_sep(osep);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %rbx
callq 0x325c
movq %rbx, %rdi
xorl %esi, %esi
callq 0x34f4
movl %eax, %r15d
leaq 0x10c3(%rip), %rsi      # 0x4113
movq %rbx, %rdi
movq %r14, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x3292
leaq 0x10b7(%rip), %rsi      # 0x411e
movq %rax, %rdi
xorl %edx, %edx
movl $0x3a, %ecx
xorl %eax, %eax
callq 0x3292
leaq 0x10a5(%rip), %rsi      # 0x4124
movq %rax, %rdi
movq %r14, %rdx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x3292
movsbl %r15b, %esi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3500
nop
// File: /workspace/github_cpp_makefile_star2_O3/mittman[P]project254/address.cpp
// Function: Address::getLength(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int const Address::getLength(const string column7) {
	int data;
	stringstream base16;
	base16 << hex << column7;
	base16 >> data;
	return data/2;
}

// Assembly:
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rsi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2130
leaq 0x18(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl 0x30(%rsp,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x30(%rsp,%rax)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
callq 0x2200
leaq 0x8(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0x2100
movl 0x4(%rsp), %eax
movl %eax, %ebx
shrl $0x1f, %ebx
addl %eax, %ebx
sarl %ebx
movq 0xa9da(%rip), %rsi      # 0xcfa8
leaq 0x8(%rsp), %rdi
callq 0x2160
leaq 0x88(%rsp), %rdi
callq 0x2090
movl %ebx, %eax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
retq
movq %rax, %rbx
movq 0xa9ae(%rip), %rsi      # 0xcfa8
leaq 0x8(%rsp), %rdi
callq 0x2160
leaq 0x88(%rsp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x2330
nop
// File: /workspace/github_cpp_makefile_star2_O3/mittman[P]project254/address.cpp
// Function: Address::getAddress(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
long const Address::getAddress(const string column6) {
	unsigned long address;
	stringstream base16;
	base16 << hex << column6;
	base16 >> address;
	return (signed long)address;
}

// Assembly:
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rsi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2130
leaq 0x18(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl 0x30(%rsp,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x30(%rsp,%rax)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
callq 0x2200
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x20f0
movq (%rsp), %rbx
movq 0xa93b(%rip), %rsi      # 0xcfa8
leaq 0x8(%rsp), %rdi
callq 0x2160
leaq 0x88(%rsp), %rdi
callq 0x2090
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
retq
movq %rax, %rbx
movq 0xa90e(%rip), %rsi      # 0xcfa8
leaq 0x8(%rsp), %rdi
callq 0x2160
leaq 0x88(%rsp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x2330
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/mittman[P]project254/binary2.cpp
// Function: Binary2::hexToBinary(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Binary2::hexToBinary(const string hexString) {
	unsigned int tmp;
	stringstream base16;

	base16 << hex << hexString;
	base16 >> tmp;
	bitset<32> binary(tmp);

	binaryString = binary.to_string();
	setLowestHighestAddress();
	
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rsp), %rdi
callq 0x2130
leaq 0x40(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl 0x58(%rsp,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x58(%rsp,%rax)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
callq 0x2200
leaq 0x30(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0x2320
movl 0x4(%rsp), %eax
leaq 0x28(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x8(%rsp), %rdi
callq 0x29b6
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2220
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x27c9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2828
movq 0xa7d0(%rip), %rsi      # 0xcfa8
leaq 0x30(%rsp), %rdi
callq 0x2160
leaq 0xb0(%rsp), %rdi
callq 0x2090
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r14
retq
jmp 0x27fe
jmp 0x27fe
movq %rax, %rbx
movq 0xa7a0(%rip), %rsi      # 0xcfa8
leaq 0x30(%rsp), %rdi
callq 0x2160
leaq 0xb0(%rsp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x2330
nop
// File: /workspace/github_cpp_makefile_star2_O3/mittman[P]project254/cycle.cpp
// Function: Cycle::getIO(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string const Cycle::getIO(const string column9) {
	if(column9 == "Wr") {
		return "Write";
	}
	else if (column9 == "Rd") {
		return "Read";
	}
	else {
		return "???";
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x75a3(%rip), %rsi      # 0xa038
movq %rdx, %rdi
callq 0x2070
testl %eax, %eax
je 0x2acb
leaq 0x7599(%rip), %rsi      # 0xa041
movq %r14, %rdi
callq 0x2070
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
testl %eax, %eax
je 0x2ae2
leaq 0x7587(%rip), %rsi      # 0xa049
leaq 0x7583(%rip), %rdx      # 0xa04c
jmp 0x2af0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x7562(%rip), %rsi      # 0xa03b
leaq 0x7560(%rip), %rdx      # 0xa040
jmp 0x2af0
leaq 0x755b(%rip), %rsi      # 0xa044
leaq 0x7558(%rip), %rdx      # 0xa048
movq %rbx, %rdi
callq 0x313c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mittman[P]project254/cycle.cpp
// Function: Cycle::toNanoSeconds(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
double Cycle::toNanoSeconds(const string reltime) {
	string nanotime = reltime.substr(0, reltime.size() - 2);
	double elapsed = 0.0;

	stringstream ss;
	ss << nanotime;
	ss >> elapsed;

	if(reltime.substr( reltime.length() - 2 ) == "ms") {
		return elapsed * 1000 * 1000;
	}
	else if(reltime.substr( reltime.length() - 2 ) == "us") {
		return elapsed * 1000;
	}
	else if(reltime.substr( reltime.length() - 2 ) == "ns") {
		return elapsed;
	}
    else {
		return 0;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1d8, %rsp            # imm = 0x1D8
movq %rsi, %rbx
movq 0x8(%rsi), %rcx
addq $-0x2, %rcx
leaq 0x30(%rsp), %rdi
xorl %edx, %edx
callq 0x21f0
movq $0x0, (%rsp)
leaq 0x50(%rsp), %rdi
callq 0x2130
leaq 0x60(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0x2200
leaq 0x50(%rsp), %rdi
movq %rsp, %rsi
callq 0x2110
movq 0x8(%rbx), %rdx
addq $-0x2, %rdx
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq $-0x1, %rcx
callq 0x21f0
leaq 0x74cf(%rip), %rsi      # 0xa04d
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2070
movl %eax, %ebp
movq (%r14), %rdi
leaq 0x18(%rsp), %r15
cmpq %r15, %rdi
je 0x2ba7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21e0
testl %ebp, %ebp
je 0x2c50
movq 0x8(%rbx), %rdx
addq $-0x2, %rdx
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq $-0x1, %rcx
callq 0x21f0
leaq 0x747e(%rip), %rsi      # 0xa050
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2070
movl %eax, %ebp
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x2bf6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21e0
testl %ebp, %ebp
je 0x2c67
movq 0x8(%rbx), %rdx
addq $-0x2, %rdx
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq $-0x1, %rcx
callq 0x21f0
leaq 0x7436(%rip), %rsi      # 0xa053
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2070
movl %eax, %ebx
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x2c41
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21e0
xorpd %xmm1, %xmm1
testl %ebx, %ebx
jne 0x2c74
movsd (%rsp), %xmm1
jmp 0x2c74
movsd 0x73d8(%rip), %xmm0     # 0xa030
movsd (%rsp), %xmm1
mulsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
jmp 0x2c74
movsd (%rsp), %xmm1
mulsd 0x73bc(%rip), %xmm1     # 0xa030
movsd %xmm1, 0x28(%rsp)
movq 0xa327(%rip), %rsi      # 0xcfa8
leaq 0x50(%rsp), %rdi
callq 0x2160
leaq 0xd0(%rsp), %rdi
callq 0x2090
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2cb3
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x21e0
movsd 0x28(%rsp), %xmm0
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2cd2
jmp 0x2cd2
jmp 0x2cd2
movq %rax, %rbx
jmp 0x2cf3
movq %rax, %rbx
movq 0xa2cc(%rip), %rsi      # 0xcfa8
leaq 0x50(%rsp), %rdi
callq 0x2160
leaq 0xd0(%rsp), %rdi
callq 0x2090
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2d0e
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O3/mittman[P]project254/cycle.cpp
// Function: Cycle::resetElapsed(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Cycle::resetElapsed(const string cycle, const string direction) {
	if(direction == "D-to-S" && cycle == "Read") {
		dsrTime = 0;
	}
	else if(direction == "D-to-S" && cycle == "Write") {
		dswTime = 0;
	}
	else if(direction == "S-to-D" && cycle == "Read") {
		sdrTime = 0;
	}
	else if(direction == "S-to-D" && cycle == "Write") {
		sdwTime = 0;
	}
	else {
		errTime = 0;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x732b(%rip), %rsi      # 0xa056
movq %rdx, %rdi
callq 0x2070
testl %eax, %eax
jne 0x2d4a
leaq 0x7306(%rip), %rsi      # 0xa044
movq %r14, %rdi
callq 0x2070
testl %eax, %eax
je 0x2dc3
leaq 0x7305(%rip), %rsi      # 0xa056
movq %r15, %rdi
callq 0x2070
testl %eax, %eax
jne 0x2d70
leaq 0x72d7(%rip), %rsi      # 0xa03b
movq %r14, %rdi
callq 0x2070
testl %eax, %eax
je 0x2dca
leaq 0x72e6(%rip), %rsi      # 0xa05d
movq %r15, %rdi
callq 0x2070
testl %eax, %eax
jne 0x2d96
leaq 0x72ba(%rip), %rsi      # 0xa044
movq %r14, %rdi
callq 0x2070
testl %eax, %eax
je 0x2dd1
leaq 0x72c0(%rip), %rsi      # 0xa05d
movq %r15, %rdi
callq 0x2070
testl %eax, %eax
jne 0x2dbc
leaq 0x728b(%rip), %rsi      # 0xa03b
movq %r14, %rdi
callq 0x2070
testl %eax, %eax
je 0x2dd8
movl $0x38, %eax
jmp 0x2ddd
movl $0x18, %eax
jmp 0x2ddd
movl $0x20, %eax
jmp 0x2ddd
movl $0x28, %eax
jmp 0x2ddd
movl $0x30, %eax
movq $0x0, (%rbx,%rax)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mittman[P]project254/cycle.cpp
// Function: Cycle::setElapsed(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Cycle::setElapsed(const string cycle, const double elapsed, const string direction) {
	if(direction == "D-to-S" && cycle == "Read") {
		dsrTime += elapsed;
	}
	else if(direction == "D-to-S" && cycle == "Write") {
		dswTime += elapsed;
	}
	else if(direction == "S-to-D" && cycle == "Read") {
		sdrTime += elapsed;
	}
	else if(direction == "S-to-D" && cycle == "Write") {
		sdwTime += elapsed;
	}
	else {
		errTime += elapsed;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movsd %xmm0, 0x8(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x724b(%rip), %rsi      # 0xa056
movq %rdx, %rdi
callq 0x2070
testl %eax, %eax
jne 0x2e2a
leaq 0x7226(%rip), %rsi      # 0xa044
movq %r14, %rdi
callq 0x2070
testl %eax, %eax
je 0x2ea3
leaq 0x7225(%rip), %rsi      # 0xa056
movq %r15, %rdi
callq 0x2070
testl %eax, %eax
jne 0x2e50
leaq 0x71f7(%rip), %rsi      # 0xa03b
movq %r14, %rdi
callq 0x2070
testl %eax, %eax
je 0x2eaa
leaq 0x7206(%rip), %rsi      # 0xa05d
movq %r15, %rdi
callq 0x2070
testl %eax, %eax
jne 0x2e76
leaq 0x71da(%rip), %rsi      # 0xa044
movq %r14, %rdi
callq 0x2070
testl %eax, %eax
je 0x2eb1
leaq 0x71e0(%rip), %rsi      # 0xa05d
movq %r15, %rdi
callq 0x2070
testl %eax, %eax
jne 0x2e9c
leaq 0x71ab(%rip), %rsi      # 0xa03b
movq %r14, %rdi
callq 0x2070
testl %eax, %eax
je 0x2eb8
movl $0x38, %eax
jmp 0x2ebd
movl $0x18, %eax
jmp 0x2ebd
movl $0x20, %eax
jmp 0x2ebd
movl $0x28, %eax
jmp 0x2ebd
movl $0x30, %eax
xorps %xmm0, %xmm0
cvtsi2sdq (%rbx,%rax), %xmm0
addsd 0x8(%rsp), %xmm0
cvttsd2si %xmm0, %rcx
movq %rcx, (%rbx,%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop