LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: VanAndelInstitute[P]intent/src/edlib.cpp
// Function: AlignmentData::AlignmentData(int, int)
AlignmentData(int maxNumBlocks, int targetLength) {
        // We build a complete table and mark first and last block for each column
        // (because algorithm is banded so only part of each columns is used).
        // TODO: do not build a whole table, but just enough blocks for each column.
         Ps     = new Word[maxNumBlocks * targetLength];
         Ms     = new Word[maxNumBlocks * targetLength];
         scores = new  int[maxNumBlocks * targetLength];
         firstBlocks = new int[targetLength];
         lastBlocks  = new int[targetLength];
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
imull -0x10(%rbp), %eax
cltq
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x8040
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl -0xc(%rbp), %eax
imull -0x10(%rbp), %eax
cltq
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x8040
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0xc(%rbp), %eax
imull -0x10(%rbp), %eax
cltq
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x8040
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movslq -0x10(%rbp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x8040
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movslq -0x10(%rbp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x8040
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: VanAndelInstitute[P]intent/src/seq_tools.cpp
// Function: getDist(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
int getDist(std::string s1, std::string s2, int method) {
  EdlibAlignResult result = edlibAlign(s1.c_str(),
                                       s1.length(),
                                       s2.c_str(),
                                       s2.length(),
                                       edlibNewAlignConfig(-1,
                                                           EDLIB_MODE_HW,
                                                           EDLIB_TASK_DISTANCE,
                                                           NULL,
                                                           0));
  if (result.status == EDLIB_STATUS_OK) {
      int dist = result.editDistance;
      edlibFreeAlignResult(result);
      return(dist);
  } else {
    return(999);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0xd8(%rbp)
movq %rsi, -0xd0(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
callq 0x8260
movq -0xd8(%rbp), %rdi
movq %rax, -0xc8(%rbp)
callq 0x8850
movq -0xd0(%rbp), %rdi
movl %eax, -0xbc(%rbp)
callq 0x8260
movq -0xd0(%rbp), %rdi
movq %rax, -0xb8(%rbp)
callq 0x8850
movl %eax, -0xac(%rbp)
leaq -0x70(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x2, %edx
xorl %r9d, %r9d
xorl %eax, %eax
movl %eax, %r8d
movl %r9d, %ecx
callq 0x673b0
movq -0xc8(%rbp), %rsi
movl -0xbc(%rbp), %edx
movq -0xb8(%rbp), %rcx
movl -0xac(%rbp), %r8d
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rax
movq (%rax), %r9
movq %r9, (%rsp)
movq 0x8(%rax), %r9
movq %r9, 0x8(%rsp)
movq 0x10(%rax), %r9
movq %r9, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x64a80
cmpl $0x0, -0x50(%rbp)
jne 0x6a500
movl -0x4c(%rbp), %eax
movl %eax, -0x74(%rbp)
leaq -0xa8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movl $0x30, %edx
callq 0x8480
movups -0xa8(%rbp), %xmm0
movups -0x98(%rbp), %xmm1
movups -0x88(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x67430
movl -0x74(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6a507
movl $0x3e7, -0x4(%rbp)      # imm = 0x3E7
movl -0x4(%rbp), %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: VanAndelInstitute[P]intent/src/seq_tools.cpp
// Function: fix_qual_length(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string fix_qual_length(std::string seq, std::string qual) {
    if(qual.length() < seq.length()) {
        qual.insert(qual.begin(), seq.length() - qual.length(), 'A');
    } else if (qual.length() > seq.length()) {
        qual = qual.substr(0, seq.length());
    }
    return(qual);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdx, -0x78(%rbp)
movq %rsi, -0x60(%rbp)
movq %rdi, %rax
movq -0x78(%rbp), %rdi
movq %rax, -0x70(%rbp)
movq %rax, %rcx
movq %rcx, -0x68(%rbp)
movq %rax, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
callq 0x8850
movq -0x60(%rbp), %rdi
movq %rax, -0x58(%rbp)
callq 0x8850
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0x6a7ce
movq -0x78(%rbp), %rdi
callq 0x84c0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6c380
movq -0x60(%rbp), %rdi
callq 0x8850
movq -0x78(%rbp), %rdi
movq %rax, -0x80(%rbp)
callq 0x8850
movq -0x80(%rbp), %rdx
movq -0x78(%rbp), %rdi
subq %rax, %rdx
movq -0x20(%rbp), %rsi
movl $0x41, %ecx
callq 0x86e0
movq %rax, -0x30(%rbp)
jmp 0x6a82b
movq -0x78(%rbp), %rdi
callq 0x8850
movq -0x60(%rbp), %rdi
movq %rax, -0x88(%rbp)
callq 0x8850
movq %rax, %rcx
movq -0x88(%rbp), %rax
cmpq %rcx, %rax
jbe 0x6a829
movq -0x60(%rbp), %rdi
callq 0x8850
movq -0x78(%rbp), %rsi
movq %rax, %rcx
leaq -0x50(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x8590
movq -0x78(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x86c0
leaq -0x50(%rbp), %rdi
callq 0x8a98
jmp 0x6a82b
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdi
callq 0x8370
movq -0x68(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: muzuka[P]Cards-Against-Humanity-Online/Server.cpp
// Function: initServer(int&, int)
void initServer(int& serverSock, int port) {
	struct sockaddr_in serverAddr;
	
	if((serverSock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
		printf("socket() failed\n");
		exit(1);
	}
	
	int yes = 1;
	if(setsockopt(serverSock, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) < 0) {
		printf("setsockopt() failed\n");
		exit(1);
	}
	
	memset(&serverAddr, 0, sizeof(serverAddr));
	serverAddr.sin_family = AF_INET;
	serverAddr.sin_port = htons(port);
	serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);
	
	if(bind(serverSock, (sockaddr *)&serverAddr, sizeof(serverAddr)) < 0) {
		printf("bind() failed\n");
		exit(1);
	}
	
	if(listen(serverSock, MAXPLAYERS) < 0) {
		printf("listen() failed\n");
		exit(1);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x2, %edi
movl $0x1, %esi
movl $0x6, %edx
callq 0x30d0
movq -0x8(%rbp), %rcx
movl %eax, (%rcx)
cmpl $0x0, %eax
jge 0x7616
leaq 0x5ce2(%rip), %rdi      # 0xd2e7
movb $0x0, %al
callq 0x3050
movl $0x1, %edi
callq 0x3350
movl $0x1, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %edi
movl $0x1, %esi
movl $0x2, %edx
leaq -0x20(%rbp), %rcx
movl $0x4, %r8d
callq 0x3460
cmpl $0x0, %eax
jge 0x7659
leaq 0x5cb0(%rip), %rdi      # 0xd2f8
movb $0x0, %al
callq 0x3050
movl $0x1, %edi
callq 0x3350
leaq -0x1c(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x31c0
movw $0x2, -0x1c(%rbp)
movl -0xc(%rbp), %eax
movzwl %ax, %edi
callq 0x3060
movw %ax, -0x1a(%rbp)
xorl %edi, %edi
callq 0x3260
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %edi
leaq -0x1c(%rbp), %rsi
movl $0x10, %edx
callq 0x3080
cmpl $0x0, %eax
jge 0x76b9
leaq 0x5c65(%rip), %rdi      # 0xd30d
movb $0x0, %al
callq 0x3050
movl $0x1, %edi
callq 0x3350
movq -0x8(%rbp), %rax
movl (%rax), %edi
movl $0xa, %esi
callq 0x3330
cmpl $0x0, %eax
jge 0x76e6
leaq 0x5c47(%rip), %rdi      # 0xd31c
movb $0x0, %al
callq 0x3050
movl $0x1, %edi
callq 0x3350
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: muzuka[P]Cards-Against-Humanity-Online/Server.cpp
// Function: splitString(char**, char*, char const*)
void splitString(char* parts[], char* target, const char* delim) {
	char* tok;
	tok = std::strtok(target, delim);
	int i = 0;
	while (tok != NULL) {
		parts[i] = tok;
		tok = strtok(NULL, delim);
		i++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x33f0
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x774f
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x33f0
movq %rax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x771c
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: muzuka[P]Cards-Against-Humanity-Online/Server.cpp
// Function: countChars(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char)
int countChars(string l, char s) {
	int elements = 0;
	for (int i = 0; i < l.length(); i++) {
		if(l[i] == s) {
			elements++;
		}
	}
	return elements;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x33d0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x77cf
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x34c0
movsbl (%rax), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jne 0x77c2
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x77c4
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7784
movl -0x10(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: muzuka[P]Cards-Against-Humanity-Online/Server.cpp
// Function: shuffle(std::vector<Card, std::allocator<Card>>, int)
vector<Card> shuffle(vector<Card> deck, int seed) {
	vector<Card> newDeck;
	newDeck.clear();
	
	for (int i = 1; i < deck.size(); i+=2) {
		newDeck.push_back(deck[i]);
	}
	for (int i = 0; i < deck.size(); i+=2) {
		newDeck.push_back(deck[i]);
	}
	if(seed == 0) {
		return newDeck;
	}
	else {
		return shuffle(newDeck, seed - 1);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x80(%rbp)
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4190
leaq -0x30(%rbp), %rdi
callq 0x8eb0
movl $0x1, -0x34(%rbp)
movq -0x80(%rbp), %rdi
movslq -0x34(%rbp), %rax
movq %rax, -0x88(%rbp)
callq 0x4280
movq %rax, %rcx
movq -0x88(%rbp), %rax
cmpq %rcx, %rax
jae 0x787a
movq -0x80(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0x42b0
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x4210
jmp 0x785c
jmp 0x785e
movl -0x34(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x34(%rbp)
jmp 0x781e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x794a
movl $0x0, -0x48(%rbp)
movq -0x80(%rbp), %rdi
movslq -0x48(%rbp), %rax
movq %rax, -0x90(%rbp)
callq 0x4280
movq %rax, %rcx
movq -0x90(%rbp), %rax
cmpq %rcx, %rax
jae 0x78cc
movq -0x80(%rbp), %rdi
movslq -0x48(%rbp), %rsi
callq 0x42b0
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x4210
jmp 0x78bf
jmp 0x78c1
movl -0x48(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x48(%rbp)
jmp 0x7881
cmpl $0x0, -0x14(%rbp)
jne 0x78e8
movq -0x78(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x9350
movl $0x1, -0x4c(%rbp)
jmp 0x7934
leaq -0x68(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4340
jmp 0x78f7
movq -0x78(%rbp), %rdi
movl -0x14(%rbp), %edx
decl %edx
leaq -0x68(%rbp), %rsi
callq 0x77e0
jmp 0x790b
leaq -0x68(%rbp), %rdi
callq 0x41b0
movl $0x1, -0x4c(%rbp)
jmp 0x7934
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x41b0
jmp 0x794a
leaq -0x30(%rbp), %rdi
callq 0x41b0
movq -0x70(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x41b0
movq -0x40(%rbp), %rdi
callq 0x3440
nopl (%rax)
// File: muzuka[P]Cards-Against-Humanity-Online/Server.cpp
// Function: composeSENDMessage[abi:cxx11](char, Card)
string composeSENDMessage(char type, Card cardToSend) {
	if(type == 'p') {
		//printf("About to send POST:\n%s\n", cardToSend.content.c_str());
		return "POST Server\n" + cardToSend.content;
	}
	else if(type == 'n') {
		//printf("About to send ANSWER:\n%s %s\n", cardToSend.owner.c_str(), cardToSend.content.c_str());
		return "ANSWER " + cardToSend.owner + "\n" + cardToSend.content;
	}
	else if (type == 'd') {
		//printf("About to send ADD:\n%s\n", cardToSend.content.c_str());
		return "ADD Server\n" + cardToSend.content;
	}
	else {
		return "";
	}
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdx, -0x80(%rbp)
movq %rdi, -0x78(%rbp)
movb %sil, %al
movq %rdi, %rcx
movq %rcx, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0x70, %eax
jne 0x7a4a
movq -0x80(%rbp), %rdx
movq -0x78(%rbp), %rdi
leaq 0x5911(%rip), %rsi      # 0xd351
callq 0x9380
jmp 0x7b51
movsbl -0x9(%rbp), %eax
cmpl $0x6e, %eax
jne 0x7ae7
movq -0x80(%rbp), %rdx
addq $0x28, %rdx
leaq 0x58f8(%rip), %rsi      # 0xd35e
leaq -0x58(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x9380
movq -0x88(%rbp), %rsi
leaq 0x561a(%rip), %rdx      # 0xd09e
leaq -0x38(%rbp), %rdi
callq 0x94e0
jmp 0x7a8f
movq -0x80(%rbp), %rdx
movq -0x78(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x9490
jmp 0x7aa2
leaq -0x38(%rbp), %rdi
callq 0x31f0
leaq -0x58(%rbp), %rdi
callq 0x31f0
jmp 0x7b51
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x7adc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x31f0
leaq -0x58(%rbp), %rdi
callq 0x31f0
jmp 0x7b5e
movsbl -0x9(%rbp), %eax
cmpl $0x64, %eax
jne 0x7b06
movq -0x80(%rbp), %rdx
movq -0x78(%rbp), %rdi
leaq 0x5867(%rip), %rsi      # 0xd366
callq 0x9380
jmp 0x7b51
leaq -0x65(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x3450
movq -0x78(%rbp), %rdi
movq -0x90(%rbp), %rdx
leaq 0x5577(%rip), %rsi      # 0xd09f
callq 0x8ef0
jmp 0x7b2f
leaq -0x65(%rbp), %rdi
callq 0x3300
jmp 0x7b51
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x65(%rbp), %rdi
callq 0x3300
jmp 0x7b5e
movq -0x70(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x3440
nopw (%rax,%rax)
// File: muzuka[P]Cards-Against-Humanity-Online/Server.cpp
// Function: shuffle(std::vector<Player, std::allocator<Player>>, int)
vector<Player> shuffle(vector<Player> deck, int seed) {
	vector<Player> newDeck;
	newDeck.clear();
	
	for (int i = 1; i < deck.size(); i+=2) {
		newDeck.push_back(deck[i]);
	}
	for (int i = 0; i < deck.size(); i+=2) {
		newDeck.push_back(deck[i]);
	}
	if (seed == 0) {
		return newDeck;
	}
	else {
		return shuffle(newDeck, seed - 1);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x80(%rbp)
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x8e30
leaq -0x30(%rbp), %rdi
callq 0x8ed0
movl $0x1, -0x34(%rbp)
movq -0x80(%rbp), %rdi
movslq -0x34(%rbp), %rax
movq %rax, -0x88(%rbp)
callq 0x8fe0
movq %rax, %rcx
movq -0x88(%rbp), %rax
cmpq %rcx, %rax
jae 0x7c0a
movq -0x80(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0x9010
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x9030
jmp 0x7bec
jmp 0x7bee
movl -0x34(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x34(%rbp)
jmp 0x7bae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x7cda
movl $0x0, -0x48(%rbp)
movq -0x80(%rbp), %rdi
movslq -0x48(%rbp), %rax
movq %rax, -0x90(%rbp)
callq 0x8fe0
movq %rax, %rcx
movq -0x90(%rbp), %rax
cmpq %rcx, %rax
jae 0x7c5c
movq -0x80(%rbp), %rdi
movslq -0x48(%rbp), %rsi
callq 0x9010
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x9030
jmp 0x7c4f
jmp 0x7c51
movl -0x48(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x48(%rbp)
jmp 0x7c11
cmpl $0x0, -0x14(%rbp)
jne 0x7c78
movq -0x78(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x9530
movl $0x1, -0x4c(%rbp)
jmp 0x7cc4
leaq -0x68(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x90d0
jmp 0x7c87
movq -0x78(%rbp), %rdi
movl -0x14(%rbp), %edx
decl %edx
leaq -0x68(%rbp), %rsi
callq 0x7b70
jmp 0x7c9b
leaq -0x68(%rbp), %rdi
callq 0x8e50
movl $0x1, -0x4c(%rbp)
jmp 0x7cc4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x8e50
jmp 0x7cda
leaq -0x30(%rbp), %rdi
callq 0x8e50
movq -0x70(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x8e50
movq -0x40(%rbp), %rdi
callq 0x3440
nopl (%rax)
// File: muzuka[P]Cards-Against-Humanity-Online/Server.cpp
// Function: composeNOTIFYMessage(char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string composeNOTIFYMessage(char purpose, string playerName) {
	if (purpose == 'j') {
		return "NOTIFY Server\nCP: " + playerName;
	}
	else if (purpose == 'w') {
		return "NOTIFY Server\nwinner: " + playerName;
	}
	else if(purpose == 'n') {
		stringstream s;
		s << answers.size();
		return "NOTIFY Server\nplayers: " + s.str();
	}
	else if(purpose == 'q') {
		return "NOTIFY Server\nquit: Server";
	}
	else {
		return "";
	}
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
movq %rdx, -0x1f0(%rbp)
movq %rdi, -0x1e8(%rbp)
movb %sil, %al
movq %rdi, %rcx
movq %rcx, -0x1e0(%rbp)
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0x6a, %eax
jne 0x7d49
movq -0x1f0(%rbp), %rdx
movq -0x1e8(%rbp), %rdi
leaq 0x5633(%rip), %rsi      # 0xd372
callq 0x9380
jmp 0x7f09
movsbl -0x9(%rbp), %eax
cmpl $0x77, %eax
jne 0x7d71
movq -0x1f0(%rbp), %rdx
movq -0x1e8(%rbp), %rdi
leaq 0x561e(%rip), %rsi      # 0xd385
callq 0x9380
jmp 0x7f09
movsbl -0x9(%rbp), %eax
cmpl $0x6e, %eax
jne 0x7e46
leaq -0x1a0(%rbp), %rdi
callq 0x3230
leaq -0x190(%rbp), %rax
movq %rax, -0x1f8(%rbp)
leaq 0xa8d9(%rip), %rdi      # 0x12678
callq 0x4280
movq -0x1f8(%rbp), %rdi
movq %rax, %rsi
callq 0x30c0
jmp 0x7db5
leaq -0x1d0(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0x32c0
jmp 0x7dca
movq -0x1e8(%rbp), %rdi
leaq 0x55c4(%rip), %rsi      # 0xd39c
leaq -0x1d0(%rbp), %rdx
callq 0x9560
jmp 0x7de6
leaq -0x1d0(%rbp), %rdi
callq 0x31f0
leaq -0x1a0(%rbp), %rdi
callq 0x3250
jmp 0x7f09
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
jmp 0x7e35
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x31f0
leaq -0x1a0(%rbp), %rdi
callq 0x3250
jmp 0x7f19
movsbl -0x9(%rbp), %eax
cmpl $0x71, %eax
jne 0x7eac
leaq -0x1d1(%rbp), %rdi
movq %rdi, -0x200(%rbp)
callq 0x3450
movq -0x1e8(%rbp), %rdi
movq -0x200(%rbp), %rdx
leaq 0x553d(%rip), %rsi      # 0xd3b4
callq 0x8ef0
jmp 0x7e7e
leaq -0x1d1(%rbp), %rdi
callq 0x3300
jmp 0x7f09
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1d1(%rbp), %rdi
callq 0x3300
jmp 0x7f19
leaq -0x1d2(%rbp), %rdi
movq %rdi, -0x208(%rbp)
callq 0x3450
movq -0x1e8(%rbp), %rdi
movq -0x208(%rbp), %rdx
leaq 0x51cb(%rip), %rsi      # 0xd09f
callq 0x8ef0
jmp 0x7edb
leaq -0x1d2(%rbp), %rdi
callq 0x3300
jmp 0x7f09
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1d2(%rbp), %rdi
callq 0x3300
jmp 0x7f19
movq -0x1e0(%rbp), %rax
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
movq -0x1a8(%rbp), %rdi
callq 0x3440
nopw %cs:(%rax,%rax)
// File: muzuka[P]Cards-Against-Humanity-Online/Server.cpp
// Function: shutdown()
void shutdown() {
	for (int i = 0; i < players.size(); i++) {
		string quit = composeNOTIFYMessage('q', "");
		bytesSent = send(players[i].getSocket(), (char*)quit.c_str(), 100, 0);
		if(bytesSent <= 0) {
			printf("Couldn't send quit.\n");
			exit(1);
		}
	}	
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl $0x0, -0x4(%rbp)
movslq -0x4(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq 0xa787(%rip), %rdi      # 0x126d8
callq 0x8fe0
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jae 0x8076
leaq -0x49(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3450
movq -0x70(%rbp), %rdx
leaq 0x5121(%rip), %rsi      # 0xd09f
leaq -0x48(%rbp), %rdi
callq 0x8ef0
jmp 0x7f89
leaq -0x28(%rbp), %rdi
movl $0x71, %esi
leaq -0x48(%rbp), %rdx
callq 0x7cf0
jmp 0x7f9d
leaq -0x48(%rbp), %rdi
callq 0x31f0
leaq -0x49(%rbp), %rdi
callq 0x3300
movslq -0x4(%rbp), %rsi
leaq 0xa71e(%rip), %rdi      # 0x126d8
callq 0x9010
movq %rax, %rdi
callq 0x3c80
movl %eax, -0x74(%rbp)
jmp 0x7fcc
leaq -0x28(%rbp), %rdi
callq 0x3170
movl -0x74(%rbp), %edi
movq %rax, %rsi
movl $0x64, %edx
xorl %ecx, %ecx
callq 0x31a0
movq %rax, -0x80(%rbp)
jmp 0x7fed
movq -0x80(%rbp), %rax
movl %eax, 0xa339(%rip)      # 0x12330
cmpl $0x0, 0xa332(%rip)      # 0x12330
jg 0x805f
leaq 0x53c8(%rip), %rdi      # 0xd3cf
xorl %eax, %eax
callq 0x3050
jmp 0x8010
movl $0x1, %edi
callq 0x3350
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x803d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x31f0
leaq -0x49(%rbp), %rdi
callq 0x3300
jmp 0x8080
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x31f0
jmp 0x8080
leaq -0x28(%rbp), %rdi
callq 0x31f0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x7f42
movl $0x1, %edi
callq 0x3350
movq -0x58(%rbp), %rdi
callq 0x3440
nopl (%rax)
// File: muzuka[P]Cards-Against-Humanity-Online/Server.cpp
// Function: getPlayerIndex(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int getPlayerIndex(string name) {
	for (int i = 0; i < players.size(); i++) {
		if (strcmp(players[i].getName().c_str(), name.c_str()) == 0) {
			return i;
		}
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq 0x9bb2(%rip), %rdi      # 0x126d8
callq 0x8fe0
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x8ba1
movslq -0x14(%rbp), %rsi
leaq 0x9b96(%rip), %rdi      # 0x126d8
callq 0x9010
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
callq 0x3c30
leaq -0x38(%rbp), %rdi
callq 0x3170
movq -0x40(%rbp), %rdi
movq %rax, -0x58(%rbp)
callq 0x3170
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x33b0
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x31f0
movl -0x4c(%rbp), %eax
cmpl $0x0, %eax
jne 0x8b91
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x8ba8
jmp 0x8b93
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8b17
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: muzuka[P]Cards-Against-Humanity-Online/Server.cpp
// Function: getPlayer(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Player getPlayer(string name) {
	for (int i = 0; i < players.size(); i++) {
		if (strcmp(players[i].getName().c_str(), name.c_str()) == 0) {
			return players[i];
		}
	}
	return Player();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x50(%rbp)
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq 0x9ae3(%rip), %rdi      # 0x126d8
callq 0x8fe0
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0x8c8a
movslq -0x14(%rbp), %rsi
leaq 0x9ac3(%rip), %rdi      # 0x126d8
callq 0x9010
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
callq 0x3c30
leaq -0x38(%rbp), %rdi
callq 0x3170
movq -0x50(%rbp), %rdi
movq %rax, -0x68(%rbp)
callq 0x3170
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x33b0
movl %eax, -0x5c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x31f0
movl -0x5c(%rbp), %eax
cmpl $0x0, %eax
jne 0x8c7a
movslq -0x14(%rbp), %rsi
leaq 0x9a71(%rip), %rdi      # 0x126d8
callq 0x9010
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x95b0
jmp 0x8c93
jmp 0x8c7c
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8be6
movq -0x48(%rbp), %rdi
callq 0x3a40
movq -0x40(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: muzuka[P]Cards-Against-Humanity-Online/Server.cpp
// Function: deletePlayer(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void deletePlayer(string playerName) {
	vector<Player> temp;
	for (int i = 0; i < players.size(); i++) {
		if (strcmp(players[i].getName().c_str(), playerName.c_str()) != 0) {
			temp.push_back(players[i]);
		}
		else {
			delete &players[i];
		}
		
	}
	players = temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x8e30
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq 0x9a06(%rip), %rdi      # 0x126d8
callq 0x8fe0
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jae 0x8db5
movslq -0x24(%rbp), %rsi
leaq 0x99e6(%rip), %rdi      # 0x126d8
callq 0x9010
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
callq 0x3c30
jmp 0x8d05
leaq -0x48(%rbp), %rdi
callq 0x3170
movq -0x60(%rbp), %rdi
movq %rax, -0x78(%rbp)
callq 0x3170
movq -0x78(%rbp), %rdi
movq %rax, %rsi
callq 0x33b0
movl %eax, -0x6c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x31f0
movl -0x6c(%rbp), %eax
cmpl $0x0, %eax
je 0x8d72
movslq -0x24(%rbp), %rsi
leaq 0x9992(%rip), %rdi      # 0x126d8
callq 0x9010
movq %rax, %rsi
leaq -0x20(%rbp), %rdi
callq 0x9030
jmp 0x8d59
jmp 0x8da5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x8e50
jmp 0x8dd9
movslq -0x24(%rbp), %rsi
leaq 0x995b(%rip), %rdi      # 0x126d8
callq 0x9010
movq %rax, -0x80(%rbp)
cmpq $0x0, %rax
je 0x8da3
movq -0x80(%rbp), %rdi
callq 0x8df0
movq -0x80(%rbp), %rdi
movl $0x58, %esi
callq 0x32e0
jmp 0x8da5
jmp 0x8da7
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x8cc3
leaq 0x991c(%rip), %rdi      # 0x126d8
leaq -0x20(%rbp), %rsi
callq 0x9660
jmp 0x8dc7
leaq -0x20(%rbp), %rdi
callq 0x8e50
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3440
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: mattearly[P]english-name-generator/src/humangenerator.cpp
// Function: HumanGenerator::HumanGenerator()
HumanGenerator::HumanGenerator()
{
  int isMale = getRandomNumber(0, 1);
  if (isMale) {
    FirstName = "John";
  } else {
    FirstName = "Jane";
  }

  LastName = "Doe";
  SSN = "555-555-5555";

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
callq 0x2260
movq -0x38(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x40(%rbp)
callq 0x2260
movq -0x38(%rbp), %rdi
addq $0x40, %rdi
movq %rdi, -0x30(%rbp)
callq 0x2260
movl $0x0, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x3580
movl %eax, -0x28(%rbp)
jmp 0x24e2
movl -0x28(%rbp), %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x252b
movq -0x48(%rbp), %rdi
leaq 0x3b0b(%rip), %rsi      # 0x6004
callq 0x2250
jmp 0x2500
jmp 0x253f
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x20f0
movq -0x40(%rbp), %rdi
callq 0x20f0
movq -0x38(%rbp), %rdi
callq 0x20f0
jmp 0x2571
movq -0x48(%rbp), %rdi
leaq 0x3ad3(%rip), %rsi      # 0x6009
callq 0x2250
jmp 0x253d
jmp 0x253f
movq -0x48(%rbp), %rdi
addq $0x20, %rdi
leaq 0x3ac0(%rip), %rsi      # 0x600e
callq 0x2250
jmp 0x2555
movq -0x48(%rbp), %rdi
addq $0x40, %rdi
leaq 0x3aae(%rip), %rsi      # 0x6012
callq 0x2250
jmp 0x256b
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x22c0
nopw (%rax,%rax)
// File: mattearly[P]english-name-generator/src/humangenerator.cpp
// Function: HumanGenerator::newFirstName()
void HumanGenerator::newFirstName()
{
  ifstream firstNameFile("./data/first_names.dat");
  string tmp = "FIRSTNAMEFAILED";

  if (firstNameFile.is_open()) {
    int seed = getRandomNumber(0, 3998);
    for (int i = 0; i < seed; i++) {
      getline(firstNameFile, tmp);   ///skip lines = to the seed
    }
    getline(firstNameFile, tmp);
  }

  FirstName = tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp            # imm = 0x270
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x268(%rbp)
leaq 0x3a7e(%rip), %rsi      # 0x601f
leaq -0x210(%rbp), %rdi
movl $0x8, %edx
callq 0x2300
leaq -0x231(%rbp), %rdi
movq %rdi, -0x260(%rbp)
callq 0x22d0
movq -0x260(%rbp), %rdx
leaq 0x3a63(%rip), %rsi      # 0x6036
leaq -0x230(%rbp), %rdi
callq 0x2c90
jmp 0x25e1
leaq -0x231(%rbp), %rdi
callq 0x21e0
leaq -0x210(%rbp), %rdi
callq 0x2290
movb %al, -0x269(%rbp)
jmp 0x2601
movb -0x269(%rbp), %al
testb $0x1, %al
jne 0x2610
jmp 0x26e2
movl $0x0, -0x24c(%rbp)
movl $0xf9e, -0x250(%rbp)    # imm = 0xF9E
leaq -0x24c(%rbp), %rdi
leaq -0x250(%rbp), %rsi
callq 0x3580
movl %eax, -0x270(%rbp)
jmp 0x263f
movl -0x270(%rbp), %eax
movl %eax, -0x248(%rbp)
movl $0x0, -0x254(%rbp)
movl -0x254(%rbp), %eax
cmpl -0x248(%rbp), %eax
jge 0x26cb
leaq -0x210(%rbp), %rdi
leaq -0x230(%rbp), %rsi
callq 0x2060
jmp 0x2678
jmp 0x267a
movl -0x254(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x254(%rbp)
jmp 0x2655
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x240(%rbp)
movl %eax, -0x244(%rbp)
leaq -0x231(%rbp), %rdi
callq 0x21e0
jmp 0x2718
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x240(%rbp)
movl %eax, -0x244(%rbp)
leaq -0x230(%rbp), %rdi
callq 0x20f0
jmp 0x2718
leaq -0x210(%rbp), %rdi
leaq -0x230(%rbp), %rsi
callq 0x2060
jmp 0x26e0
jmp 0x26e2
movq -0x268(%rbp), %rdi
leaq -0x230(%rbp), %rsi
callq 0x2030
jmp 0x26f7
leaq -0x230(%rbp), %rdi
callq 0x20f0
leaq -0x210(%rbp), %rdi
callq 0x2070
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
leaq -0x210(%rbp), %rdi
callq 0x2070
movq -0x240(%rbp), %rdi
callq 0x22c0
// File: mattearly[P]english-name-generator/src/humangenerator.cpp
// Function: HumanGenerator::newLastName()
void HumanGenerator::newLastName()
{
  ifstream lastNameFile("./data/last_names.dat");
  string tmp = "LASTNAMEFAILED";

  if (lastNameFile.is_open()) {
    int seed = getRandomNumber(0, 998);
    for (int i = 0; i < seed; i++) {
      getline(lastNameFile, tmp);   ///skip lines = to the seed
    }
    getline(lastNameFile, tmp);
  }

  LastName = tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp            # imm = 0x270
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x268(%rbp)
leaq 0x38f5(%rip), %rsi      # 0x6046
leaq -0x210(%rbp), %rdi
movl $0x8, %edx
callq 0x2300
leaq -0x231(%rbp), %rdi
movq %rdi, -0x260(%rbp)
callq 0x22d0
movq -0x260(%rbp), %rdx
leaq 0x38d9(%rip), %rsi      # 0x605c
leaq -0x230(%rbp), %rdi
callq 0x2c90
jmp 0x2791
leaq -0x231(%rbp), %rdi
callq 0x21e0
leaq -0x210(%rbp), %rdi
callq 0x2290
movb %al, -0x269(%rbp)
jmp 0x27b1
movb -0x269(%rbp), %al
testb $0x1, %al
jne 0x27c0
jmp 0x2892
movl $0x0, -0x24c(%rbp)
movl $0x3e6, -0x250(%rbp)    # imm = 0x3E6
leaq -0x24c(%rbp), %rdi
leaq -0x250(%rbp), %rsi
callq 0x3580
movl %eax, -0x270(%rbp)
jmp 0x27ef
movl -0x270(%rbp), %eax
movl %eax, -0x248(%rbp)
movl $0x0, -0x254(%rbp)
movl -0x254(%rbp), %eax
cmpl -0x248(%rbp), %eax
jge 0x287b
leaq -0x210(%rbp), %rdi
leaq -0x230(%rbp), %rsi
callq 0x2060
jmp 0x2828
jmp 0x282a
movl -0x254(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x254(%rbp)
jmp 0x2805
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x240(%rbp)
movl %eax, -0x244(%rbp)
leaq -0x231(%rbp), %rdi
callq 0x21e0
jmp 0x28cc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x240(%rbp)
movl %eax, -0x244(%rbp)
leaq -0x230(%rbp), %rdi
callq 0x20f0
jmp 0x28cc
leaq -0x210(%rbp), %rdi
leaq -0x230(%rbp), %rsi
callq 0x2060
jmp 0x2890
jmp 0x2892
movq -0x268(%rbp), %rdi
addq $0x20, %rdi
leaq -0x230(%rbp), %rsi
callq 0x2030
jmp 0x28ab
leaq -0x230(%rbp), %rdi
callq 0x20f0
leaq -0x210(%rbp), %rdi
callq 0x2070
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
leaq -0x210(%rbp), %rdi
callq 0x2070
movq -0x240(%rbp), %rdi
callq 0x22c0
nopw %cs:(%rax,%rax)
// File: mattearly[P]english-name-generator/src/humangenerator.cpp
// Function: HumanGenerator::newSSN()
void HumanGenerator::newSSN()
{
  string tmp = "SSNFAILED";
  tmp = to_string(getRandomNumber(100, 999)) + "-";
  tmp += to_string(getRandomNumber(10, 99)) + "-";
  tmp += to_string(getRandomNumber(1000, 9999));
  SSN = tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x108(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0x22d0
movq -0x100(%rbp), %rdx
leaq 0x3743(%rip), %rsi      # 0x606b
leaq -0x28(%rbp), %rdi
callq 0x2c90
jmp 0x2933
leaq -0x29(%rbp), %rdi
callq 0x21e0
movl $0x64, -0x84(%rbp)
movl $0x3e7, -0x88(%rbp)     # imm = 0x3E7
leaq -0x84(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x3580
movl %eax, -0x10c(%rbp)
jmp 0x296b
movl -0x10c(%rbp), %esi
leaq -0x80(%rbp), %rdi
callq 0x2d90
jmp 0x297c
leaq 0x36f2(%rip), %rdx      # 0x6075
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x2d40
jmp 0x2992
leaq -0x28(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movq %rsi, -0x118(%rbp)
callq 0x2220
movq -0x118(%rbp), %rdi
callq 0x20f0
leaq -0x80(%rbp), %rdi
callq 0x20f0
movl $0xa, -0xcc(%rbp)
movl $0x63, -0xd0(%rbp)
leaq -0xcc(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x3580
movl %eax, -0x110(%rbp)
jmp 0x29ea
movl -0x110(%rbp), %esi
leaq -0xc8(%rbp), %rdi
callq 0x2d90
jmp 0x29fe
leaq 0x3670(%rip), %rdx      # 0x6075
leaq -0xa8(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0x2d40
jmp 0x2a1a
leaq -0x28(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x2240
jmp 0x2a2c
leaq -0xa8(%rbp), %rdi
callq 0x20f0
leaq -0xc8(%rbp), %rdi
callq 0x20f0
movl $0x3e8, -0xf4(%rbp)     # imm = 0x3E8
movl $0x270f, -0xf8(%rbp)    # imm = 0x270F
leaq -0xf4(%rbp), %rdi
leaq -0xf8(%rbp), %rsi
callq 0x3580
movl %eax, -0x11c(%rbp)
jmp 0x2a73
movl -0x11c(%rbp), %esi
leaq -0xf0(%rbp), %rdi
callq 0x2d90
jmp 0x2a87
leaq -0x28(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
callq 0x2240
jmp 0x2a99
leaq -0xf0(%rbp), %rdi
callq 0x20f0
movq -0x108(%rbp), %rdi
addq $0x40, %rdi
leaq -0x28(%rbp), %rsi
callq 0x2030
jmp 0x2abb
leaq -0x28(%rbp), %rdi
callq 0x20f0
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x21e0
jmp 0x2b5e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x2b55
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x20f0
jmp 0x2b55
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x2b2f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x20f0
leaq -0xc8(%rbp), %rdi
callq 0x20f0
jmp 0x2b55
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x20f0
leaq -0x28(%rbp), %rdi
callq 0x20f0
movq -0x38(%rbp), %rdi
callq 0x22c0
nopw (%rax,%rax)
// File: mattearly[P]english-name-generator/src/main.cpp
// Function: main
int main(int argc, char** argv) {

  cout << "BEGIN RANDOM NAME GEN!!\n";

  HumanGenerator human;
  for (int i = 0; i < 10; i++) {
    human.newFirstName();
    human.newLastName();
    human.newSSN();

    cout << human.getFirstName() << endl;
    cout << human.getLastName() << endl;
    cout << human.getSSN() << endl;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x5c78(%rip), %rdi      # 0x8fd8
leaq 0x2e12(%rip), %rsi      # 0x6179
callq 0x2190
leaq -0x70(%rbp), %rdi
callq 0x2480
movl $0x0, -0x74(%rbp)
cmpl $0xa, -0x74(%rbp)
jge 0x350a
leaq -0x70(%rbp), %rdi
callq 0x2580
jmp 0x3391
leaq -0x70(%rbp), %rdi
callq 0x2730
jmp 0x339c
leaq -0x70(%rbp), %rdi
callq 0x28f0
jmp 0x33a7
leaq -0xa8(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x2bd0
jmp 0x33b9
movq 0x5c18(%rip), %rdi      # 0x8fd8
leaq -0xa8(%rbp), %rsi
callq 0x2180
movq %rax, -0xf0(%rbp)
jmp 0x33d5
movq -0xf0(%rbp), %rdi
movq 0x5be5(%rip), %rsi      # 0x8fc8
callq 0x21c0
jmp 0x33ea
leaq -0xa8(%rbp), %rdi
callq 0x20f0
leaq -0xc8(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x2b70
jmp 0x3408
movq 0x5bc9(%rip), %rdi      # 0x8fd8
leaq -0xc8(%rbp), %rsi
callq 0x2180
movq %rax, -0xf8(%rbp)
jmp 0x3424
movq -0xf8(%rbp), %rdi
movq 0x5b96(%rip), %rsi      # 0x8fc8
callq 0x21c0
jmp 0x3439
leaq -0xc8(%rbp), %rdi
callq 0x20f0
leaq -0xe8(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x2c30
jmp 0x3457
movq 0x5b7a(%rip), %rdi      # 0x8fd8
leaq -0xe8(%rbp), %rsi
callq 0x2180
movq %rax, -0x100(%rbp)
jmp 0x3473
movq -0x100(%rbp), %rdi
movq 0x5b47(%rip), %rsi      # 0x8fc8
callq 0x21c0
jmp 0x3488
leaq -0xe8(%rbp), %rdi
callq 0x20f0
movl -0x74(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x74(%rbp)
jmp 0x337c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x3526
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x20f0
jmp 0x3526
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x20f0
jmp 0x3526
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0x20f0
jmp 0x3526
movl $0x0, -0x4(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x3540
movl -0x4(%rbp), %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
leaq -0x70(%rbp), %rdi
callq 0x3540
movq -0x80(%rbp), %rdi
callq 0x22c0
nopl (%rax,%rax)
// File: mattearly[P]english-name-generator/src/utility.cpp
// Function: getRandomNumber(int const&, int const&)
int getRandomNumber(const int& start, const int& end) {

  static long long int timeSeed = std::chrono::high_resolution_clock::now().time_since_epoch().count();

  static std::seed_seq ss{uint32_t(timeSeed & 0xffffffff), uint32_t(timeSeed >> 32)};

  std::uniform_int_distribution<int> unif(start, end);

  static std::mt19937 mgen(ss);

  return unif(mgen);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpb $0x0, 0x5c31(%rip)      # 0x91c8
jne 0x35f0
leaq 0x5c28(%rip), %rdi      # 0x91c8
callq 0x22f0
cmpl $0x0, %eax
je 0x35f0
callq 0x2040
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3730
movq %rax, -0x58(%rbp)
jmp 0x35c2
movq -0x58(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3750
movq %rax, -0x60(%rbp)
jmp 0x35d9
movq -0x60(%rbp), %rax
movq %rax, 0x5bdc(%rip)      # 0x91c0
leaq 0x5bdd(%rip), %rdi      # 0x91c8
callq 0x2110
cmpb $0x0, 0x5bf1(%rip)      # 0x91e8
jne 0x3668
leaq 0x5be8(%rip), %rdi      # 0x91e8
callq 0x22f0
cmpl $0x0, %eax
je 0x3668
movl 0x5bb0(%rip), %eax      # 0x91c0
movl %eax, -0x48(%rbp)
movl 0x5bab(%rip), %eax      # 0x91c4
movl %eax, -0x44(%rbp)
leaq -0x48(%rbp), %rax
movq %rax, -0x40(%rbp)
movq $0x2, -0x38(%rbp)
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
leaq 0x5b95(%rip), %rdi      # 0x91d0
callq 0x3770
jmp 0x3642
leaq 0x1f7(%rip), %rdi       # 0x3840
leaq 0x5b80(%rip), %rsi      # 0x91d0
leaq 0x5b51(%rip), %rdx      # 0x91a8
callq 0x2170
leaq 0x5b85(%rip), %rdi      # 0x91e8
callq 0x2110
movq -0x8(%rbp), %rax
movl (%rax), %esi
movq -0x10(%rbp), %rax
movl (%rax), %edx
leaq -0x50(%rbp), %rdi
callq 0x3860
cmpb $0x0, 0x6ef4(%rip)      # 0xa578
jne 0x36b8
leaq 0x6eeb(%rip), %rdi      # 0xa578
callq 0x22f0
cmpl $0x0, %eax
je 0x36b8
leaq 0x5b52(%rip), %rdi      # 0x91f0
leaq 0x5b2b(%rip), %rsi      # 0x91d0
callq 0x3890
jmp 0x36ac
leaq 0x6ec5(%rip), %rdi      # 0xa578
callq 0x2110
leaq -0x50(%rbp), %rdi
leaq 0x5b2d(%rip), %rsi      # 0x91f0
callq 0x38c0
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq 0x5ae7(%rip), %rdi      # 0x91c8
callq 0x2100
jmp 0x371a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq 0x5aed(%rip), %rdi      # 0x91e8
callq 0x2100
jmp 0x371a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq 0x6e63(%rip), %rdi      # 0xa578
callq 0x2100
movq -0x28(%rbp), %rdi
callq 0x22c0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Luthaf[P]zeopp/network.cc
// Function: toUpperCase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string toUpperCase(const std::string & s)
{
    std::string ret(s.size(), char());
    for(unsigned int i = 0; i < s.size(); ++i)
        ret[i] = (s[i] <= 'z' && s[i] >= 'a') ? s[i]-('a'-'A') : s[i];
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5360
movq %rax, -0x38(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x5900
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rcx
xorl %edx, %edx
callq 0xd060
jmp 0x683e
leaq -0x12(%rbp), %rdi
callq 0x55d0
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5360
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x6926
movq -0x10(%rbp), %rdi
movl -0x28(%rbp), %eax
movl %eax, %esi
callq 0x55f0
movsbl (%rax), %eax
cmpl $0x7a, %eax
jg 0x68b3
movq -0x10(%rbp), %rdi
movl -0x28(%rbp), %eax
movl %eax, %esi
callq 0x55f0
movsbl (%rax), %eax
cmpl $0x61, %eax
jl 0x68b3
movq -0x10(%rbp), %rdi
movl -0x28(%rbp), %eax
movl %eax, %esi
callq 0x55f0
movsbl (%rax), %eax
subl $0x20, %eax
movl %eax, -0x54(%rbp)
jmp 0x68c7
movq -0x10(%rbp), %rdi
movl -0x28(%rbp), %eax
movl %eax, %esi
callq 0x55f0
movsbl (%rax), %eax
movl %eax, -0x54(%rbp)
movq -0x40(%rbp), %rdi
movl -0x54(%rbp), %eax
movb %al, -0x61(%rbp)
movl -0x28(%rbp), %eax
movl %eax, %esi
callq 0x5a00
movq %rax, -0x60(%rbp)
jmp 0x68e1
movq -0x60(%rbp), %rax
movb -0x61(%rbp), %cl
movb %cl, (%rax)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x684e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x55d0
jmp 0x6943
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x5300
jmp 0x6943
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x6939
movq -0x40(%rbp), %rdi
callq 0x5300
movq -0x48(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x58f0
nopl (%rax)
// File: Luthaf[P]zeopp/network.cc
// Function: performVoronoiDecomp(bool, ATOM_NETWORK*, VORONOI_NETWORK*, std::vector<VOR_CELL, std::allocator<VOR_CELL>>*, bool, std::vector<BASIC_VCELL, std::allocator<BASIC_VCELL>>*)
bool performVoronoiDecomp(bool radial, ATOM_NETWORK *atmnet, VORONOI_NETWORK *vornet, vector<VOR_CELL> *cells, bool saveVorCells,
			   vector<BASIC_VCELL> *bvcells){

    container_periodic_poly *rad_con = NULL;
    container_periodic *no_rad_con = NULL;
    if (radial)
        rad_con = (container_periodic_poly *)performVoronoiDecomp(radial, atmnet, vornet, *cells, saveVorCells, *bvcells);
     else 
          no_rad_con = (container_periodic *)performVoronoiDecomp (radial, atmnet, vornet, *cells, saveVorCells, *bvcells); 

     delete rad_con;
     delete no_rad_con;
     return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %r8b, %al
andb $0x1, %dil
movb %dil, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq %r9, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
testb $0x1, -0x1(%rbp)
je 0x733e
movb -0x1(%rbp), %dil
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movb -0x21(%rbp), %al
movq -0x30(%rbp), %r9
andb $0x1, %dil
andb $0x1, %al
movzbl %dil, %edi
movzbl %al, %r8d
callq 0x6950
movq %rax, -0x38(%rbp)
jmp 0x736c
movb -0x1(%rbp), %dil
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movb -0x21(%rbp), %al
movq -0x30(%rbp), %r9
andb $0x1, %dil
andb $0x1, %al
movzbl %dil, %edi
movzbl %al, %r8d
callq 0x6950
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x7391
movq -0x48(%rbp), %rdi
callq 0xece0
movq -0x48(%rbp), %rdi
movl $0x298, %esi            # imm = 0x298
callq 0x5570
movq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x73b6
movq -0x50(%rbp), %rdi
callq 0xed10
movq -0x50(%rbp), %rdi
movl $0x270, %esi            # imm = 0x270
callq 0x5570
movb $0x1, %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
// File: Luthaf[P]zeopp/network.cc
// Function: viewVoronoiDecomp(ATOM_NETWORK*, double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void viewVoronoiDecomp(ATOM_NETWORK *atmnet, double r_probe, string filename){
  ATOM_NETWORK newAtomNet;
  atmnet->copy(&newAtomNet);
  for(int i = 0; i < newAtomNet.numAtoms; i++){ newAtomNet.atoms[i].radius += r_probe; }
  VORONOI_NETWORK vornet;
  vector<BASIC_VCELL> bvcells;
  vector<VOR_CELL> advCells;
  container_periodic_poly *new_rad_con = (container_periodic_poly *)performVoronoiDecomp(true, &newAtomNet, &vornet, advCells, true, bvcells);
  writeZeoVisFile((char *)filename.data(), &advCells, &newAtomNet, &vornet);
  delete new_rad_con;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x570, %rsp            # imm = 0x570
movq %rsi, -0x548(%rbp)
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x478(%rbp), %rdi
movq %rdi, -0x540(%rbp)
callq 0x95350
movq -0x540(%rbp), %rsi
movq -0x8(%rbp), %rdi
callq 0x96980
jmp 0x94a4
movl $0x0, -0x488(%rbp)
movl -0x488(%rbp), %eax
cmpl -0x368(%rbp), %eax
jge 0x951d
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x550(%rbp)
leaq -0x478(%rbp), %rdi
addq $0x2f0, %rdi            # imm = 0x2F0
movslq -0x488(%rbp), %rsi
callq 0xfcc0
movsd -0x550(%rbp), %xmm0
addsd 0x30(%rax), %xmm0
movsd %xmm0, 0x30(%rax)
movl -0x488(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x488(%rbp)
jmp 0x94ae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x480(%rbp)
movl %eax, -0x484(%rbp)
jmp 0x965d
leaq -0x500(%rbp), %rdi
callq 0x99ba0
jmp 0x952b
leaq -0x518(%rbp), %rdi
movq %rdi, -0x560(%rbp)
callq 0xfce0
leaq -0x530(%rbp), %rdi
movq %rdi, -0x568(%rbp)
callq 0xfd00
movq -0x568(%rbp), %rcx
movq -0x560(%rbp), %r9
leaq -0x478(%rbp), %rsi
leaq -0x500(%rbp), %rdx
movl $0x1, %r8d
movl %r8d, %edi
callq 0x6950
movq %rax, -0x558(%rbp)
jmp 0x9584
movq -0x548(%rbp), %rdi
movq -0x558(%rbp), %rax
movq %rax, -0x538(%rbp)
callq 0x52c0
movq %rax, %rdi
leaq -0x530(%rbp), %rsi
leaq -0x478(%rbp), %rdx
leaq -0x500(%rbp), %rcx
callq 0xbef10
jmp 0x95bd
movq -0x538(%rbp), %rax
movq %rax, -0x570(%rbp)
cmpq $0x0, %rax
je 0x95ee
movq -0x570(%rbp), %rdi
callq 0xece0
movq -0x570(%rbp), %rdi
movl $0x298, %esi            # imm = 0x298
callq 0x5570
leaq -0x530(%rbp), %rdi
callq 0xfd20
leaq -0x518(%rbp), %rdi
callq 0xfd80
leaq -0x500(%rbp), %rdi
callq 0xf8a0
leaq -0x478(%rbp), %rdi
callq 0xfde0
addq $0x570, %rsp            # imm = 0x570
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x480(%rbp)
movl %eax, -0x484(%rbp)
leaq -0x530(%rbp), %rdi
callq 0xfd20
leaq -0x518(%rbp), %rdi
callq 0xfd80
leaq -0x500(%rbp), %rdi
callq 0xf8a0
leaq -0x478(%rbp), %rdi
callq 0xfde0
movq -0x480(%rbp), %rdi
callq 0x58f0
nopw %cs:(%rax,%rax)
// File: Luthaf[P]zeopp/network.cc
// Function: loadRadii(ATOM_NETWORK*)
void loadRadii(ATOM_NETWORK *atmnet){
  vector <ATOM> ::iterator iter = atmnet->atoms.begin();
  while(iter != atmnet->atoms.end()){ 
    iter->radius = lookupRadius(iter->type, true);
    iter++;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x2f0, %rdi            # imm = 0x2F0
callq 0xd0f0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x2f0, %rdi            # imm = 0x2F0
callq 0xd160
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xd120
testb $0x1, %al
jne 0x96c7
jmp 0x9740
leaq -0x10(%rbp), %rdi
callq 0xd190
movq %rax, %rsi
addq $0x40, %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x5220
movq -0x60(%rbp), %rdi
movl $0x1, %esi
callq 0x466e0
movsd %xmm0, -0x58(%rbp)
jmp 0x96f9
leaq -0x10(%rbp), %rdi
callq 0xd190
movsd -0x58(%rbp), %xmm0
movsd %xmm0, 0x30(%rax)
leaq -0x38(%rbp), %rdi
callq 0x5300
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0xd220
movq %rax, -0x50(%rbp)
jmp 0x96a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5300
jmp 0x9746
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x58f0
nop