LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2a7e
movq 0x358a(%rip), %r14      # 0x5fd8
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20a0
movl %ebp, 0x4c(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2ac4
movq 0x3542(%rip), %r15      # 0x5fd8
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20a0
movl $0x0, 0x4c(%rbx)
movl 0x54(%r14), %esi
movq 0x3509(%rip), %rdi      # 0x5fd8
callq 0x21b0
cmpl $0x9, 0x4c(%rbx)
je 0x2af2
movq 0x34f7(%rip), %rdi      # 0x5fd8
leaq 0x158a(%rip), %rsi      # 0x4072
movl $0x1, %edx
callq 0x2130
incl 0x4c(%rbx)
movq 0x8(%r14), %r14
testq %r14, %r14
je 0x2b0f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2a7e
movq 0x10(%r14), %r14
jmp 0x2af9
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2b3c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2b16
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x2b26
jmp 0x2b69
movslq 0x50(%rsi), %rax
movq 0x40(%rbx), %rcx
testq %rax, %rax
je 0x2b4e
addq (%rcx), %rax
jmp 0x2b55
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_O1/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 0x2b16
movq 0x68(%rbx), %r12
movq 0x70(%rbx), %r13
cmpq %r13, %r12
je 0x2bee
movq 0x3439(%rip), %rbx      # 0x5fd8
leaq 0xf(%rsp), %r14
movb (%r12), %al
movb %al, 0xf(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2130
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20a0
incq %r12
cmpq %r13, %r12
jne 0x2ba4
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2c2f
movl %ebx, %ebp
movl $0x2b, %edi
callq 0x2180
decl %ebp
jne 0x2c21
movl $0x5b, %edi
callq 0x2180
movslq 0x4c(%r14), %r12
testq %r12, %r12
jle 0x2c5f
movslq 0x48(%r14), %r13
movq 0x40(%r15), %rax
movq (%rax), %rax
movsbl (%rax,%r13), %edi
callq 0x2180
incq %r13
decq %r12
jne 0x2c46
movl $0x5d, %edi
callq 0x2180
movl $0x7b, %edi
callq 0x2180
movq 0x8(%r14), %r12
testq %r12, %r12
je 0x2ca0
movl $0xa, %edi
callq 0x2180
leal 0x1(%rbx), %ebp
movq %r15, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x2c08
movq 0x10(%r12), %r12
testq %r12, %r12
jne 0x2c89
testl %ebx, %ebx
jle 0x2cb9
cmpq $0x0, 0x8(%r14)
je 0x2cb9
movl $0x2b, %edi
callq 0x2180
decl %ebx
jne 0x2cab
leaq 0x14cd(%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_O1/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 0x3184(%rip), %rbx      # 0x5fd8
leaq 0x126d(%rip), %rsi      # 0x40c8
movl $0x26, %edx
movq %rbx, %rdi
callq 0x2130
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 0x20f0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20a0
leaq 0x1247(%rip), %rsi      # 0x40ef
movl $0x30, %edx
movq %rbx, %rdi
callq 0x2130
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20a0
movq 0x60(%r14), %rax
movq 0x8(%rax), %r12
testq %r12, %r12
je 0x2f1e
movq 0x30e8(%rip), %r14      # 0x5fd8
leaq 0x117b(%rip), %r15      # 0x4072
movl 0x50(%r12), %esi
movq %r14, %rdi
callq 0x21b0
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2130
movq 0x10(%r12), %r12
testq %r12, %r12
jne 0x2ef7
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x20a0
// File: /workspace/github_cpp_makefile_star2_O1/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), %rax
testb $0x2, 0x20(%r14,%rax)
jne 0x30fd
movq %r14, %rdi
movq %r12, %rsi
callq 0x2160
cmpb $0x3e, 0xf(%rsp)
jne 0x30dc
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %ecx
leaq 0x80030(%rsp), %r12
movl $0x400000, %edx         # imm = 0x400000
movq %r14, %rdi
movq %r12, %rsi
callq 0x21f0
leaq 0x105c(%rip), %rsi      # 0x418f
leaq 0x30(%rsp), %r13
movq %r12, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x2100
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 0x3262
movq %r15, %rdi
movq %r12, %rsi
callq 0x2150
movq (%r12), %rdi
cmpq %rbp, %rdi
je 0x318f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2120
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 0x2160
movb (%r15), %al
cmpb $0x3e, %al
je 0x3201
leaq 0xf(%rsp), %r15
movq (%r14), %rcx
movq -0x18(%rcx), %rcx
testb $0x2, 0x20(%r14,%rcx)
jne 0x3201
cmpb $0xa, %al
je 0x31ee
movzbl %al, %ecx
cmpl $0xd, %ecx
je 0x31ee
movslq %r12d, %rcx
incl %r12d
movb %al, 0x80030(%rsp,%rcx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x2160
movb 0xf(%rsp), %al
cmpb $0x3e, %al
jne 0x31c6
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 0x3262
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2150
movq (%r14), %rdi
cmpq %rbp, %rdi
je 0x324f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2120
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_O1/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 0x3333
leaq 0xecf(%rip), %rdi       # 0x41e2
callq 0x21a0
movq (%rbx), %rsi
leaq 0xe70(%rip), %rdi       # 0x4192
xorl %eax, %eax
callq 0x2040
movl $0x1, %ebx
jmp 0x3458
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 0x3376
movq 0x8(%rbx), %rsi
leaq 0xe5a(%rip), %rdi       # 0x41bf
xorl %eax, %eax
callq 0x2040
movl $0x2, %ebx
jmp 0x344e
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 0x30a4
movl $0x80, %edi
callq 0x2110
movq %rax, %rbx
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0xe10(%rip), %rsi       # 0x41dc
leaq 0xe0e(%rip), %rdx       # 0x41e1
leaq 0x8(%rsp), %rdi
callq 0x3262
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x237c
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x3406
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2120
movq %rbx, %rdi
callq 0x24ca
movq %rbx, %rdi
callq 0x2d50
movq %rbx, %rdi
callq 0x2e42
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x3435
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2120
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x344c
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2120
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 0x348a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2120
jmp 0x348a
movq %rax, %r14
movl $0x80, %esi
movq %rbx, %rdi
callq 0x2120
jmp 0x349e
jmp 0x349b
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x34b5
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2120
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x34cc
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2120
leaq 0x68(%rsp), %rdi
callq 0x2050
movq %r14, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2c5d
movq (%r14), %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x2120
movl %eax, 0x4(%rbx)
testl %eax, %eax
js 0x2c6b
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1401(%rip), %rdi      # 0x4065
callq 0x2140
jmp 0x2c42
leaq 0x1407(%rip), %rdi      # 0x4079
popq %rbx
popq %r14
popq %rbp
jmp 0x2140
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x110a(%rip), %rsi      # 0x40c0
movl $0x10, %edx
callq 0x20a0
cmpl $-0x1, %eax
je 0x3078
leaq 0x1119(%rip), %rsi      # 0x40e9
leaq -0x60(%rbp), %rdi
movl %r15d, %edx
xorl %eax, %eax
callq 0x2040
leaq -0x40(%rbp), %rdi
movq 0x8(%rdi), %rdx
leaq 0x10ff(%rip), %rcx      # 0x40ec
movl $0x1, %r8d
xorl %esi, %esi
callq 0x2220
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x2280
leaq 0x10de(%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 0x3089
movl (%rbx), %edi
movq (%r14), %rsi
movq 0x8(%r14), %rdx
callq 0x20a0
cmpl $-0x1, %eax
je 0x3097
movl (%rbx), %edi
leaq 0x10a7(%rip), %rsi      # 0x40ee
movl $0xe, %edx
callq 0x20a0
cmpl $-0x1, %eax
je 0x30a5
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x306b
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x2180
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1052(%rip), %rdi      # 0x40d1
callq 0x2140
jmp 0x2fc9
leaq 0x1041(%rip), %rdi      # 0x40d1
callq 0x2140
jmp 0x302b
leaq 0x1033(%rip), %rdi      # 0x40d1
callq 0x2140
jmp 0x303e
leaq 0x1025(%rip), %rdi      # 0x40d1
callq 0x2140
jmp 0x3056
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x30cb
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x2180
movq %rbx, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, (%rsp)
movq $-0x8, %r12
xorl %r13d, %r13d
leaq 0x10082(%rip), %r15     # 0x14b30
xorl %ebp, %ebp
leal 0x32(%r12), %r14d
movl (%r15,%rbp,4), %ebx
cmpl %ebx, %r14d
jne 0x4ac3
incq %rbp
jmp 0x4ad8
movl $0x38, %edx
movq (%rsp), %rdi
leaq 0xf647(%rip), %rsi      # 0x1411a
callq 0x42a0
cmpl %ebx, %r14d
jne 0x4ae8
incq %r12
sete %r13b
jne 0x4ab0
jmp 0x4aee
testb $0x1, %r13b
je 0x4b69
movl $0x2a, %eax
movl $0x4, %ecx
cmpq $0x20, %rcx
je 0x4b0f
incl %eax
leaq 0x4(%rcx), %rdx
cmpl (%rcx,%r15), %eax
movq %rdx, %rcx
je 0x4af8
jmp 0x4b54
movl $0x31, %ecx
movl $0x4, %edx
leaq 0x10030(%rip), %rax     # 0x14b50
cmpq $0x20, %rdx
je 0x4b36
decl %ecx
leaq 0x4(%rdx), %rsi
cmpl (%rdx,%rax), %ecx
movq %rsi, %rdx
je 0x4b20
jmp 0x4b54
movl $0x31, %ecx
movl $0x4, %edx
cmpq $0x20, %rdx
je 0x4b7a
decl %ecx
leaq 0x4(%rdx), %rsi
cmpl (%rdx,%rax), %ecx
movq %rsi, %rdx
je 0x4b40
leaq 0xf5f8(%rip), %rsi      # 0x14153
movl $0x35, %edx
movq (%rsp), %rdi
callq 0x42a0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %al
jmp 0x4b6b
// File: /workspace/github_cpp_makefile_star2_O1/oknenavin[P]cxon/examples/named-parameters-ex01.cxx
// Function: main
int main() {
    using namespace cxon::json;
    std::string json;
        cxon::to_bytes(json, 3.1415926, fp_precision::set<3>()); // floating-point precision
    assert(json == "3.14");
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
leaq 0x20(%rsp), %rbx
movl $0x0, (%rbx)
callq 0x1050
movq %rax, 0x8(%rbx)
movq %rsp, %rdi
movsd 0xe11(%rip), %xmm0      # 0x2008
movq %rbx, %rsi
callq 0x128d
cmpl $0x0, 0x20(%rsp)
setne %cl
xorb %cl, %al
je 0x1236
leaq 0xdfe(%rip), %rsi       # 0x2010
movq %rsp, %rdi
callq 0x1040
testl %eax, %eax
jne 0x1255
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x122c
callq 0x1080
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
leaq 0xe0c(%rip), %rdi       # 0x2049
leaq 0xe12(%rip), %rsi       # 0x2056
leaq 0xe20(%rip), %rcx       # 0x206b
movl $0xe6, %edx
callq 0x1060
leaq 0xdb9(%rip), %rdi       # 0x2015
leaq 0xdc1(%rip), %rsi       # 0x2024
leaq 0xdd4(%rip), %rcx       # 0x203e
movl $0xa, %edx
callq 0x1060
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x1285
callq 0x1080
movq %rbx, %rdi
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3fe0
callq 0x69c3
callq 0xafd5
callq 0xe8ca
callq 0x1140e
callq 0x12cee
callq 0x155c1
callq 0x17e94
callq 0x197de
callq 0x1b11c
callq 0x1c90e
callq 0x1d9c9
callq 0x1e667
callq 0x1ff2f
callq 0x21797
callq 0x227a0
callq 0x26681
callq 0x29051
callq 0x2998b
callq 0x2c42a
movq 0x1b6fb(%rip), %rbx     # 0x48fd8
leaq 0xdcb5(%rip), %rsi      # 0x3b599
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_O1/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 0xcd63(%rip), %rax      # 0x3b5df
leaq 0xcd61(%rip), %rsi      # 0x3b5e4
cmpb $0x0, 0x20(%rdi)
cmovneq %rax, %rsi
movl $0x4, %eax
movl $0xf, %edx
cmovneq %rax, %rdx
movq 0x1a738(%rip), %r14     # 0x48fd8
movq %r14, %rdi
callq 0x2230
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq 0x1a712(%rip), %rdi     # 0x48fd8
callq 0x2030
movq %rax, %rdi
callq 0x2140
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x2e8f1
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 0x2ffae
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2f146
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
leaq (%r14,%r13), %rdi
addq $0x10, %rdi
movq %r15, %rax
testb $0x1, %r15b
je 0x2f11d
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 0x2f104
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 0x2f178
movq (%rdi), %r15
movl $0x18, %esi
callq 0x21f0
movq %r15, %rdi
cmpq %rbx, %r15
jne 0x2f163
movq %r14, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3098c
movq 0x10(%r15), %r13
movq 0x30(%r15), %r12
cmpq %r12, %r13
je 0x2f4e1
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 0x2f4bc
movl (%rsi), %ecx
movl %ecx, (%rax)
addq $0x4, %rax
movq %rax, 0x30(%rbx)
jmp 0x2f4c4
movq %rbx, %rdi
callq 0x352e2
addq $0x4, %r13
cmpq %rbp, %r13
jne 0x2f4dc
movq 0x8(%r15), %r13
addq $0x8, %r15
leaq 0x200(%r13), %rbp
cmpq %r12, %r13
jne 0x2f499
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 0x3093c
movq %r14, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2ff1e
leaq 0x8(%rsp), %rdi
callq 0x387ce
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 0x2fb81
leaq 0x1390(%rsp), %rdx
movq $0x270, 0x1380(%rdx) # imm = 0x270
movq %r14, %rdi
movq %r15, %rsi
callq 0x38bf4
leaq 0x8(%rsp), %rdi
callq 0x21c0
movq %rbx, %rax
addq $0x2718, %rsp           # imm = 0x2718
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x2fc10
movq %rax, %r14
jmp 0x2fbf4
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x21c0
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x2fc08
movq (%r12), %rsi
incq %rsi
callq 0x21f0
movq %r14, %rdi
callq 0x2320
movq %rax, %rdi
callq 0x2ffae
// File: /workspace/github_cpp_makefile_star2_O1/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 0x33b90
movq %rdi, %rbx
movq (%rbx), %rbx
movq (%rax), %rax
testq %rax, %rax
jne 0x33b85
callq 0x33ba0
movq (%rbx), %rcx
movq %rcx, (%rax)
movq %rax, (%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3264
movq %rbx, %rdi
xorl %esi, %esi
callq 0x34fc
movl %eax, %r15d
leaq 0x10bb(%rip), %rsi      # 0x4113
movq %rbx, %rdi
movq %r14, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x329a
leaq 0x10af(%rip), %rsi      # 0x411e
movq %rax, %rdi
xorl %edx, %edx
movl $0x3a, %ecx
xorl %eax, %eax
callq 0x329a
leaq 0x109d(%rip), %rsi      # 0x4124
movq %rax, %rdi
movq %r14, %rdx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x329a
movsbl %r15b, %esi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3508
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa9ca(%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 0xa99e(%rip), %rsi      # 0xcfa8
leaq 0x8(%rsp), %rdi
callq 0x2160
leaq 0x88(%rsp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x2340
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa92b(%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 0xa8fe(%rip), %rsi      # 0xcfa8
leaq 0x8(%rsp), %rdi
callq 0x2160
leaq 0x88(%rsp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x2340
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2330
movl 0x4(%rsp), %eax
leaq 0x28(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x8(%rsp), %rdi
callq 0x29c0
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2220
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x27d9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2838
movq 0xa7c0(%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 0x280e
jmp 0x280e
movq %rax, %rbx
movq 0xa790(%rip), %rsi      # 0xcfa8
leaq 0x30(%rsp), %rdi
callq 0x2160
leaq 0xb0(%rsp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x2340
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x759b(%rip), %rsi      # 0xa038
movq %rdx, %rdi
callq 0x2070
testl %eax, %eax
je 0x2ad3
leaq 0x7591(%rip), %rsi      # 0xa041
movq %r14, %rdi
callq 0x2070
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
testl %eax, %eax
je 0x2aea
leaq 0x757f(%rip), %rsi      # 0xa049
leaq 0x757b(%rip), %rdx      # 0xa04c
jmp 0x2af8
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x755a(%rip), %rsi      # 0xa03b
leaq 0x7558(%rip), %rdx      # 0xa040
jmp 0x2af8
leaq 0x7553(%rip), %rsi      # 0xa044
leaq 0x7550(%rip), %rdx      # 0xa048
movq %rbx, %rdi
callq 0x3144
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x74c7(%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 0x2baf
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21e0
testl %ebp, %ebp
je 0x2c58
movq 0x8(%rbx), %rdx
addq $-0x2, %rdx
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq $-0x1, %rcx
callq 0x21f0
leaq 0x7476(%rip), %rsi      # 0xa050
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2070
movl %eax, %ebp
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x2bfe
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21e0
testl %ebp, %ebp
je 0x2c6f
movq 0x8(%rbx), %rdx
addq $-0x2, %rdx
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq $-0x1, %rcx
callq 0x21f0
leaq 0x742e(%rip), %rsi      # 0xa053
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2070
movl %eax, %ebx
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x2c49
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21e0
xorpd %xmm1, %xmm1
testl %ebx, %ebx
jne 0x2c7c
movsd (%rsp), %xmm1
jmp 0x2c7c
movsd 0x73d0(%rip), %xmm0     # 0xa030
movsd (%rsp), %xmm1
mulsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
jmp 0x2c7c
movsd (%rsp), %xmm1
mulsd 0x73b4(%rip), %xmm1     # 0xa030
movsd %xmm1, 0x28(%rsp)
movq 0xa31f(%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 0x2cbb
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 0x2cda
jmp 0x2cda
jmp 0x2cda
movq %rax, %rbx
jmp 0x2cfb
movq %rax, %rbx
movq 0xa2c4(%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 0x2d16
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7323(%rip), %rsi      # 0xa056
movq %rdx, %rdi
callq 0x2070
testl %eax, %eax
jne 0x2d52
leaq 0x72fe(%rip), %rsi      # 0xa044
movq %r14, %rdi
callq 0x2070
testl %eax, %eax
je 0x2dcb
leaq 0x72fd(%rip), %rsi      # 0xa056
movq %r15, %rdi
callq 0x2070
testl %eax, %eax
jne 0x2d78
leaq 0x72cf(%rip), %rsi      # 0xa03b
movq %r14, %rdi
callq 0x2070
testl %eax, %eax
je 0x2dd2
leaq 0x72de(%rip), %rsi      # 0xa05d
movq %r15, %rdi
callq 0x2070
testl %eax, %eax
jne 0x2d9e
leaq 0x72b2(%rip), %rsi      # 0xa044
movq %r14, %rdi
callq 0x2070
testl %eax, %eax
je 0x2dd9
leaq 0x72b8(%rip), %rsi      # 0xa05d
movq %r15, %rdi
callq 0x2070
testl %eax, %eax
jne 0x2dc4
leaq 0x7283(%rip), %rsi      # 0xa03b
movq %r14, %rdi
callq 0x2070
testl %eax, %eax
je 0x2de0
movl $0x38, %eax
jmp 0x2de5
movl $0x18, %eax
jmp 0x2de5
movl $0x20, %eax
jmp 0x2de5
movl $0x28, %eax
jmp 0x2de5
movl $0x30, %eax
movq $0x0, (%rbx,%rax)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7243(%rip), %rsi      # 0xa056
movq %rdx, %rdi
callq 0x2070
testl %eax, %eax
jne 0x2e32
leaq 0x721e(%rip), %rsi      # 0xa044
movq %r14, %rdi
callq 0x2070
testl %eax, %eax
je 0x2eab
leaq 0x721d(%rip), %rsi      # 0xa056
movq %r15, %rdi
callq 0x2070
testl %eax, %eax
jne 0x2e58
leaq 0x71ef(%rip), %rsi      # 0xa03b
movq %r14, %rdi
callq 0x2070
testl %eax, %eax
je 0x2eb2
leaq 0x71fe(%rip), %rsi      # 0xa05d
movq %r15, %rdi
callq 0x2070
testl %eax, %eax
jne 0x2e7e
leaq 0x71d2(%rip), %rsi      # 0xa044
movq %r14, %rdi
callq 0x2070
testl %eax, %eax
je 0x2eb9
leaq 0x71d8(%rip), %rsi      # 0xa05d
movq %r15, %rdi
callq 0x2070
testl %eax, %eax
jne 0x2ea4
leaq 0x71a3(%rip), %rsi      # 0xa03b
movq %r14, %rdi
callq 0x2070
testl %eax, %eax
je 0x2ec0
movl $0x38, %eax
jmp 0x2ec5
movl $0x18, %eax
jmp 0x2ec5
movl $0x20, %eax
jmp 0x2ec5
movl $0x28, %eax
jmp 0x2ec5
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
// File: /workspace/github_cpp_makefile_star2_O1/mittman[P]project254/cycle.cpp
// Function: Cycle::plusType(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::plusType(const string cycle, const string direction) {
	if(direction == "D-to-S" && cycle == "Read") {
		++dsReads;
	}
	else if(direction == "D-to-S" && cycle == "Write") {
		++dsWrites;
	}
	else if(direction == "S-to-D" && cycle == "Read") {
		++sdReads;
	}
	else if(direction == "S-to-D" && cycle == "Write") {
		++sdWrites;
	}
	else {
		++errors;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x7159(%rip), %rsi      # 0xa056
movq %rdx, %rdi
callq 0x2070
testl %eax, %eax
jne 0x2f1c
leaq 0x7134(%rip), %rsi      # 0xa044
movq %r14, %rdi
callq 0x2070
testl %eax, %eax
je 0x2f93
leaq 0x7133(%rip), %rsi      # 0xa056
movq %r15, %rdi
callq 0x2070
testl %eax, %eax
jne 0x2f42
leaq 0x7105(%rip), %rsi      # 0xa03b
movq %r14, %rdi
callq 0x2070
testl %eax, %eax
je 0x2f97
leaq 0x7114(%rip), %rsi      # 0xa05d
movq %r15, %rdi
callq 0x2070
testl %eax, %eax
jne 0x2f68
leaq 0x70e8(%rip), %rsi      # 0xa044
movq %r14, %rdi
callq 0x2070
testl %eax, %eax
je 0x2f9c
leaq 0x70ee(%rip), %rsi      # 0xa05d
movq %r15, %rdi
callq 0x2070
testl %eax, %eax
jne 0x2f8e
leaq 0x70b9(%rip), %rsi      # 0xa03b
movq %r14, %rdi
callq 0x2070
testl %eax, %eax
je 0x2fa1
incl 0x10(%rbx)
jmp 0x2fa4
incl (%rbx)
jmp 0x2fa4
incl 0x4(%rbx)
jmp 0x2fa4
incl 0x8(%rbx)
jmp 0x2fa4
incl 0xc(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/mittman[P]project254/cycle.cpp
// Function: Cycle::getBits(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int Cycle::getBits(const string cycle, const string direction) {
	if(direction == "D-to-S" && cycle == "Read") {
		return dsReads * 32;
	}
	else if(direction == "D-to-S" && cycle == "Write") {
		return dsWrites * 32;
	}
	else if(direction == "S-to-D" && cycle == "Read") {
		return sdReads * 32;
	}
	else if(direction == "S-to-D" && cycle == "Write") {
		return sdWrites * 32;
	}
	else {
		return errors * 32;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x7097(%rip), %rsi      # 0xa056
movq %rdx, %rdi
callq 0x2070
testl %eax, %eax
jne 0x2fde
leaq 0x7072(%rip), %rsi      # 0xa044
movq %r14, %rdi
callq 0x2070
testl %eax, %eax
je 0x3054
leaq 0x7071(%rip), %rsi      # 0xa056
movq %r15, %rdi
callq 0x2070
testl %eax, %eax
jne 0x3004
leaq 0x7043(%rip), %rsi      # 0xa03b
movq %r14, %rdi
callq 0x2070
testl %eax, %eax
je 0x305f
leaq 0x7052(%rip), %rsi      # 0xa05d
movq %r15, %rdi
callq 0x2070
testl %eax, %eax
jne 0x302a
leaq 0x7026(%rip), %rsi      # 0xa044
movq %r14, %rdi
callq 0x2070
testl %eax, %eax
je 0x3065
leaq 0x702c(%rip), %rsi      # 0xa05d
movq %r15, %rdi
callq 0x2070
testl %eax, %eax
jne 0x3050
leaq 0x6ff7(%rip), %rsi      # 0xa03b
movq %r14, %rdi
callq 0x2070
testl %eax, %eax
je 0x306b
addq $0x10, %rbx
movl (%rbx), %eax
shll $0x5, %eax
popq %rbx
popq %r14
popq %r15
retq
addq $0x4, %rbx
jmp 0x3054
addq $0x8, %rbx
jmp 0x3054
addq $0xc, %rbx
jmp 0x3054
nop
// File: /workspace/github_cpp_makefile_star2_O1/mittman[P]project254/cycle.cpp
// Function: Cycle::getElapsed(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
long Cycle::getElapsed(const string cycle, const string direction) {
	if(direction == "D-to-S" && cycle == "Read") {
		return dsrTime;
	}
	else if(direction == "D-to-S" && cycle == "Write") {
		return dswTime;
	}
	else if(direction == "S-to-D" && cycle == "Read") {
		return sdrTime;
	}
	else if(direction == "S-to-D" && cycle == "Write") {
		return sdwTime;
	}
	else {
		return errTime;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x6fcf(%rip), %rsi      # 0xa056
movq %rdx, %rdi
callq 0x2070
testl %eax, %eax
jne 0x30a6
leaq 0x6faa(%rip), %rsi      # 0xa044
movq %r14, %rdi
callq 0x2070
testl %eax, %eax
je 0x311f
leaq 0x6fa9(%rip), %rsi      # 0xa056
movq %r15, %rdi
callq 0x2070
testl %eax, %eax
jne 0x30cc
leaq 0x6f7b(%rip), %rsi      # 0xa03b
movq %r14, %rdi
callq 0x2070
testl %eax, %eax
je 0x3126
leaq 0x6f8a(%rip), %rsi      # 0xa05d
movq %r15, %rdi
callq 0x2070
testl %eax, %eax
jne 0x30f2
leaq 0x6f5e(%rip), %rsi      # 0xa044
movq %r14, %rdi
callq 0x2070
testl %eax, %eax
je 0x312d
leaq 0x6f64(%rip), %rsi      # 0xa05d
movq %r15, %rdi
callq 0x2070
testl %eax, %eax
jne 0x3118
leaq 0x6f2f(%rip), %rsi      # 0xa03b
movq %r14, %rdi
callq 0x2070
testl %eax, %eax
je 0x3134
movl $0x38, %eax
jmp 0x3139
movl $0x18, %eax
jmp 0x3139
movl $0x20, %eax
jmp 0x3139
movl $0x28, %eax
jmp 0x3139
movl $0x30, %eax
movq (%rbx,%rax), %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/mittman[P]project254/datarate.cpp
// Function: DataRate::MegaBits(int, long)
float const DataRate::MegaBits(const int words, const long nanoSec) {
	int bits = words * 32;
	float microSec = 0;
	microSec = nanoSec / 1000;
	return bits / microSec;
}

// Assembly:
movq %rdx, %rax
movabsq $0x20c49ba5e353f7cf, %rcx # imm = 0x20C49BA5E353F7CF
imulq %rcx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %rdx
addq %rax, %rdx
cvtsi2ss %rdx, %xmm1
shll $0x5, %esi
cvtsi2ss %esi, %xmm0
divss %xmm1, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/mittman[P]project254/output.cpp
// Function: Output::setMode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Output::setMode(const string mode) {
	stdout = false;
	logfile = false;

	if(mode == "print") {
		stdout = true;
	}
	else if(mode == "file") {
		logfile = true;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movw $0x0, (%rdi)
leaq 0x6c2e(%rip), %rsi      # 0xa09c
movq %r14, %rdi
callq 0x2070
testl %eax, %eax
je 0x3490
leaq 0x6c21(%rip), %rsi      # 0xa0a2
movq %r14, %rdi
callq 0x2070
testl %eax, %eax
jne 0x3493
incq %rbx
movb $0x1, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/mittman[P]project254/output.cpp
// Function: Output::writeBlank(std::basic_fstream<char, std::char_traits<char>>&)
void const Output::writeBlank(fstream &f) {
	if(stdout) {
		cout << endl;
	}

	if(logfile) {
		f << endl;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x1, (%rdi)
jne 0x34da
movq 0x9b1d(%rip), %r15      # 0xcfd0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2120
cmpb $0x1, 0x1(%r14)
jne 0x3512
movq 0x10(%rbx), %rax
addq $0x10, %rbx
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2120
popq %rbx
popq %r14
popq %r15
retq