LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ivanzamanov[P]kmeans/src/kmeans/kmeans.cpp
// Function: recomputeCentroid(cluster&)
void recomputeCentroid(cluster& cl) {
	vector &centroid = cl.centroid;
	list<vector*> vectors;
	for(int i=0; i<cl.members.size();i++)
		vectors.add(&(cl.members.get(i)->v));

	centroid.size = 0;
	computeCentroid(centroid, vectors);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x27f0
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x50(%rsp), %rdi
addq $0x18, %rdi
callq 0x2850
movl %eax, 0x14(%rsp)
jmp 0x1cb1
movl 0x10(%rsp), %eax
movl 0x14(%rsp), %ecx
cmpl %ecx, %eax
jge 0x1d1e
movq 0x50(%rsp), %rdi
addq $0x18, %rdi
movl 0x34(%rsp), %esi
callq 0x2960
movq %rax, 0x8(%rsp)
jmp 0x1cd6
movq 0x8(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x18(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x2860
jmp 0x1cf5
jmp 0x1cf7
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x1c95
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x2980
jmp 0x1d49
movq 0x48(%rsp), %rax
movl $0x0, (%rax)
movq 0x48(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x1780
jmp 0x1d3a
leaq 0x38(%rsp), %rdi
callq 0x2980
addq $0x58, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x1130
nopw %cs:(%rax,%rax)
// File: ivanzamanov[P]kmeans/src/kmeans/kmeans.cpp
// Function: selectSeeds(cluster*, list<article_entry*>&, int)
void selectSeeds(cluster* clusters, entryList &l, int k) {
	int index = 0;
	for(int i=0; i<l.size(); i++) {
		index = i % k;
		cluster &cl = clusters[index];
		article_entry* e = l.get(i);
		cl.members.add(e);
	}
	printf("Computing centroids ");
	for(int i=0; i<k; i++) {
		printf("%d ", i);
		recomputeCentroid(clusters[i]);
	}
	printf("\n");
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movl $0x0, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, (%rsp)
movq 0x28(%rsp), %rdi
callq 0x2850
movl %eax, %ecx
movl (%rsp), %eax
cmpl %ecx, %eax
jge 0x1df2
movl 0x1c(%rsp), %eax
cltd
idivl 0x24(%rsp)
movl %edx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movslq 0x20(%rsp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x2960
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
leaq 0x8(%rsp), %rsi
callq 0x29b0
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x1d82
leaq 0x3227(%rip), %rdi      # 0x5020
movb $0x0, %al
callq 0x1040
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0x1e47
movl 0x4(%rsp), %esi
leaq 0x3218(%rip), %rdi      # 0x5035
movb $0x0, %al
callq 0x1040
movq 0x30(%rsp), %rdi
movslq 0x4(%rsp), %rax
imulq $0x28, %rax, %rax
addq %rax, %rdi
callq 0x1c70
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x1e08
leaq 0x3287(%rip), %rdi      # 0x50d5
movb $0x0, %al
callq 0x1040
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: ivanzamanov[P]kmeans/src/kmeans/kmeans.cpp
// Function: findBestCluster(cluster*, int, vector&)
cluster& findBestCluster(cluster* clusters, int k, vector& v) {
	int best_cl = 0;
	double best_dist = INFINITY;
	for(int i=0; i<k; i++) {
		double dist = distanceSQ(v, clusters[i].centroid);
		if(dist < best_dist) {
			best_dist = dist;
			best_cl = i;
		}
	}
	return clusters[best_cl];
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movsd 0x3186(%rip), %xmm0     # 0x5008
movsd %xmm0, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jge 0x1eed
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rsi
movslq 0xc(%rsp), %rax
imulq $0x28, %rax, %rax
addq %rax, %rsi
callq 0x14d0
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm1
movsd 0x10(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x1ede
movsd (%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x1c(%rsp)
jmp 0x1ee0
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1e90
movq 0x30(%rsp), %rax
movslq 0x1c(%rsp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ivanzamanov[P]kmeans/src/kmeans/kmeans.cpp
// Function: calculateRSS(cluster&)
double calculateRSS(cluster& c) {
	double result = 0;
	for (int i=0; i<c.members.size(); i++) {
		result += distanceSQ(c.centroid, c.members.get(i)->v);
	}
	return result;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
addq $0x18, %rdi
callq 0x2850
movl %eax, %ecx
movl 0x10(%rsp), %eax
cmpl %ecx, %eax
jge 0x1f90
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
addq $0x18, %rdi
movl 0x14(%rsp), %esi
callq 0x2960
movq 0x8(%rsp), %rdi
movq %rax, %rsi
addq $0x8, %rsi
callq 0x14d0
addsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x1f2a
movsd 0x18(%rsp), %xmm0
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: ivanzamanov[P]kmeans/src/kmeans/kmeans.cpp
// Function: printRSS(cluster*, int)
double printRSS(cluster* clusters, int n) {
	double result = 0;
	for(int i=0; i<n; i++) {
		double rss = calculateRSS(clusters[i]);
		printf("Cluster %d: RSS = %f Members = %d\n", i, rss, clusters[i].members.size());
		result += rss;
	}
	printf("Total RSS = %f\n", result);
	return result;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jge 0x2052
movq 0x30(%rsp), %rdi
movslq 0x1c(%rsp), %rax
imulq $0x28, %rax, %rax
addq %rax, %rdi
callq 0x1f10
movsd %xmm0, 0x10(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0x4(%rsp)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movslq 0x1c(%rsp), %rax
imulq $0x28, %rax, %rax
addq %rax, %rdi
addq $0x18, %rdi
callq 0x2850
movl 0x4(%rsp), %esi
movsd 0x8(%rsp), %xmm0
movl %eax, %edx
leaq 0x3010(%rip), %rdi      # 0x5039
movb $0x1, %al
callq 0x1040
movsd 0x10(%rsp), %xmm0
addsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x1fbe
movsd 0x20(%rsp), %xmm0
leaq 0x2ffd(%rip), %rdi      # 0x505c
movb $0x1, %al
callq 0x1040
movsd 0x20(%rsp), %xmm0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ivanzamanov[P]kmeans/src/kmeans/kmeans.cpp
// Function: normalize(article_entry*)
void normalize(article_entry* entry) {
	double factor = 0;
	for(int i=0; i<entry->v.size; i++) {
		double d = entry->v.values[i];
		factor += d * d;
	}
	factor = sqrt(factor);
	for (int i=0; i<entry->v.size; i++) {
		entry->v.values[i] = entry->v.values[i] / factor;
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x24ee
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0x14(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
movsd 0x8(%rsp), %xmm2
movsd 0x18(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x249a
movsd 0x18(%rsp), %xmm0
callq 0x1090
movsd %xmm0, 0x18(%rsp)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x254e
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0x4(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
divsd 0x18(%rsp), %xmm0
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0x4(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x2507
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ivanzamanov[P]kmeans/src/kmeans/kmeans.cpp
// Function: kmeans(list<article_entry*>&)
void kmeans(list<article_entry*> &l) {
	// Normalize vectors
	printf("Normalizing vectors\n");
	for(int i=0; i<l.size(); i++)
		normalize(l.get(i));
	clusterize(CLUSTERS, l);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
leaq 0x2b27(%rip), %rdi      # 0x5097
movb $0x0, %al
callq 0x1040
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2850
movl %eax, %ecx
movl 0x8(%rsp), %eax
cmpl %ecx, %eax
jge 0x25be
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x2960
movq %rax, %rdi
callq 0x2480
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x257f
movq 0x10(%rsp), %rsi
movl $0xa, %edi
callq 0x2080
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ivanzamanov[P]kmeans/src/kmeans/../common/list.h
// Function: list<iter*>::add(iter* const&)
void add(const T& el) {
		if(s == cap) {
			int new_c = cap << 1;
			T* new_arr = new T[new_c];
			for (int i=0; i<cap; i++)
				new_arr[i] = arr[i];
			delete arr;
			arr = new_arr;
			cap = new_c;
		}
		arr[s] = el;
		s++;
	}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movl (%rcx), %eax
cmpl 0x4(%rcx), %eax
jne 0x2760
movq 0x8(%rsp), %rax
movl 0x4(%rax), %eax
shll %eax
movl %eax, 0x24(%rsp)
movslq 0x24(%rsp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x1030
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x4(%rcx), %eax
jge 0x272f
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
movq 0x18(%rsp), %rax
movslq 0x14(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x26f4
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x274b
movq (%rsp), %rdi
callq 0x10b0
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl 0x24(%rsp), %ecx
movl %ecx, 0x4(%rax)
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
movq (%rcx), %rsi
movq 0x8(%rax), %rcx
movslq (%rax), %rdx
movq %rsi, (%rcx,%rdx,8)
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: ivanzamanov[P]kmeans/src/kmeans/../common/list.h
// Function: list<article_entry*>::clear()
void clear() {
		s = 0;
		cap = 2;
		delete arr;
		arr = new T[cap];
	}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movl $0x0, (%rax)
movl $0x2, 0x4(%rax)
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x2b38
movq 0x8(%rsp), %rdi
callq 0x10b0
movq (%rsp), %rax
movslq 0x4(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x1030
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: ivanzamanov[P]kmeans/src/kmeans/kmeans_main.cpp
// Function: save(list<article_entry*>&, hash<double>&, char const*)
void save(list<article_entry*> &entries, hash<double> &h, const char* name) {
	article_entry* entry = new article_entry;
	entries.add(entry);
	int size = h.size;
	entry->v.size = size;
	int* keys = new int[size];
	double* values = new double[size];
	for(int i=0; i<size; i++) {
		keys[i] = h.keys[i];
		values[i] = h.data[i];
	}
	int nameLength = strlen(name);
	char* entry_name = new char[nameLength + 1];
	for(int i=0; i<nameLength; i++)
		entry_name[i] = name[i];
	entry_name[nameLength] = 0;
	entry->name = entry_name;
	entry->v.keys = keys;
	entry->v.values = values;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movl $0x20, %edi
callq 0x10c0
movq %rax, %rdi
movq %rdi, (%rsp)
callq 0x3460
movq (%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x50(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x29b0
movq 0x48(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %ecx
movq 0x38(%rsp), %rax
movl %ecx, 0x8(%rax)
movslq 0x34(%rsp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x1030
movq %rax, 0x28(%rsp)
movslq 0x34(%rsp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x1030
movq %rax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x34(%rsp), %eax
jge 0x2d4e
movq 0x48(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x1c(%rsp), %rcx
movl (%rax,%rcx,4), %edx
movq 0x28(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x1c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x20(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x2cf7
movq 0x40(%rsp), %rdi
callq 0x1070
movl %eax, 0x18(%rsp)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdi
movq $-0x1, %rax
cmpq $0x0, %rdi
cmovlq %rax, %rdi
callq 0x1030
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x18(%rsp), %eax
jge 0x2db8
movq 0x40(%rsp), %rax
movslq 0xc(%rsp), %rcx
movb (%rax,%rcx), %dl
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x2d87
movq 0x10(%rsp), %rax
movslq 0x18(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x10(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, (%rax)
movq 0x28(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x20(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x18(%rax)
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ivanzamanov[P]kmeans/src/kmeans/kmeans_main.cpp
// Function: processFile(char const*, char const*, ptree<int>&, list<article_entry*>&)
void processFile(const char* path, const char* name, ptree<int>& p, list<article_entry*> &entries) {
	if(*name == '.')
		return;
	int fd = open(path, O_RDONLY);
	if(fd < 0) {
		printf("Cannot open file %s\nCode = %d\n", path, fd);
		return;
	}
	char* fullData = 0;
	readFullData(fd, &fullData);
	close(fd);

	char buffer[4096];
	int offset = 0;
	
	hash<double> h;
	int* index_ptr = 0;
	int index = 0;
	while(readToken(fullData, offset, buffer, 4096)) {
		if(strlen(buffer) <= 3)
			continue;
		index_ptr = p.get(buffer);
		if(index_ptr == 0) {
			p.add(buffer, tokenCount);
			index = tokenCount;
			tokenCount++;
		} else {
			index = *index_ptr;
		}

		int tf = h.get(index, 0);
		tf++;
		h.insert(index, tf);
	}

	save(entries, h, name);

	delete fullData;
}

// Assembly:
subq $0x1088, %rsp           # imm = 0x1088
movq %rdi, 0x1080(%rsp)
movq %rsi, 0x1078(%rsp)
movq %rdx, 0x1070(%rsp)
movq %rcx, 0x1068(%rsp)
movq 0x1078(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x2e3c
jmp 0x2fef
movq 0x1080(%rsp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x1080
movl %eax, 0x1064(%rsp)
cmpl $0x0, 0x1064(%rsp)
jge 0x2e80
movq 0x1080(%rsp), %rsi
movl 0x1064(%rsp), %edx
leaq 0x2244(%rip), %rdi      # 0x50b8
movb $0x0, %al
callq 0x1040
jmp 0x2fef
movq $0x0, 0x1058(%rsp)
movl 0x1064(%rsp), %edi
leaq 0x1058(%rsp), %rsi
callq 0x42d0
movl 0x1064(%rsp), %edi
callq 0x1140
movl $0x0, 0x4c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x3480
movq $0x0, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movq 0x1058(%rsp), %rdi
leaq 0x50(%rsp), %rdx
leaq 0x4c(%rsp), %rsi
movl $0x1000, %ecx           # imm = 0x1000
callq 0x4180
testb $0x1, %al
jne 0x2ef4
jmp 0x2fb8
leaq 0x50(%rsp), %rdi
callq 0x1070
cmpq $0x3, %rax
ja 0x2f06
jmp 0x2ecf
movq 0x1070(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x3550
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x2f58
movq 0x1070(%rsp), %rdi
leaq 0x50(%rsp), %rsi
movl 0x4190(%rip), %edx      # 0x70c8
callq 0x3640
movl 0x4185(%rip), %eax      # 0x70c8
movl %eax, 0x24(%rsp)
movl 0x417b(%rip), %eax      # 0x70c8
addl $0x1, %eax
movl %eax, 0x4172(%rip)      # 0x70c8
jmp 0x2f63
movq 0x28(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x24(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x24(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x3770
cvttsd2si (%rax), %eax
movl %eax, 0x20(%rsp)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
cvtsi2sdl 0x20(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x24(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x37e0
jmp 0x2ecf
movq 0x1068(%rsp), %rdi
movq 0x1078(%rsp), %rdx
leaq 0x30(%rsp), %rsi
callq 0x2c40
movq 0x1058(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x2fef
movq 0x8(%rsp), %rdi
callq 0x10b0
addq $0x1088, %rsp           # imm = 0x1088
retq
nopw (%rax,%rax)
// File: ivanzamanov[P]kmeans/src/kmeans/kmeans_main.cpp
// Function: main
int main(int argc, char** argv) {
	setbuf(stdout, NULL);
	if(argc < 2) {
		printf("Not enough arguments\n");
		printf("Usage: %s <input_dir> <output_file>", argv[0]);
		return 1;
	}

	const char* inputPath = argv[1];
	processDirectory(inputPath);
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
movl %edi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x3bd4(%rip), %rax      # 0x6fd0
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10e0
cmpl $0x2, 0x10(%rsp)
jge 0x343d
leaq 0x1cea(%rip), %rdi      # 0x5100
movb $0x0, %al
callq 0x1040
movq 0x8(%rsp), %rax
movq (%rax), %rsi
leaq 0x1cea(%rip), %rdi      # 0x5116
movb $0x0, %al
callq 0x1040
movl $0x1, 0x14(%rsp)
jmp 0x3453
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rdi
callq 0x3000
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: ivanzamanov[P]kmeans/src/kmeans/../common/hash.h
// Function: hash<double>::hash()
hash<T>::hash() {
  hash<T>& h = *this;
  h.cap = 2;
  h.size = 0;
  h.keys = new int[cap];
  for (int i=0; i<cap; i++) {
    h.keys[i] = -1;
  }
  h.data = new T[cap];
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rcx
movl $0x2, (%rcx)
movq 0x18(%rsp), %rcx
movl $0x0, 0x4(%rcx)
movslq (%rax), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x1030
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl (%rcx), %eax
jge 0x3516
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x14(%rsp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x34e7
movq 0x8(%rsp), %rax
movslq (%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x1030
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
addq $0x28, %rsp
retq
// File: ivanzamanov[P]kmeans/src/kmeans/../common/ptree.h
// Function: ptree<int>::get(char const*)
T* ptree<T>::get(const char* str) {
	const char* s = str;
	int state = 0;
	while(*s != '\0' && state >= 0) {
		int c = getIndex(*s);
		state = table[state][c];
		s++;
	}

	if(state == -1 || !flags[state])
		return 0;

	return values + state;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x18(%rsp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x7(%rsp)
je 0x3599
cmpl $0x0, 0x14(%rsp)
setge %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x35a3
jmp 0x35e8
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rax
movsbl (%rax), %esi
callq 0x3af0
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x10(%rsp)
movq (%rax), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x10(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x357a
cmpl $-0x1, 0x14(%rsp)
je 0x3603
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x14(%rsp), %rcx
testb $0x1, (%rax,%rcx)
jne 0x360e
movq $0x0, 0x30(%rsp)
jmp 0x3628
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x14(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ivanzamanov[P]kmeans/src/kmeans/../common/ptree.h
// Function: ptree<int>::add(char const*, int)
void ptree<T>::add(const char* str, T i) {
	const char* s = str;
	int state = 0;
	while(*s != '\0') {
		int c = getIndex(*s);
		int n_state = table[state][c];
		if(n_state == -1) {
			break;
		}
		state = n_state;
		s++;
	}

	while(*s != '\0') {
		int c = getIndex(*s);
		int n_state = buildState();
		table[state][c] = n_state;
		state = n_state;
		s++;
	}
	values[state] = i;
	flags[state] = 1;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movq 0x28(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x36d1
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rax
movsbl (%rax), %esi
callq 0x3af0
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x20(%rsp)
movq (%rax), %rax
movslq 0x24(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x20(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x1c(%rsp)
cmpl $-0x1, 0x1c(%rsp)
jne 0x36b9
jmp 0x36d1
movl 0x1c(%rsp), %eax
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x366e
jmp 0x36d3
movq 0x28(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x373b
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rax
movsbl (%rax), %esi
callq 0x3af0
movq 0x8(%rsp), %rdi
movl %eax, 0x18(%rsp)
callq 0x3b10
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x14(%rsp)
movl 0x14(%rsp), %edx
movq (%rax), %rax
movslq 0x24(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x18(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0x14(%rsp), %eax
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x36d3
movq 0x8(%rsp), %rax
movl 0x34(%rsp), %esi
movq 0x8(%rax), %rcx
movslq 0x24(%rsp), %rdx
movl %esi, (%rcx,%rdx,4)
movq 0x10(%rax), %rax
movslq 0x24(%rsp), %rcx
movb $0x1, (%rax,%rcx)
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ivanzamanov[P]kmeans/src/kmeans/../common/hash.h
// Function: hash<double>::get(int const&, double const&)
const T& hash<T>::get(const int& key, const T& def) {
  int index = bin_search(keys, size, key);
  if(index >= 0)
    return data[index];
  
  return def;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rax), %rdi
movl 0x4(%rax), %esi
movq 0x20(%rsp), %rdx
callq 0x3db0
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jl 0x37c5
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x14(%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x30(%rsp)
jmp 0x37cf
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: ivanzamanov[P]kmeans/src/kmeans/../common/hash.h
// Function: hash<double>::insert(int const&, double const&)
void hash<T>::insert(const int& key, const T& el) {
  int index = bin_search(keys, size, key);
  if(index >= 0) {
    this->data[index] = el;
  } else {
    if(size >= cap)
      expand();
    index = -index - 1;
    for (int i = size; i > index; i--) {
      keys[i] = keys[i-1];
      data[i] = data[i-1];
    }
    keys[index] = key;
    data[index] = el;
    size++;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rax), %rdi
movl 0x4(%rax), %esi
movq 0x18(%rsp), %rdx
callq 0x3db0
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jl 0x3838
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movsd (%rcx), %xmm0
movq 0x8(%rax), %rax
movslq 0xc(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0x38f4
movq (%rsp), %rcx
movl 0x4(%rcx), %eax
cmpl (%rcx), %eax
jl 0x384c
movq (%rsp), %rdi
callq 0x3e70
movq (%rsp), %rax
xorl %ecx, %ecx
subl 0xc(%rsp), %ecx
subl $0x1, %ecx
movl %ecx, 0xc(%rsp)
movl 0x4(%rax), %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jle 0x38bd
movq (%rsp), %rax
movq 0x10(%rax), %rcx
movl 0x8(%rsp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movl (%rcx,%rdx,4), %esi
movq 0x10(%rax), %rcx
movslq 0x8(%rsp), %rdx
movl %esi, (%rcx,%rdx,4)
movq 0x8(%rax), %rcx
movl 0x8(%rsp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x8(%rax), %rax
movslq 0x8(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x8(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x3864
movq (%rsp), %rax
movq 0x18(%rsp), %rcx
movl (%rcx), %esi
movq 0x10(%rax), %rcx
movslq 0xc(%rsp), %rdx
movl %esi, (%rcx,%rdx,4)
movq 0x10(%rsp), %rcx
movsd (%rcx), %xmm0
movq 0x8(%rax), %rcx
movslq 0xc(%rsp), %rdx
movsd %xmm0, (%rcx,%rdx,8)
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: ivanzamanov[P]kmeans/src/kmeans/../common/ptree.h
// Function: ptree<int>::ptree()
ptree<T>::ptree() {
	cap = 1;
	size = 1;
	table = new int*[cap];
	table[0] = new int[SIZE];
	for(int i=0; i<SIZE; i++)
		table[0][i] = -1;
	values = new T[cap];
	values[0] = -1;
	flags = new bool[cap];
	flags[0] = 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movl $0x1, 0x18(%rax)
movl $0x1, 0x1c(%rax)
movslq 0x18(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x1030
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movslq 0x376a(%rip), %rax      # 0x70c0
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x1030
movq %rax, %rcx
movq (%rsp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x372a(%rip), %eax      # 0x70c0
jge 0x39bb
movq (%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movslq 0xc(%rsp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x398c
movq (%rsp), %rax
movslq 0x18(%rax), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x1030
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rcx
movl $0xffffffff, (%rcx)     # imm = 0xFFFFFFFF
movslq 0x18(%rax), %rdi
movq $-0x1, %rax
cmpq $0x0, %rdi
cmovlq %rax, %rdi
callq 0x1030
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rax
movb $0x0, (%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: ivanzamanov[P]kmeans/src/kmeans/../common/ptree.h
// Function: ptree<int>::~ptree()
ptree<T>::~ptree() {
	for(int i=0; i<size; i++)
		delete table[i];
	delete table;
	delete values;
	delete flags;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x20(%rsp), %rcx
movl 0x2c(%rsp), %eax
cmpl 0x1c(%rcx), %eax
jge 0x3a8e
movq 0x20(%rsp), %rax
movq (%rax), %rax
movslq 0x2c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x3a7f
movq 0x18(%rsp), %rdi
callq 0x10b0
jmp 0x3a81
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x3a4b
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x3aab
movq 0x10(%rsp), %rdi
callq 0x10b0
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x3ac9
movq 0x8(%rsp), %rdi
callq 0x10b0
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x3ae5
movq (%rsp), %rdi
callq 0x10b0
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: ivanzamanov[P]kmeans/src/kmeans/../common/ptree.h
// Function: ptree<int>::buildState()
int ptree<T>::buildState() {
	if(size == cap)
		expand();
	if(size == 1423)
		size = size;

	int result = size;
	size++;
	table[result] = new int[SIZE];
	for(int i=0; i<SIZE; i++)
		table[result][i] = -1;
	return result;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
movl 0x1c(%rcx), %eax
cmpl 0x18(%rcx), %eax
jne 0x3b33
movq (%rsp), %rdi
callq 0x3be0
movq (%rsp), %rax
cmpl $0x58f, 0x1c(%rax)      # imm = 0x58F
jne 0x3b4a
movq (%rsp), %rax
movl 0x1c(%rax), %ecx
movl %ecx, 0x1c(%rax)
movq (%rsp), %rax
movl 0x1c(%rax), %ecx
movl %ecx, 0xc(%rsp)
movl 0x1c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1c(%rax)
movslq 0x355b(%rip), %rax      # 0x70c0
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x1030
movq %rax, %rdx
movq (%rsp), %rax
movq (%rax), %rax
movslq 0xc(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0x3515(%rip), %eax      # 0x70c0
jge 0x3bd6
movq (%rsp), %rax
movq (%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x8(%rsp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x3ba1
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: ivanzamanov[P]kmeans/src/kmeans/../common/ptree.h
// Function: ptree<int>::expand()
void ptree<T>::expand() {
	int new_cap = cap << 1;
	int** new_table = new int*[new_cap];
	T* new_values = new T[new_cap];
	bool* new_flags = new bool[new_cap];
	for(int i=0; i<cap; i++) {
		new_table[i] = table[i];
		new_values[i] = values[i];
		new_flags[i] = flags[i];
	}
	for(int i=cap; i<new_cap; i++) {
		new_table[i] = 0;
		new_flags[i] = 0;
	}

	delete table;
	delete values;
	delete flags;

	table = new_table;
	values = new_values;
	flags = new_flags;
	cap = new_cap;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0x18(%rax), %eax
shll %eax
movl %eax, 0x4c(%rsp)
movslq 0x4c(%rsp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x1030
movq %rax, 0x40(%rsp)
movslq 0x4c(%rsp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x1030
movq %rax, 0x38(%rsp)
movslq 0x4c(%rsp), %rdi
movq $-0x1, %rax
cmpq $0x0, %rdi
cmovlq %rax, %rdi
callq 0x1030
movq %rax, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x20(%rsp), %rcx
movl 0x2c(%rsp), %eax
cmpl 0x18(%rcx), %eax
jge 0x3ce7
movq 0x20(%rsp), %rax
movq (%rax), %rcx
movslq 0x2c(%rsp), %rdx
movq (%rcx,%rdx,8), %rsi
movq 0x40(%rsp), %rcx
movslq 0x2c(%rsp), %rdx
movq %rsi, (%rcx,%rdx,8)
movq 0x8(%rax), %rcx
movslq 0x2c(%rsp), %rdx
movl (%rcx,%rdx,4), %esi
movq 0x38(%rsp), %rcx
movslq 0x2c(%rsp), %rdx
movl %esi, (%rcx,%rdx,4)
movq 0x10(%rax), %rax
movslq 0x2c(%rsp), %rcx
movb (%rax,%rcx), %dl
movq 0x30(%rsp), %rax
movslq 0x2c(%rsp), %rcx
andb $0x1, %dl
movb %dl, (%rax,%rcx)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x3c78
movq 0x20(%rsp), %rax
movl 0x18(%rax), %eax
movl %eax, 0x28(%rsp)
movl 0x28(%rsp), %eax
cmpl 0x4c(%rsp), %eax
jge 0x3d2a
movq 0x40(%rsp), %rax
movslq 0x28(%rsp), %rcx
movq $0x0, (%rax,%rcx,8)
movq 0x30(%rsp), %rax
movslq 0x28(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x3cf3
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x3d47
movq 0x18(%rsp), %rdi
callq 0x10b0
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x3d65
movq 0x10(%rsp), %rdi
callq 0x10b0
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x3d83
movq 0x8(%rsp), %rdi
callq 0x10b0
movq 0x20(%rsp), %rax
movq 0x40(%rsp), %rcx
movq %rcx, (%rax)
movq 0x38(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x30(%rsp), %rcx
movq %rcx, 0x10(%rax)
movl 0x4c(%rsp), %ecx
movl %ecx, 0x18(%rax)
addq $0x58, %rsp
retq
nop
// File: ivanzamanov[P]kmeans/src/kmeans/../common/utils.h
// Function: int bin_search<int>(int*, int, int const&)
inline int bin_search(T* array, int n, const T& x) {
  int left = 0;
  int right = n;
  int current;
  while (left < right) {
    current = (left + right) / 2;
    if(array[current] == x) {
      return current;
    } else if (array[current] > x) {
      right = current;
    } else if (array[current] < x) {
      left = current + 1;
    }
  }
  return -(right + 1);
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movq %rdx, -0x20(%rsp)
movl $0x0, -0x24(%rsp)
movl -0x14(%rsp), %eax
movl %eax, -0x28(%rsp)
movl -0x24(%rsp), %eax
cmpl -0x28(%rsp), %eax
jge 0x3e56
movl -0x24(%rsp), %eax
addl -0x28(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x2c(%rsp)
movq -0x10(%rsp), %rax
movslq -0x2c(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x20(%rsp), %rcx
cmpl (%rcx), %eax
jne 0x3e0c
movl -0x2c(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0x3e65
movq -0x10(%rsp), %rax
movslq -0x2c(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x20(%rsp), %rcx
cmpl (%rcx), %eax
jle 0x3e2c
movl -0x2c(%rsp), %eax
movl %eax, -0x28(%rsp)
jmp 0x3e4f
movq -0x10(%rsp), %rax
movslq -0x2c(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x20(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x3e4d
movl -0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rsp)
jmp 0x3e4f
jmp 0x3e51
jmp 0x3dce
movl -0x28(%rsp), %ecx
addl $0x1, %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw (%rax,%rax)
// File: ivanzamanov[P]kmeans/src/kmeans/../common/hash.h
// Function: hash<double>::expand()
void hash<T>::expand() {
  hash<T>& table = *this;
  int new_c = table.cap + 1;
  expand_array(table.keys, table.cap, new_c);
  expand_array(table.data, table.cap, new_c);
  table.cap = new_c;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl (%rax), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movq 0x8(%rsp), %rax
movl (%rax), %esi
movl 0x4(%rsp), %edx
callq 0x3ee0
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
movq 0x8(%rsp), %rax
movl (%rax), %esi
movl 0x4(%rsp), %edx
callq 0x3f90
movl 0x4(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ivanzamanov[P]kmeans/src/kmeans/../common/utils.h
// Function: void expand_array<int>(int*&, int, int)
inline void expand_array(T*& array, const int n, const int new_n) {
  T* new_array = new T[new_n];
  for (int i=0; i<n; i++) {
    new_array[i] = array[i];
  }
  delete array;
  array = new_array;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movslq 0x18(%rsp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x1030
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x3f58
movq 0x20(%rsp), %rax
movq (%rax), %rax
movslq 0xc(%rsp), %rcx
movl (%rax,%rcx,4), %edx
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x3f24
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x3f73
movq (%rsp), %rdi
callq 0x10b0
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: iZhangHui[P]CppPrimer/CH17_SpecializedLibraryFacilities/examples/rand6.cc
// Function: bad_randVec()
vector<unsigned> bad_randVec()
{
	default_random_engine e;    
	uniform_int_distribution<unsigned> u(0,9);
	vector<unsigned> ret;
	for (size_t i = 0; i < 100; ++i)
    	ret.push_back(u(e));
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x1660
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x9, %edx
callq 0x1680
movq -0x48(%rbp), %rdi
movb $0x0, -0x19(%rbp)
callq 0x16b0
movq $0x0, -0x28(%rbp)
cmpq $0x64, -0x28(%rbp)
jae 0x131a
leaq -0x18(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x1700
movl %eax, -0x54(%rbp)
jmp 0x12de
movq -0x48(%rbp), %rdi
movl -0x54(%rbp), %eax
movl %eax, -0x2c(%rbp)
leaq -0x2c(%rbp), %rsi
callq 0x16d0
jmp 0x12f3
jmp 0x12f5
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x12c5
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x1730
jmp 0x1337
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x132d
movq -0x48(%rbp), %rdi
callq 0x1730
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x1120
// File: iZhangHui[P]CppPrimer/CH17_SpecializedLibraryFacilities/examples/rand6.cc
// Function: good_randVec()
vector<unsigned> good_randVec()
{
	// because engines and distributions retain state, they usually should be
	// defined as static so that new numbers are generated on each call
	static default_random_engine e;    
	static uniform_int_distribution<unsigned> u(0,9);
	vector<unsigned> ret;
	for (size_t i = 0; i < 100; ++i)
    	ret.push_back(u(e));
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
cmpb $0x0, 0x4d72(%rip)      # 0x60d0
jne 0x138b
leaq 0x4d69(%rip), %rdi      # 0x60d0
callq 0x1130
cmpl $0x0, %eax
je 0x138b
leaq 0x4d50(%rip), %rdi      # 0x60c8
callq 0x1660
jmp 0x137f
leaq 0x4d4a(%rip), %rdi      # 0x60d0
callq 0x1090
cmpb $0x0, 0x4d4e(%rip)      # 0x60e0
jne 0x13c6
leaq 0x4d45(%rip), %rdi      # 0x60e0
callq 0x1130
cmpl $0x0, %eax
je 0x13c6
leaq 0x4d2c(%rip), %rdi      # 0x60d8
xorl %esi, %esi
movl $0x9, %edx
callq 0x1680
jmp 0x13ba
leaq 0x4d1f(%rip), %rdi      # 0x60e0
callq 0x1090
movq -0x38(%rbp), %rdi
movb $0x0, -0x15(%rbp)
callq 0x16b0
movq $0x0, -0x20(%rbp)
cmpq $0x64, -0x20(%rbp)
jae 0x146e
leaq 0x4ceb(%rip), %rdi      # 0x60d8
leaq 0x4cd4(%rip), %rsi      # 0x60c8
callq 0x1700
movl %eax, -0x3c(%rbp)
jmp 0x13fe
movq -0x38(%rbp), %rdi
movl -0x3c(%rbp), %eax
movl %eax, -0x24(%rbp)
leaq -0x24(%rbp), %rsi
callq 0x16d0
jmp 0x1413
jmp 0x1415
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x13db
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq 0x4c9a(%rip), %rdi      # 0x60d0
callq 0x1080
jmp 0x148b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq 0x4c90(%rip), %rdi      # 0x60e0
callq 0x1080
jmp 0x148b
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x1730
jmp 0x148b
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x1481
movq -0x38(%rbp), %rdi
callq 0x1730
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x1120
nopw %cs:(%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH17_SpecializedLibraryFacilities/examples/rand6.cc
// Function: main
int main()
{
	vector<unsigned> v1(bad_randVec());
	vector<unsigned> v2(bad_randVec());

	// will print equal
	cout << ((v1 == v2) ? "equal" : "not equal") << endl;

	// very unlikely to print equal
	if (good_randVec() == good_randVec())
		cout << "equal!" << endl;
	else
		cout << "not equal" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x1280
leaq -0x38(%rbp), %rdi
callq 0x1280
jmp 0x14c6
leaq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1790
movb %al, -0x79(%rbp)
jmp 0x14d8
movb -0x79(%rbp), %cl
leaq 0x1b26(%rip), %rax      # 0x3008
leaq 0x1b1b(%rip), %rsi      # 0x3004
testb $0x1, %cl
cmovneq %rax, %rsi
movq 0x4ae1(%rip), %rdi      # 0x5fd8
callq 0x10c0
movq %rax, -0x88(%rbp)
jmp 0x1505
movq -0x88(%rbp), %rdi
movq 0x4ab5(%rip), %rsi      # 0x5fc8
callq 0x10f0
jmp 0x151a
leaq -0x60(%rbp), %rdi
callq 0x1340
jmp 0x1525
leaq -0x78(%rbp), %rdi
callq 0x1340
jmp 0x1530
leaq -0x60(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x1790
movb %al, -0x89(%rbp)
jmp 0x1545
leaq -0x78(%rbp), %rdi
callq 0x1730
leaq -0x60(%rbp), %rdi
callq 0x1730
movb -0x89(%rbp), %al
testb $0x1, %al
jne 0x1566
jmp 0x15e9
movq 0x4a6b(%rip), %rdi      # 0x5fd8
leaq 0x1a9a(%rip), %rsi      # 0x300e
callq 0x10c0
movq %rax, -0x98(%rbp)
jmp 0x1582
movq -0x98(%rbp), %rdi
movq 0x4a38(%rip), %rsi      # 0x5fc8
callq 0x10f0
jmp 0x1597
jmp 0x161c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1643
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x163a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x15de
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x1730
leaq -0x60(%rbp), %rdi
callq 0x1730
jmp 0x163a
movq 0x49e8(%rip), %rdi      # 0x5fd8
leaq 0x1a0d(%rip), %rsi      # 0x3004
callq 0x10c0
movq %rax, -0xa0(%rbp)
jmp 0x1605
movq -0xa0(%rbp), %rdi
movq 0x49b5(%rip), %rsi      # 0x5fc8
callq 0x10f0
jmp 0x161a
jmp 0x161c
leaq -0x38(%rbp), %rdi
callq 0x1730
leaq -0x20(%rbp), %rdi
callq 0x1730
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x1730
leaq -0x20(%rbp), %rdi
callq 0x1730
movq -0x40(%rbp), %rdi
callq 0x1120
nopw %cs:(%rax,%rax)
nop
// File: Juan313[P]RockPaperScissor/RPS.cpp
// Function: Rock::fight(Tool*)
int Rock::fight(Tool *comp)
{
	int result;
	//Checks the type used by the computer, adjusts strength
	//accordingly and then stores the difference between
	//player and computer strenght in result.
	if(comp->getType()=='p')
	{
		result = this->getStrength() - 2*comp->getStrength();
	}
	else if(comp->getType()=='s')
	{
                result = 2*this->getStrength() - comp->getStrength();
        }
	else
	{
		result = this->getStrength() - comp->getStrength();
	}
	
	//Checks the value stored in result and changes its value to 
	//1,2,or 3 if the player won, lost, or tied respectivey
	if(result<0)
	result = 2;
	else if(result>0)
	result = 1;
	else
	result = 3;

	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3210
movsbl %al, %eax
cmpl $0x70, %eax
jne 0x25fc
movq -0x20(%rbp), %rdi
callq 0x31f0
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31f0
movl %eax, %ecx
movl -0x24(%rbp), %eax
shll %ecx
subl %ecx, %eax
movl %eax, -0x14(%rbp)
jmp 0x2651
movq -0x10(%rbp), %rdi
callq 0x3210
movsbl %al, %eax
cmpl $0x73, %eax
jne 0x2630
movq -0x20(%rbp), %rdi
callq 0x31f0
shll %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31f0
movl %eax, %ecx
movl -0x28(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x14(%rbp)
jmp 0x264f
movq -0x20(%rbp), %rdi
callq 0x31f0
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31f0
movl %eax, %ecx
movl -0x2c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x14(%rbp)
jmp 0x2651
cmpl $0x0, -0x14(%rbp)
jge 0x2660
movl $0x2, -0x14(%rbp)
jmp 0x2678
cmpl $0x0, -0x14(%rbp)
jle 0x266f
movl $0x1, -0x14(%rbp)
jmp 0x2676
movl $0x3, -0x14(%rbp)
jmp 0x2678
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Juan313[P]RockPaperScissor/RPS.cpp
// Function: Paper::fight(Tool*)
int Paper::fight(Tool *comp)
{
    int result;
    //Checks the type used by the computer, adjusts strength
    //accordingly and then stores the difference between
    //player and computer strenght in result.
    if(comp->getType()=='s')
    {
        result = this->getStrength() - 2*comp->getStrength();
    }
    else if(comp->getType()=='r')
    {
        result = 2*this->getStrength() - comp->getStrength();
    }
    else
    {
        result = this->getStrength() - comp->getStrength();
    }
    
    //Checks the value stored in result and changes its value to
    //1,2,or 3 if the player won, lost, or tied respectivey
    if(result<0)
        result = 2;
    else if(result>0)
        result = 1;
    else
        result = 3;
    
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3210
movsbl %al, %eax
cmpl $0x73, %eax
jne 0x275c
movq -0x20(%rbp), %rdi
callq 0x31f0
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31f0
movl %eax, %ecx
movl -0x24(%rbp), %eax
shll %ecx
subl %ecx, %eax
movl %eax, -0x14(%rbp)
jmp 0x27b1
movq -0x10(%rbp), %rdi
callq 0x3210
movsbl %al, %eax
cmpl $0x72, %eax
jne 0x2790
movq -0x20(%rbp), %rdi
callq 0x31f0
shll %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31f0
movl %eax, %ecx
movl -0x28(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x14(%rbp)
jmp 0x27af
movq -0x20(%rbp), %rdi
callq 0x31f0
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31f0
movl %eax, %ecx
movl -0x2c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x14(%rbp)
jmp 0x27b1
cmpl $0x0, -0x14(%rbp)
jge 0x27c0
movl $0x2, -0x14(%rbp)
jmp 0x27d8
cmpl $0x0, -0x14(%rbp)
jle 0x27cf
movl $0x1, -0x14(%rbp)
jmp 0x27d6
movl $0x3, -0x14(%rbp)
jmp 0x27d8
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Juan313[P]RockPaperScissor/RPSGame.cpp
// Function: RPSGame::RPSGame(int, int, int, int, int, int)
RPSGame::RPSGame (int hr, int hp, int hs, int cr, int cp, int cs) {
    human_rock = new Rock(hr);
    human_paper = new Paper(hp);
    human_scissors = new Scissors(hs);
    computer_rock = new Rock(cr);
    computer_paper = new Paper(cp);
    computer_scissors = new Scissors(cs);
    computer_wins = 0;
    human_wins = 0;
    ties = 0;
    last_winner = 0;    // lets AI know its first round
    unsigned seed = time(0);    // seed srand
    srand(seed);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x10, %edi
callq 0x2180
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movl -0xc(%rbp), %esi
callq 0x2570
jmp 0x2b46
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movl $0x10, %edi
callq 0x2180
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movl -0x10(%rbp), %esi
callq 0x26d0
jmp 0x2b6f
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x10, %edi
callq 0x2180
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movl -0x14(%rbp), %esi
callq 0x2830
jmp 0x2b99
movq -0x40(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl $0x10, %edi
callq 0x2180
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movl -0x18(%rbp), %esi
callq 0x2570
jmp 0x2bc3
movq -0x40(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, 0x18(%rax)
movl $0x10, %edi
callq 0x2180
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movl -0x1c(%rbp), %esi
callq 0x26d0
jmp 0x2bed
movq -0x40(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, 0x20(%rax)
movl $0x10, %edi
callq 0x2180
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movl 0x10(%rbp), %esi
callq 0x2830
jmp 0x2c17
movq -0x40(%rbp), %rax
movq -0x68(%rbp), %rcx
movq %rcx, 0x28(%rax)
movl $0x0, 0x34(%rax)
movl $0x0, 0x30(%rax)
movl $0x0, 0x38(%rax)
movl $0x0, 0x40(%rax)
xorl %eax, %eax
movl %eax, %edi
callq 0x2150
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %edi
callq 0x2160
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x10, %esi
callq 0x2190
jmp 0x2d02
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x10, %esi
callq 0x2190
jmp 0x2d02
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x10, %esi
callq 0x2190
jmp 0x2d02
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x10, %esi
callq 0x2190
jmp 0x2d02
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x10, %esi
callq 0x2190
jmp 0x2d02
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x10, %esi
callq 0x2190
movq -0x28(%rbp), %rdi
callq 0x2270
nopl (%rax,%rax)
// File: Juan313[P]RockPaperScissor/RPSGame.cpp
// Function: RPSGame::~RPSGame()
RPSGame::~RPSGame() {
  delete human_rock;
  delete human_paper;
  delete human_scissors;
  delete computer_rock;
  delete computer_paper;
  delete computer_scissors;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x2d3b
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x2d57
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x2d73
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x2d8f
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x2dab
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x2dc7
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)