LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/ridgelab[P]Kmer-SSR/test/src/findSSRs.cpp
// Function: fillSSRSetFromFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<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>>>>*)
void fillSSRSetFromFile(const string &fn, set<string>* ssrs)
{
	ifstream fd;
	fd.open(fn.c_str());

	string line;
	getline(fd, line); // skip past the header line
	while(getline(fd, line))
	{
		ssrs->insert(line);
	}

	fd.close();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x230, %rsp            # imm = 0x230
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x4340
movq (%r14), %rsi
pushq $0x8
popq %rdx
movq %r15, %rdi
callq 0x41e0
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x4080
leaq 0x28(%rsp), %r14
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x4080
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x63f0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x67b2
jmp 0x63ca
leaq 0x28(%rsp), %rdi
callq 0x40a0
leaq 0x8(%rsp), %rdi
callq 0x45e8
leaq 0x28(%rsp), %rdi
callq 0x40e0
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x642f
jmp 0x6422
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x45e8
leaq 0x28(%rsp), %rdi
callq 0x40e0
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O2/ridgelab[P]Kmer-SSR/test/src/findSSRs.cpp
// Function: actualOutputMatchedExpected(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool actualOutputMatchedExpected(const string &actual_fn, const string &expected_fn)
{
	bool ret_val = true;
	
	set<string>* actual = new set<string>();
	set<string>* expected = new set<string>();
	
	fillSSRSetFromFile(actual_fn, actual);
	fillSSRSetFromFile(expected_fn, expected);

	if (actual->size() != expected->size())
	{
		ret_val = false;
	}
	else
	{
		set<string>::iterator a_itr = actual->begin();
		set<string>::iterator e_itr = expected->begin();
		while (e_itr != expected->end() && a_itr != actual->end()) // expected.size() == actual.size()
		{
			if (*e_itr != *a_itr)
			{
				ret_val = false;
				break;
			}

			++e_itr;
			++a_itr;
		}
	}

	delete actual;
	delete expected;

	return ret_val;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r12
pushq $0x30
popq %r14
movq %r14, %rdi
callq 0x42f0
movq %rax, %rbp
leaq 0x8(%rax), %r13
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movq %r13, 0x18(%rax)
movq %r13, 0x20(%rax)
andq $0x0, 0x28(%rax)
movq %r14, %rdi
callq 0x42f0
movq %rax, %r14
leaq 0x8(%rax), %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movq %rbx, 0x18(%rax)
movq %rbx, 0x20(%rax)
andq $0x0, 0x28(%rax)
movq %r12, %rdi
movq %rbp, %rsi
callq 0x6373
movq %r15, %rdi
movq %r14, %rsi
callq 0x6373
movq 0x28(%rbp), %rax
cmpq 0x28(%r14), %rax
movq %rbp, (%rsp)
jne 0x650a
movq 0x18(%rbp), %r15
movq 0x18(%r14), %r12
cmpq %rbx, %r12
sete %al
cmpq %r13, %r15
sete %bpl
orb %al, %bpl
jne 0x650c
leaq 0x20(%r12), %rdi
leaq 0x20(%r15), %rsi
callq 0x65bd
testb %al, %al
jne 0x650c
movq %r12, %rdi
callq 0x4350
movq %rax, %r12
movq %r15, %rdi
callq 0x4350
movq %rax, %r15
jmp 0x64ce
xorl %ebp, %ebp
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x65d2
pushq $0x30
popq %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4300
movq %r14, %rdi
callq 0x65d2
movq %r14, %rdi
movq %r15, %rsi
callq 0x4300
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/eryxcc[P]lois/tests/../include/loisextra.h
// Function: lois::lsetof<lois::lpair<lois::elem, lois::elem>> lois::operator|<lois::lpair<lois::elem, lois::elem>>(lois::lsetof<lois::lpair<lois::elem, lois::elem>> const&, lois::lsetof<lois::lpair<lois::elem, lois::elem>> const&)
lsetof<T> operator | (const lsetof<T>& x, const lsetof<T>& y) { 
  lsetof<T> xy;
  for(const T& e: x) xy += e;
  for(const T& e: y) xy += e;
  return xy;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x14a9c
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x16a64
leaq 0x38(%rsp), %rdi
movq %r15, %rsi
callq 0x16a74
leaq 0x8(%rsp), %r15
leaq 0x38(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x16a88
testb %al, %al
je 0x14794
movq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x14c44
movq %r15, %rdi
callq 0x16ace
jmp 0x1476e
leaq 0x38(%rsp), %rdi
callq 0x16ae4
leaq 0x8(%rsp), %rdi
callq 0x16ae4
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x16a64
leaq 0x38(%rsp), %rdi
movq %r14, %rsi
callq 0x16a74
leaq 0x8(%rsp), %r14
leaq 0x38(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x16a88
testb %al, %al
je 0x147f2
movq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x14c44
movq %r14, %rdi
callq 0x16ace
jmp 0x147cc
leaq 0x38(%rsp), %rdi
callq 0x16ae4
leaq 0x8(%rsp), %rdi
callq 0x16ae4
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x14819
jmp 0x1481e
movq %rax, %r14
jmp 0x14836
movq %rax, %r14
jmp 0x14840
jmp 0x14829
jmp 0x14829
jmp 0x14829
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x16ae4
leaq 0x8(%rsp), %rdi
callq 0x16ae4
movq %rbx, %rdi
callq 0x14a32
movq %r14, %rdi
callq 0x7410
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk-extras/exprtk_testgen.cpp
// Function: main
int main(int argc, char* argv[])
{
   if (argc != 2)
   {
      printf("usage: exprtk_testgen <file name>\n");
      return 1;
   }

   const std::string file_name = argv[1];
   test_gen<double>(file_name);

   return 0;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
cmpl $0x2, %edi
jne 0x112282
movq 0x8(%rsi), %rsi
leaq 0x10(%rsp), %rbx
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x11234e
movq %rbx, %rdi
callq 0x112389
leaq 0x10(%rsp), %rdi
callq 0x1105f8
xorl %eax, %eax
jmp 0x112291
leaq 0x131a25(%rip), %rdi    # 0x243cae
callq 0x110520
pushq $0x1
popq %rax
addq $0x30, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1105f8
movq %rbx, %rdi
callq 0x110340
// File: /workspace/github_cpp_makefile_star2_O2/EnderGed[P]fast-random-walk/Graph.cpp
// Function: Graph::doWalk(unsigned int, unsigned int, FastPRNG&, char*) const
size_t Graph::doWalk(uint node, uint32_t walk_len, FastPRNG & prng, char * const out) const
{
	// Write start node to output string
	char * outPos = out;

	{
		unsigned const wrote = writeInt(outPos, node);
		outPos += wrote;
	}

	while(--walk_len)
	{
		// Determine the number of outgoing transitions (from the current node)
		uint const outgoingTransitions = getNumTransitions(node);
		if(!outgoingTransitions)
		{
			fprintf(stderr, "Node %d has no outgoing transitions\n", node);
			break;
		}

		// Choose a successor node
		node = getNode(node, prng.uniformInRange<uint>(outgoingTransitions - 1));

		// Write node number to output
		{
			*(outPos++) = ',';
			unsigned const wrote = writeInt(outPos, node);
			outPos += wrote;
		}
	}

	*outPos = '\0';

	return outPos - out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r15
movl %edx, %ebp
movl %esi, %r13d
movq %rdi, %r12
movq %r8, %rdi
callq 0x38c5
movl %eax, %r14d
movq %rbx, (%rsp)
addq %rbx, %r14
decl %ebp
subl $0x1, %ebp
jb 0x24c7
cmpl %r13d, 0x8(%r12)
jbe 0x24ac
movq 0x10(%r12), %rax
movl %r13d, %ebx
movl 0x8(%rax,%rbx,8), %esi
subl (%rax,%rbx,8), %esi
je 0x24ac
decl %esi
movq %r15, %rdi
callq 0x2c04
movq 0x10(%r12), %rcx
movq (%rcx,%rbx,8), %rcx
shlq $0x2, %rcx
addq 0x18(%r12), %rcx
movl %eax, %eax
movl (%rcx,%rax,4), %r13d
leaq 0x1(%r14), %rdi
movb $0x2c, (%r14)
movl %r13d, %esi
callq 0x38c5
movl %eax, %eax
addq %rax, %r14
incq %r14
jmp 0x2453
movq 0x6b2d(%rip), %rax      # 0x8fe0
movq (%rax), %rdi
leaq 0x3b47(%rip), %rsi      # 0x6004
movl %r13d, %edx
xorl %eax, %eax
callq 0x2250
movb $0x0, (%r14)
subq (%rsp), %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/EnderGed[P]fast-random-walk/Graph.cpp
// Function: Graph::toString[abi:cxx11]() const
std::string Graph::toString() const
{
	unsigned const maxDigits = hasDigits(getNumNodes() - 1);

	char asString[maxDigits];

	std::string res;
	res.reserve((maxDigits * 2 + 5) * getNumTransitions());

	for(uint node = 0; node < numNodes; ++node)
	{
		uint const numTrans = getNumTransitions(node);

		for(uint trans = 0; trans < numTrans; ++trans)
		{
			// Add source node
			unsigned len = writeInt(asString, node);
			res.append(asString, len);
			// Add " ->"
			res.append(" -> ", 4);
			// Add destination node
			len = writeInt(asString, getNode(node, trans));
			res.append(asString, len);
			res.append(1, '\n');
		}
	}

	return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %edi
decl %edi
callq 0x2c68
movl %eax, %ecx
movq %rsp, %r15
addq $0xf, %rcx
andq $-0x10, %rcx
subq %rcx, %r15
movq %r15, %rsp
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
leal 0x5(,%rax,2), %esi
movq 0x10(%r14), %rax
movl 0x8(%r14), %ecx
imulq (%rax,%rcx,8), %rsi
movq %rbx, %rdi
callq 0x2290
xorl %r12d, %r12d
movl 0x8(%r14), %eax
cmpq %rax, %r12
jae 0x261a
movq 0x10(%r14), %rax
leaq 0x1(%r12), %rcx
movq %rcx, -0x30(%rbp)
movl 0x8(%rax,%r12,8), %ecx
subl (%rax,%r12,8), %ecx
movq %rcx, -0x38(%rbp)
xorl %r13d, %r13d
cmpq %r13, -0x38(%rbp)
je 0x2611
movq %r15, %rdi
movl %r12d, %esi
callq 0x38c5
movl %eax, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2050
movq %rbx, %rdi
leaq 0x3a5c(%rip), %rsi      # 0x6029
pushq $0x4
popq %rdx
callq 0x2050
movq 0x10(%r14), %rax
movq (%rax,%r12,8), %rax
shlq $0x2, %rax
addq 0x18(%r14), %rax
movl (%rax,%r13,4), %esi
movq %r15, %rdi
callq 0x38c5
movl %eax, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2050
movq %rbx, %rdi
pushq $0x1
popq %rsi
pushq $0xa
popq %rdx
callq 0x21a0
incq %r13
jmp 0x25a5
movq -0x30(%rbp), %r12
jmp 0x257b
movq %rbx, %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x262e
movq %rax, %r14
movq %rbx, %rdi
callq 0x20b0
movq %r14, %rdi
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/EnderGed[P]fast-random-walk/Graph.cpp
// Function: Graph::readInt(char const*, char const*, unsigned int&)
uint Graph::readInt(char const * const start, char const * const end, unsigned & readLen)
{
	char const * pos = start;
	read_t result = 0;

	// Skip space characters
	while(pos < end && *pos > 0 && *pos <= ' ') ++pos;

	// Ensure that the first non-space character is a digit
	if(pos >= end || *pos < '0' || *pos > '9') {fprintf(stderr, "Not a number: %c\n", *pos); exit(1);}

	// Read digit by digit until a non-digit occurs
	for(; pos < end; ++pos)
	{
		char const c = *pos;
		if(c < '0' || c > '9') break;

		result *= 10;
		result += c - '0';

		if(result > ((uint)-1)) printError("Specified integer type is too small to hold this number.");
	}

	readLen = pos - start;

	// Return the number
	return (uint) result;
}

// Assembly:
pushq %rax
xorl %ecx, %ecx
leaq (%rdi,%rcx), %r8
movsbl (%rdi,%rcx), %eax
cmpq %rsi, %r8
jae 0x26c0
leal -0x1(%rax), %r8d
cmpb $0x1f, %r8b
ja 0x267d
incq %rcx
jmp 0x2661
leal -0x3a(%rax), %r8d
cmpb $-0xa, %r8b
jb 0x26c0
xorl %eax, %eax
leaq (%rdi,%rcx), %r8
cmpq %rsi, %r8
jae 0x26bc
movzbl (%r8), %r8d
leal -0x3a(%r8), %r9d
cmpb $-0xa, %r9b
jb 0x26bc
imulq $0xa, %rax, %r9
andl $0xf, %r8d
movq %r8, %rax
addq %r9, %rax
movq %rax, %r8
shrq $0x20, %r8
jne 0x26e2
incq %rcx
jmp 0x2689
movl %ecx, (%rdx)
popq %rcx
retq
movq 0x6919(%rip), %rcx      # 0x8fe0
movq (%rcx), %rdi
leaq 0x395d(%rip), %rsi      # 0x602e
movl %eax, %edx
xorl %eax, %eax
callq 0x2250
pushq $0x1
popq %rdi
callq 0x2200
leaq 0x3957(%rip), %rdi      # 0x6040
callq 0x3715
// File: /workspace/github_cpp_makefile_star2_O2/EnderGed[P]fast-random-walk/./FastPRNG.hpp
// Function: unsigned int FastPRNG::uniformInRange<unsigned int>(unsigned int)
T FastPRNG::uniformInRange(T max)
{
	// If PRNG 2 was used 256 times ...
	if(++prngResetCounter > 0xffff)
	{
		prngResetCounter = 0;

		// Re-Seed PRNG 2 with output of PRNG 1
		g2.seed(g1());
	}

	return std::uniform_int_distribution<T>(0, max)(g2);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl 0x1390(%rdi), %eax
incl %eax
movl %eax, 0x1390(%rdi)
cmpl $0x10000, %eax          # imm = 0x10000
jb 0x2c49
andl $0x0, 0x1390(%rbx)
movq %rbx, %rdi
callq 0x2dd6
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
xorl %edx, %edx
divq %rcx
cmpq $0x1, %rdx
adcq $0x0, %rdx
movq %rdx, 0x1388(%rbx)
movq %rsp, %rdi
andl $0x0, (%rdi)
movl %ebp, 0x4(%rdi)
addq $0x1388, %rbx           # imm = 0x1388
movq %rbx, %rsi
callq 0x2e3a
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/EnderGed[P]fast-random-walk/HelperFunctions.cpp
// Function: readFile[abi:cxx11](char const*)
std::string readFile(char const * const fileName)
{
	// Open file
	FILE * const file = fopen(fileName, "r");
	if(!file) printError("File could not be opened for reading");

	// Determine file size
	fseek(file, 0L, SEEK_END);
	size_t const fileSize = ftell(file);
	fseek(file, 0L, SEEK_SET);

	// Create buffer array
	char * const result = (char *) malloc(fileSize * sizeof(*result) + 1);

	// Read whole file
	size_t const read = fread(result, 1, fileSize, file);
	result[read] = '\n';

	// Error if file size and number of bytes read are different
	if(fileSize != read)
	{
		fprintf(stderr, "File size: %lu, but read: %lu\n", (unsigned long) fileSize, (unsigned long) read);
		exit(1);
	}

	// Close file
	fclose(file);

	std::string const res = std::string(result, fileSize);
	
	free(result);
	
	return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x29f2(%rip), %rsi      # 0x6140
movq %rax, %rdi
callq 0x21e0
testq %rax, %rax
je 0x37e4
movq %rax, %r15
pushq $0x2
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x21b0
movq %r15, %rdi
callq 0x2030
movq %rax, %r14
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x21b0
leaq 0x1(%r14), %rdi
callq 0x2210
movq %rax, %r12
pushq $0x1
popq %rsi
movq %rax, %rdi
movq %r14, %rdx
movq %r15, %rcx
callq 0x2270
movb $0xa, (%r12,%rax)
cmpq %rax, %r14
jne 0x37f0
movq %r15, %rdi
callq 0x2180
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
addq %r12, %r14
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x3d88
movq %r12, %rdi
callq 0x21f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x28b1(%rip), %rdi      # 0x609c
callq 0x3715
movq 0x57e9(%rip), %rcx      # 0x8fe0
movq (%rcx), %rdi
leaq 0x28c0(%rip), %rsi      # 0x60c1
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x2250
pushq $0x1
popq %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O2/EnderGed[P]fast-random-walk/HelperFunctions.cpp
// Function: writeFile(char const*, char const*)
void writeFile(char const * const fileName, char const * const content)
{
	size_t const len = strlen(content);

	// Open file
	FILE * const file = fopen(fileName, "w");
	if(!file) printError("File could not be opened for writing");

	// Write to file
	size_t const w = fwrite(content, sizeof(*content), len, file);
	if(w < len) printError("Could not write full file content");

	// Close file
	fclose(file);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x20a0
movq %rax, %rbx
leaq 0x28ad(%rip), %rsi      # 0x60e0
movq %r15, %rdi
callq 0x21e0
testq %rax, %rax
je 0x3866
movq %rax, %r15
pushq $0x1
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x22e0
cmpq %rbx, %rax
jb 0x3872
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2180
leaq 0x2875(%rip), %rdi      # 0x60e2
callq 0x3715
leaq 0x288e(%rip), %rdi      # 0x6107
callq 0x3715
// File: /workspace/github_cpp_makefile_star2_O2/EnderGed[P]fast-random-walk/HelperFunctions.cpp
// Function: toInt(char const*)
uint32_t toInt(char const * str)
{
	register uint64_t res = 0;

	// For every character in str ...
	for(; *str != '\0'; ++str)
	{
		// Check if character is a number
		if(*str < '0' || *str > '9') printError("Argument is not a number");

		// Adapt result according to character
		res *= 10;
		res += *str - '0';

		// Check for integer overflow
		if(res > 0xffffffff) printError("Number in argument is too large");
	}

	return (uint32_t) res;
}

// Assembly:
pushq %rax
xorl %eax, %eax
movb (%rdi), %cl
testb %cl, %cl
je 0x38b7
leal -0x3a(%rcx), %edx
cmpb $-0xb, %dl
jbe 0x38b9
imulq $0xa, %rax, %rdx
addb $-0x30, %cl
movzbl %cl, %eax
addq %rdx, %rax
movq %rax, %rcx
shrq $0x20, %rcx
incq %rdi
testq %rcx, %rcx
je 0x3881
leaq 0x2890(%rip), %rdi      # 0x6142
callq 0x3715
popq %rcx
retq
leaq 0x2869(%rip), %rdi      # 0x6129
callq 0x3715
// File: /workspace/github_cpp_makefile_star2_O2/EnderGed[P]fast-random-walk/HelperFunctions.cpp
// Function: writeInt(char*, unsigned int)
unsigned writeInt(char * const target, uint number)
{
	register char * pos = target;

	// For every decimal digit of number (at least once)
	do
	{
		// Add digicimal digit to output
		*pos++ = ((char)(number % 10)) + '0';
		// Remove decimal digit from number
		number /= 10;
	}while(number);

	// Reverse output
	std::reverse(target, pos);

	// Return number of written characters
	return pos - target;
}

// Assembly:
pushq %rbx
xorl %ebx, %ebx
pushq $0xa
popq %rcx
movl %esi, %eax
xorl %edx, %edx
divl %ecx
orb $0x30, %dl
movb %dl, (%rdi,%rbx)
incq %rbx
cmpl $0x9, %esi
movl %eax, %esi
ja 0x38cb
leaq (%rdi,%rbx), %rsi
callq 0x3e1d
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/EnderGed[P]fast-random-walk/HelperFunctions.cpp
// Function: countSort2D(unsigned int*, unsigned long, unsigned long, unsigned long)
void countSort2D(uint * const arr, size_t const size_x, size_t const size_y, size_t column)
{
	// Prepare break condition
	uint * const arrEnd = arr + size_x * size_y;

	// Determine maximum index
	uint maxIndex = 0;
	for(uint * pos = arr + column; pos < arrEnd; pos += size_x)
		if(*pos > maxIndex) maxIndex = *pos;

	// Allocate adjacency list
	read_t * const adj = (read_t*)calloc((maxIndex + 2), sizeof(*adj));
	read_t * const counts = adj + 1;

	if(!adj) printError("Memory allocation failed");

	// Count occurences of each index
	for(uint * pos = arr + column; pos < arrEnd; pos += size_x) ++(counts[*pos]);

	// Convert occurency counts to real adjacency list
	read_t * const adj_end = adj + maxIndex + 1;
	adj[0] = 0;
	for(read_t * pos_adj = adj; pos_adj < adj_end; ++pos_adj) pos_adj[1] += pos_adj[0];

	// Copy arr
	uint * arrCpy = (uint*)malloc(size_x * size_y * sizeof(*arrCpy));
	if(!arrCpy) printError("Memory allocation failed");
	memcpy(arrCpy, arr, size_x * size_y * sizeof(*arrCpy));
	uint const * const arrCpyEnd = arrCpy + size_x * size_y;

	// Move rows back to arr but to the correct position
	for(uint const * cpyPos = arrCpy; cpyPos < arrCpyEnd; cpyPos += size_x)
	{
		for(size_t i = 0; i < size_x; ++i) arr[adj[cpyPos[column]] * size_x + i] = cpyPos[i];
		++adj[cpyPos[column]];
	}

	// Clean up
	free(arrCpy);
	free(adj);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
imulq %rsi, %rdx
leaq (%rdi,%rdx,4), %rdi
leaq (%r15,%rcx,4), %r13
leaq (,%rsi,4), %rbp
xorl %esi, %esi
movq %r13, %rax
cmpq %rdi, %rax
jae 0x392f
movl (%rax), %ecx
cmpl %esi, %ecx
cmoval %ecx, %esi
addq %rbp, %rax
jmp 0x391e
movq %rdi, 0x8(%rsp)
movq %rdx, (%rsp)
movq %rsi, 0x10(%rsp)
leal 0x2(%rsi), %edi
pushq $0x8
popq %rsi
callq 0x2100
testq %rax, %rax
je 0x3a25
movq %rax, %r12
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rdx
cmpq %rdx, %r13
jae 0x3971
movl (%r13), %eax
incq 0x8(%r12,%rax,8)
addq %rbp, %r13
jmp 0x395e
andq $0x0, (%r12)
movl %ecx, %eax
leaq (%r12,%rax,8), %rax
addq $0x8, %rax
xorl %ecx, %ecx
movq %r12, %rdx
cmpq %rax, %rdx
jae 0x3998
addq 0x8(%rdx), %rcx
movq %rcx, 0x8(%rdx)
addq $0x8, %rdx
jmp 0x3985
movq (%rsp), %rax
leaq (,%rax,4), %r13
movq %r13, %rdi
callq 0x2210
testq %rax, %rax
je 0x3a25
movq %rax, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %rax, %r13
callq 0x2150
movq %r13, %rdi
movq (%rsp), %rax
leaq (,%rax,4), %rax
addq %r13, %rax
movq %r13, %rcx
cmpq %rax, %rcx
jae 0x3a0a
xorl %edx, %edx
cmpq %rdx, %r14
je 0x39fe
movl (%rcx,%rdx,4), %esi
movl (%rcx,%rbx,4), %r8d
movq (%r12,%r8,8), %r8
imulq %rbp, %r8
addq %r15, %r8
movl %esi, (%r8,%rdx,4)
incq %rdx
jmp 0x39de
movl (%rcx,%rbx,4), %edx
incq (%r12,%rdx,8)
addq %rbp, %rcx
jmp 0x39d7
callq 0x21f0
movq %r12, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21f0
leaq 0x2736(%rip), %rdi      # 0x6162
callq 0x3715
// File: /workspace/github_cpp_makefile_star2_O2/EnderGed[P]fast-random-walk/HelperFunctions.cpp
// Function: prepareAdjList(unsigned int const*, unsigned long, unsigned int)
read_t * prepareAdjList(uint const * const list, size_t const size, uint maxVal)
{
	// Allocate adjacency list
	read_t * const adj = (read_t*) calloc((maxVal + 2), sizeof(*adj));
	if(!adj) printError("Memory allocation failed");
	read_t * const counts = adj + 1;

	// Count occurences of each index
	for(register uint const * pos = list; pos < (list + size); ++pos) ++(counts[*pos]);

	// Convert occurency counts to real adjacency list
	read_t * const adjEnd = adj + maxVal + 1;
	adj[0] = 0;
	for(register read_t * adjPos = adj; adjPos < adjEnd; ++adjPos) adjPos[1] += adjPos[0];

	// Return adjacency list
	return adj;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
leal 0x2(%rbx), %edi
pushq $0x8
popq %rsi
callq 0x2100
testq %rax, %rax
je 0x3aa6
leaq (%r14,%r15,4), %rcx
cmpq %rcx, %r14
jae 0x3a7e
movl (%r14), %edx
incq 0x8(%rax,%rdx,8)
addq $0x4, %r14
jmp 0x3a6b
movl %ebx, %ecx
leaq (%rax,%rcx,8), %rcx
addq $0x8, %rcx
xorl %edx, %edx
movq %rax, %rsi
cmpq %rcx, %rsi
jae 0x3aa0
addq 0x8(%rsi), %rdx
movq %rdx, 0x8(%rsi)
addq $0x8, %rsi
jmp 0x3a8d
popq %rbx
popq %r14
popq %r15
retq
leaq 0x26b5(%rip), %rdi      # 0x6162
callq 0x3715
// File: /workspace/github_cpp_makefile_star2_O2/EnderGed[P]fast-random-walk/HelperFunctions.cpp
// Function: countSort(unsigned int*, unsigned long)
void countSort(uint * const list, size_t const size)
{
	// Determine maximum list value
	uint const maxVal = maxValue(list, size);

	// Allocate counter list
	read_t * const counts = (read_t*) calloc((maxVal + 1), sizeof(*counts));
	if(!counts) printError("Memory allocation failed");

	// Count occurences of each index
	for(uint const * pos = list; pos < (list + size); ++pos) ++(counts[*pos]);

	// Write counted elements back to list
	register uint val = 0;
	for(register read_t pos = 0; pos < size; ++pos)
	{
		// Go to next count greater zero
		while(!counts[val]) ++val;
		
		// Add value to list
		list[pos] = val;
		--counts[val];
	}
	
	free(counts);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x3a31
leal 0x1(%rax), %edi
pushq $0x8
popq %rsi
callq 0x2100
testq %rax, %rax
je 0x3b20
leaq (%r14,%rbx,4), %rcx
movq %r14, %rdx
cmpq %rcx, %rdx
jae 0x3ae9
movl (%rdx), %esi
incq (%rax,%rsi,8)
addq $0x4, %rdx
jmp 0x3ad8
xorl %ecx, %ecx
xorl %edx, %edx
cmpq %rbx, %rdx
je 0x3b11
movl %ecx, %esi
movq (%rax,%rsi,8), %rdi
incl %ecx
testq %rdi, %rdi
je 0x3af2
decl %ecx
movl %ecx, (%r14,%rdx,4)
decq %rdi
movq %rdi, (%rax,%rsi,8)
incq %rdx
jmp 0x3aed
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21f0
leaq 0x263b(%rip), %rdi      # 0x6162
callq 0x3715
// File: /workspace/github_cpp_makefile_star2_O2/EnderGed[P]fast-random-walk/HelperFunctions.cpp
// Function: boolSort(unsigned int*, unsigned long)
void boolSort(uint * const list, size_t const size)
{
	// Determine maximum list value
	uint const maxVal = maxValue(list, size);

	std::vector<bool> bitSet(maxVal + 1, false);

	// Set the corresponding bit in bitSet for every value in the list
	for(uint const * pos = list; pos < list + size; ++pos)
	{
		// If bit is already set ...
		if(bitSet[*pos])
		{
			// Print warning and call countSort as fallback
			printf("Value occures multiple times. Fallback tack countSort.\n");
			countSort(list, size);
			return;
		}
		else bitSet[*pos] = true;
	}

	// Write the found values back to the list
	register uint val = 0;
	for(register uint * pos = list; pos < list + size; ++pos)
	{
		while(!bitSet[val]) ++val;
		*pos = val++;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3a31
leal 0x1(%rax), %esi
leaq 0x7(%rsp), %rdx
movb $0x0, (%rdx)
leaq 0x8(%rsp), %r15
leaq 0x6(%rsp), %rcx
movq %r15, %rdi
callq 0x2c82
leaq (%rbx,%r14,4), %r12
movq %rbx, %r13
cmpq %r12, %r13
jae 0x3b93
movl (%r13), %esi
movq %r15, %rdi
callq 0x2d0c
testq %rdx, (%rax)
jne 0x3bbf
movl (%r13), %esi
movq %r15, %rdi
callq 0x2d0c
orq %rdx, (%rax)
addq $0x4, %r13
jmp 0x3b68
xorl %r15d, %r15d
leaq 0x8(%rsp), %r14
cmpq %r12, %rbx
jae 0x3bd6
movl %r15d, %esi
movq %r14, %rdi
callq 0x2d0c
incl %r15d
testq %rdx, (%rax)
je 0x3ba0
leal -0x1(%r15), %eax
movl %eax, (%rbx)
addq $0x4, %rbx
jmp 0x3b9b
leaq 0x25e8(%rip), %rdi      # 0x61ae
callq 0x2280
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3ab2
leaq 0x8(%rsp), %rdi
callq 0x2d86
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x3bf2
jmp 0x3bf2
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2d86
movq %rbx, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O2/EnderGed[P]fast-random-walk/HelperFunctions.cpp
// Function: countSort2D(std::vector<unsigned int*, std::allocator<unsigned int*>>, unsigned long)
void countSort2D(std::vector<uint *> const lists, size_t const rows)
{
	// Determine maximum index
	uint const maxIndex = maxValue(lists[0], rows);

	// Allocate adjacency list
	read_t * const adj = prepareAdjList(lists[0], rows, maxIndex);

	uint * const arrCpy = (uint*)malloc(rows * sizeof(*arrCpy));
	if(!arrCpy) printError("Memory allocation failed");

	// Sort all lists (except the first one) with respect to values in first list
	for(size_t i = 1; i < lists.size(); ++i)
	{
		// Copy arr
		memcpy(arrCpy, lists[i], rows * sizeof(*arrCpy));

		// Move rows back to arr but to the correct position
		for(register size_t pos = 0; pos < rows; ++pos)
		{
			uint const targetRow = adj[lists[0][pos]];
			lists[i][targetRow] = arrCpy[pos];
			++adj[lists[0][pos]];
		}

		memmove(adj + 1, adj, (maxIndex + 1) * sizeof(*adj));
		adj[0] = 0;
	}

	// Sort the first list
	memcpy(arrCpy, lists[0], rows * sizeof(*arrCpy));

	for(register size_t pos = 0; pos < rows; ++pos)
	{
		uint const targetRow = adj[arrCpy[pos]];
		lists[0][targetRow] = arrCpy[pos];
		++adj[arrCpy[pos]];
	}

	// Clean up
	free(arrCpy);
	free(adj);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, 0x20(%rsp)
movq (%rdi), %rax
movq (%rax), %r14
movq %r14, %rdi
callq 0x3a31
movl %eax, %r13d
movq %r14, %rdi
movq %rbx, %rsi
movl %eax, %edx
callq 0x3a4a
movq %rax, %r14
leaq (,%rbx,4), %rdi
movq %rdi, 0x8(%rsp)
callq 0x2210
testq %rax, %rax
je 0x3d7b
movq %rax, %r15
movq %r14, %rax
addq $0x8, %rax
movq %rax, 0x10(%rsp)
incl %r13d
shlq $0x3, %r13
pushq $0x1
popq %rbp
movq %r13, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %r12
movq 0x8(%rax), %rax
subq %r12, %rax
sarq $0x3, %rax
cmpq %rax, %rbp
jae 0x3d28
movq (%r12,%rbp,8), %r13
movq %r15, %rdi
movq %r13, %rsi
movq 0x8(%rsp), %rdx
callq 0x2150
xorl %eax, %eax
cmpq %rax, %rbx
je 0x3d0d
movq (%r12), %rcx
movl (%rcx,%rax,4), %edx
movl (%r14,%rdx,8), %edx
movl (%r15,%rax,4), %esi
movl %esi, (%r13,%rdx,4)
movl (%rcx,%rax,4), %ecx
incq (%r14,%rcx,8)
incq %rax
jmp 0x3ce8
movq 0x10(%rsp), %rdi
movq %r14, %rsi
movq 0x18(%rsp), %rdx
callq 0x22a0
andq $0x0, (%r14)
incq %rbp
jmp 0x3cba
movq (%r12), %r12
movq %r15, %rdi
movq %r12, %rsi
movq 0x8(%rsp), %rdx
callq 0x2150
xorl %eax, %eax
cmpq %rax, %rbx
je 0x3d5d
movl (%r15,%rax,4), %ecx
movq (%r14,%rcx,8), %rdx
movl %edx, %esi
movl %ecx, (%r12,%rsi,4)
incq %rdx
movq %rdx, (%r14,%rcx,8)
incq %rax
jmp 0x3d3e
movq %r15, %rdi
callq 0x21f0
movq %r14, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21f0
leaq 0x23e0(%rip), %rdi      # 0x6162
callq 0x3715
nop
// File: /workspace/github_cpp_makefile_star2_O2/EnderGed[P]fast-random-walk/WeightedGraph.cpp
// Function: WeightedGraph::WeightedGraph(WeightedGraph&&)
WeightedGraph::WeightedGraph(WeightedGraph && other) : Graph(other.numNodes, other.nodes, other.transitions), weights(other.weights)
{
	other.numNodes = 0;
	other.nodes = 0;
	other.transitions = 0;
	other.weights = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rsi), %esi
movq 0x10(%rbx), %rdx
movq 0x18(%rbx), %rcx
callq 0x23ec
leaq 0x4f01(%rip), %rax      # 0x8d80
movq %rax, (%r14)
movq 0x20(%rbx), %rax
movq %rax, 0x20(%r14)
andl $0x0, 0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
andq $0x0, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/EnderGed[P]fast-random-walk/WeightedGraph.cpp
// Function: WeightedGraph::doWalk(unsigned int, unsigned int, FastPRNG&, char*) const
size_t WeightedGraph::doWalk(uint node, uint32_t walk_len, FastPRNG & prng, char * const out) const
{
	// Write start node to output string
	char * outPos = out;

	{
		unsigned const wrote = writeInt(outPos, node);
		outPos += wrote;
	}

	while(--walk_len)
	{
		// Determine the number of outgoing transitions (from the current node)
		uint const outgoingTransitions = getNumTransitions(node);
		if(!outgoingTransitions)
		{
			fprintf(stderr, "Node %d has no outgoing transitions\n", node);
			break;
		}

		// Choose a successor node
		uint const accWeight = weights[nodes[node + 1] - 1];
		node = getNodeByWeight(node, prng.uniformInRange<uint>(accWeight - 1));

		// Write node number to output
		{
			*(outPos++) = ',';
			unsigned const wrote = writeInt(outPos, node);
			outPos += wrote;
		}
	}

	*outPos = '\0';

	return outPos - out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r15
movl %edx, %r12d
movl %esi, %ebp
movq %rdi, %r13
movq %r8, %rdi
callq 0x38c5
movl %eax, %r14d
addq %rbx, %r14
decl %r12d
subl $0x1, %r12d
jb 0x3f3b
cmpl %ebp, 0x8(%r13)
jbe 0x3f21
movq 0x10(%r13), %rcx
movl %ebp, %edx
movq 0x8(%rcx,%rdx,8), %rax
cmpl (%rcx,%rdx,8), %eax
je 0x3f21
movq 0x20(%r13), %rcx
movl -0x4(%rcx,%rax,4), %esi
decl %esi
movq %r15, %rdi
callq 0x2c04
movq %r13, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x48f6
movl %eax, %ebp
leaq 0x1(%r14), %rdi
movb $0x2c, (%r14)
movl %eax, %esi
callq 0x38c5
movl %eax, %eax
addq %rax, %r14
incq %r14
jmp 0x3ecc
movq 0x50b8(%rip), %rax      # 0x8fe0
movq (%rax), %rdi
leaq 0x20d2(%rip), %rsi      # 0x6004
movl %ebp, %edx
xorl %eax, %eax
callq 0x2250
movb $0x0, (%r14)
subq %rbx, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/EnderGed[P]fast-random-walk/./HelperFunctions.hpp
// Function: unsigned int const* binaryFind<unsigned int const, unsigned int>(unsigned int const*, unsigned int const*, unsigned int)
inline ITER * binaryFind(ITER * const first, ITER * const last, T const val) noexcept
{
	size_t const off = (last - first) >> 1;
	ITER * const mid = last - off;

	if(off < 8) return std::lower_bound(first, last, val);

	return (*mid > val) ? binaryFind(first, mid, val) : binaryFind(mid, last, val);
}

// Assembly:
pushq %rax
movl %edx, 0x4(%rsp)
movq %rsi, %rax
subq %rdi, %rax
sarq $0x3, %rax
cmpq $0x7, %rax
jbe 0x497b
shlq $0x2, %rax
movq %rsi, %rcx
subq %rax, %rcx
negq %rax
cmpl %edx, (%rsi,%rax)
ja 0x4976
movq %rcx, %rdi
jmp 0x494b
movq %rcx, %rsi
jmp 0x494b
leaq 0x4(%rsp), %rdx
callq 0x4a81
popq %rcx
retq
movq %rax, %rdi
callq 0x2dca
nop
// File: /workspace/github_cpp_makefile_star2_O2/EnderGed[P]fast-random-walk/walk.cpp
// Function: readParam(int, char const* const*, char const*)
char const * readParam(int argc, char const * const * const argv, char const * argName)
{
	size_t const argLen = strlen(argName);

	//    --argName <value>
	// or --argName=<value>
	if(!strcmp(argv[0] + 2, argName))
	{
		if(argc > 1) return argv[1];
		else
		{
			printf("Missing argument for option %s\n\n", argName);
			printHelp();
			exit(1);
		}
	}
	else if(!strncmp(argv[0] + 2, argName, argLen) && argv[0][argLen + 2] == '=') return argv[0] + argLen + 3;

	// If argument not found ... return NULL
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movl %edi, %ebp
movq %rdx, %rdi
callq 0x20a0
movq %rax, %r14
movq (%r15), %r13
leaq 0x2(%r13), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x2240
testl %eax, %eax
je 0x4f60
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x20c0
testl %eax, %eax
je 0x4f6b
xorl %eax, %eax
jmp 0x4f7c
cmpl $0x2, %ebp
jl 0x4f8b
movq 0x8(%r15), %rax
jmp 0x4f7c
xorl %eax, %eax
cmpb $0x3d, 0x2(%r13,%r14)
leaq 0x3(%r13,%r14), %rcx
cmoveq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x13e3(%rip), %rdi      # 0x6375
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2040
callq 0x4fa9
pushq $0x1
popq %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O2/EnderGed[P]fast-random-walk/walk.cpp
// Function: printHelp()
void printHelp()
{
	printf("Usage:\n");
	printf("walk [options]\n\n");
	printf("Options (mandatory):\n");
	printf("--if <input file>\n");
	printf("--of <output file>\n");
	printf("--length <walk length>\n");
	printf("--walks <number of walks>\n");
	printf("\n");
	printf("Options (optional):\n");
	printf("-o, --optiTransOrder: Optimize order of transitions\n");
	printf("-p, --print: Print graph\n");
	printf("-r, --reflect: Reflects all transitions (even if counterpart exists)\n");
	printf("-u, --undirected: Converts the graph to an undirected graph\n");
	printf("-w, --weighted: Runs walks on weighted graph\n");
}

// Assembly:
pushq %rax
leaq 0x13e5(%rip), %rdi      # 0x6396
callq 0x2280
leaq 0x13e0(%rip), %rdi      # 0x639d
callq 0x2280
leaq 0x13e4(%rip), %rdi      # 0x63ad
callq 0x2280
leaq 0x13ed(%rip), %rdi      # 0x63c2
callq 0x2280
leaq 0x13f3(%rip), %rdi      # 0x63d4
callq 0x2280
leaq 0x13fa(%rip), %rdi      # 0x63e7
callq 0x2280
leaq 0x1405(%rip), %rdi      # 0x63fe
callq 0x2280
pushq $0xa
popq %rdi
callq 0x2230
leaq 0x140b(%rip), %rdi      # 0x6418
callq 0x2280
leaq 0x1413(%rip), %rdi      # 0x642c
callq 0x2280
leaq 0x143b(%rip), %rdi      # 0x6460
callq 0x2280
leaq 0x1448(%rip), %rdi      # 0x6479
callq 0x2280
leaq 0x1481(%rip), %rdi      # 0x64be
callq 0x2280
leaq 0x14b1(%rip), %rdi      # 0x64fa
popq %rax
jmp 0x2280
// File: /workspace/github_cpp_makefile_star2_O2/EnderGed[P]fast-random-walk/walk.cpp
// Function: doWalk(Graph const&, unsigned int, unsigned int, unsigned int, unsigned int, Out&)
void doWalk(Graph const & graph, uint from, uint const to, uint32_t const walk_len, uint32_t const numWalks, Out &out)
{
	FastPRNG prng;

	// Malloc array for output string
	unsigned const maxDigits = hasDigits(graph.getNumNodes() - 1);
	char * const walk = (char *) malloc((maxDigits + 1) * sizeof(*walk) * walk_len);

	for(uint startNode = from; startNode < to; ++startNode) // For every assigned start node
	{
		// Ensure that the node really exists (has outgoing transitions)
		if(graph.getNumTransitions(startNode) == 0) continue;

		for(uint32_t i = 0; i < numWalks; ++i)
		{
			size_t out_len = graph.doWalk(startNode, walk_len, prng, walk);

			walk[out_len++] = '\n';

			// Write output string to file
			out.write(walk, out_len);
		}
	}

	free(walk);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x13b8, %rsp           # imm = 0x13B8
movq %r9, %rbx
movl %r8d, 0xc(%rsp)
movl %ecx, %r14d
movl %edx, %r12d
movl %esi, %ebp
movq %rdi, %r15
xorl %edi, %edi
callq 0x2160
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x5194
movl 0x8(%r15), %edi
decl %edi
callq 0x2c68
incl %eax
movl %r14d, %edi
imulq %rax, %rdi
callq 0x2210
movq %rax, %r13
movl %ebp, %esi
movl %r12d, %edx
movq %rdx, 0x10(%rsp)
cmpq %rdx, %rsi
jae 0x513f
movq %rsi, %rbp
movl 0x8(%r15), %eax
cmpq %rax, %rsi
jae 0x512b
movq 0x10(%r15), %rax
leaq 0x1(%rbp), %rsi
movl 0x8(%rax,%rbp,8), %ecx
cmpl (%rax,%rbp,8), %ecx
je 0x50cc
movq %rsi, 0x18(%rsp)
movl 0xc(%rsp), %r12d
subl $0x1, %r12d
jb 0x5133
movq (%r15), %rax
movq %r15, %rdi
movl %ebp, %esi
movl %r14d, %edx
leaq 0x20(%rsp), %rcx
movq %r13, %r8
callq *0x10(%rax)
movb $0xa, (%r13,%rax)
leaq 0x1(%rax), %rdx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x51c8
jmp 0x50f8
incq %rbp
movq %rbp, %rsi
jmp 0x50cc
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rsi
jmp 0x50cc
movq %r13, %rdi
callq 0x21f0
addq $0x13b8, %rsp           # imm = 0x13B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/amit-mittal[P]FTP/ftpClient.cpp
// Function: ftpClient::transferFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int ftpClient::transferFile(string filename){
	
	FILE* fp;
	char data[MAXBUFFSIZE];
	size_t bytes_read, bytes_sent;
	long fSize, remaining;

	fp = fopen(filename.c_str(), "r");

	if (fp == NULL) {
		fputs("File not found\n", stderr); 
		return 7;
	}

	// obtain file size:
  	fseek (fp, 0, SEEK_END);
	fSize = ftell(fp);
	rewind(fp);

	remaining = fSize;
	do {
		bytes_read = fread(data, 1, MAXBUFFSIZE-1, fp);
	
		if (bytes_read < 0) {
			fputs("Error in reading the file\n", stderr);
			return 8;
		}

		if ((bytes_sent = sendData(data, bytes_read)) < 0) {
			fputs("Error in send function\n", stderr);
			return 9;
		}
		
		if(remaining == bytes_sent)
			sendControl("EOF");

		else	sendControl("FSR");

		fseek(fp, bytes_sent-bytes_read, SEEK_CUR);	//As send() function may not send bytes_read amount of data
		remaining -= bytes_sent;		
		
	} while (remaining > 0);

	fclose(fp);
	cout << "\nSize of file transferred : " << calculateSize(fSize);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x458, %rsp            # imm = 0x458
movq %rdi, -0x38(%rbp)
movq (%rsi), %rdi
leaq 0x29a3(%rip), %rsi      # 0x5657
callq 0x2280
testq %rax, %rax
je 0x2dcd
movq %rax, %r14
pushq $0x2
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x2250
movq %r14, %rdi
callq 0x2030
movq %rax, %r12
movq %r14, %rdi
callq 0x2050
movq %r12, -0x40(%rbp)
movl $0x3ff, %edx            # imm = 0x3FF
leaq -0x480(%rbp), %r13
movq %r13, %rdi
pushq $0x1
popq %rsi
movq %r14, %rcx
callq 0x2330
movq %rax, %r15
movq -0x38(%rbp), %rdi
movq %r13, %rsi
movl %r15d, %edx
callq 0x2bd0
movslq %eax, %r13
subq %r13, %r12
jne 0x2d42
leaq -0x80(%rbp), %rbx
movq %rbx, %rdi
leaq 0x236c(%rip), %rsi      # 0x5097
leaq -0x29(%rbp), %rdx
callq 0x20f0
movq -0x38(%rbp), %rdi
movq %rbx, %rsi
callq 0x2be6
jmp 0x2d65
leaq -0x60(%rbp), %rbx
movq %rbx, %rdi
leaq 0x234b(%rip), %rsi      # 0x509b
leaq -0x29(%rbp), %rdx
callq 0x20f0
movq -0x38(%rbp), %rdi
movq %rbx, %rsi
callq 0x2be6
movq %rbx, %rdi
callq 0x2110
subq %r15, %r13
movq %r14, %rdi
movq %r13, %rsi
pushq $0x1
popq %rdx
callq 0x2250
testq %r12, %r12
jg 0x2ce9
movq %r14, %rdi
callq 0x2220
movq 0x5232(%rip), %rdi      # 0x7fc8
leaq 0x2302(%rip), %rsi      # 0x509f
callq 0x2210
movq %rax, %rbx
movq -0x40(%rbp), %rsi
callq 0x2e0c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2210
xorl %eax, %eax
addq $0x458, %rsp            # imm = 0x458
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x51fc(%rip), %rax      # 0x7fd0
movq (%rax), %rsi
leaq 0x22a9(%rip), %rdi      # 0x5087
callq 0x2260
pushq $0x7
popq %rax
jmp 0x2dbb
jmp 0x2dea
movq %rax, %rbx
jmp 0x2e04
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
jmp 0x2dff
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x2110
movq %rbx, %rdi
callq 0x23d0
// File: /workspace/github_cpp_makefile_star2_O2/amit-mittal[P]FTP/ftpClient.cpp
// Function: ftpClient::calculateSize(long)
char * ftpClient::calculateSize(long size)
{   
    char *result = (char *) malloc(sizeof(char) * 20);
    unsigned long  multiplier = exbibytes;
    int i;

    for (i = 0; i < DIM(sizes); i++, multiplier /= 1024)
    {   
        if (size < multiplier)
            continue;
        if (size % multiplier == 0)
            sprintf(result, "%lu %s", (unsigned long) size / multiplier, sizes[i]);
        else
            sprintf(result, "%.5f %s", (float) size / multiplier, sizes[i]);
        return result;
    }
    strcpy(result, "0");
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
pushq $0x14
popq %rdi
callq 0x22d0
movq %rax, %rbx
movl $0x40000000, %esi       # imm = 0x40000000
xorl %ecx, %ecx
cmpl $0x20, %ecx
je 0x2e3c
cmpq %r14, %rsi
jbe 0x2e43
shrq $0xa, %rsi
addq $0x8, %rcx
jmp 0x2e28
movw $0x30, (%rbx)
jmp 0x2ea3
leaq -0x1(%rsi), %rax
testq %r14, %rax
je 0x2e7c
cvtsi2ss %r14, %xmm0
cvtsi2ss %rsi, %xmm1
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x4f1b(%rip), %rax      # 0x7d80
movq (%rcx,%rax), %rdx
leaq 0x269f(%rip), %rsi      # 0x550f
movq %rbx, %rdi
movb $0x1, %al
callq 0x2070
jmp 0x2ea3
movq %r14, %rax
xorl %edx, %edx
divq %rsi
leaq 0x4ef5(%rip), %rdx      # 0x7d80
movq (%rcx,%rdx), %rcx
leaq 0x2672(%rip), %rsi      # 0x5508
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x2070
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/amit-mittal[P]FTP/ftpClient.cpp
// Function: ftpClient::receiveFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int ftpClient::receiveFile(string filename){

	char data[MAXBUFFSIZE];
	string msgControl;
	size_t bytes_recv;
	long filesize = 0;
	FILE* fp = fopen(filename.c_str(), "w");

	if (fp == NULL) {
		fputs("File not found\n", stderr); 
		return 6;	
	}
    
	while ((bytes_recv = recvData(data)) > 0) {
        	fwrite(data, 1, bytes_recv, fp);
		msgControl = recvControl(4);
		filesize += bytes_recv;	
		if(msgControl == "EOF")
			break;
	}

	if (bytes_recv < 0) {
        	perror("recv");
	}

	fclose(fp);
	cout << "\nSize of file received : " << calculateSize(filesize);

	return 0;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x448, %rsp            # imm = 0x448
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rdi, %r14
movb $0x0, (%rax)
movq (%rsi), %rdi
leaq 0x21df(%rip), %rsi      # 0x50bc
callq 0x2280
movq %rax, -0x30(%rbp)
testq %rax, %rax
je 0x2fad
xorl %ebx, %ebx
leaq -0x70(%rbp), %r13
leaq -0x50(%rbp), %r15
movq %r14, %rdi
leaq -0x470(%rbp), %rsi
callq 0x2c38
testl %eax, %eax
je 0x2f5c
movslq %eax, %r12
leaq -0x470(%rbp), %rdi
pushq $0x1
popq %rsi
movq %r12, %rdx
movq -0x30(%rbp), %rcx
callq 0x2430
movq %r13, %rdi
movq %r14, %rsi
pushq $0x4
popq %rdx
callq 0x2c76
movq %r15, %rdi
movq %r13, %rsi
callq 0x22b0
movq %r13, %rdi
callq 0x2110
addq %r12, %rbx
movq %r15, %rdi
leaq 0x2144(%rip), %rsi      # 0x5097
callq 0x46d5
testb %al, %al
je 0x2ef9
movq -0x30(%rbp), %rdi
callq 0x2220
movq 0x505c(%rip), %rdi      # 0x7fc8
leaq 0x214b(%rip), %rsi      # 0x50be
callq 0x2210
movq %rax, %r14
movq %rbx, %rsi
callq 0x2e0c
xorl %ebx, %ebx
movq %r14, %rdi
movq %rax, %rsi
callq 0x2210
leaq -0x50(%rbp), %rdi
callq 0x2110
movl %ebx, %eax
addq $0x448, %rsp            # imm = 0x448
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x501c(%rip), %rax      # 0x7fd0
movq (%rax), %rsi
leaq 0x20c9(%rip), %rdi      # 0x5087
callq 0x2260
pushq $0x6
popq %rbx
jmp 0x2f90
jmp 0x2fcc
jmp 0x2fcc
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x2110
movq %rbx, %rdi
callq 0x23d0
// File: /workspace/github_cpp_makefile_star2_O2/amit-mittal[P]FTP/ftpClient.cpp
// Function: ftpClient::getInput[abi:cxx11]()
string ftpClient::getInput(){//takes the input
	char input[MAX_CMD_LEN];
	string cmd;

	fgets(input, MAX_CMD_LEN-1, stdin);
	input[strlen(input)-1] = '\0';
	stringstream s;
	s << input;
	cmd = s.str();
	if(DEBUG)
		cout << "Command entered: " << cmd << endl;
	cmd = reduce(cmd);

	return cmd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x5f0, %rsp            # imm = 0x5F0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
xorl %r12d, %r12d
movb %r12b, 0x10(%rdi)
movq 0x4d4c(%rip), %rax      # 0x7fc0
movq (%rax), %rdx
leaq -0x610(%rbp), %r15
movq %r15, %rdi
movl $0x3ff, %esi            # imm = 0x3FF
callq 0x2370
movq %r15, %rdi
callq 0x2100
movb %r12b, -0x1(%rax,%r15)
leaq -0x210(%rbp), %rdi
callq 0x2160
leaq -0x200(%rbp), %rdi
leaq -0x610(%rbp), %rsi
callq 0x2210
leaq -0x1f8(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0x2380
leaq -0x88(%rbp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x22b0
movq %r15, %rdi
callq 0x2110
leaq 0x1f2d(%rip), %rsi      # 0x5218
leaq -0x68(%rbp), %rdi
leaq -0x22(%rbp), %rdx
callq 0x20f0
leaq 0x1e2f(%rip), %rsi      # 0x512e
leaq -0x48(%rbp), %rdi
leaq -0x21(%rbp), %rdx
callq 0x20f0
leaq -0x88(%rbp), %rdi
leaq -0x68(%rbp), %rcx
leaq -0x48(%rbp), %r8
movq %r14, %rsi
movq %rbx, %rdx
callq 0x33b6
leaq -0x88(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x22b0
movq %r14, %rdi
callq 0x2110
leaq -0x48(%rbp), %rdi
callq 0x2110
leaq -0x68(%rbp), %rdi
callq 0x2110
leaq -0x210(%rbp), %rdi
callq 0x2180
movq %rbx, %rax
addq $0x5f0, %rsp            # imm = 0x5F0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x2110
jmp 0x3382
movq %rax, %r14
leaq -0x68(%rbp), %rdi
callq 0x2110
jmp 0x3394
jmp 0x3391
jmp 0x3391
movq %rax, %r14
leaq -0x210(%rbp), %rdi
callq 0x2180
movq %rbx, %rdi
callq 0x2110
movq %r14, %rdi
callq 0x23d0
movq %rax, %r14
jmp 0x33a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/amit-mittal[P]FTP/ftpClient.cpp
// Function: ftpClient::reduce(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string ftpClient::reduce(const string& str,
                   const string& fill,
                   const string& whitespace) {
    // trim first
    auto result = trim(str, whitespace);

    // replace sub ranges
    auto beginSpace = result.find_first_of(whitespace);
    while (beginSpace != string::npos) {

        const auto endSpace = result.find_first_not_of(whitespace, beginSpace);
        const auto range = endSpace - beginSpace;

        result.replace(beginSpace, range, fill);

        const auto newStart = beginSpace + fill.length();
        beginSpace = result.find_first_of(whitespace, newStart);
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %rbx
movq %r8, %rcx
callq 0x3438
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x21f0
movq %rax, %r12
cmpq $-0x1, %rax
je 0x3419
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x21c0
subq %r12, %rax
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
movq %r15, %rcx
callq 0x20e0
addq 0x8(%r15), %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
jmp 0x33da
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2110
movq %r14, %rdi
callq 0x23d0