LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, -0x28(%rbp)
movq 0x40(%rax), %rdi
movq -0x18(%rbp), %rax
movslq 0x48(%rax), %rsi
callq 0x2340
movb (%rax), %al
movb %al, -0x29(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x31ef
movq -0x38(%rbp), %rax
movsbl -0x29(%rbp), %ecx
movl %ecx, -0x3c(%rbp)
movq 0x40(%rax), %rdi
movq -0x28(%rbp), %rax
movslq 0x48(%rax), %rsi
callq 0x2340
movq %rax, %rcx
movl -0x3c(%rbp), %eax
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x31d9
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
cmpq $0x0, -0x20(%rbp)
jne 0x31cb
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x31d7
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x31ef
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x3176
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movl $0x0, 0x4c(%rdi)
movq 0x10(%rdi), %rsi
callq 0x3250
movq 0x4dad(%rip), %rdi      # 0x7fd8
movq 0x4d96(%rip), %rsi      # 0x7fc8
callq 0x21b0
movq -0x10(%rbp), %rax
movl $0x0, 0x4c(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0xa, 0x4c(%rax)
jne 0x328c
movq 0x4d63(%rip), %rdi      # 0x7fd8
movq 0x4d4c(%rip), %rsi      # 0x7fc8
callq 0x21b0
movq -0x20(%rbp), %rax
movl $0x0, 0x4c(%rax)
movq -0x10(%rbp), %rax
movl 0x54(%rax), %esi
movq 0x4d3e(%rip), %rdi      # 0x7fd8
callq 0x22d0
movq -0x20(%rbp), %rax
cmpl $0x9, 0x4c(%rax)
je 0x32bc
movq 0x4d28(%rip), %rdi      # 0x7fd8
leaq 0x1dce(%rip), %rsi      # 0x5085
callq 0x2180
movq -0x20(%rbp), %rax
movl 0x4c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4c(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x32f7
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3250
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x32d5
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x33c4
movq -0x10(%rbp), %rax
cmpl $0x0, 0x50(%rax)
jne 0x3380
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x40(%rax), %rdi
callq 0x2290
movq -0x30(%rbp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0x2340
movq -0x20(%rbp), %rcx
movb (%rax), %al
movb %al, -0x21(%rbp)
movq %rcx, %rdi
addq $0x68, %rdi
movl 0x50(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x50(%rcx)
movslq %eax, %rsi
callq 0x38e0
movb -0x21(%rbp), %cl
movb %cl, (%rax)
jmp 0x33c2
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x50(%rax), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x2340
movq -0x20(%rbp), %rcx
movb (%rax), %al
movb %al, -0x31(%rbp)
movq %rcx, %rdi
addq $0x68, %rdi
movl 0x50(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x50(%rcx)
movslq %eax, %rsi
callq 0x38e0
movb -0x31(%rbp), %cl
movb %cl, (%rax)
jmp 0x33f2
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x33f2
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3300
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x33d0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq 0x10(%rdi), %rsi
callq 0x3300
movq -0x30(%rbp), %rax
addq $0x68, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3900
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3930
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x3960
testb $0x1, %al
jne 0x3456
jmp 0x348e
leaq -0x18(%rbp), %rdi
callq 0x39a0
movb (%rax), %al
movb %al, -0x21(%rbp)
movq 0x4b6d(%rip), %rdi      # 0x7fd8
movsbl -0x21(%rbp), %esi
callq 0x2200
movq %rax, %rdi
movq 0x4b4a(%rip), %rsi      # 0x7fc8
callq 0x21b0
leaq -0x18(%rbp), %rdi
callq 0x39c0
jmp 0x3443
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %edi
callq 0x35a0
leaq 0x1b9d(%rip), %rdi      # 0x5097
movb $0x0, %al
callq 0x2030
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x35e0
leaq 0x1b84(%rip), %rdi      # 0x5099
movb $0x0, %al
callq 0x2030
leaq 0x1b78(%rip), %rdi      # 0x509b
movb $0x0, %al
callq 0x2030
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x354b
leaq 0x1ca4(%rip), %rdi      # 0x51e8
movb $0x0, %al
callq 0x2030
jmp 0x354d
cmpq $0x0, -0x20(%rbp)
je 0x3575
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x14(%rbp), %edx
addl $0x1, %edx
callq 0x34d0
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x354d
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3588
movl -0x14(%rbp), %edi
callq 0x35a0
leaq 0x1b0e(%rip), %rdi      # 0x509d
movb $0x0, %al
callq 0x2030
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x488d(%rip), %rdi      # 0x7fd8
leaq 0x1997(%rip), %rsi      # 0x50e9
callq 0x2180
movq %rax, %rdi
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rax
movl 0x54(%rax), %esi
callq 0x22d0
movq %rax, %rdi
movq 0x4854(%rip), %rsi      # 0x7fc8
callq 0x21b0
movq 0x4858(%rip), %rdi      # 0x7fd8
leaq 0x1989(%rip), %rsi      # 0x5110
callq 0x2180
movq %rax, %rdi
movq 0x4832(%rip), %rsi      # 0x7fc8
callq 0x21b0
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x37e2
movq -0x10(%rbp), %rax
movl 0x50(%rax), %esi
movq 0x4818(%rip), %rdi      # 0x7fd8
callq 0x22d0
movq %rax, %rdi
leaq 0x18b6(%rip), %rsi      # 0x5085
callq 0x2180
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x37ab
movq 0x47ef(%rip), %rdi      # 0x7fd8
movq 0x47d8(%rip), %rsi      # 0x7fc8
callq 0x21b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, %rax
movq -0x30(%rbp), %rdi
movq %rdx, -0x28(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x20d0
movq %rax, %rdi
movl $0x1, %esi
movb $0x0, %al
callq 0x2170
movq -0x20(%rbp), %rcx
movl %eax, (%rcx)
cmpl $0x0, %eax
jge 0x2ba6
leaq 0x149a(%rip), %rdi      # 0x403b
callq 0x2180
movq -0x28(%rbp), %rdi
callq 0x20d0
movq %rax, %rdi
movl $0x2, %esi
movb $0x0, %al
callq 0x2170
movq -0x20(%rbp), %rcx
movl %eax, 0x4(%rcx)
cmpl $0x0, %eax
jge 0x2bd6
leaq 0x147e(%rip), %rdi      # 0x404f
callq 0x2180
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2140
movabsq $0x400921fb4d12d84a, %rax # imm = 0x400921FB4D12D84A
movq %rax, -0x30(%rbp)
callq 0x2450
jmp 0x22cd
leaq -0x60(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x30(%rbp), %rdx
leaq -0x31(%rbp), %rcx
callq 0x2410
jmp 0x22e4
leaq 0x1d19(%rip), %rsi      # 0x4004
leaq -0x28(%rbp), %rdi
callq 0x2460
movb %al, -0x61(%rbp)
jmp 0x22f9
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x2302
jmp 0x2304
jmp 0x233a
leaq 0x1cfe(%rip), %rdi      # 0x4009
leaq 0x1d06(%rip), %rsi      # 0x4018
movl $0xa, %edx
leaq 0x1d14(%rip), %rcx      # 0x4032
callq 0x20d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x20b0
jmp 0x234c
leaq -0x28(%rbp), %rdi
callq 0x20b0
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x2170
nopw %cs:(%rax,%rax)
// File: killwing[P]underscore/./underscore.h
// Function: std::vector<std::decay<decltype(fp0(*std::begin(fp)))>::type> _::map<std::vector, std::vector<int, std::allocator<int>>, test_map()::$_3>(std::vector<int, std::allocator<int>> const&, test_map()::$_3)
auto
map(const Collection& obj, Function iterator)
    -> RetCollection<typename std::decay<decltype(iterator(*std::begin(obj)))>::type> {

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x691a0
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x5dff0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x5e020
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x69c30
testb $0x1, %al
jne 0xe44c
jmp 0xe4b6
leaq -0x30(%rbp), %rdi
callq 0x69c70
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movl (%rax), %edx
leaq -0x60(%rbp), %rdi
leaq -0x9(%rbp), %rsi
callq 0x430c0
jmp 0xe46e
movq -0x80(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x691c0
jmp 0xe47d
leaq -0x60(%rbp), %rdi
callq 0x34a8
leaq -0x30(%rbp), %rdi
callq 0x69c90
jmp 0xe439
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0xe4d6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x34a8
jmp 0xe4d6
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0xe4c9
movq -0x80(%rbp), %rdi
callq 0x53340
movq -0x78(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x53340
movq -0x68(%rbp), %rdi
callq 0x3440
nopl (%rax,%rax)
// File: killwing[P]underscore/./underscore.h
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> _::filter<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, test_filter()::$_0>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, test_filter()::$_0)
Collection
filter(const Collection& obj, Function iterator) {
    Collection result;
    for (auto& i : obj) {
        if (iterator(i)) {
            util::add(result, i);
        }
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x3390
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3250
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3470
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x69b70
testb $0x1, %al
jne 0x1d929
jmp 0x1d989
leaq -0x30(%rbp), %rdi
callq 0x69bb0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movsbl (%rax), %esi
leaq -0x9(%rbp), %rdi
callq 0x46780
movb %al, -0x61(%rbp)
jmp 0x1d94b
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x1d954
jmp 0x1d97c
movq -0x60(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x73ed0
jmp 0x1d963
jmp 0x1d97c
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x34a8
jmp 0x1d9a6
jmp 0x1d97e
leaq -0x30(%rbp), %rdi
callq 0x69c00
jmp 0x1d916
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x1d99c
movq -0x60(%rbp), %rdi
callq 0x34a8
movq -0x58(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3440
nop
// File: killwing[P]underscore/./underscore.h
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> _::reject<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, test_reject()::$_0>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, test_reject()::$_0)
Collection
reject(const Collection& obj, Function iterator) {
    Collection result;
    for (auto& i : obj) {
        if (!iterator(i)) {
            util::add(result, i);
        }
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x3390
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3250
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3470
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x69b70
testb $0x1, %al
jne 0x216b9
jmp 0x21719
leaq -0x30(%rbp), %rdi
callq 0x69bb0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movsbl (%rax), %esi
leaq -0x9(%rbp), %rdi
callq 0x46920
movb %al, -0x61(%rbp)
jmp 0x216db
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x2170c
jmp 0x216e4
movq -0x60(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x73ed0
jmp 0x216f3
jmp 0x2170c
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x34a8
jmp 0x21736
jmp 0x2170e
leaq -0x30(%rbp), %rdi
callq 0x69c00
jmp 0x216a6
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x2172c
movq -0x60(%rbp), %rdi
callq 0x34a8
movq -0x58(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3440
nop
// File: killwing[P]underscore/./underscore.h
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> _::sortBy<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, test_sortBy()::$_1>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, test_sortBy()::$_1)
Collection
sortBy(const Collection& obj, Function iterator) {
    Collection result = obj;
    using R = typename Collection::value_type;
    std::sort(std::begin(result), std::end(result), [&](const R& a, const R& b) {
        return iterator(a) < iterator(b);
    });
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x18(%rbp), %rsi
callq 0x30f0
movq -0x50(%rbp), %rdi
callq 0x5d5a0
movq -0x50(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0x5d5d0
movq %rax, -0x30(%rbp)
leaq -0x9(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x4e2c0
jmp 0x321ad
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x321d9
jmp 0x321d0
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x34a8
jmp 0x321e3
movq -0x50(%rbp), %rdi
callq 0x34a8
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3440
nopl (%rax)
// File: killwing[P]underscore/./underscore.h
// Function: std::multimap<std::decay<decltype(fp0(*std::begin(fp)))>::type, std::decay<decltype(*std::begin(fp))>::type, std::less<std::decay<decltype(fp0(*std::begin(fp)))>::type>, std::allocator<std::pair<std::decay<decltype(fp0(*std::begin(fp)))>::type const, std::decay<decltype(*std::begin(fp))>::type>>> _::groupBy<std::map<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<int>, std::allocator<std::pair<int const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, test_groupBy()::$_11>(std::map<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<int>, std::allocator<std::pair<int const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&, test_groupBy()::$_11)
auto
groupBy(const Collection& obj, Function iterator) 
    -> std::multimap<typename std::decay<decltype(iterator(*std::begin(obj)))>::type, 
                     typename std::decay<decltype(*std::begin(obj))>::type> {

    using R = std::multimap<typename std::decay<decltype(iterator(*std::begin(obj)))>::type, 
                            typename std::decay<decltype(*std::begin(obj))>::type>;
    R result;
    for (auto& i : obj) {
        result.insert(typename R::value_type(iterator(i), i)); 
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x84df0
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x724c0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x724f0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x65250
testb $0x1, %al
jne 0x37255
jmp 0x372fe
leaq -0x30(%rbp), %rdi
callq 0x652d0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
leaq -0x9(%rbp), %rdi
callq 0x51c70
movb %al, -0xa1(%rbp)
jmp 0x37277
movb -0xa1(%rbp), %al
andb $0x1, %al
movb %al, -0x71(%rbp)
movq -0x40(%rbp), %rdx
leaq -0x70(%rbp), %rdi
leaq -0x71(%rbp), %rsi
callq 0x575b0
jmp 0x37295
movq -0xa0(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x84e10
movq %rax, -0xb0(%rbp)
jmp 0x372ae
movq -0xb0(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x57700
leaq -0x30(%rbp), %rdi
callq 0x652f0
jmp 0x3723f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x37324
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x57700
jmp 0x37324
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x37314
movq -0xa0(%rbp), %rdi
callq 0x57750
movq -0x98(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0xa0(%rbp), %rdi
callq 0x57750
movq -0x80(%rbp), %rdi
callq 0x3440
nopl (%rax)
// File: killwing[P]underscore/./underscore.h
// Function: std::map<std::decay<decltype(fp0(*std::begin(fp)))>::type, unsigned long, std::less<std::decay<decltype(fp0(*std::begin(fp)))>::type>, std::allocator<std::pair<std::decay<decltype(fp0(*std::begin(fp)))>::type const, unsigned long>>> _::countBy<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, test_countBy()::$_2>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, test_countBy()::$_2)
auto
countBy(const Collection& obj, Function iterator) 
    -> std::map<typename std::decay<decltype(iterator(*std::begin(obj)))>::type, std::size_t> {

    using R = std::map<typename std::decay<decltype(iterator(*std::begin(obj)))>::type, std::size_t>;
    R result;
    for (auto& i : obj) {
        auto&& v = iterator(i);
        typename R::iterator it = result.find(v);
        if (it == result.end()) {
            result.insert(typename R::value_type(std::forward<decltype(v)>(v), 1)); 
        } else {
            ++it->second;
        }
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x87aa0
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3250
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3470
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x69b70
testb $0x1, %al
jne 0x3aab5
jmp 0x3abce
leaq -0x30(%rbp), %rdi
callq 0x69bb0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movsbl (%rax), %esi
leaq -0x9(%rbp), %rdi
callq 0x51da0
movb %al, -0xa9(%rbp)
jmp 0x3aada
movq -0xa8(%rbp), %rdi
movb -0xa9(%rbp), %al
andb $0x1, %al
movb %al, -0x49(%rbp)
leaq -0x49(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rsi
callq 0x87ac0
movq %rax, -0xb8(%rbp)
jmp 0x3ab06
movq -0xa8(%rbp), %rdi
movq -0xb8(%rbp), %rax
movq %rax, -0x68(%rbp)
callq 0x87b20
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x87af0
testb $0x1, %al
jne 0x3ab34
jmp 0x3aba9
movq -0x48(%rbp), %rsi
movl $0x1, -0x84(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x84(%rbp), %rdx
callq 0x87b90
jmp 0x3ab54
movq -0xa8(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x87b50
movb %dl, -0xc1(%rbp)
movq %rax, -0xc0(%rbp)
jmp 0x3ab73
movb -0xc1(%rbp), %al
movq -0xc0(%rbp), %rcx
movq %rcx, -0x98(%rbp)
movb %al, -0x90(%rbp)
jmp 0x3abbe
movq -0xa8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0x57a10
jmp 0x3abf4
leaq -0x68(%rbp), %rdi
callq 0x87bc0
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
jmp 0x3abc0
leaq -0x30(%rbp), %rdi
callq 0x69c00
jmp 0x3aa9f
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x3abe4
movq -0xa8(%rbp), %rdi
callq 0x57a10
movq -0xa0(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x3440
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
callq 0x36c0
callq 0x6fe0
callq 0xf020
callq 0x13ed0
callq 0x17f20
callq 0x1a6c0
callq 0x1e450
callq 0x221e0
callq 0x24820
callq 0x26e60
callq 0x292c0
callq 0x2ae90
callq 0x2c760
callq 0x2ebc0
callq 0x31020
callq 0x32360
callq 0x37730
callq 0x3c060
callq 0x3ce50
callq 0x40610
movq 0x7d73e(%rip), %rdi     # 0xbffd8
leaq 0x4dca4(%rip), %rsi     # 0x90545
callq 0x3260
movq %rax, %rdi
movq 0x7d710(%rip), %rsi     # 0xbffc0
callq 0x32b0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: killwing[P]underscore/test.cpp
// Function: Tracer::~Tracer()
~Tracer() {
        if (supported_) {
            cout << "[ok]" << endl;
        } else {
            cout << "[not supported]" << endl;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
testb $0x1, 0x20(%rax)
je 0x521c7
movq 0x6de37(%rip), %rdi     # 0xbffd8
leaq 0x3e3b9(%rip), %rsi     # 0x90561
callq 0x3260
movq %rax, -0x18(%rbp)
jmp 0x521b3
movq -0x18(%rbp), %rdi
movq 0x6de02(%rip), %rsi     # 0xbffc0
callq 0x32b0
jmp 0x521c5
jmp 0x521f4
movq 0x6de0a(%rip), %rdi     # 0xbffd8
leaq 0x3e391(%rip), %rsi     # 0x90566
callq 0x3260
movq %rax, -0x20(%rbp)
jmp 0x521e0
movq -0x20(%rbp), %rdi
movq 0x6ddd5(%rip), %rsi     # 0xbffc0
callq 0x32b0
jmp 0x521f2
jmp 0x521f4
movq -0x10(%rbp), %rdi
callq 0x34a8
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x58f20
nopl (%rax,%rax)
// File: killwing[P]underscore/./underscore.h
// Function: std::enable_if<!std::is_void<decltype(*std::begin(fp).*fp0(fp1...))>::value, std::vector<std::decay<decltype(*std::begin(fp).*fp0(fp1...))>::type>>::type _::invoke<std::vector, std::vector<Data, std::allocator<Data>>, int (Data::*)() const>(std::vector<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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rsi, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %rax, -0x30(%rbp)
movb $0x0, -0x31(%rbp)
callq 0x52ad0
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x78800
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x78830
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x78860
testb $0x1, %al
jne 0x54cd7
jmp 0x54d92
leaq -0x48(%rbp), %rdi
callq 0x788a0
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x28(%rbp), %rdx
addq %rdx, %rcx
movq %rcx, -0x88(%rbp)
andq $0x1, %rax
cmpq $0x0, %rax
je 0x54d2d
movq -0x90(%rbp), %rcx
movq -0x88(%rbp), %rax
movq (%rax), %rax
subq $0x1, %rcx
movq (%rax,%rcx), %rax
movq %rax, -0x98(%rbp)
jmp 0x54d3b
movq -0x90(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x88(%rbp), %rdi
movq -0x98(%rbp), %rax
callq *%rax
movl %eax, -0x9c(%rbp)
jmp 0x54d53
movq -0x80(%rbp), %rdi
movl -0x9c(%rbp), %eax
movl %eax, -0x5c(%rbp)
leaq -0x5c(%rbp), %rsi
callq 0x77df0
jmp 0x54d6b
jmp 0x54d6d
leaq -0x48(%rbp), %rdi
callq 0x788c0
jmp 0x54cc1
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x52430
jmp 0x54db2
movb $0x1, -0x31(%rbp)
testb $0x1, -0x31(%rbp)
jne 0x54da5
movq -0x80(%rbp), %rdi
callq 0x52430
movq -0x78(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x3440
nopl (%rax,%rax)
// File: killwing[P]underscore/./underscore.h
// Function: std::vector<std::decay<decltype(*std::begin(fp).*fp0)>::type> _::pluck<std::vector, Data [10], int Data::*>(Data const (&) [10], 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x52ad0
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
je 0x564c3
movq -0x60(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
movq -0x18(%rbp), %rax
addq %rax, %rsi
callq 0x73f00
jmp 0x5649c
jmp 0x5649e
movq -0x30(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
jmp 0x56474
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x52430
jmp 0x564e0
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x564d6
movq -0x60(%rbp), %rdi
callq 0x52430
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3440
nopl (%rax)
// File: killwing[P]underscore/./underscore.h
// Function: std::deque<int, std::allocator<int>> _::shuffle<std::deque<int, std::allocator<int>>>(std::deque<int, std::allocator<int>> 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 %rbp
movq %rsp, %rbp
subq $0x2790, %rsp           # imm = 0x2790
movq %rdi, -0x2788(%rbp)
movq %rdi, %rax
movq %rax, -0x2780(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rsi
callq 0x81260
leaq -0x13a0(%rbp), %rdi
callq 0x89120
jmp 0x57e6f
movq -0x2788(%rbp), %rsi
leaq -0x13d0(%rbp), %rdi
callq 0x5edc0
movq -0x2788(%rbp), %rsi
leaq -0x13f0(%rbp), %rdi
callq 0x5edf0
leaq -0x13a0(%rbp), %rdi
callq 0x893e0
movl %eax, -0x278c(%rbp)
jmp 0x57ea9
movl -0x278c(%rbp), %eax
movl %eax, %eax
movl %eax, %esi
leaq -0x2778(%rbp), %rdi
callq 0x89400
jmp 0x57ec1
leaq -0x13d0(%rbp), %rdi
leaq -0x13f0(%rbp), %rsi
leaq -0x2778(%rbp), %rdx
callq 0x8a1f0
jmp 0x57edd
movb $0x1, -0x11(%rbp)
leaq -0x13a0(%rbp), %rdi
callq 0x89430
testb $0x1, -0x11(%rbp)
jne 0x57f35
jmp 0x57f29
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x13a8(%rbp)
movl %eax, -0x13ac(%rbp)
jmp 0x57f45
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x13a8(%rbp)
movl %eax, -0x13ac(%rbp)
leaq -0x13a0(%rbp), %rdi
callq 0x89430
jmp 0x57f45
movq -0x2788(%rbp), %rdi
callq 0x525a0
movq -0x2780(%rbp), %rax
addq $0x2790, %rsp           # imm = 0x2790
popq %rbp
retq
movq -0x2788(%rbp), %rdi
callq 0x525a0
movq -0x13a8(%rbp), %rdi
callq 0x3440
nopl (%rax)
// File: killwing[P]underscore/./underscore.h
// Function: std::enable_if<!util::HasSize<int [9]>::value, unsigned long>::type _::size<int [9]>(int const (&) [9])
typename std::enable_if<!util::HasSize<Collection>::value, size_t>::type
size(const Collection& obj) {
    size_t s = 0;
    for (auto& _ : obj) {
        ++s;
    }
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x24, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0x58cf8
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
jmp 0x58ccc
movq -0x10(%rbp), %rax
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6ce10
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6ce40
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6ce70
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6cea0
testb $0x1, %al
jne 0x6cd32
jmp 0x6cd53
leaq -0x28(%rbp), %rdi
callq 0x6ced0
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x6cef0
leaq -0x28(%rbp), %rdi
callq 0x6cef0
jmp 0x6cd1f
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x6cf60
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x40(%rbp), %rsi
callq 0x6cf10
movq %rax, -0x48(%rbp)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: stevedonovan[P]outstreams/testout.cpp
// Function: writing_to_file()
int writing_to_file() {
    outs("*writing to file")();
    double x = 1.1, y = 2.0, z = 2.8;
    Writer("test.txt").sep(',')(x)(y)(z)();
    return system("cat test.txt");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
leaq 0x76f1(%rip), %rdi      # 0xa1c0
leaq 0x3593(%rip), %rsi      # 0x6069
xorl %eax, %eax
movl %eax, %edx
callq 0x3010
movq %rax, %rdi
callq 0x5110
movabsq $0x3ff199999999999a, %rax # imm = 0x3FF199999999999A
movq %rax, -0x8(%rbp)
movabsq $0x4000000000000000, %rax # imm = 0x4000000000000000
movq %rax, -0x10(%rbp)
movabsq $0x4006666666666666, %rax # imm = 0x4006666666666666
movq %rax, -0x18(%rbp)
leaq 0x3568(%rip), %rsi      # 0x6080
leaq 0x355b(%rip), %rdx      # 0x607a
leaq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x4e80
movq -0x50(%rbp), %rdi
movl $0x2c, %esi
callq 0x5070
movq %rax, -0x48(%rbp)
jmp 0x2b40
movq -0x48(%rbp), %rdi
movsd -0x8(%rbp), %xmm0
xorl %eax, %eax
movl %eax, %esi
callq 0x3680
movq %rax, -0x58(%rbp)
jmp 0x2b58
movq -0x58(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
xorl %eax, %eax
movl %eax, %esi
callq 0x3680
movq %rax, -0x60(%rbp)
jmp 0x2b70
movq -0x60(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
xorl %eax, %eax
movl %eax, %esi
callq 0x3680
movq %rax, -0x68(%rbp)
jmp 0x2b88
movq -0x68(%rbp), %rdi
callq 0x5110
jmp 0x2b93
leaq -0x30(%rbp), %rdi
callq 0x4fa0
leaq 0x34d9(%rip), %rdi      # 0x607c
callq 0x2170
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4fa0
movq -0x38(%rbp), %rdi
callq 0x22c0
nopl (%rax)
// File: stevedonovan[P]outstreams/testout.cpp
// Function: building_strings()
void building_strings() {
    outs("*building strings")();
    StrWriter sw(' ');
    sw(42)("and")(3.4);

    outs(sw.str())();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
leaq 0x75de(%rip), %rdi      # 0xa1c0
leaq 0x34a0(%rip), %rsi      # 0x6089
xorl %eax, %eax
movl %eax, %edx
movq %rdx, -0x78(%rbp)
callq 0x3010
movq %rax, %rdi
callq 0x5110
movq -0x78(%rbp), %rdx
leaq -0x38(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movl $0x20, %esi
callq 0x5240
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rdx
movl $0x2a, %esi
callq 0x36c0
movq %rax, -0x70(%rbp)
jmp 0x2c2c
movq -0x70(%rbp), %rdi
leaq 0x3464(%rip), %rsi      # 0x609b
xorl %eax, %eax
movl %eax, %edx
callq 0x3010
movq %rax, -0x88(%rbp)
jmp 0x2c49
movq -0x88(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movsd 0x33ac(%rip), %xmm0     # 0x6008
callq 0x3680
jmp 0x2c63
leaq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3740
jmp 0x2c72
leaq 0x7547(%rip), %rdi      # 0xa1c0
xorl %eax, %eax
movl %eax, %edx
leaq -0x68(%rbp), %rsi
callq 0x3700
movq %rax, -0x90(%rbp)
jmp 0x2c8f
movq -0x90(%rbp), %rdi
callq 0x5110
jmp 0x2c9d
leaq -0x68(%rbp), %rdi
callq 0x20f0
leaq -0x38(%rbp), %rdi
callq 0x3770
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2cdb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x20f0
leaq -0x38(%rbp), %rdi
callq 0x3770
movq -0x40(%rbp), %rdi
callq 0x22c0
nopl (%rax)
// File: stevedonovan[P]outstreams/testout.cpp
// Function: macro_magic()
void macro_magic() {
    outs("*macro magic")();
    #define VA(var) (#var)(var,"Q")
    #define VX64(var) (#var)(var,"%#016" PRIX64)
    string full_name = "bonzo the dog";
    uint64_t  id_number = 666;

    outs VA(full_name) VA(id_number)   ();

    outs VX64(id_number) ();

    #undef VA
    #undef VX64
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
leaq 0x74be(%rip), %rdi      # 0xa1c0
leaq 0x3396(%rip), %rsi      # 0x609f
xorl %eax, %eax
movl %eax, %edx
callq 0x3010
movq %rax, %rdi
callq 0x5110
leaq -0x21(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x22d0
movq -0x48(%rbp), %rdx
leaq 0x337a(%rip), %rsi      # 0x60ac
leaq -0x20(%rbp), %rdi
callq 0x33f0
jmp 0x2d3d
leaq -0x21(%rbp), %rdi
callq 0x21e0
movq $0x29a, -0x40(%rbp)     # imm = 0x29A
leaq 0x746b(%rip), %rdi      # 0xa1c0
leaq 0x335e(%rip), %rsi      # 0x60ba
xorl %eax, %eax
movl %eax, %edx
callq 0x3010
movq %rax, -0x50(%rbp)
jmp 0x2d6b
movq -0x50(%rbp), %rdi
leaq 0x32f1(%rip), %rdx      # 0x6067
leaq -0x20(%rbp), %rsi
callq 0x3700
movq %rax, -0x58(%rbp)
jmp 0x2d85
movq -0x58(%rbp), %rdi
leaq 0x3334(%rip), %rsi      # 0x60c4
xorl %eax, %eax
movl %eax, %edx
callq 0x3010
movq %rax, -0x60(%rbp)
jmp 0x2d9f
movq -0x60(%rbp), %rdi
movq -0x40(%rbp), %rsi
leaq 0x32b9(%rip), %rdx      # 0x6067
callq 0x37b0
movq %rax, -0x68(%rbp)
jmp 0x2db9
movq -0x68(%rbp), %rdi
callq 0x5110
jmp 0x2dc4
leaq 0x73f5(%rip), %rdi      # 0xa1c0
leaq 0x32f2(%rip), %rsi      # 0x60c4
xorl %eax, %eax
movl %eax, %edx
callq 0x3010
movq %rax, -0x70(%rbp)
jmp 0x2de1
movq -0x70(%rbp), %rdi
movq -0x40(%rbp), %rsi
leaq 0x32de(%rip), %rdx      # 0x60ce
callq 0x37b0
movq %rax, -0x78(%rbp)
jmp 0x2dfb
movq -0x78(%rbp), %rdi
callq 0x5110
jmp 0x2e06
leaq -0x20(%rbp), %rdi
callq 0x20f0
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x21e0
jmp 0x2e44
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x20f0
movq -0x30(%rbp), %rdi
callq 0x22c0
nopl (%rax)
// File: stevedonovan[P]outstreams/testout.cpp
// Function: outstream_tests()
void outstream_tests() {
    outs("*basic tests")();
    // not initially true
    outs.sep(' ');

    // outstreams are good for quick dumps of variable values
    int i = 10;
    string s = "hello you";
    double x = 3.1412;
    long n = 34343;

    outs(s)(i)(x)(n)("finis")('\n');

    writing_iterator_range();

    writing_to_file();

    building_strings();

    custom_type_point();

    macro_magic();

 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
leaq 0x735e(%rip), %rdi      # 0xa1c0
movq %rdi, -0x60(%rbp)
leaq 0x3269(%rip), %rsi      # 0x60d6
xorl %eax, %eax
movl %eax, %edx
callq 0x3010
movq %rax, %rdi
callq 0x5110
movq -0x60(%rbp), %rdi
movl $0x20, %esi
callq 0x5070
movl $0xa, -0x4(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x22d0
movq -0x58(%rbp), %rdx
leaq 0x3238(%rip), %rsi      # 0x60e3
leaq -0x28(%rbp), %rdi
callq 0x33f0
jmp 0x2eb6
leaq -0x29(%rbp), %rdi
callq 0x21e0
movabsq $0x4009212d77318fc5, %rax # imm = 0x4009212D77318FC5
movq %rax, -0x48(%rbp)
movq $0x8627, -0x50(%rbp)    # imm = 0x8627
leaq 0x72e4(%rip), %rdi      # 0xa1c0
xorl %eax, %eax
movl %eax, %edx
leaq -0x28(%rbp), %rsi
callq 0x3700
movq %rax, -0x68(%rbp)
jmp 0x2eef
movq -0x68(%rbp), %rdi
movl -0x4(%rbp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x36c0
movq %rax, -0x70(%rbp)
jmp 0x2f05
movq -0x70(%rbp), %rdi
movsd -0x48(%rbp), %xmm0
xorl %eax, %eax
movl %eax, %esi
callq 0x3680
movq %rax, -0x78(%rbp)
jmp 0x2f1d
movq -0x78(%rbp), %rdi
movq -0x50(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x37f0
movq %rax, -0x80(%rbp)
jmp 0x2f34
movq -0x80(%rbp), %rdi
leaq 0x31ae(%rip), %rsi      # 0x60ed
xorl %eax, %eax
movl %eax, %edx
callq 0x3010
movq %rax, -0x88(%rbp)
jmp 0x2f51
movq -0x88(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0xa, %esi
callq 0x30e0
jmp 0x2f68
callq 0x2530
jmp 0x2f6f
callq 0x2ac0
jmp 0x2f76
callq 0x2bd0
jmp 0x2f7d
callq 0x24b0
jmp 0x2f84
callq 0x2cf0
jmp 0x2f8b
leaq -0x28(%rbp), %rdi
callq 0x20f0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x21e0
jmp 0x2fc9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x20f0
movq -0x38(%rbp), %rdi
callq 0x22c0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x10(%rbp)
movl %edx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x4bb0
movq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x50b0
movq -0x30(%rbp), %rdi
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3010
movq %rax, %rdi
movl $0x3a, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x30e0
movq %rax, %rdi
movl -0x8(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x36c0
movq -0x30(%rbp), %rdi
movsbl -0x21(%rbp), %esi
callq 0x50e0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rsi, -0x1c0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x31a0
leaq -0x190(%rbp), %rdi
leaq 0x14c(%rip), %rsi       # 0x3890
callq 0x30c0
movq %rax, -0x1b8(%rbp)
jmp 0x3752
movq -0x1c0(%rbp), %rsi
movq -0x1b8(%rbp), %rdi
callq 0x3240
jmp 0x3767
leaq -0x1a0(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x3160
jmp 0x3779
movl -0x14(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x1c4(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x31e0
movl -0x1c4(%rbp), %eax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x31e0
movq -0x1a8(%rbp), %rdi
callq 0x3440
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rsi, -0x1c0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x31a0
leaq -0x190(%rbp), %rdi
leaq 0x8c(%rip), %rsi        # 0x3890
callq 0x30c0
movq %rax, -0x1b8(%rbp)
jmp 0x3812
movq -0x1c0(%rbp), %rsi
movq -0x1b8(%rbp), %rdi
callq 0x3240
jmp 0x3827
leaq -0x1a0(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x33a0
jmp 0x3839
movq -0x18(%rbp), %rax
movq %rax, -0x1c8(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x31e0
movq -0x1c8(%rbp), %rax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x31e0
movq -0x1a8(%rbp), %rdi
callq 0x3440
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rsi, -0x1f0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1e8(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x31a0
leaq -0x190(%rbp), %rdi
leaq -0x1ff(%rip), %rsi      # 0x3890
callq 0x30c0
movq %rax, -0x1e0(%rbp)
jmp 0x3a9d
movq -0x1f0(%rbp), %rsi
movq -0x1e0(%rbp), %rdi
callq 0x3240
jmp 0x3ab2
leaq -0x1a0(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x3050
jmp 0x3ac4
movl -0x14(%rbp), %eax
movl %eax, %esi
leaq -0x1b8(%rbp), %rdi
movq %rdi, -0x1f8(%rbp)
callq 0x3c80
movq -0x1f8(%rbp), %rsi
leaq -0x1d8(%rbp), %rdi
callq 0x3cd0
jmp 0x3af1
movq -0x1e8(%rbp), %rdi
leaq -0x1d8(%rbp), %rsi
movq %rsi, -0x200(%rbp)
callq 0x3310
movq -0x200(%rbp), %rdi
callq 0x3170
movq -0x1e8(%rbp), %rdi
callq 0x3b70
jmp 0x3b25
leaq -0x1a0(%rbp), %rdi
callq 0x31e0
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x31e0
movq -0x1a8(%rbp), %rdi
callq 0x3440
nopw %cs:(%rax,%rax)
// File: mittman[P]project254/cycle.cpp
// Function: Cycle::Cycle()
Cycle::Cycle() {
	dsReads = 0;
	dsWrites = 0;
	sdReads = 0;
	sdWrites = 0;
	errors = 0;
	dsrTime = 0;
	dswTime = 0;
	sdrTime = 0;
	sdwTime = 0;
	errTime = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, 0x4(%rax)
movl $0x0, 0x8(%rax)
movl $0x0, 0xc(%rax)
movl $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq $0x0, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq $0x0, 0x30(%rax)
movq $0x0, 0x38(%rax)
popq %rbp
retq
nopl (%rax,%rax)