LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x90, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x3a10
movl %eax, %edi
decl %edi
callq 0x39f0
movq -0x78(%rbp), %rdi
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq %rsp, %rcx
movq %rcx, -0x20(%rbp)
movq %rax, %rdx
addq $0xf, %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x70(%rbp)
movq %rcx, %rsp
movq %rax, -0x28(%rbp)
movb $0x0, -0x29(%rbp)
callq 0x2250
movq -0x68(%rbp), %rdi
movl -0x14(%rbp), %ecx
movl %ecx, %eax
leal 0x5(%rax,%rax), %eax
movq %rax, -0x60(%rbp)
callq 0x3a20
movq %rax, -0x58(%rbp)
jmp 0x26c6
movq -0x78(%rbp), %rdi
movq -0x58(%rbp), %rax
movq -0x60(%rbp), %rsi
imulq %rax, %rsi
callq 0x22a0
jmp 0x26dd
movl $0x0, -0x40(%rbp)
movq -0x68(%rbp), %rcx
movl -0x40(%rbp), %eax
cmpl 0x8(%rcx), %eax
jae 0x2803
movq -0x68(%rbp), %rdi
movl -0x40(%rbp), %esi
callq 0x38d0
movl %eax, -0x84(%rbp)
jmp 0x2708
movl -0x84(%rbp), %eax
movl %eax, -0x44(%rbp)
movl $0x0, -0x48(%rbp)
movl -0x48(%rbp), %eax
cmpl -0x44(%rbp), %eax
jae 0x27f3
movq -0x70(%rbp), %rdi
movl -0x40(%rbp), %esi
callq 0x6680
movl %eax, -0x88(%rbp)
jmp 0x2738
movq -0x70(%rbp), %rsi
movq -0x78(%rbp), %rdi
movl -0x88(%rbp), %eax
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movl %eax, %edx
callq 0x2050
jmp 0x2755
movq -0x78(%rbp), %rdi
leaq 0x98cc(%rip), %rsi      # 0xc02c
movl $0x4, %edx
callq 0x2050
jmp 0x276c
movq -0x68(%rbp), %rdi
movl -0x40(%rbp), %esi
movl -0x48(%rbp), %edx
callq 0x3930
movl %eax, -0x8c(%rbp)
jmp 0x2783
movl -0x8c(%rbp), %esi
movq -0x70(%rbp), %rdi
callq 0x6680
movl %eax, -0x90(%rbp)
jmp 0x279a
movq -0x70(%rbp), %rsi
movq -0x78(%rbp), %rdi
movl -0x90(%rbp), %eax
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movl %eax, %edx
callq 0x2050
jmp 0x27b7
movq -0x78(%rbp), %rdi
movl $0x1, %esi
movl $0xa, %edx
callq 0x21c0
jmp 0x27cc
jmp 0x27ce
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x2718
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x2110
jmp 0x2826
jmp 0x27f5
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x26e4
movb $0x1, -0x29(%rbp)
testb $0x1, -0x29(%rbp)
jne 0x2816
movq -0x78(%rbp), %rdi
callq 0x2110
movq -0x80(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, %rsp
movq %rbp, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x22d0
nop
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x18(%rsp), %rcx
xorl %eax, %eax
cmpq 0x28(%rsp), %rcx
movb %al, 0xe(%rsp)
jae 0x290d
movq 0x18(%rsp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0xe(%rsp)
jle 0x290d
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
setle %al
movb %al, 0xe(%rsp)
movb 0xe(%rsp), %al
testb $0x1, %al
jne 0x2917
jmp 0x2927
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x28d6
movq 0x18(%rsp), %rax
cmpq 0x28(%rsp), %rax
jae 0x294d
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0x294d
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
jle 0x2977
movq 0xd68c(%rip), %rax      # 0xffe0
movq (%rax), %rdi
movq 0x18(%rsp), %rax
movsbl (%rax), %edx
leaq 0x96cb(%rip), %rsi      # 0xc031
movb $0x0, %al
callq 0x2270
movl $0x1, %edi
callq 0x2230
jmp 0x2979
movq 0x18(%rsp), %rax
cmpq 0x28(%rsp), %rax
jae 0x29ef
movq 0x18(%rsp), %rax
movb (%rax), %al
movb %al, 0xf(%rsp)
movsbl 0xf(%rsp), %eax
cmpl $0x30, %eax
jl 0x29a4
movsbl 0xf(%rsp), %eax
cmpl $0x39, %eax
jle 0x29a6
jmp 0x29ef
imulq $0xa, 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
movsbl 0xf(%rsp), %eax
subl $0x30, %eax
cltq
addq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, 0x10(%rsp)
jbe 0x29dd
leaq 0x966b(%rip), %rdi      # 0xc043
callq 0x6380
jmp 0x29df
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x2979
movq 0x18(%rsp), %rax
movq 0x30(%rsp), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movl 0x1390(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x1390(%rcx)
cmpl $0xffff, %eax           # imm = 0xFFFF
jbe 0x39ba
movq 0x8(%rsp), %rdi
movl $0x0, 0x1390(%rdi)
movq %rdi, %rax
addq $0x1388, %rax           # imm = 0x1388
movq %rax, (%rsp)
callq 0x4030
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x3fd0
movl 0x1c(%rsp), %edx
leaq 0x14(%rsp), %rdi
xorl %esi, %esi
callq 0x4100
movq 0x8(%rsp), %rsi
addq $0x1388, %rsi           # imm = 0x1388
leaq 0x14(%rsp), %rdi
callq 0x4130
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x68(%rsp), %rdi
leaq 0x5d6d(%rip), %rsi      # 0xc144
callq 0x2210
movq %rax, 0x60(%rsp)
cmpq $0x0, 0x60(%rsp)
jne 0x63f5
leaq 0x5cb0(%rip), %rdi      # 0xc0a0
callq 0x6380
movq 0x60(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x21e0
movq 0x60(%rsp), %rdi
callq 0x2030
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x21e0
movq 0x58(%rsp), %rdi
shlq $0x0, %rdi
addq $0x1, %rdi
callq 0x2240
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
movq 0x58(%rsp), %rdx
movq 0x60(%rsp), %rcx
movl $0x1, %esi
callq 0x2290
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq 0x48(%rsp), %rcx
movb $0xa, (%rax,%rcx)
movq 0x58(%rsp), %rax
cmpq 0x48(%rsp), %rax
je 0x64a2
movq 0x9b63(%rip), %rax      # 0xffe0
movq (%rax), %rdi
movq 0x58(%rsp), %rdx
movq 0x48(%rsp), %rcx
leaq 0x5c34(%rip), %rsi      # 0xc0c5
movb $0x0, %al
callq 0x2270
movl $0x1, %edi
callq 0x2230
movq 0x60(%rsp), %rdi
callq 0x21a0
movb $0x0, 0x47(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x46(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x22e0
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0x2200
jmp 0x64ef
leaq 0x46(%rsp), %rdi
callq 0x21d0
movq 0x50(%rsp), %rdi
callq 0x2220
movb $0x1, 0x47(%rsp)
testb $0x1, 0x47(%rsp)
jne 0x6535
jmp 0x652b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x46(%rsp), %rdi
callq 0x21d0
jmp 0x653f
movq 0x20(%rsp), %rdi
callq 0x2110
movq 0x28(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x22d0
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x20c0
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x5b6b(%rip), %rsi      # 0xc0e4
callq 0x2210
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x6597
leaq 0x5b54(%rip), %rdi      # 0xc0e6
callq 0x6380
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
movl $0x1, %esi
callq 0x22f0
movq %rax, (%rsp)
movq (%rsp), %rax
cmpq 0x10(%rsp), %rax
jae 0x65cb
leaq 0x5b45(%rip), %rdi      # 0xc10b
callq 0x6380
movq 0x8(%rsp), %rdi
callq 0x21a0
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x6671
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0x6619
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
jle 0x6625
leaq 0x5b0d(%rip), %rdi      # 0xc12d
callq 0x6380
imulq $0xa, 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
subl $0x30, %eax
cltq
addq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, 0x8(%rsp)
jbe 0x665f
leaq 0x5aec(%rip), %rdi      # 0xc146
callq 0x6380
jmp 0x6661
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x65f2
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movl 0xc(%rsp), %eax
movl $0xa, %ecx
xorl %edx, %edx
divl %ecx
movb %dl, %al
movsbl %al, %eax
addl $0x30, %eax
movb %al, %cl
movq (%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, (%rsp)
movb %cl, (%rax)
movl 0xc(%rsp), %eax
movl $0xa, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x6696
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
callq 0x7280
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
subq %rcx, %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movl 0x34(%rsp), %eax
addl $0x2, %eax
movl %eax, %eax
movl %eax, %edi
movl $0x8, %esi
callq 0x2120
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x6a70
leaq 0x56fb(%rip), %rdi      # 0xc166
callq 0x6380
movq 0x28(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x40(%rsp), %rcx
movq 0x38(%rsp), %rdx
shlq $0x2, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x6acb
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
movl (%rcx), %ecx
movq (%rax,%rcx,8), %rdx
addq $0x1, %rdx
movq %rdx, (%rax,%rcx,8)
movq 0x18(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x18(%rsp)
jmp 0x6a88
movq 0x28(%rsp), %rax
movl 0x34(%rsp), %ecx
shlq $0x3, %rcx
addq %rcx, %rax
addq $0x8, %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq $0x0, (%rax)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
jae 0x6b2b
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rsp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
jmp 0x6afa
movq 0x28(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x69c0
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
movl $0x8, %esi
callq 0x2120
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x6b8f
leaq 0x55dc(%rip), %rdi      # 0xc166
callq 0x6380
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %rdx
shlq $0x2, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x6bdc
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
movl (%rcx), %ecx
movq (%rax,%rcx,8), %rdx
addq $0x1, %rdx
movq %rdx, (%rax,%rcx,8)
movq 0x10(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x10(%rsp)
jmp 0x6b99
movl $0x0, 0xc(%rsp)
movq $0x0, (%rsp)
movq (%rsp), %rax
cmpq 0x28(%rsp), %rax
jae 0x6c52
jmp 0x6bf9
movq 0x18(%rsp), %rax
movl 0xc(%rsp), %ecx
cmpq $0x0, (%rax,%rcx,8)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x6c12
jmp 0x6c1f
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x6bf9
movl 0xc(%rsp), %edx
movq 0x30(%rsp), %rax
movq (%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movq 0x18(%rsp), %rax
movl 0xc(%rsp), %ecx
movq (%rax,%rcx,8), %rdx
addq $-0x1, %rdx
movq %rdx, (%rax,%rcx,8)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x6bec
movq 0x18(%rsp), %rdi
callq 0x2220
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x8(%rsp), %rax
movl 0x8(%rax), %esi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdx
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rcx
callq 0x2400
movq (%rsp), %rax
leaq 0x88ff(%rip), %rcx      # 0xfd70
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x8(%rsp), %rcx
movq 0x20(%rcx), %rcx
movq %rcx, 0x20(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x8(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x20(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movl %edx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq %r8, 0x28(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl 0x3c(%rsp), %esi
callq 0x6680
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
movl 0x38(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x38(%rsp)
cmpl $0x0, %eax
je 0x75f2
movq 0x8(%rsp), %rdi
movl 0x3c(%rsp), %esi
callq 0x38d0
movl %eax, 0x18(%rsp)
cmpl $0x0, 0x18(%rsp)
jne 0x7562
movq 0x8a98(%rip), %rax      # 0xffe0
movq (%rax), %rdi
movl 0x3c(%rsp), %edx
leaq 0x4aae(%rip), %rsi      # 0xc004
movb $0x0, %al
callq 0x2270
jmp 0x75f2
movq 0x8(%rsp), %rcx
movq 0x20(%rcx), %rax
movq 0x10(%rcx), %rcx
movl 0x3c(%rsp), %edx
addl $0x1, %edx
movl %edx, %edx
movq (%rcx,%rdx,8), %rcx
subq $0x1, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x14(%rsp)
movl 0x3c(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x30(%rsp), %rdi
movl 0x14(%rsp), %esi
subl $0x1, %esi
callq 0x3960
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
movl %eax, %edx
callq 0x8f40
movl %eax, 0x3c(%rsp)
movq 0x20(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rsp)
movb $0x2c, (%rax)
movq 0x20(%rsp), %rdi
movl 0x3c(%rsp), %esi
callq 0x6680
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
jmp 0x7514
movq 0x20(%rsp), %rax
movb $0x0, (%rax)
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
subq %rcx, %rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movl %edx, 0x2c(%rsp)
movq 0x30(%rsp), %rax
movq 0x38(%rsp), %rcx
subq %rcx, %rax
sarq $0x2, %rax
sarq %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
xorl %ecx, %ecx
subq 0x20(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
cmpq $0x8, 0x20(%rsp)
jae 0x91a2
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
leaq 0x2c(%rsp), %rdx
callq 0x9b40
movq %rax, 0x10(%rsp)
jmp 0x9196
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x91eb
movq 0x18(%rsp), %rax
movl (%rax), %eax
cmpl 0x2c(%rsp), %eax
jbe 0x91c9
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x2c(%rsp), %edx
callq 0x9130
movq %rax, 0x8(%rsp)
jmp 0x91e1
movq 0x18(%rsp), %rdi
movq 0x30(%rsp), %rsi
movl 0x2c(%rsp), %edx
callq 0x9130
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
movq %rax, %rdi
callq 0x5630
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movl %edi, 0x1c(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x20c0
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
addq $0x2, %rdi
movq 0x8(%rsp), %rsi
callq 0x2260
cmpl $0x0, %eax
jne 0xa774
cmpl $0x1, 0x1c(%rsp)
jle 0xa752
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0xa7cb
movq 0x8(%rsp), %rsi
leaq 0x1db5(%rip), %rdi      # 0xc513
movb $0x0, %al
callq 0x2040
callq 0xa7e0
movl $0x1, %edi
callq 0x2230
movq 0x10(%rsp), %rax
movq (%rax), %rdi
addq $0x2, %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0x20d0
cmpl $0x0, %eax
jne 0xa7c0
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rcx
movsbl 0x2(%rax,%rcx), %eax
cmpl $0x3d, %eax
jne 0xa7c0
movq 0x10(%rsp), %rax
movq (%rax), %rax
addq (%rsp), %rax
addq $0x3, %rax
movq %rax, 0x20(%rsp)
jmp 0xa7cb
jmp 0xa7c2
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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 0x1b8d(%rip), %rdi      # 0xc375
movb $0x0, %al
callq 0x2040
leaq 0x1b87(%rip), %rdi      # 0xc37d
movb $0x0, %al
callq 0x2040
leaq 0x1b8a(%rip), %rdi      # 0xc38e
movb $0x0, %al
callq 0x2040
leaq 0x1b92(%rip), %rdi      # 0xc3a4
movb $0x0, %al
callq 0x2040
leaq 0x1b97(%rip), %rdi      # 0xc3b7
movb $0x0, %al
callq 0x2040
leaq 0x1b9d(%rip), %rdi      # 0xc3cb
movb $0x0, %al
callq 0x2040
leaq 0x1ba7(%rip), %rdi      # 0xc3e3
movb $0x0, %al
callq 0x2040
leaq 0x1b42(%rip), %rdi      # 0xc38c
movb $0x0, %al
callq 0x2040
leaq 0x1ba6(%rip), %rdi      # 0xc3fe
movb $0x0, %al
callq 0x2040
leaq 0x1bad(%rip), %rdi      # 0xc413
movb $0x0, %al
callq 0x2040
leaq 0x1bd4(%rip), %rdi      # 0xc448
movb $0x0, %al
callq 0x2040
leaq 0x1be0(%rip), %rdi      # 0xc462
movb $0x0, %al
callq 0x2040
leaq 0x1c18(%rip), %rdi      # 0xc4a8
movb $0x0, %al
callq 0x2040
leaq 0x1c47(%rip), %rdi      # 0xc4e5
movb $0x0, %al
callq 0x2040
popq %rax
retq
nopw (%rax,%rax)
// File: 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:
subq $0x13d8, %rsp           # imm = 0x13D8
movq %rdi, 0x13d0(%rsp)
movl %esi, 0x13cc(%rsp)
movl %edx, 0x13c8(%rsp)
movl %ecx, 0x13c4(%rsp)
movl %r8d, 0x13c0(%rsp)
movq %r9, 0x13b8(%rsp)
xorl %eax, %eax
movl %eax, %edi
callq 0x2180
movq %rax, %rsi
leaq 0x20(%rsp), %rdi
callq 0xac20
movq 0x13d0(%rsp), %rdi
callq 0x3a10
movl %eax, %edi
subl $0x1, %edi
callq 0x39f0
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
shlq $0x0, %rdi
movl 0x13c4(%rsp), %eax
imulq %rax, %rdi
callq 0x2240
movq %rax, 0x10(%rsp)
movl 0x13cc(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x13c8(%rsp), %eax
jae 0xaa26
movq 0x13d0(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x38d0
cmpl $0x0, %eax
jne 0xa99d
jmp 0xaa16
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0x13c0(%rsp), %eax
jae 0xaa14
movq 0x13d0(%rsp), %rdi
movl 0xc(%rsp), %esi
movl 0x13c4(%rsp), %edx
movq 0x10(%rsp), %r8
movq (%rdi), %rax
leaq 0x20(%rsp), %rcx
callq *0x10(%rax)
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movq (%rsp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, (%rsp)
movb $0xa, (%rax,%rcx)
movq 0x13b8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq (%rsp), %rdx
callq 0xac80
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0xa9a5
jmp 0xaa16
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xa974
movq 0x10(%rsp), %rdi
callq 0x2220
addq $0x13d8, %rsp           # imm = 0x13D8
retq
nopl (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x14, %edi
callq 0x3330
movq %rax, -0x20(%rbp)
movq $0x40000000, -0x28(%rbp) # imm = 0x40000000
movl $0x0, -0x2c(%rbp)
movslq -0x2c(%rbp), %rax
cmpq $0x4, %rax
jae 0x47f1
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x470a
jmp 0x47d7
movq -0x18(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x28(%rbp)
cmpq $0x0, %rdx
jne 0x474e
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x28(%rbp)
movq %rax, %rdx
movslq -0x2c(%rbp), %rcx
leaq 0x6b46(%rip), %rax      # 0xb280
movq (%rax,%rcx,8), %rcx
leaq 0x3ec5(%rip), %rsi      # 0x860a
movb $0x0, %al
callq 0x3080
jmp 0x47cd
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
cvtsi2ssq -0x18(%rbp), %xmm0
movss %xmm0, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, -0x34(%rbp)
testq %rax, %rax
movss %xmm0, -0x30(%rbp)
js 0x479a
movss -0x34(%rbp), %xmm0
movss %xmm0, -0x30(%rbp)
movq -0x40(%rbp), %rdi
movss -0x38(%rbp), %xmm0
movss -0x30(%rbp), %xmm1
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movslq -0x2c(%rbp), %rcx
leaq 0x6ac5(%rip), %rax      # 0xb280
movq (%rax,%rcx,8), %rdx
leaq 0x3e4b(%rip), %rsi      # 0x8611
movb $0x1, %al
callq 0x3080
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4809
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
shrq $0xa, %rax
movq %rax, -0x28(%rbp)
jmp 0x46ed
movq -0x20(%rbp), %rdi
leaq 0x3e1d(%rip), %rsi      # 0x8619
callq 0x3230
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x4d0, %rsp            # imm = 0x4D0
movq %rsi, -0x498(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x4a0(%rbp)
leaq -0x440(%rbp), %rdi
callq 0x3360
movq -0x498(%rbp), %rdi
movq $0x0, -0x450(%rbp)
callq 0x3100
movq %rax, %rdi
leaq 0x387d(%rip), %rsi      # 0x80ef
callq 0x32e0
movq %rax, -0x490(%rbp)
jmp 0x4880
movq -0x490(%rbp), %rax
movq %rax, -0x458(%rbp)
cmpq $0x0, -0x458(%rbp)
jne 0x48e9
movq 0x6739(%rip), %rax      # 0xafd8
movq (%rax), %rsi
leaq 0x37de(%rip), %rdi      # 0x8087
callq 0x32c0
jmp 0x48b0
movl $0x6, -0x4(%rbp)
movl $0x1, -0x468(%rbp)
jmp 0x4a53
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x460(%rbp)
movl %eax, -0x464(%rbp)
leaq -0x440(%rbp), %rdi
callq 0x3160
jmp 0x4a6b
jmp 0x48eb
movq -0x4a0(%rbp), %rdi
leaq -0x420(%rbp), %rsi
callq 0x4280
movl %eax, -0x4a4(%rbp)
jmp 0x4906
movl -0x4a4(%rbp), %eax
cltq
movq %rax, -0x448(%rbp)
cmpq $0x0, %rax
jbe 0x49cd
movq -0x448(%rbp), %rdx
movq -0x458(%rbp), %rcx
leaq -0x420(%rbp), %rdi
movl $0x1, %esi
callq 0x34a0
jmp 0x4940
movq -0x4a0(%rbp), %rsi
leaq -0x488(%rbp), %rdi
movl $0x4, %edx
callq 0x4320
jmp 0x495a
leaq -0x440(%rbp), %rdi
movq %rdi, -0x4b0(%rbp)
leaq -0x488(%rbp), %rsi
movq %rsi, -0x4b8(%rbp)
callq 0x3310
movq -0x4b8(%rbp), %rdi
callq 0x3160
movq -0x4b0(%rbp), %rdi
movq -0x448(%rbp), %rcx
movq -0x450(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x450(%rbp)
leaq 0x371d(%rip), %rsi      # 0x80ca
callq 0x7390
movb %al, -0x4a5(%rbp)
jmp 0x49ba
movb -0x4a5(%rbp), %al
testb $0x1, %al
jne 0x49c6
jmp 0x49c8
jmp 0x49cd
jmp 0x48eb
cmpq $0x0, -0x448(%rbp)
jae 0x49e7
leaq 0x36a4(%rip), %rdi      # 0x8082
callq 0x31d0
jmp 0x49e5
jmp 0x49e7
movq -0x458(%rbp), %rdi
callq 0x3260
jmp 0x49f5
movq 0x65d4(%rip), %rdi      # 0xafd0
leaq 0x36ee(%rip), %rsi      # 0x80f1
callq 0x3250
movq %rax, -0x4c0(%rbp)
jmp 0x4a11
movq -0x4a0(%rbp), %rdi
movq -0x450(%rbp), %rsi
callq 0x46c0
movq %rax, -0x4c8(%rbp)
jmp 0x4a2d
movq -0x4c8(%rbp), %rsi
movq -0x4c0(%rbp), %rdi
callq 0x3250
jmp 0x4a42
movl $0x0, -0x4(%rbp)
movl $0x1, -0x468(%rbp)
leaq -0x440(%rbp), %rdi
callq 0x3160
movl -0x4(%rbp), %eax
addq $0x4d0, %rsp            # imm = 0x4D0
popq %rbp
retq
movq -0x460(%rbp), %rdi
callq 0x3440
nopw (%rax,%rax)
// File: 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
subq $0x680, %rsp            # imm = 0x680
movq %rdi, -0x658(%rbp)
movq %rdi, %rax
movq %rax, -0x650(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x648(%rbp)
movb $0x0, -0x411(%rbp)
callq 0x3360
movq 0x6176(%rip), %rax      # 0xafc8
movq (%rax), %rdx
leaq -0x410(%rbp), %rdi
movl $0x3ff, %esi            # imm = 0x3FF
callq 0x33f0
jmp 0x4e68
leaq -0x410(%rbp), %rdi
movq %rdi, -0x660(%rbp)
callq 0x3120
movq -0x660(%rbp), %rcx
movb $0x0, -0x1(%rax,%rcx)
leaq -0x5b0(%rbp), %rdi
callq 0x3180
jmp 0x4e95
leaq -0x5a0(%rbp), %rdi
leaq -0x410(%rbp), %rsi
callq 0x3250
jmp 0x4eaa
leaq -0x5d0(%rbp), %rdi
leaq -0x5b0(%rbp), %rsi
callq 0x3240
jmp 0x4ebf
movq -0x658(%rbp), %rdi
leaq -0x5d0(%rbp), %rsi
movq %rsi, -0x670(%rbp)
callq 0x3310
movq -0x670(%rbp), %rdi
callq 0x3160
leaq -0x611(%rbp), %rdi
movq %rdi, -0x668(%rbp)
callq 0x3450
movq -0x668(%rbp), %rdx
leaq 0x338e(%rip), %rsi      # 0x8294
leaq -0x610(%rbp), %rdi
callq 0x3350
jmp 0x4f14
leaq -0x639(%rbp), %rdi
movq %rdi, -0x678(%rbp)
callq 0x3450
movq -0x678(%rbp), %rdx
leaq 0x3275(%rip), %rsi      # 0x81aa
leaq -0x638(%rbp), %rdi
callq 0x3350
jmp 0x4f43
movq -0x658(%rbp), %rdx
movq -0x648(%rbp), %rsi
leaq -0x5f0(%rbp), %rdi
leaq -0x610(%rbp), %rcx
leaq -0x638(%rbp), %r8
callq 0x50c0
jmp 0x4f6d
movq -0x658(%rbp), %rdi
leaq -0x5f0(%rbp), %rsi
callq 0x3310
leaq -0x5f0(%rbp), %rdi
callq 0x3160
leaq -0x638(%rbp), %rdi
callq 0x3160
leaq -0x639(%rbp), %rdi
callq 0x32a0
leaq -0x610(%rbp), %rdi
callq 0x3160
leaq -0x611(%rbp), %rdi
callq 0x32a0
movb $0x1, -0x411(%rbp)
leaq -0x5b0(%rbp), %rdi
callq 0x31a0
testb $0x1, -0x411(%rbp)
jne 0x5090
jmp 0x5084
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x420(%rbp)
movl %eax, -0x424(%rbp)
jmp 0x50a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x420(%rbp)
movl %eax, -0x424(%rbp)
jmp 0x5076
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x420(%rbp)
movl %eax, -0x424(%rbp)
jmp 0x506a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x420(%rbp)
movl %eax, -0x424(%rbp)
jmp 0x5052
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x420(%rbp)
movl %eax, -0x424(%rbp)
leaq -0x638(%rbp), %rdi
callq 0x3160
leaq -0x639(%rbp), %rdi
callq 0x32a0
leaq -0x610(%rbp), %rdi
callq 0x3160
leaq -0x611(%rbp), %rdi
callq 0x32a0
leaq -0x5b0(%rbp), %rdi
callq 0x31a0
jmp 0x50a0
movq -0x658(%rbp), %rdi
callq 0x3160
movq -0x650(%rbp), %rax
addq $0x680, %rsp            # imm = 0x680
popq %rbp
retq
movq -0x658(%rbp), %rdi
callq 0x3160
movq -0x420(%rbp), %rdi
callq 0x3440
nopl (%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rsi
movb $0x0, -0x29(%rbp)
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x51d0
movq -0x68(%rbp), %rdi
movq -0x28(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x3210
movq %rax, -0x38(%rbp)
cmpq $-0x1, -0x38(%rbp)
je 0x51a7
movq -0x68(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x31e0
movq -0x68(%rbp), %rdi
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x30f0
jmp 0x515a
movq -0x38(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x20(%rbp), %rdi
callq 0x33c0
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movq -0x78(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x60(%rbp)
movq -0x28(%rbp), %rsi
movq -0x60(%rbp), %rdx
callq 0x3210
movq %rax, -0x38(%rbp)
jmp 0x5114
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
callq 0x3160
jmp 0x51c7
movb $0x1, -0x29(%rbp)
testb $0x1, -0x29(%rbp)
jne 0x51ba
movq -0x68(%rbp), %rdi
callq 0x3160
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3440
// File: amit-mittal[P]FTP/ftpClient.cpp
// Function: ftpClient::trim(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::trim(const string& str,
                       const string& whitespace) {

    const auto strBegin = str.find_first_not_of(whitespace);
    if (strBegin == string::npos)
        return ""; // no content

    const auto strEnd = str.find_last_not_of(whitespace);
    const auto strRange = strEnd - strBegin + 1;

    return str.substr(strBegin, strRange);
}

// 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, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x31e0
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x28(%rbp)
jne 0x5254
leaq -0x29(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x3450
movq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rdx
leaq 0x2f81(%rip), %rsi      # 0x81ac
callq 0x3350
jmp 0x5232
leaq -0x29(%rbp), %rdi
callq 0x32a0
jmp 0x5291
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x32a0
jmp 0x529b
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq $-0x1, %rdx
callq 0x3480
movq -0x60(%rbp), %rdi
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
subq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x50(%rbp), %rcx
callq 0x3270
movq -0x58(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3440
nopw %cs:(%rax,%rax)
// File: amit-mittal[P]FTP/ftpClient.cpp
// Function: ftpClient::fileExists(char const*)
int ftpClient::fileExists(const char* filename){

	struct stat buffer;
	if (stat(filename, &buffer) != -1)
		return 1;	//File exists
	return 0;		//File does not exist
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x3220
cmpl $-0x1, %eax
je 0x6f01
movl $0x1, -0x4(%rbp)
jmp 0x6f08
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: amit-mittal[P]FTP/ftpClient.cpp
// Function: help()
void help(){
	cout << "*********************** \nClient Program for FTP \n***********************\n";
	cout << "Amit Mittal & Rahul Radhakrishnan, IIT Guwahati\n\n";
	cout << "Usage : ./ftpClient Hostname Port\n\n";
	cout << "-- *Hostname* refers to the hostname/IP address of the server\n";
	cout << "-- *Port* refers to the server's control port (8182 in our case)\n";
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x3f75(%rip), %rdi      # 0xafd0
leaq 0x15b9(%rip), %rsi      # 0x861b
callq 0x3250
movq 0x3f62(%rip), %rdi      # 0xafd0
leaq 0x15f0(%rip), %rsi      # 0x8665
callq 0x3250
movq 0x3f4f(%rip), %rdi      # 0xafd0
leaq 0x160f(%rip), %rsi      # 0x8697
callq 0x3250
movq 0x3f3c(%rip), %rdi      # 0xafd0
leaq 0x1620(%rip), %rsi      # 0x86bb
callq 0x3250
movq 0x3f29(%rip), %rdi      # 0xafd0
leaq 0x164c(%rip), %rsi      # 0x86fa
callq 0x3250
movl $0x1, %edi
callq 0x32f0
nopl (%rax)
// File: amit-mittal[P]FTP/ftpClient.cpp
// Function: main
int main(int argc, char *argv[]){

	if(argc != 3){
		help();
	}

	string IP(argv[1]);
	ftpClient client;
	if(client.connect(IP, atoi(argv[2])) != 0){
		cout << "Error while connecting to server" << endl;
		exit(1);
	}

	while(1){
		printf("ftp> ");
		if(client.sendRequest() != 0){
			cout << "Error while sending a request to server" << endl;
			break;
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x8(%rbp)
je 0x70e4
callq 0x7050
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x258(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x250(%rbp)
callq 0x3450
movq -0x258(%rbp), %rsi
movq -0x250(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x3350
jmp 0x711c
leaq -0x31(%rbp), %rdi
callq 0x32a0
leaq -0x228(%rbp), %rdi
callq 0x7480
jmp 0x7133
leaq -0x248(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3110
jmp 0x7145
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x33e0
movl %eax, %edx
leaq -0x228(%rbp), %rdi
leaq -0x248(%rbp), %rsi
callq 0x4a80
movl %eax, -0x25c(%rbp)
jmp 0x716f
leaq -0x248(%rbp), %rdi
callq 0x3160
movl -0x25c(%rbp), %eax
cmpl $0x0, %eax
je 0x721e
movq 0x3e3f(%rip), %rdi      # 0xafd0
leaq 0x15a4(%rip), %rsi      # 0x873c
callq 0x3250
movq %rax, -0x268(%rbp)
jmp 0x71a6
movq -0x268(%rbp), %rdi
movq 0x3e04(%rip), %rsi      # 0xafb8
callq 0x3280
jmp 0x71bb
movl $0x1, %edi
callq 0x32f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x32a0
jmp 0x72c3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x72ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x72ae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x248(%rbp), %rdi
callq 0x3160
jmp 0x72ae
jmp 0x7220
jmp 0x7222
leaq 0x1534(%rip), %rdi      # 0x875d
xorl %eax, %eax
callq 0x3050
jmp 0x7232
leaq -0x228(%rbp), %rdi
callq 0x52b0
movl %eax, -0x26c(%rbp)
jmp 0x7246
movl -0x26c(%rbp), %eax
cmpl $0x0, %eax
je 0x7284
movq 0x3d78(%rip), %rdi      # 0xafd0
leaq 0x1504(%rip), %rsi      # 0x8763
callq 0x3250
movq %rax, -0x278(%rbp)
jmp 0x726d
movq -0x278(%rbp), %rdi
movq 0x3d3d(%rip), %rsi      # 0xafb8
callq 0x3280
jmp 0x7282
jmp 0x7286
jmp 0x7220
movl $0x0, -0x4(%rbp)
leaq -0x228(%rbp), %rdi
callq 0x74d0
leaq -0x30(%rbp), %rdi
callq 0x3160
movl -0x4(%rbp), %eax
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
leaq -0x228(%rbp), %rdi
callq 0x74d0
leaq -0x30(%rbp), %rdi
callq 0x3160
movq -0x40(%rbp), %rdi
callq 0x3440
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH05_Statements/examples/guess.cc
// Function: main
int main()
{
	do {
		cout << "Guess a number between 0 and 9" << endl;
		unsigned i, mynum = 7;
		cin >> i;

		if (i == mynum) {
			cout << "Congrats you guessed right!" << endl;
			break;
		} else
			if (i < mynum)
				cout << "too low" << endl;
			else
				cout << "too high" << endl;

		if (i != mynum)
			if (i < mynum)
				cout << "too low" << endl;
			else
				cout << "too high" << endl;
		else {
			cout << "Congrats you guessed right!" << endl;
			break;
		}
	} while (true);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movq 0x2dfa(%rip), %rdi      # 0x3fd0
leaq 0xe27(%rip), %rsi       # 0x2004
callq 0x1050
movq %rax, %rdi
movq 0x2dd4(%rip), %rsi      # 0x3fc0
callq 0x1060
movl $0x7, -0xc(%rbp)
movq 0x2de1(%rip), %rdi      # 0x3fe0
leaq -0x8(%rbp), %rsi
callq 0x1030
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
jne 0x1237
movq 0x2db9(%rip), %rdi      # 0x3fd0
leaq 0xe05(%rip), %rsi       # 0x2023
callq 0x1050
movq %rax, %rdi
movq 0x2d93(%rip), %rsi      # 0x3fc0
callq 0x1060
jmp 0x1311
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x1263
movq 0x2d8a(%rip), %rdi      # 0x3fd0
leaq 0xdf2(%rip), %rsi       # 0x203f
callq 0x1050
movq %rax, %rdi
movq 0x2d64(%rip), %rsi      # 0x3fc0
callq 0x1060
jmp 0x1285
movq 0x2d66(%rip), %rdi      # 0x3fd0
leaq 0xdd6(%rip), %rsi       # 0x2047
callq 0x1050
movq %rax, %rdi
movq 0x2d40(%rip), %rsi      # 0x3fc0
callq 0x1060
jmp 0x1287
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
je 0x12df
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x12bb
movq 0x2d32(%rip), %rdi      # 0x3fd0
leaq 0xd9a(%rip), %rsi       # 0x203f
callq 0x1050
movq %rax, %rdi
movq 0x2d0c(%rip), %rsi      # 0x3fc0
callq 0x1060
jmp 0x12dd
movq 0x2d0e(%rip), %rdi      # 0x3fd0
leaq 0xd7e(%rip), %rsi       # 0x2047
callq 0x1050
movq %rax, %rdi
movq 0x2ce8(%rip), %rsi      # 0x3fc0
callq 0x1060
jmp 0x1303
movq 0x2cea(%rip), %rdi      # 0x3fd0
leaq 0xd36(%rip), %rsi       # 0x2023
callq 0x1050
movq %rax, %rdi
movq 0x2cc4(%rip), %rsi      # 0x3fc0
callq 0x1060
jmp 0x1311
jmp 0x1305
movb $0x1, %al
testb $0x1, %al
jne 0x11cf
jmp 0x1311
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: ef-gy[P]libefgy/include/ef.gy/json.h
// Function: efgy::json::value<long double>::size() const
const std::size_t size(void) const {
    if (isObject()) {
      const auto &a = *((const objectType *)payload);
      return a.size();
    } else if (isArray()) {
      const auto &a = *((const arrayType *)payload);
      return a.size();
    }
    return 1;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x2f500
testb $0x1, %al
jne 0xb6cf
jmp 0xb6ea
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3c900
movq %rax, -0x8(%rbp)
jmp 0xb71e
movq -0x28(%rbp), %rdi
callq 0x304d0
testb $0x1, %al
jne 0xb6f9
jmp 0xb714
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x30690
movq %rax, -0x8(%rbp)
jmp 0xb71e
jmp 0xb716
movq $0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)