LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: auton1[P]motiflocation/motif.cpp
// Function: motif::getComplement(char)
char motif::getComplement(char base)
{
	switch (base)
	{
	case 'a': return 't';
	case 'c': return 'g';
	case 'g': return 'c';
	case 't': return 'a';
	case 'r': return 'y';
	case 'y': return 'r';
	case 'k': return 'm';
	case 'm': return 'k';
	case 's': return 's';
	case 'w': return 'w';
	case 'b': return 'v';
	case 'd': return 'h';
	case 'h': return 'd';
	case 'v': return 'b';
	case 'n': return 'n';
	case '1': return '1';
	case '2': return '2';
	case '3': return '3';
	case '4': return '4';
	case '5': return '5';
	case '6': return '6';
	case '7': return '7';
	case '8': return '8';
	case '9': return '9';
	default:
		cout << "Cannot find base complement of : " << base << endl;
		abort();
		return base;
	}
}

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x18(%rsp)
movb %al, 0x17(%rsp)
movsbl 0x17(%rsp), %eax
addl $-0x31, %eax
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
subl $0x48, %eax
ja 0xafac
movq 0x8(%rsp), %rax
leaq 0x66fc(%rip), %rcx      # 0x115d0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x74, 0x27(%rsp)
jmp 0xafe0
movb $0x67, 0x27(%rsp)
jmp 0xafe0
movb $0x63, 0x27(%rsp)
jmp 0xafe0
movb $0x61, 0x27(%rsp)
jmp 0xafe0
movb $0x79, 0x27(%rsp)
jmp 0xafe0
movb $0x72, 0x27(%rsp)
jmp 0xafe0
movb $0x6d, 0x27(%rsp)
jmp 0xafe0
movb $0x6b, 0x27(%rsp)
jmp 0xafe0
movb $0x73, 0x27(%rsp)
jmp 0xafe0
movb $0x77, 0x27(%rsp)
jmp 0xafe0
movb $0x76, 0x27(%rsp)
jmp 0xafe0
movb $0x68, 0x27(%rsp)
jmp 0xafe0
movb $0x64, 0x27(%rsp)
jmp 0xafe0
movb $0x62, 0x27(%rsp)
jmp 0xafe0
movb $0x6e, 0x27(%rsp)
jmp 0xafe0
movb $0x31, 0x27(%rsp)
jmp 0xafe0
movb $0x32, 0x27(%rsp)
jmp 0xafe0
movb $0x33, 0x27(%rsp)
jmp 0xafe0
movb $0x34, 0x27(%rsp)
jmp 0xafe0
movb $0x35, 0x27(%rsp)
jmp 0xafe0
movb $0x36, 0x27(%rsp)
jmp 0xafe0
movb $0x37, 0x27(%rsp)
jmp 0xafe0
movb $0x38, 0x27(%rsp)
jmp 0xafe0
movb $0x39, 0x27(%rsp)
jmp 0xafe0
movq 0xc025(%rip), %rdi      # 0x16fd8
leaq 0x67d6(%rip), %rsi      # 0x11790
callq 0x4320
movq %rax, %rdi
movsbl 0x17(%rsp), %esi
callq 0x43b0
movq %rax, %rdi
movq 0xbff2(%rip), %rsi      # 0x16fc8
callq 0x4360
callq 0x41c0
movb 0x27(%rsp), %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: auton1[P]motiflocation/DNA.cpp
// Function: DNA::DNA(char*)
DNA::DNA(char *seq)
{
	string seqstring = seq;
	std::transform (seqstring.begin(), seqstring.end(), seqstring.begin(), ToLower());
	Trim(seqstring);
	sequence.resize(1);
	sequence[0].append(seqstring);
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq 0xb0(%rsp), %rdi
movq %rdi, 0x28(%rsp)
leaq 0xaddd(%rip), %rax      # 0x16ad8
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, 0x18(%rsp)
callq 0x6480
movq 0x28(%rsp), %rdi
addq $0x20, %rdi
movq %rdi, 0x20(%rsp)
callq 0x6480
movq 0x28(%rsp), %rdi
addq $0x38, %rdi
movq %rdi, 0x30(%rsp)
callq 0xd730
movq 0xa8(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x87(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x4610
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdx
leaq 0x88(%rsp), %rdi
callq 0x6300
jmp 0xbd6a
leaq 0x87(%rsp), %rdi
callq 0x4380
leaq 0x88(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x42c0
movq 0x8(%rsp), %rdi
movq %rax, 0x68(%rsp)
callq 0x41f0
movq 0x8(%rsp), %rdi
movq %rax, 0x60(%rsp)
callq 0x42c0
movq %rax, 0x58(%rsp)
movq 0x68(%rsp), %rdi
movq 0x60(%rsp), %rsi
movq 0x58(%rsp), %rdx
callq 0xd740
movq %rax, 0x10(%rsp)
jmp 0xbdc7
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0x88(%rsp), %rsi
callq 0xbea0
jmp 0xbde5
movq 0x28(%rsp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0xd7c0
jmp 0xbdfa
movq 0x28(%rsp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6460
movq %rax, %rdi
leaq 0x88(%rsp), %rsi
callq 0x4680
jmp 0xbe1e
leaq 0x88(%rsp), %rdi
callq 0x4220
addq $0xb8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x87(%rsp), %rdi
callq 0x4380
jmp 0xbe6b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x4220
movq 0x30(%rsp), %rdi
callq 0xd860
movq 0x20(%rsp), %rdi
callq 0x6960
movq 0x18(%rsp), %rdi
callq 0x6960
movq 0x78(%rsp), %rdi
callq 0x4600
nopw %cs:(%rax,%rax)
// File: auton1[P]motiflocation/DNA.cpp
// Function: DNA::Trim(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void DNA::Trim(string &str)
{
		// trim leading whitespace
		string::size_type  notwhite = str.find_first_not_of(" \t\n\v\b\r\f\a\\\?\'\"\0");
		str.erase(0,notwhite);

		// trim trailing whitespace
		notwhite = str.find_last_not_of(" \t\n\v\b\r\f\a\\\?\'\"\0"); 
		str.erase(notwhite+1); 
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x5a2c(%rip), %rsi      # 0x118e6
xorl %eax, %eax
movl %eax, %edx
callq 0x41e0
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
movq (%rsp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x4090
movq 0x8(%rsp), %rdi
leaq 0x5a01(%rip), %rsi      # 0x118e6
movq $-0x1, %rdx
callq 0x4650
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
addq $0x1, %rsi
movq $-0x1, %rdx
callq 0x4090
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: auton1[P]motiflocation/DNA.cpp
// Function: DNA::remove_upper_or_lowercase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, bool, bool)
void DNA::remove_upper_or_lowercase(string &string1, bool uppercase_only, bool lowercase_only)
{
	if (uppercase_only == true)
	{
		size_t position = string1.find_first_of("acgt");
		while ( position != string::npos )
		{
			string1.replace( position, 1, "N" );
			position = string1.find_first_of("acgt", position + 1 );
		}
	}
	else if (lowercase_only == true)
	{
		size_t position = string1.find_first_of("ACGT");
		while ( position != string::npos )
		{
			string1.replace( position, 1, "N" );
			position = string1.find_first_of("ACGT", position + 1 );
		}
	}
}

// Assembly:
subq $0x28, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
andb $0x1, %cl
movb %cl, 0x17(%rsp)
andb $0x1, %al
movb %al, 0x16(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0xc98d
movq 0x18(%rsp), %rdi
leaq 0x4f87(%rip), %rsi      # 0x118c0
xorl %eax, %eax
movl %eax, %edx
callq 0x4190
movq %rax, 0x8(%rsp)
cmpq $-0x1, 0x8(%rsp)
je 0xc98b
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x1, %edx
leaq 0x4f60(%rip), %rcx      # 0x118c5
callq 0x4210
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rdx
addq $0x1, %rdx
leaq 0x4f41(%rip), %rsi      # 0x118c0
callq 0x4190
movq %rax, 0x8(%rsp)
jmp 0xc947
jmp 0xc9f8
movb 0x16(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0xc9f6
movq 0x18(%rsp), %rdi
leaq 0x4f20(%rip), %rsi      # 0x118c7
xorl %eax, %eax
movl %eax, %edx
callq 0x4190
movq %rax, (%rsp)
cmpq $-0x1, (%rsp)
je 0xc9f4
movq 0x18(%rsp), %rdi
movq (%rsp), %rsi
movl $0x1, %edx
leaq 0x4ef5(%rip), %rcx      # 0x118c5
callq 0x4210
movq 0x18(%rsp), %rdi
movq (%rsp), %rdx
addq $0x1, %rdx
leaq 0x4ede(%rip), %rsi      # 0x118c7
callq 0x4190
movq %rax, (%rsp)
jmp 0xc9b4
jmp 0xc9f6
jmp 0xc9f8
addq $0x28, %rsp
retq
nopl (%rax)
// File: auton1[P]motiflocation/DNA.cpp
// Function: DNA::CountMotifOccurances(motif&)
int DNA::CountMotifOccurances(motif &Motif)
{
	int i;
	int count = 0;
	bool match;

	for (i=NSeqs; i--;)
	{
		match = Motif.IsMotifInSequence(sequence[i].c_str(), Motif.sequence.c_str(), 0);
		if (match)
		{
			// have found motif so we're done
			count++;
		}
		else
		{
			// we didn't find the motif, so we need to test the complement
			match = Motif.IsMotifInSequence(sequence[i].c_str(), Motif.complement.c_str() ,0 );
			if (match)
			{
				count++;
			}
		}
	}
	return count;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x30(%rsp)
movl 0x50(%rax), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, 0x34(%rsp)
cmpl $0x0, %eax
je 0xd71c
movq 0x20(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x8, %rdi
movslq 0x34(%rsp), %rsi
callq 0x6460
movq %rax, %rdi
callq 0x4140
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
addq $0x8, %rdi
callq 0x4140
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0xaff0
andb $0x1, %al
movb %al, 0x2f(%rsp)
testb $0x1, 0x2f(%rsp)
je 0xd6b3
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0xd717
movq 0x20(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
addq $0x8, %rdi
movslq 0x34(%rsp), %rsi
callq 0x6460
movq %rax, %rdi
callq 0x4140
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
addq $0x28, %rdi
callq 0x4140
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0xaff0
andb $0x1, %al
movb %al, 0x2f(%rsp)
testb $0x1, 0x2f(%rsp)
je 0xd715
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0xd717
jmp 0xd637
movl 0x30(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: auton1[P]motiflocation/random.cpp
// Function: ran2(double, double)
double ran2(double min, double max)
{
	double r = ran2();
	r *= (max - min);
	r += min;
	return r;
}

// Assembly:
subq $0x18, %rsp
movsd %xmm0, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
callq 0xf090
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
subsd 0x10(%rsp), %xmm0
mulsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x10(%rsp), %xmm0
addsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: auton1[P]motiflocation/random.cpp
// Function: ran2(int, int)
int ran2(int min, int max)
{
	double r = ran2();
	r *= (double)(max - min);
	r += min;
	return (int)r;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl %esi, 0x10(%rsp)
callq 0xf090
movsd %xmm0, 0x8(%rsp)
movl 0x10(%rsp), %eax
subl 0x14(%rsp), %eax
cvtsi2sd %eax, %xmm0
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
cvtsi2sdl 0x14(%rsp), %xmm0
addsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
cvttsd2si 0x8(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: auton1[P]motiflocation/random.cpp
// Function: gammln(double)
double gammln(double xx)
{
	double x,y,tmp,ser;
	static double cof[6]={76.18009172947146,-86.50532032941677,
	24.01409824083091,-1.231739572450155,
	0.1208650973866179e-2,-0.5395239384953e-5};
	int j;
	y=x=xx;
	tmp=x+5.5;
	tmp -= (x+0.5)*log(tmp);
	ser=1.000000000190015;
	for (j=0;j<=5;j++) ser += cof[j]/++y;
	return -tmp+log(2.5066282746310005*ser/x);
}

// Assembly:
subq $0x48, %rsp
movsd %xmm0, 0x40(%rsp)
movsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x38(%rsp)
movsd %xmm0, 0x30(%rsp)
movsd 0x24c4(%rip), %xmm0     # 0x11928
addsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x24a8(%rip), %xmm0     # 0x11920
addsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x28(%rsp), %xmm0
callq 0x4290
movaps %xmm0, %xmm2
movsd 0x10(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x244d(%rip), %xmm0     # 0x11918
movsd %xmm0, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
cmpl $0x5, 0x1c(%rsp)
jg 0xf522
movslq 0x1c(%rsp), %rcx
leaq 0x7eb4(%rip), %rax      # 0x173a0
movsd (%rax,%rcx,8), %xmm0
movsd 0x223f(%rip), %xmm1     # 0x11738
addsd 0x30(%rsp), %xmm1
movsd %xmm1, 0x30(%rsp)
divsd %xmm1, %xmm0
addsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0xf4d9
movsd 0x28(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x23e3(%rip), %xmm0     # 0x11930
mulsd 0x20(%rsp), %xmm0
divsd 0x38(%rsp), %xmm0
callq 0x4290
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
addsd %xmm1, %xmm0
addq $0x48, %rsp
retq
// File: auton1[P]motiflocation/random.cpp
// Function: normrnd()
double normrnd(void)
{
	extern long *idum;
	static int iset=0;
	static double gset;
	double fac, r, v1, v2;

	if (iset == 0)
	{
		do
		{
			v1 = 2.0 * ran2() - 1.0;
			v2 = 2.0 * ran2() - 1.0;
			r = v1 * v1 + v2 * v2;
		} while (r >= 1.0);
		
		fac = sqrt(-2.0*log(r) / r);
		gset = v1 * fac;
		iset = 1;
		return v2*fac;
	} 
	else
	{
		iset = 0;
		return gset;
	}
}

// Assembly:
subq $0x28, %rsp
cmpl $0x0, 0x7fa5(%rip)      # 0x17520
jne 0xf64c
jmp 0xf583
callq 0xf090
addsd %xmm0, %xmm0
movsd 0x23a4(%rip), %xmm1     # 0x11938
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0xf090
addsd %xmm0, %xmm0
movsd 0x2389(%rip), %xmm1     # 0x11938
addsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
movsd 0x8(%rsp), %xmm2
movsd (%rsp), %xmm1
mulsd (%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
movsd 0x214e(%rip), %xmm1     # 0x11738
ucomisd %xmm1, %xmm0
jae 0xf583
movsd 0x10(%rsp), %xmm0
callq 0x4290
movaps %xmm0, %xmm1
movsd 0x233a(%rip), %xmm0     # 0x11940
mulsd %xmm1, %xmm0
divsd 0x10(%rsp), %xmm0
callq 0x4270
movsd %xmm0, 0x18(%rsp)
movsd 0x8(%rsp), %xmm0
mulsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x7ef9(%rip)     # 0x17528
movl $0x1, 0x7ee7(%rip)      # 0x17520
movsd (%rsp), %xmm0
mulsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
jmp 0xf664
movl $0x0, 0x7eca(%rip)      # 0x17520
movsd 0x7eca(%rip), %xmm0     # 0x17528
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
addq $0x28, %rsp
retq
nop
// File: roberty65[P]bServer/frame/testServer/src/mtServer.cpp
// Function: main
int main(int argc, char **argv)
{
	if (argc < 2) {
		fprintf(stderr, "Usage: %s host\n", argv[0]);
		exit(1);
	}
	
	const char *host = argv[1];
	int cfd, fd = beyondy::XbsServer(host, 1024);

	if (fd < 0) {
		fprintf(stderr, "listen at %s failed: %m\n", host);
		exit(2);
	}

	while (true) {
		if ((cfd = ::accept(fd, NULL, NULL)) < 0)
			continue;
		pthread_t tid;
		errno = pthread_create(&tid, NULL, worker, (void *)(long)cfd);
		if (errno) {
			fprintf(stderr, "pthread-create failed: %m\n");
			close(cfd);
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0x1375
movq 0x3c8d(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0x1ca0(%rip), %rsi      # 0x3004
movb $0x0, %al
callq 0x11a0
movl $0x1, %edi
callq 0x1160
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %edx, %edx
movl $0x3, %ecx
callq 0x1c80
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jge 0x13c5
movq 0x3c3a(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0x1c60(%rip), %rsi      # 0x3014
movb $0x0, %al
callq 0x11a0
movl $0x2, %edi
callq 0x1160
jmp 0x13c7
movl -0x20(%rbp), %edi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x1060
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jge 0x13e0
jmp 0x13c7
movslq -0x1c(%rbp), %rcx
leaq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0x4d(%rip), %rdx        # 0x1440
callq 0x1200
movl %eax, -0x2c(%rbp)
callq 0x1030
movl -0x2c(%rbp), %ecx
movl %ecx, (%rax)
callq 0x1030
cmpl $0x0, (%rax)
je 0x142f
movq 0x3bca(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
leaq 0x1c0d(%rip), %rsi      # 0x302d
movb $0x0, %al
callq 0x11a0
movl -0x1c(%rbp), %edi
callq 0x1220
jmp 0x13c7
nopw %cs:(%rax,%rax)
// File: roberty65[P]bServer/frame/testServer/src/mtServer.cpp
// Function: worker(void*)
static void *worker(void *p)
{
	int fd = (int)(long)p;
	char buf[8192];

	while (true) {
		ssize_t rlen = ::read(fd, buf, sizeof buf);
		if (rlen < 0) {
			if (errno == EAGAIN) continue;
			fprintf(stderr, "socket %d read failed: %m\n", fd);
			break;
		}
		else if (rlen == 0) {
			fprintf(stderr, "socket %d is closed by peer\n", fd);
			break;
		}	

		ssize_t wlen = ::write(fd, buf, rlen);
		if (wlen != rlen) {
			fprintf(stderr, "socket %d write failed: %m\n", fd);
			break;
		}
	}

	close(fd);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2020, %rsp           # imm = 0x2020
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
leaq -0x2010(%rbp), %rsi
movl $0x2000, %edx           # imm = 0x2000
callq 0x11b0
movq %rax, -0x2018(%rbp)
cmpq $0x0, -0x2018(%rbp)
jge 0x14a4
callq 0x1030
cmpl $0xb, (%rax)
jne 0x1487
jmp 0x1456
movq 0x3b52(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
movl -0xc(%rbp), %edx
leaq 0x1bad(%rip), %rsi      # 0x3048
movb $0x0, %al
callq 0x11a0
jmp 0x151c
cmpq $0x0, -0x2018(%rbp)
jne 0x14cb
movq 0x3b2b(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
movl -0xc(%rbp), %edx
leaq 0x1ba1(%rip), %rsi      # 0x3063
movb $0x0, %al
callq 0x11a0
jmp 0x151c
jmp 0x14cd
movl -0xc(%rbp), %edi
leaq -0x2010(%rbp), %rsi
movq -0x2018(%rbp), %rdx
callq 0x1070
movq %rax, -0x2020(%rbp)
movq -0x2020(%rbp), %rax
cmpq -0x2018(%rbp), %rax
je 0x1517
movq 0x3adf(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
movl -0xc(%rbp), %edx
leaq 0x1b72(%rip), %rsi      # 0x3080
movb $0x0, %al
callq 0x11a0
jmp 0x151c
jmp 0x1456
movl -0xc(%rbp), %edi
callq 0x1220
xorl %eax, %eax
addq $0x2020, %rsp           # imm = 0x2020
popq %rbp
retq
nop
// File: tap3edit[P]tap3xml/tap3xml.cpp
// Function: help()
void help()
{
    cerr << "Copyright (C) 2005-2018 Javier Gutierrez <https://github.com/tap3edit>\n";
    cerr << "Usage: tap3xml -x|-a inputfile [outputfile]\n";
    cerr << "  -x: ASN -> XML\n";
    cerr << "  -a: XML -> ASN\n";
    exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x2af4d(%rip), %rdi     # 0x31fe8
leaq 0x1e120(%rip), %rsi     # 0x251c2
callq 0x4340
movq 0x2af3a(%rip), %rdi     # 0x31fe8
leaq 0x1e155(%rip), %rsi     # 0x2520a
callq 0x4340
movq 0x2af27(%rip), %rdi     # 0x31fe8
leaq 0x1e16f(%rip), %rsi     # 0x25237
callq 0x4340
movq 0x2af14(%rip), %rdi     # 0x31fe8
leaq 0x1e16e(%rip), %rsi     # 0x25249
callq 0x4340
movl $0x1, %edi
callq 0x4470
nopw (%rax,%rax)
// File: tap3edit[P]tap3xml/tap3xml.cpp
// Function: get_specfilename[abi:cxx11](TapInfo*)
string get_specfilename(TapInfo *tapinfo)
{
    ostringstream    spec_filename;

    spec_filename << tapinfo->type();
    spec_filename << setw(2) << setfill('0') << tapinfo->version();
    spec_filename << setw(2) << setfill('0') << tapinfo->release();
    spec_filename << ".asn";

    return get_specdir(spec_filename.str());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movq %rdi, -0x1f8(%rbp)
movq %rdi, %rax
movq %rax, -0x1f0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x4540
movq -0x10(%rbp), %rsi
leaq -0x1a8(%rbp), %rdi
callq 0xb260
jmp 0x7132
leaq -0x188(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
callq 0x42e0
jmp 0x7147
leaq -0x1a8(%rbp), %rdi
callq 0x41e0
movl $0x2, %edi
callq 0x7e30
movl %eax, -0x1fc(%rbp)
jmp 0x7165
movl -0x1fc(%rbp), %eax
movl %eax, -0x1b8(%rbp)
movl -0x1b8(%rbp), %esi
leaq -0x188(%rbp), %rdi
callq 0x4410
movq %rax, -0x208(%rbp)
jmp 0x718c
movl $0x30, %edi
callq 0x7e50
movb %al, -0x209(%rbp)
jmp 0x719e
movq -0x208(%rbp), %rdi
movb -0x209(%rbp), %al
movb %al, -0x1b9(%rbp)
movzbl -0x1b9(%rbp), %esi
callq 0x4620
movq %rax, -0x218(%rbp)
jmp 0x71c6
movq -0x10(%rbp), %rdi
callq 0xb1e0
movl %eax, -0x21c(%rbp)
jmp 0x71d7
movl -0x21c(%rbp), %esi
movq -0x218(%rbp), %rdi
callq 0x46a0
jmp 0x71eb
movl $0x2, %edi
callq 0x7e30
movl %eax, -0x220(%rbp)
jmp 0x71fd
movl -0x220(%rbp), %eax
movl %eax, -0x1c0(%rbp)
movl -0x1c0(%rbp), %esi
leaq -0x188(%rbp), %rdi
callq 0x4410
movq %rax, -0x228(%rbp)
jmp 0x7224
movl $0x30, %edi
callq 0x7e50
movb %al, -0x229(%rbp)
jmp 0x7236
movq -0x228(%rbp), %rdi
movb -0x229(%rbp), %al
movb %al, -0x1c1(%rbp)
movzbl -0x1c1(%rbp), %esi
callq 0x4620
movq %rax, -0x238(%rbp)
jmp 0x725e
movq -0x10(%rbp), %rdi
callq 0xb200
movl %eax, -0x23c(%rbp)
jmp 0x726f
movl -0x23c(%rbp), %esi
movq -0x238(%rbp), %rdi
callq 0x46a0
jmp 0x7283
leaq 0x1ddef(%rip), %rsi     # 0x25079
leaq -0x188(%rbp), %rdi
callq 0x4340
jmp 0x7298
leaq -0x1e8(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x4380
jmp 0x72ad
movq -0x1f8(%rbp), %rdi
leaq -0x1e8(%rbp), %rsi
callq 0x7590
jmp 0x72c2
leaq -0x1e8(%rbp), %rdi
callq 0x41e0
leaq -0x188(%rbp), %rdi
callq 0x40c0
movq -0x1f0(%rbp), %rax
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
jmp 0x733c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
leaq -0x1a8(%rbp), %rdi
callq 0x41e0
jmp 0x733c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
leaq -0x1e8(%rbp), %rdi
callq 0x41e0
leaq -0x188(%rbp), %rdi
callq 0x40c0
movq -0x1b0(%rbp), %rdi
callq 0x46d0
nopw %cs:(%rax,%rax)
// File: tap3edit[P]tap3xml/tap3xml.cpp
// Function: get_specsuplfilename[abi:cxx11](TapInfo*)
string get_specsuplfilename (TapInfo *tapinfo)
{
    ostringstream    spec_filename;

    spec_filename << "TAP";
    spec_filename << setw(2) << setfill('0') << tapinfo->suplversion();
    spec_filename << setw(2) << setfill('0') << tapinfo->suplrelease();
    spec_filename << ".asn";

    return get_specdir(spec_filename.str());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movq %rdi, -0x1e0(%rbp)
movq %rdi, %rax
movq %rax, -0x1d8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1d0(%rbp)
callq 0x4540
movq -0x1d0(%rbp), %rdi
leaq 0x1de06(%rip), %rsi     # 0x251ab
callq 0x4340
jmp 0x73ac
movl $0x2, %edi
callq 0x7e30
movl %eax, -0x1e4(%rbp)
jmp 0x73be
movl -0x1e4(%rbp), %eax
movl %eax, -0x198(%rbp)
movl -0x198(%rbp), %esi
leaq -0x188(%rbp), %rdi
callq 0x4410
movq %rax, -0x1f0(%rbp)
jmp 0x73e5
movl $0x30, %edi
callq 0x7e50
movb %al, -0x1f1(%rbp)
jmp 0x73f7
movq -0x1f0(%rbp), %rdi
movb -0x1f1(%rbp), %al
movb %al, -0x199(%rbp)
movzbl -0x199(%rbp), %esi
callq 0x4620
movq %rax, -0x200(%rbp)
jmp 0x741f
movq -0x10(%rbp), %rdi
callq 0xb240
movl %eax, -0x204(%rbp)
jmp 0x7430
movl -0x204(%rbp), %esi
movq -0x200(%rbp), %rdi
callq 0x46a0
jmp 0x7444
movl $0x2, %edi
callq 0x7e30
movl %eax, -0x208(%rbp)
jmp 0x7456
movl -0x208(%rbp), %eax
movl %eax, -0x1a0(%rbp)
movl -0x1a0(%rbp), %esi
leaq -0x188(%rbp), %rdi
callq 0x4410
movq %rax, -0x210(%rbp)
jmp 0x747d
movl $0x30, %edi
callq 0x7e50
movb %al, -0x211(%rbp)
jmp 0x748f
movq -0x210(%rbp), %rdi
movb -0x211(%rbp), %al
movb %al, -0x1a1(%rbp)
movzbl -0x1a1(%rbp), %esi
callq 0x4620
movq %rax, -0x220(%rbp)
jmp 0x74b7
movq -0x10(%rbp), %rdi
callq 0xb220
movl %eax, -0x224(%rbp)
jmp 0x74c8
movl -0x224(%rbp), %esi
movq -0x220(%rbp), %rdi
callq 0x46a0
jmp 0x74dc
leaq 0x1db96(%rip), %rsi     # 0x25079
leaq -0x188(%rbp), %rdi
callq 0x4340
jmp 0x74f1
leaq -0x1c8(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x4380
jmp 0x7506
movq -0x1e0(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x7590
jmp 0x751b
leaq -0x1c8(%rbp), %rdi
callq 0x41e0
leaq -0x188(%rbp), %rdi
callq 0x40c0
movq -0x1d8(%rbp), %rax
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0x7575
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x41e0
leaq -0x188(%rbp), %rdi
callq 0x40c0
movq -0x190(%rbp), %rdi
callq 0x46d0
nopl (%rax)
// File: tap3edit[P]tap3xml/TapInfo.cpp
// Function: TapInfo::TapInfo()
TapInfo::TapInfo() 
{
    _version=-1;
    _release=-1;
    _suplversion=-1;
    _suplrelease=-1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x18, %rdi
callq 0x4570
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, 0xc(%rax)  # imm = 0xFFFFFFFF
movl $0xffffffff, 0x14(%rax) # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: tap3edit[P]tap3xml/TapInfo.cpp
// Function: TapInfo::tree(treenode*)
void TapInfo::tree(treenode *tree)
{
    int i;

    _version=_release=_suplversion=_suplrelease=-1;
    _type="ERR";
    _findtreeversion(tree, 0);

    if (_type=="RAP")
    {
        i=_version;
        _version=_suplversion;
        _suplversion=i;

        i=_release;
        _release=_suplrelease;
        _suplrelease=i;

        if ( _suplversion < 0 )
            _suplversion=3;

        if ( _suplrelease < 0 )
            _suplrelease=1;

    }

    if (_type=="ACK" )
    {
        _version=1;
        _release=1;
        _suplversion=3;
        _suplrelease=1;
        _type="RAP";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl $0xffffffff, 0x14(%rdi) # imm = 0xFFFFFFFF
movl $0xffffffff, 0xc(%rdi)  # imm = 0xFFFFFFFF
movl $0xffffffff, 0x10(%rdi) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x8(%rdi)  # imm = 0xFFFFFFFF
addq $0x18, %rdi
leaq 0x1a06d(%rip), %rsi     # 0x2517c
callq 0x4560
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0xab50
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
leaq 0x1a075(%rip), %rsi     # 0x251a7
callq 0x7d30
testb $0x1, %al
jne 0xb13d
jmp 0xb18d
movq -0x20(%rbp), %rax
movl 0x8(%rax), %ecx
movl %ecx, -0x14(%rbp)
movl 0xc(%rax), %ecx
movl %ecx, 0x8(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0xc(%rax)
movl 0x10(%rax), %ecx
movl %ecx, -0x14(%rbp)
movl 0x14(%rax), %ecx
movl %ecx, 0x10(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x14(%rax)
cmpl $0x0, 0xc(%rax)
jge 0xb176
movq -0x20(%rbp), %rax
movl $0x3, 0xc(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x14(%rax)
jge 0xb18b
movq -0x20(%rbp), %rax
movl $0x1, 0x14(%rax)
jmp 0xb18d
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
leaq 0x1a11a(%rip), %rsi     # 0x252b6
callq 0x7d30
testb $0x1, %al
jne 0xb1a7
jmp 0xb1d7
movq -0x20(%rbp), %rdi
movl $0x1, 0x8(%rdi)
movl $0x1, 0x10(%rdi)
movl $0x3, 0xc(%rdi)
movl $0x1, 0x14(%rdi)
addq $0x18, %rdi
leaq 0x19fd5(%rip), %rsi     # 0x251a7
callq 0x4560
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: wellenvogel[P]simple-cpp-threads/test.cpp
// Function: MyRunnable::run()
virtual void run() {
        {
            Synchronized x(mmutex);
            currentState=RUNNING;
        }
        cout << "Thread "<<id<<" started" << endl;
        while(true){
            {
                Synchronized x(mmutex);
                if (requestedState==STOP){
                    currentState=STOP;
                    cout << "stopping thread "<<id<<endl;
                    return;
                }
                condition->wait(x,1000);
            }
            cout << "hello thread " <<id<< endl;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x40(%rbp)
addq $0x8, %rsi
leaq -0x18(%rbp), %rdi
callq 0x31b0
movq -0x40(%rbp), %rax
movl $0x1, 0x3c(%rax)
leaq -0x18(%rbp), %rdi
callq 0x31f0
movq 0x4fac(%rip), %rdi      # 0x7fd8
leaq 0x204d(%rip), %rsi      # 0x5080
callq 0x2100
movq %rax, %rdi
movq -0x40(%rbp), %rax
movl 0x40(%rax), %esi
callq 0x21a0
movq %rax, %rdi
leaq 0x2037(%rip), %rsi      # 0x5088
callq 0x2100
movq %rax, %rdi
movq 0x4f60(%rip), %rsi      # 0x7fc0
callq 0x2120
movq -0x40(%rbp), %rsi
addq $0x8, %rsi
leaq -0x28(%rbp), %rdi
callq 0x31b0
movq -0x40(%rbp), %rax
cmpl $0x2, 0x38(%rax)
jne 0x30ec
movq -0x40(%rbp), %rax
movl $0x2, 0x3c(%rax)
movq 0x4f46(%rip), %rdi      # 0x7fd8
leaq 0x1ff8(%rip), %rsi      # 0x5091
callq 0x2100
movq %rax, -0x48(%rbp)
jmp 0x30a4
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rax
movl 0x40(%rax), %esi
callq 0x21a0
movq %rax, -0x50(%rbp)
jmp 0x30ba
movq -0x50(%rbp), %rdi
movq 0x4efb(%rip), %rsi      # 0x7fc0
callq 0x2120
jmp 0x30cc
movl $0x1, -0x38(%rbp)
jmp 0x310b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x31f0
jmp 0x315b
movq -0x40(%rbp), %rax
movq 0x30(%rax), %rdi
leaq -0x28(%rbp), %rsi
movl $0x3e8, %edx            # imm = 0x3E8
callq 0x3230
jmp 0x3104
movl $0x0, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x31f0
movl -0x38(%rbp), %eax
testl %eax, %eax
je 0x311f
jmp 0x311d
jmp 0x3155
movq 0x4eb2(%rip), %rdi      # 0x7fd8
leaq 0x1f75(%rip), %rsi      # 0x50a2
callq 0x2100
movq %rax, %rdi
movq -0x40(%rbp), %rax
movl 0x40(%rax), %esi
callq 0x21a0
movq %rax, %rdi
movq 0x4e75(%rip), %rsi      # 0x7fc0
callq 0x2120
jmp 0x3065
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x21b0
nopw %cs:(%rax,%rax)
nop
// File: lhartmann[P]orangepi-i2s-steppers/check.cpp
// Function: main
int main() {
	uint32_t r, c=0;
	while (cin.read((char*)&r, 4)) {
		if (r & 2) {
			cout << c << endl;
			c = 0;
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl $0x0, -0xc(%rbp)
movq 0x2df3(%rip), %rdi      # 0x3fe0
leaq -0x8(%rbp), %rsi
movl $0x4, %edx
callq 0x1060
movq %rax, %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x1050
testb $0x1, %al
jne 0x1210
jmp 0x1242
movl -0x8(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x1240
movl -0xc(%rbp), %esi
movq 0x2dab(%rip), %rdi      # 0x3fd0
callq 0x1070
movq %rax, %rdi
movq 0x2d8c(%rip), %rsi      # 0x3fc0
callq 0x1040
movl $0x0, -0xc(%rbp)
jmp 0x11e6
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: simonho288[P]webassembly_cppvsjs/main.cpp
// Function: ProcessProducts()
auto ProcessProducts() {
  vector<Product> products_orig = CreateProducts();

  // Find the products which the price between 100 & 150
  vector<Product> products1;
  copy_if(products_orig.begin(), products_orig.end(), std::back_inserter(products1), [](const Product& p) {
    return (p._price >= 20.0) && (p._price <= 200.0);
  });

  // Find the products which the product description contains "pretium"
  vector<Product> products2; // working products
  copy_if(products1.begin(), products1.end(), std::back_inserter(products2), [](const Product& p) {
    return (p._description.find("pretium") != std::string::npos);
  });

  // Sort the products by price ascending using Lambda (requires C++ 14)
  sort(products2.begin(), products2.end(), Product::CompareByPrice);

  return products2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xd0(%rbp)
movq %rdi, %rax
movq %rax, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x2370
leaq -0x38(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x37a0
movq -0xc0(%rbp), %rdi
callq 0x37c0
movq -0xc0(%rbp), %rdi
movq %rax, -0x40(%rbp)
callq 0x37f0
movq -0xb8(%rbp), %rdi
movq %rax, -0x48(%rbp)
callq 0x3820
movq %rax, -0xb0(%rbp)
jmp 0x3135
movq -0xb0(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0x32b0
movq %rax, -0xd8(%rbp)
jmp 0x315a
movq -0xd0(%rbp), %rdi
movq -0xd8(%rbp), %rax
movq %rax, -0x68(%rbp)
movb $0x0, -0x69(%rbp)
callq 0x37a0
leaq -0x38(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x37c0
movq -0xe8(%rbp), %rdi
movq %rax, -0x78(%rbp)
callq 0x37f0
movq -0xd0(%rbp), %rdi
movq %rax, -0x80(%rbp)
callq 0x3820
movq %rax, -0xe0(%rbp)
jmp 0x31ae
movq -0xe0(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x78(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0x88(%rbp), %rdx
callq 0x3340
movq %rax, -0xf0(%rbp)
jmp 0x31d9
movq -0xd0(%rbp), %rdi
movq -0xf0(%rbp), %rax
movq %rax, -0x98(%rbp)
callq 0x37c0
movq -0xd0(%rbp), %rdi
movq %rax, -0xa0(%rbp)
callq 0x37f0
movq %rax, -0xa8(%rbp)
movq -0xa0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
leaq 0x67e(%rip), %rdx       # 0x38a0
callq 0x3850
jmp 0x3229
movb $0x1, -0x69(%rbp)
testb $0x1, -0x69(%rbp)
jne 0x3269
jmp 0x325d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x328b
movq -0xd0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0x3740
jmp 0x328b
movq -0xd0(%rbp), %rdi
callq 0x3740
leaq -0x38(%rbp), %rdi
callq 0x3740
leaq -0x20(%rbp), %rdi
callq 0x3740
movq -0xc8(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x3740
leaq -0x20(%rbp), %rdi
callq 0x3740
movq -0x58(%rbp), %rdi
callq 0x21b0
nopw %cs:(%rax,%rax)
// File: simonho288[P]webassembly_cppvsjs/main.cpp
// Function: ProcessMillionTimes
double EMSCRIPTEN_KEEPALIVE ProcessMillionTimes(int argc, char** argv) {
  clock_t begin = clock();

  vector<Product> products;
  for (int i = 0; i < 1000000; i++) {
    products = ProcessProducts();
  }

  clock_t end = clock();
  double elapsed_secs = double(end - begin) / CLOCKS_PER_SEC;

  // Print all final product(s)
  for (auto it : products) {
    cout << it << endl;
  }

  return elapsed_secs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x20a0
movq %rax, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x37a0
movl $0x0, -0x34(%rbp)
cmpl $0xf4240, -0x34(%rbp)   # imm = 0xF4240
jge 0x3441
leaq -0x50(%rbp), %rdi
callq 0x30c0
jmp 0x340f
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x38d0
leaq -0x50(%rbp), %rdi
callq 0x3740
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x33fb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x3546
callq 0x20a0
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
subq -0x18(%rbp), %rax
cvtsi2sd %rax, %xmm0
movsd 0x3ba9(%rip), %xmm1     # 0x7008
divsd %xmm1, %xmm0
movsd %xmm0, -0x70(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rdi
callq 0x37c0
movq %rax, -0x80(%rbp)
movq -0x78(%rbp), %rdi
callq 0x37f0
movq %rax, -0x88(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x3900
testb $0x1, %al
jne 0x34a3
jmp 0x351f
leaq -0x80(%rbp), %rdi
callq 0x3940
movq %rax, %rsi
leaq -0xd0(%rbp), %rdi
callq 0x3960
jmp 0x34bd
movq 0x7b14(%rip), %rdi      # 0xafd8
leaq -0xd0(%rbp), %rsi
callq 0x6380
movq %rax, -0xd8(%rbp)
jmp 0x34d9
movq -0xd8(%rbp), %rdi
movq 0x7ae1(%rip), %rsi      # 0xafc8
callq 0x2120
jmp 0x34ee
leaq -0xd0(%rbp), %rdi
callq 0x3710
leaq -0x80(%rbp), %rdi
callq 0x39e0
jmp 0x348d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x3710
jmp 0x3546
movsd -0x70(%rbp), %xmm0
movsd %xmm0, -0xe0(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3740
movsd -0xe0(%rbp), %xmm0
addq $0xe0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x3740
movq -0x58(%rbp), %rdi
callq 0x21b0
nopl (%rax,%rax)
// File: simonho288[P]webassembly_cppvsjs/main.cpp
// Function: main
int main()
{
#if !defined(NDEBUG)
  double time = ProcessMillionTimes(0, 0);
  cout << "Elapsed second: " << time << endl;
  getchar();
#endif

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
xorl %edi, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x33d0
movsd %xmm0, -0x10(%rbp)
movq 0x7a52(%rip), %rdi      # 0xafd8
leaq 0x430a(%rip), %rsi      # 0x7897
callq 0x20e0
movq %rax, %rdi
movsd -0x10(%rbp), %xmm0
callq 0x21d0
movq %rax, %rdi
movq 0x7a1f(%rip), %rsi      # 0xafc8
callq 0x2120
callq 0x2160
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: simonho288[P]webassembly_cppvsjs/product.cpp
// Function: operator<<(std::ostream&, Product const&)
ostream& operator<<(ostream& sm, const Product& p) {
  const size_t MAX_DESCIPTION_LEN = 50;
  sm << "Name: " << p._name << endl;
  if (p._description.length() > MAX_DESCIPTION_LEN) {
    sm << "Description: " << p._description.substr(0, MAX_DESCIPTION_LEN - 1) << "..." << endl;
  } else {
    sm << "Description: " << p._description << endl;
  }
  sm << "Price: " << p._price << endl;
  return sm;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x32, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1558(%rip), %rsi      # 0x78fb
callq 0x20e0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x20d0
movq %rax, %rdi
movq 0x4c0a(%rip), %rsi      # 0xafc8
callq 0x2120
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x2180
cmpq $0x32, %rax
jbe 0x6469
movq -0x8(%rbp), %rdi
leaq 0x151d(%rip), %rsi      # 0x7902
callq 0x20e0
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
xorl %eax, %eax
movl %eax, %edx
leaq -0x38(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movl $0x31, %ecx
callq 0x2110
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x20d0
movq %rax, -0x50(%rbp)
jmp 0x641f
movq -0x50(%rbp), %rdi
leaq 0x14e6(%rip), %rsi      # 0x7910
callq 0x20e0
movq %rax, -0x68(%rbp)
jmp 0x6435
movq -0x68(%rbp), %rdi
movq 0x4b88(%rip), %rsi      # 0xafc8
callq 0x2120
jmp 0x6447
leaq -0x38(%rbp), %rdi
callq 0x2090
jmp 0x6498
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2090
jmp 0x64d2
movq -0x8(%rbp), %rdi
leaq 0x148e(%rip), %rsi      # 0x7902
callq 0x20e0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
callq 0x20d0
movq %rax, %rdi
movq 0x4b35(%rip), %rsi      # 0xafc8
callq 0x2120
movq -0x8(%rbp), %rdi
leaq 0x1471(%rip), %rsi      # 0x7914
callq 0x20e0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movsd 0x40(%rax), %xmm0
callq 0x21d0
movq %rax, %rdi
movq 0x4b05(%rip), %rsi      # 0xafc8
callq 0x2120
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x21b0
// File: onfe[P]Completionist/src/completionist.cpp
// Function: complete(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string complete(string inp) {
  string out;
  cout << "Getting suggestions for \"" << inp << "\". \n";
  pvc_t results = suggest(pl, st, inp, 4);
  cout << "Got " << results.size() <<" suggestions.\n";
  for (int i = 0; i < results.size(); ++i) {
    cout << results[i].phrase + "\n";
  }

  return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0x88(%rbp)
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x21e0
movq 0xea7b(%rip), %rdi      # 0x10fd0
leaq 0x8aa8(%rip), %rsi      # 0xb004
callq 0x2180
movq %rax, -0x70(%rbp)
jmp 0x2567
movq -0x88(%rbp), %rsi
movq -0x70(%rbp), %rdi
callq 0x2170
movq %rax, -0x90(%rbp)
jmp 0x2580
movq -0x90(%rbp), %rdi
leaq 0x8a90(%rip), %rsi      # 0xb01e
callq 0x2180
jmp 0x2595
movq -0x88(%rbp), %rcx
leaq 0xebd5(%rip), %rsi      # 0x11178
leaq 0xebe6(%rip), %rdx      # 0x11190
leaq -0x40(%rbp), %rdi
movl $0x4, %r8d
callq 0x51d0
jmp 0x25bb
movq 0xea0e(%rip), %rdi      # 0x10fd0
leaq 0x8a5a(%rip), %rsi      # 0xb023
callq 0x2180
movq %rax, -0x98(%rbp)
jmp 0x25d7
leaq -0x40(%rbp), %rdi
callq 0x2c80
movq -0x98(%rbp), %rdi
movq %rax, %rsi
callq 0x2060
movq %rax, -0xa0(%rbp)
jmp 0x25f8
movq -0xa0(%rbp), %rdi
leaq 0x8a22(%rip), %rsi      # 0xb028
callq 0x2180
jmp 0x260d
movl $0x0, -0x44(%rbp)
movslq -0x44(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2c80
movq %rax, %rcx
movq -0xa8(%rbp), %rax
cmpq %rcx, %rax
jae 0x26b6
movslq -0x44(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x2d30
movq %rax, %rsi
addq $0x8, %rsi
leaq 0x89cf(%rip), %rdx      # 0xb021
leaq -0x68(%rbp), %rdi
callq 0x2cb0
jmp 0x265d
movq 0xe96c(%rip), %rdi      # 0x10fd0
leaq -0x68(%rbp), %rsi
callq 0x2170
jmp 0x266f
leaq -0x68(%rbp), %rdi
callq 0x2130
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x2614
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x26ec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x26cb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x2130
jmp 0x26cb
movb $0x1, -0x11(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2d50
testb $0x1, -0x11(%rbp)
jne 0x26df
jmp 0x26d6
leaq -0x40(%rbp), %rdi
callq 0x2d50
jmp 0x26ec
movq -0x80(%rbp), %rdi
callq 0x2130
movq -0x78(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x2130
movq -0x20(%rbp), %rdi
callq 0x2260
nop
// File: onfe[P]Completionist/src/SegmentTree.cpp
// Function: SegmentTree::calcHeap(int)
int SegmentTree::calcHeap(int len) {
  int out = 0;
  while (len > 1) {
    len /= 2;
    ++out;
  }
  out = 1 << (out + 2);
  return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x1, -0xc(%rbp)
jle 0x9911
movl -0xc(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x98f2
movl -0x10(%rbp), %ecx
addl $0x2, %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: onfe[P]Completionist/src/SegmentTree.cpp
// Function: SegmentTree::init(std::vector<unsigned int, std::allocator<unsigned int>>)
void SegmentTree::init(std::vector<uint32_t> elements) {
  if (elements.empty()) {
    this->init(0);
  } else {
    this->init(elements.size());
    // start the recursive build process
    this->build(0, 0, elements.size() -1, elements);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x58(%rbp)
movq %rdi, %rax
movq -0x58(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x9eb0
testb $0x1, %al
jne 0x9962
jmp 0x996f
movq -0x48(%rbp), %rdi
xorl %esi, %esi
callq 0x9890
jmp 0x99e6
movq -0x50(%rbp), %rdi
callq 0x4950
movq -0x48(%rbp), %rdi
movl %eax, %esi
callq 0x9890
movq -0x50(%rbp), %rdi
callq 0x4950
movq -0x50(%rbp), %rsi
decl %eax
movl %eax, -0x6c(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x2f50
movq -0x48(%rbp), %rdi
movl -0x6c(%rbp), %ecx
movq -0x68(%rbp), %r8
xorl %edx, %edx
movl %edx, %esi
callq 0x9a00
movq %rax, -0x60(%rbp)
jmp 0x99bc
movq -0x60(%rbp), %rax
movq %rax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3040
jmp 0x99e6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3040
jmp 0x99ec
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x2260
nopw %cs:(%rax,%rax)
// File: onfe[P]Completionist/src/SegmentTree.cpp
// Function: SegmentTree::qmax(unsigned int, unsigned int, unsigned int, unsigned int, unsigned int)
uip_t SegmentTree::qmax(
  uint32_t heapidx,
  uint32_t idx1,
  uint32_t idx2,
  uint32_t firstidx,
  uint32_t lastidx
) {
  // std::cout << "h1:" << heapidx << " i1:" << idx1 << " i2:" << idx2 << " f:" << firstidx << " l:" << lastidx << std::endl;
  if (idx1 > idx2 || firstidx > idx2 || lastidx < idx1) {
    // the indexes provided are incorrect, return [-1, -1].
    return uip_t((uint32_t)0 - 1, (uint32_t)0 - 1);
  }

  if (idx1 >= firstidx && idx2 <= lastidx) {
    // if node within range, return the node.
    return this->heap[heapidx];
  }

  // otherwise, check the children.
  uint32_t midpoint = idx1 + (idx2 - idx1) / 2;
  uip_t left = this->qmax(heapidx*2 + 1, idx1, midpoint, firstidx, lastidx);
  uip_t right = this->qmax(heapidx*2 + 2, midpoint+1, idx2, firstidx, lastidx);

  if (left.second == (uint32_t)0 - 1) {
    return right;
  } else if (right.second == (uint32_t)0 - 1) {
    return left;
  } else {
    return left.first > right.first? left : right;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
ja 0x9cdd
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
ja 0x9cdd
movl -0x24(%rbp), %eax
cmpl -0x18(%rbp), %eax
jae 0x9d01
movl $0xffffffff, -0x28(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
leaq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
callq 0x9f90
jmp 0x9dcf
movl -0x18(%rbp), %eax
cmpl -0x20(%rbp), %eax
jb 0x9d2f
movl -0x1c(%rbp), %eax
cmpl -0x24(%rbp), %eax
ja 0x9d2f
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x9f40
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x9dcf
movq -0x48(%rbp), %rdi
movl -0x18(%rbp), %eax
movl -0x1c(%rbp), %ecx
subl -0x18(%rbp), %ecx
shrl %ecx
addl %ecx, %eax
movl %eax, -0x30(%rbp)
movl -0x14(%rbp), %esi
shll %esi
addl $0x1, %esi
movl -0x18(%rbp), %edx
movl -0x30(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
callq 0x9ca0
movq -0x48(%rbp), %rdi
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %esi
shll %esi
addl $0x2, %esi
movl -0x30(%rbp), %edx
addl $0x1, %edx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
callq 0x9ca0
movq %rax, -0x40(%rbp)
cmpl $-0x1, -0x34(%rbp)
jne 0x9d98
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9dcf
cmpl $-0x1, -0x3c(%rbp)
jne 0x9da8
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9dcf
movl -0x38(%rbp), %eax
cmpl -0x40(%rbp), %eax
jbe 0x9dba
leaq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x9dc4
leaq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x9dc4
movq -0x50(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: onfe[P]Completionist/src/SegmentTreeNode.cpp
// Function: SegmentTreeNode::SegmentTreeNode()
SegmentTreeNode::SegmentTreeNode() {
  s = 0;
  min = 0;
  max = 0;
  from = 0;
  to = 0;
  pval = 0;
  pending = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, 0x4(%rax)
movl $0x0, 0x8(%rax)
movl $0x0, 0xc(%rax)
movl $0x0, 0x10(%rax)
movl $0x0, 0x14(%rax)
movb $0x0, 0x18(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: WojciechMula[P]utf16utf8/tests/unittest.cpp
// Function: compare_strings(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool compare_strings(const std::string& reference, const std::string& result) {
    const size_t reference_size = reference.size();
    const size_t result_size = result.size();
    if (reference_size != result_size) {
        printf("Different lengths: %lu != %lu\n", reference_size, result_size);
        printf("reference = "); dump(reference); putchar('\n');
        printf("result    = "); dump(result); putchar('\n');
        return false;
    }

    for (size_t i=0; i < reference_size; i++) {
        if (reference[i] != result[i]) {
            printf("Difference at %lu\n", i);
            printf("reference = "); dump(reference); putchar('\n');
            printf("result    = "); dump(result); putchar('\n');
            return false;
        }
    }

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2100
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2100
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0xc4a5
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq 0x8e5f(%rip), %rdi      # 0x152b2
movb $0x0, %al
callq 0x2030
leaq 0x8e70(%rip), %rdi      # 0x152d1
movb $0x0, %al
callq 0x2030
movq -0x10(%rbp), %rdi
callq 0xc3a0
movl $0xa, %edi
callq 0x2210
leaq 0x8e5c(%rip), %rdi      # 0x152de
movb $0x0, %al
callq 0x2030
movq -0x18(%rbp), %rdi
callq 0xc3a0
movl $0xa, %edi
callq 0x2210
movb $0x0, -0x1(%rbp)
jmp 0xc559
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0xc555
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x2190
movsbl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x2190
movq %rax, %rcx
movl -0x34(%rbp), %eax
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0xc542
movq -0x30(%rbp), %rsi
leaq 0x8df8(%rip), %rdi      # 0x152eb
movb $0x0, %al
callq 0x2030
leaq 0x8dd0(%rip), %rdi      # 0x152d1
movb $0x0, %al
callq 0x2030
movq -0x10(%rbp), %rdi
callq 0xc3a0
movl $0xa, %edi
callq 0x2210
leaq 0x8dbc(%rip), %rdi      # 0x152de
movb $0x0, %al
callq 0x2030
movq -0x18(%rbp), %rdi
callq 0xc3a0
movl $0xa, %edi
callq 0x2210
movb $0x0, -0x1(%rbp)
jmp 0xc559
jmp 0xc544
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xc4ad
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)