LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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:
cmpb $0x0, 0x57af(%rip)      # 0xd410
je 0x7c77
movb $0x0, 0x57a6(%rip)      # 0xd410
movsd 0x57a6(%rip), %xmm1     # 0xd418
jmp 0x7d27
subq $0x18, %rsp
callq 0x79af
movapd %xmm0, %xmm1
addsd %xmm0, %xmm1
movsd 0x1b48(%rip), %xmm0     # 0x97d8
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
callq 0x79af
movsd (%rsp), %xmm3
addsd %xmm0, %xmm0
addsd 0x1b29(%rip), %xmm0     # 0x97d8
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
mulsd %xmm3, %xmm3
addsd %xmm1, %xmm3
ucomisd 0x1901(%rip), %xmm3     # 0x95c8
jae 0x7c7b
movsd %xmm0, 0x10(%rsp)
movapd %xmm3, %xmm0
movsd %xmm3, 0x8(%rsp)
callq 0x31d0
mulsd 0x1afa(%rip), %xmm0     # 0x97e0
divsd 0x8(%rsp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x7cfc
sqrtsd %xmm0, %xmm0
jmp 0x7d01
callq 0x31c0
movsd (%rsp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x5706(%rip)     # 0xd418
movb $0x1, 0x56f7(%rip)      # 0xd410
movsd 0x10(%rsp), %xmm1
mulsd %xmm0, %xmm1
addq $0x18, %rsp
movapd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]motiflocation/random.cpp
// Function: poissrnd(double)
int poissrnd(double xm)
{
	//float gammln(float xx);
	static double sq, alxm, g, oldm=(-1.0);
	double em,t,y;
	
	if (xm < 12.0) { 
		if (xm != oldm) {
			oldm=xm;
			g=exp(-xm); 
		}
		em = -1;
		t=1.0;
		do {
			++em;
			t *= ran2();
		} while (t > g);
	} else { 
		if (xm != oldm) { 
			oldm=xm;
			sq=sqrt(2.0*xm);
			alxm=log(xm);
			g = xm*alxm - gammln(xm + 1.0);
		}
		do {
			do { 
				y=tan(PI * ran2());
				em=sq*y+xm; 
			} while (em < 0.0); 
			em=floor(em); 
			t=0.9*(1.0+y*y)*exp(em*alxm-gammln(em+1.0)-g);
		} while (ran2() > t);
	}
	return (int)em;
}

// Assembly:
subq $0x28, %rsp
movapd %xmm0, %xmm2
movsd 0x1843(%rip), %xmm0     # 0x9808
ucomisd %xmm2, %xmm0
movsd 0x52ef(%rip), %xmm0     # 0xd2c0
jbe 0x8002
ucomisd %xmm2, %xmm0
jne 0x7fdb
jnp 0x8034
movsd %xmm2, 0x52dd(%rip)     # 0xd2c0
xorpd 0x1845(%rip), %xmm2     # 0x9830
movapd %xmm2, %xmm0
callq 0x34e0
movapd %xmm0, %xmm1
movsd %xmm0, 0x5430(%rip)     # 0xd430
jmp 0x803c
ucomisd %xmm2, %xmm0
movapd %xmm2, 0x10(%rsp)
jne 0x8014
jnp 0x80dd
movsd %xmm2, 0x52a4(%rip)     # 0xd2c0
movapd %xmm2, %xmm0
addsd %xmm2, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x808a
sqrtsd %xmm0, %xmm0
jmp 0x8095
movsd 0x53f4(%rip), %xmm1     # 0xd430
movsd 0x1794(%rip), %xmm0     # 0x97d8
movsd 0x157c(%rip), %xmm2     # 0x95c8
movsd %xmm1, 0x10(%rsp)
movsd %xmm2, (%rsp)
addsd 0x1569(%rip), %xmm0     # 0x95c8
movsd %xmm0, 0x8(%rsp)
callq 0x79af
movsd (%rsp), %xmm2
movsd 0x10(%rsp), %xmm1
mulsd %xmm0, %xmm2
movsd 0x8(%rsp), %xmm0
ucomisd %xmm1, %xmm2
ja 0x8052
jmp 0x819b
callq 0x31c0
movapd 0x10(%rsp), %xmm2
movsd %xmm0, 0x5383(%rip)     # 0xd420
movapd %xmm2, %xmm0
callq 0x31d0
movsd %xmm0, (%rsp)
movsd %xmm0, 0x5375(%rip)     # 0xd428
movsd 0x150d(%rip), %xmm0     # 0x95c8
addsd 0x10(%rsp), %xmm0
callq 0x7bb7
movsd (%rsp), %xmm1
mulsd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x5353(%rip)     # 0xd430
callq 0x79af
mulsd 0x1726(%rip), %xmm0     # 0x9810
callq 0x3170
movapd %xmm0, %xmm2
movsd 0x5325(%rip), %xmm0     # 0xd420
mulsd %xmm2, %xmm0
addsd 0x10(%rsp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x80dd
movsd %xmm2, (%rsp)
callq 0x3450
movapd %xmm0, %xmm2
movsd (%rsp), %xmm3
mulsd %xmm3, %xmm3
movsd 0x149a(%rip), %xmm1     # 0x95c8
addsd %xmm1, %xmm3
mulsd 0x16de(%rip), %xmm3     # 0x9818
movsd %xmm3, (%rsp)
addsd %xmm1, %xmm0
movsd 0x52dd(%rip), %xmm1     # 0xd428
movsd %xmm2, 0x8(%rsp)
mulsd %xmm2, %xmm1
movsd %xmm1, 0x20(%rsp)
callq 0x7bb7
movsd 0x20(%rsp), %xmm1
subsd %xmm0, %xmm1
subsd 0x52be(%rip), %xmm1     # 0xd430
movapd %xmm1, %xmm0
callq 0x34e0
mulsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
callq 0x79af
ucomisd (%rsp), %xmm0
ja 0x80dd
movsd 0x8(%rsp), %xmm0
cvttsd2si %xmm0, %eax
addq $0x28, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq 0x16793(%rip), %rbx     # 0x1cff0
leaq 0xe95e(%rip), %rsi      # 0x151c2
movq %rbx, %rdi
callq 0x42b0
leaq 0xe997(%rip), %rsi      # 0x1520a
movq %rbx, %rdi
callq 0x42b0
leaq 0xe9b5(%rip), %rsi      # 0x15237
movq %rbx, %rdi
callq 0x42b0
leaq 0xe9b8(%rip), %rsi      # 0x15249
movq %rbx, %rdi
callq 0x42b0
movl $0x1, %edi
callq 0x4380
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
callq 0x4420
movq %rsp, %rdi
movq %r14, %rsi
callq 0x8284
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x20(%rsp), %rdi
callq 0x4340
leaq 0x10(%rsp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x68fb
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42e0
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rcx
movq $0x2, 0x30(%rsp,%rcx)
movq -0x18(%rax), %rax
leaq (%rsp,%rax), %r15
addq $0x20, %r15
cmpb $0x0, 0xe1(%r15)
jne 0x6938
movq %r15, %rdi
movl $0x20, %esi
callq 0x42a0
movb $0x1, 0xe1(%r15)
movb $0x30, 0xe0(%r15)
movq %r14, %rdi
callq 0x8274
leaq 0x20(%rsp), %rdi
movl %eax, %esi
callq 0x4560
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rcx
movq $0x2, 0x30(%rsp,%rcx)
movq -0x18(%rax), %rax
leaq (%rsp,%rax), %r15
addq $0x20, %r15
cmpb $0x0, 0xe1(%r15)
jne 0x6991
movq %r15, %rdi
movl $0x20, %esi
callq 0x42a0
movb $0x1, 0xe1(%r15)
movb $0x30, 0xe0(%r15)
movq %r14, %rdi
callq 0x8278
leaq 0x20(%rsp), %rdi
movl %eax, %esi
callq 0x4560
leaq 0xe6c5(%rip), %rsi      # 0x15079
leaq 0x20(%rsp), %rdi
movl $0x4, %edx
callq 0x4340
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x44e0
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x6c27
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x69f1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42e0
movq 0x165c8(%rip), %rsi     # 0x1cfc0
leaq 0x20(%rsp), %rdi
callq 0x4170
leaq 0x90(%rsp), %rdi
callq 0x4100
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
jne 0x6a42
jmp 0x6a56
jmp 0x6a53
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6a56
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42e0
jmp 0x6a56
jmp 0x6a53
movq %rax, %rbx
movq 0x16563(%rip), %rsi     # 0x1cfc0
leaq 0x20(%rsp), %rdi
callq 0x4170
leaq 0x90(%rsp), %rdi
callq 0x4100
movq %rbx, %rdi
callq 0x4590
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x4420
leaq 0xe709(%rip), %rsi      # 0x151ab
movl $0x3, %edx
movq %r15, %rdi
callq 0x4340
movq 0x28(%rsp), %rax
movq -0x18(%rax), %rcx
movq $0x2, 0x38(%rsp,%rcx)
movq -0x18(%rax), %rax
leaq (%rsp,%rax), %r15
addq $0x28, %r15
cmpb $0x0, 0xe1(%r15)
jne 0x6aec
movq %r15, %rdi
movl $0x20, %esi
callq 0x42a0
movb $0x1, 0xe1(%r15)
movb $0x30, 0xe0(%r15)
movq %r14, %rdi
callq 0x8280
leaq 0x28(%rsp), %rdi
movl %eax, %esi
callq 0x4560
movq 0x28(%rsp), %rax
movq -0x18(%rax), %rcx
movq $0x2, 0x38(%rsp,%rcx)
movq -0x18(%rax), %rax
leaq (%rsp,%rax), %r15
addq $0x28, %r15
cmpb $0x0, 0xe1(%r15)
jne 0x6b45
movq %r15, %rdi
movl $0x20, %esi
callq 0x42a0
movb $0x1, 0xe1(%r15)
movb $0x30, 0xe0(%r15)
movq %r14, %rdi
callq 0x827c
leaq 0x28(%rsp), %rdi
movl %eax, %esi
callq 0x4560
leaq 0xe511(%rip), %rsi      # 0x15079
leaq 0x28(%rsp), %rdi
movl $0x4, %edx
callq 0x4340
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x44e0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x6c27
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6bae
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
movq 0x1640b(%rip), %rsi     # 0x1cfc0
leaq 0x28(%rsp), %rdi
callq 0x4170
leaq 0x98(%rsp), %rdi
callq 0x4100
movq %rbx, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6c01
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
jmp 0x6c01
jmp 0x6bfe
movq %rax, %rbx
movq 0x163b8(%rip), %rsi     # 0x1cfc0
leaq 0x28(%rsp), %rdi
callq 0x4170
leaq 0x98(%rsp), %rdi
callq 0x4100
movq %rbx, %rdi
callq 0x4590
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x8(%rdi)
movq 0x20(%rdi), %rdx
leaq 0xcfb1(%rip), %rcx      # 0x1517c
movl $0x3, %r8d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44c0
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x7e4a
leaq 0xcfb8(%rip), %rsi      # 0x151a7
movq %rbx, %rdi
callq 0x40d0
testl %eax, %eax
jne 0x822e
leaq 0x8(%r14), %rax
movdqu (%rax), %xmm0
pshufd $0xb1, %xmm0, %xmm1     # xmm1 = xmm0[1,0,3,2]
cmpl $0x0, (%rax)
movdqu %xmm1, (%rax)
jns 0x8219
movl $0x3, 0xc(%r14)
pshufd $0xee, %xmm0, %xmm0     # xmm0 = xmm0[2,3,2,3]
movd %xmm0, %eax
testl %eax, %eax
jns 0x822e
movl $0x1, 0x14(%r14)
leaq 0xd09f(%rip), %rsi      # 0x152d4
movq %rbx, %rdi
callq 0x40d0
testl %eax, %eax
je 0x8247
popq %rbx
popq %r14
popq %r15
retq
movaps 0xd062(%rip), %xmm0     # 0x152b0
movups %xmm0, 0x8(%r14)
movq 0x20(%r14), %rdx
leaq 0xcf49(%rip), %rcx      # 0x151a7
movl $0x3, %r8d
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x44c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %r13
leaq -0x38(%rbp), %r14
movq %r13, (%r14)
xorl %eax, %eax
movb %al, 0x8(%r14)
movq %r14, %rdi
callq 0x2b94
movb $0x1, %r12b
movb %r12b, 0x8(%r14)
movl $0x1, 0x3c(%rbx)
movq %r14, %rdi
callq 0x2b7a
movq 0x25fc(%rip), %r15      # 0x4fd8
leaq 0x69d(%rip), %rsi       # 0x3080
movl $0x7, %edx
movq %r15, %rdi
callq 0x2130
movl 0x40(%rbx), %esi
movq %r15, %rdi
callq 0x21b0
movq %rax, %r15
leaq 0x683(%rip), %rsi       # 0x3088
movl $0x8, %edx
movq %rax, %rdi
callq 0x2130
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2110
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20b0
movq %r13, (%r14)
xorl %eax, %eax
movb %al, 0x8(%r14)
movq %r14, %rdi
callq 0x2b94
movb %r12b, 0x8(%r14)
cmpl $0x2, 0x38(%rbx)
je 0x2af4
movq 0x2579(%rip), %r12      # 0x4fd8
movq 0x30(%rbx), %r15
addq $0x8, %r15
callq 0x2140
addq $0x3b9aca00, %rax       # imm = 0x3B9ACA00
movq %rax, -0x40(%rbp)
movq %r15, %rdi
movq %r14, %rsi
leaq -0x40(%rbp), %rdx
callq 0x2c1a
movq %r14, %rdi
callq 0x2b7a
movl $0xd, %edx
movq %r12, %rdi
leaq 0x606(%rip), %rsi       # 0x30a2
callq 0x2130
movl 0x40(%rbx), %esi
movq %r12, %rdi
callq 0x21b0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2110
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20b0
movq %r13, -0x38(%rbp)
movb $0x0, -0x30(%rbp)
movq %r14, %rdi
callq 0x2b94
movb $0x1, -0x30(%rbp)
cmpl $0x2, 0x38(%rbx)
jne 0x2a5f
movl $0x2, 0x3c(%rbx)
movq 0x24d6(%rip), %rdi      # 0x4fd8
leaq 0x588(%rip), %rsi       # 0x3091
movl $0x10, %edx
callq 0x2130
movl 0x40(%rbx), %esi
movq 0x24bb(%rip), %rdi      # 0x4fd8
callq 0x21b0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2110
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20b0
leaq -0x38(%rbp), %rdi
callq 0x2b7a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2b66
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x2b7a
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq -0x58(%rbp), %r15
movq %r15, %rdi
callq 0x233c
xorpd %xmm0, %xmm0
movapd %xmm0, -0x40(%rbp)
movq $0x0, -0x30(%rbp)
movq (%r15), %r14
movq 0x8(%r15), %r12
cmpq %r12, %r14
je 0x29e5
leaq -0x40(%rbp), %r15
movsd 0x40(%r14), %xmm0
ucomisd 0x26f3(%rip), %xmm0     # 0x5008
jb 0x2930
movsd 0x26f1(%rip), %xmm1     # 0x5010
ucomisd %xmm0, %xmm1
jb 0x2930
movq %r15, %rdi
movq %r14, %rsi
callq 0x30ce
addq $0x48, %r14
cmpq %r12, %r14
jne 0x2907
movq -0x40(%rbp), %r14
movq -0x38(%rbp), %r12
xorpd %xmm0, %xmm0
movupd %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
cmpq %r12, %r14
je 0x29f1
leaq 0x2fcc(%rip), %r15      # 0x592d
leaq 0x20(%r14), %rdi
movl $0x7, %ecx
movq %r15, %rsi
xorl %edx, %edx
callq 0x2190
cmpq $-0x1, %rax
je 0x2985
movq %rbx, %rdi
movq %r14, %rsi
callq 0x30ce
addq $0x48, %r14
cmpq %r12, %r14
jne 0x2961
movq (%rbx), %r14
movq 0x8(%rbx), %r15
cmpq %r15, %r14
je 0x29f1
movq %r15, %rax
subq %r14, %rax
sarq $0x3, %rax
movabsq $-0x71c71c71c71c71c7, %rcx # imm = 0x8E38E38E38E38E39
imulq %rax, %rcx
bsrq %rcx, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
leaq 0x3cc(%rip), %rcx       # 0x2d92
movq %r14, %rdi
movq %r15, %rsi
callq 0x3423
leaq 0x3ba(%rip), %rdx       # 0x2d92
movq %r14, %rdi
movq %r15, %rsi
callq 0x3574
jmp 0x29f1
movupd %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
leaq -0x40(%rbp), %rdi
callq 0x2d54
leaq -0x58(%rbp), %rdi
callq 0x2d54
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2a15
movq %rax, %r14
movq %rbx, %rdi
callq 0x2d54
jmp 0x2a25
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x2d54
leaq -0x58(%rbp), %rdi
callq 0x2d54
movq %r14, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
callq 0x2080
movq %rax, %r12
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
movl $0xf4240, %ebx          # imm = 0xF4240
leaq -0xc0(%rbp), %r14
leaq -0x98(%rbp), %r15
movq %r14, %rdi
callq 0x28c4
movaps -0x50(%rbp), %xmm0
movq -0x40(%rbp), %rax
movaps -0xc0(%rbp), %xmm1
movaps %xmm1, -0x50(%rbp)
movq -0xb0(%rbp), %rcx
movq %rcx, -0x40(%rbp)
movups %xmm0, -0x98(%rbp)
movq %rax, -0x88(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0xc0(%rbp)
movq $0x0, -0xb0(%rbp)
movq %r15, %rdi
callq 0x2d54
movq %r14, %rdi
callq 0x2d54
decl %ebx
jne 0x2a7d
movq %r12, -0x30(%rbp)
callq 0x2080
movq %rax, -0xa0(%rbp)
movq -0x50(%rbp), %r14
movq -0x48(%rbp), %r13
cmpq %r13, %r14
je 0x2bc6
leaq -0x68(%rbp), %r15
leaq -0x98(%rbp), %r12
leaq -0x88(%rbp), %rax
movq %rax, -0x98(%rbp)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x2da6
movq %r15, -0x78(%rbp)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
leaq -0x78(%rbp), %rdi
callq 0x2da6
movsd 0x40(%r14), %xmm0
movsd %xmm0, -0x58(%rbp)
movq 0x5488(%rip), %rdi      # 0x7fd8
movq %r12, %rsi
callq 0x4290
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2090
movq -0x78(%rbp), %rdi
cmpq %r15, %rdi
je 0x2b97
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x2100
movq -0x98(%rbp), %rdi
leaq -0x88(%rbp), %rax
cmpq %rax, %rdi
je 0x2bb9
movq -0x88(%rbp), %rsi
incq %rsi
callq 0x2100
addq $0x48, %r14
cmpq %r13, %r14
jne 0x2b06
movq -0xa0(%rbp), %rax
subq -0x30(%rbp), %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
divsd 0x2437(%rip), %xmm0     # 0x5018
movsd %xmm0, -0x30(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x2d54
movsd -0x30(%rbp), %xmm0
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2c2f
movq %rax, %rbx
movq -0x98(%rbp), %rdi
leaq -0x88(%rbp), %rax
cmpq %rax, %rdi
je 0x2c43
movq -0x88(%rbp), %rsi
incq %rsi
callq 0x2100
jmp 0x2c43
movq %rax, %rbx
jmp 0x2c43
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0x2d0e
leaq -0x50(%rbp), %rdi
callq 0x2d54
movq %rbx, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rbx
pushq %rax
callq 0x2a3f
movsd %xmm0, -0x10(%rbp)
movq 0x536d(%rip), %rbx      # 0x7fd8
leaq 0x2c35(%rip), %rsi      # 0x58a7
movl $0x10, %edx
movq %rbx, %rdi
callq 0x2120
movq %rbx, %rdi
movsd -0x10(%rbp), %xmm0
callq 0x2170
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2090
callq 0x2140
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x168b(%rip), %rsi      # 0x5935
movl $0x6, %edx
callq 0x2120
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x2120
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x20e0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2090
movq 0x28(%r14), %r15
leaq 0x1644(%rip), %rsi      # 0x593c
movl $0xd, %edx
movq %rbx, %rdi
callq 0x2120
cmpq $0x33, %r15
jb 0x438a
leaq 0x20(%r14), %rsi
leaq -0x38(%rbp), %r15
movl $0x31, %ecx
movq %r15, %rdi
xorl %edx, %edx
callq 0x2110
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x2120
movq %rax, %r15
leaq 0x160f(%rip), %rsi      # 0x594a
movl $0x3, %edx
movq %rax, %rdi
callq 0x2120
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x20e0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2090
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x43c4
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2100
jmp 0x43c4
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
movq %rbx, %rdi
callq 0x2120
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x20e0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2090
leaq 0x1583(%rip), %rsi      # 0x594e
movl $0x7, %edx
movq %rbx, %rdi
callq 0x2120
movsd 0x40(%r14), %xmm0
movq %rbx, %rdi
callq 0x2170
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x20e0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2090
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x443a
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2100
movq %rbx, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O3/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:
xorl %ecx, %ecx
cmpl $0x2, %esi
jl 0x4f56
xorl %ecx, %ecx
movl %esi, %eax
shrl %eax
incl %ecx
cmpl $0x3, %esi
movl %eax, %esi
ja 0x4f4b
movl $0x4, %eax
shll %cl, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rsi
cmpq %rsi, %rax
je 0x4fda
subq %rax, %rsi
shrq $0x2, %rsi
movq %rbx, %rdi
callq 0x4f06
movq 0x8(%r14), %r15
subq (%r14), %r15
shrq $0x2, %r15
decl %r15d
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x2e50
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
movl %r15d, %ecx
movq %r12, %r8
callq 0x5028
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4fce
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2150
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x0, (%rbx)
leaq 0x8(%rbx), %rdi
movq 0x8(%rbx), %rax
cmpq %rax, 0x10(%rbx)
je 0x4ff2
movq %rax, 0x10(%rbx)
movl $0x4, %esi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x5276
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5020
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2150
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O3/onfe[P]Completionist/src/SegmentTree.cpp
// Function: SegmentTree::build(unsigned int, unsigned int, unsigned int, std::vector<unsigned int, std::allocator<unsigned int>>)
uip_t SegmentTree::build (
  uint32_t heapidx,
  uint32_t idx1,
  uint32_t idx2,
  std::vector<uint32_t> weights
) {
  uint32_t midpoint = idx1 + (idx2 - idx1) / 2;
  // if idx1 = idx 2, must be pointing at 1 element.
  if (idx1 == idx2) {
    // add the pair [weight, index] to the heap.
    this->heap[heapidx] = uip_t(weights[idx1], idx1);
    return this->heap[heapidx];

  } else {
    // otherwise, get the child nodes (recursive step)
    uip_t left = this->build(heapidx*2 + 1, idx1, midpoint, weights);
    uip_t right = this->build(heapidx*2 + 2, midpoint+1, idx2, weights);
    // and set the values of this node to the best child weight
    this->heap[heapidx] = (left.first > right.first ? left : right);
    return this->heap[heapidx];
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, %ebx
movl %esi, %r13d
movl %ecx, %ebp
subl %edx, %ebp
jne 0x505b
movl %ebx, %eax
movq (%r8), %rcx
movl (%rcx,%rax,4), %ecx
movl %r13d, %eax
movq 0x8(%rdi), %rdx
leaq (%rdx,%rax,8), %rax
movl %ecx, (%rax)
jmp 0x5127
movl %edx, %r12d
shrl %ebp
addl %edx, %ebp
leal 0x1(,%r13,2), %r14d
leaq 0x18(%rsp), %rax
movq %rdi, %r15
movq %rax, %rdi
movq %r8, 0x10(%rsp)
movq %r8, %rsi
callq 0x2e50
movq %r15, 0x8(%rsp)
movq %r15, %rdi
movl %r14d, %esi
movl %r12d, %edx
movl %ebp, %ecx
leaq 0x18(%rsp), %r8
callq 0x5028
movq %rax, %r15
leal (,%r13,2), %r12d
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x50be
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x2150
addl $0x2, %r12d
incl %ebp
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq 0x10(%rsp), %rsi
callq 0x2e50
movq 0x8(%rsp), %rdi
movl %r12d, %esi
movl %ebp, %edx
movl %ebx, %ecx
movq %r14, %r8
callq 0x5028
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x5104
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x2150
cmpl %ebx, %r15d
movl %r13d, %eax
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
leaq (%rcx,%rax,8), %rax
movl %ebx, %ecx
cmoval %r15d, %ecx
movl %ecx, (%rax)
cmovaq %r15, %rbx
shrq $0x20, %rbx
movl %ebx, 0x4(%rax)
movq (%rax), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x40(%rsp), %rcx
movq %rax, %rbx
movq 0x30(%rsp), %rdi
jmp 0x5158
leaq 0x28(%rsp), %rcx
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x5168
movq (%rcx), %rsi
subq %rdi, %rsi
callq 0x2150
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r14d
movl %edx, %r12d
movl %esi, %r13d
movabsq $-0x100000000, %rsi     # imm = 0xFFFFFFFF00000000
movl %ecx, %r15d
subl %edx, %r15d
setb %al
cmpl %ecx, %r8d
seta %cl
cmpl %edx, %r9d
setb %dl
orb %al, %dl
orb %cl, %dl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jne 0x525a
movl %r9d, %ebx
movl %r8d, %ebp
cmpl %r8d, %r12d
setb %al
cmpl %r9d, %r14d
seta %cl
orb %al, %cl
je 0x524c
shrl %r15d
leal (%r15,%r12), %ecx
leal 0x1(,%r13,2), %esi
movq %rdi, 0x10(%rsp)
movl %r12d, %edx
movl %ebp, %r8d
movl %ebx, %r9d
callq 0x5184
movq %rax, 0x8(%rsp)
leal 0x2(,%r13,2), %esi
leal (%r15,%r12), %edx
incl %edx
movq 0x10(%rsp), %rdi
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
callq 0x5184
movq 0x8(%rsp), %rdx
movabsq $-0x100000000, %rsi     # imm = 0xFFFFFFFF00000000
leaq -0x1(%rsi), %rcx
cmpq %rcx, %rdx
ja 0x5257
cmpq %rcx, %rax
jbe 0x526e
andq %rdx, %rsi
movq %rdx, %rax
jmp 0x525a
movl %r13d, %eax
movq 0x8(%rdi), %rcx
movq (%rcx,%rax,8), %rax
andq %rax, %rsi
movl %eax, %eax
orq %rsi, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl %eax, %edx
cmovaq %rdx, %rax
jmp 0x5257
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x8(%rdi), %rsi
movq 0x8(%rbx), %rdx
movq %rdi, %r14
cmpq %rdx, %rsi
jne 0x4705
movb $0x1, %bpl
testq %rsi, %rsi
je 0x4768
movq (%r14), %rcx
movq (%rbx), %rdx
xorl %eax, %eax
movb (%rcx,%rax), %dil
cmpb (%rdx,%rax), %dil
jne 0x4715
incq %rax
cmpq %rax, %rsi
jne 0x46f1
jmp 0x4768
leaq 0x6bd6(%rip), %rdi      # 0xb2e2
xorl %eax, %eax
callq 0x2030
jmp 0x4726
leaq 0x6bff(%rip), %rdi      # 0xb31b
movq %rax, %rsi
xorl %eax, %eax
callq 0x2030
leaq 0x6bd4(%rip), %rdi      # 0xb301
xorl %eax, %eax
xorl %ebp, %ebp
callq 0x2030
movq %r14, %rdi
callq 0x4690
movl $0xa, %edi
callq 0x21b0
leaq 0x6bbf(%rip), %rdi      # 0xb30e
xorl %eax, %eax
callq 0x2030
movq %rbx, %rdi
callq 0x4690
movl $0xa, %edi
callq 0x21b0
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/WojciechMula[P]utf16utf8/tests/unittest.cpp
// Function: validate(std::vector<unsigned short, std::allocator<unsigned short>> const&, unsigned long)
bool validate(const std::vector<uint16_t>& input, size_t size) {
    // reference
    std::string tmp;
    tmp.resize(4 * size);
    utf16_to_utf8(input.data(), (uint8_t*)tmp.data());
    const std::string reference{tmp.c_str()};

    // SSE
    tmp.assign("");
    tmp.resize(8 * size);
    const size_t output_size = sse_convert_utf16_to_utf8(input.data(), size, (uint8_t*)tmp.data());
    const std::string sse{tmp.data(), output_size};

    if(! compare_strings(reference, sse) ) {
        display<uint16_t>(input);
        return false;
    }
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
leaq 0x18(%rsp), %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq (,%rsi,4), %rsi
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq 0x8(%rsp), %rdi
xorl %edx, %edx
callq 0x2050
movq (%rbx), %rdi
movq 0x8(%rsp), %rsi
callq 0x48fc
movq 0x8(%rsp), %rsi
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x2070
leaq 0x8(%rsp), %rdi
movq 0x8(%rdi), %rdx
leaq 0x6b27(%rip), %rcx      # 0xb300
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x21e0
leaq (,%r14,8), %rsi
leaq 0x8(%rsp), %rdi
xorl %edx, %edx
callq 0x2050
movq 0x8(%rsp), %rdx
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x3b7c
movq 0x8(%rsp), %rsi
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
addq %rsi, %rax
leaq 0x28(%rsp), %rdi
movq %rax, %rdx
callq 0x5a4a
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x46ca
movl %eax, %ebp
testb %al, %al
jne 0x4842
movq %rbx, %rdi
callq 0x578b
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x4859
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2170
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4874
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2170
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x488b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2170
movl %ebp, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x28(%rsp), %rdi
movq %rax, %rbx
cmpq %r14, %rdi
je 0x48c2
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2170
jmp 0x48c2
jmp 0x48bf
jmp 0x48bf
jmp 0x48ba
movq %rax, %rbx
jmp 0x48dd
movq %rax, %rbx
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x48dd
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2170
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x48f4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2170
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O3/WojciechMula[P]utf16utf8/include/reference.h
// Function: utf16_to_utf8(unsigned short const*, unsigned char*)
static inline uint8_t *utf16_to_utf8(const uint16_t *utf16, uint8_t *utf8)
{
	size_t i, j;
	uint32_t c;

	if (utf16==NULL)
		return NULL;

	if (utf8==NULL)
		utf8 = (uint8_t*)calloc(strlen_utf16_to_utf8(utf16) + 1, sizeof(uint8_t));

	for (i=0, j=0, c=1; c; i++)
	{
		c = utf16_to_unicode32(&utf16[i], &i);
		sprint_unicode(&utf8[j], c);
		j += codepoint_utf8_size(c);
	}

	return utf8;
}

// Assembly:
testq %rdi, %rdi
je 0x4ac7
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
jne 0x498b
movzwl (%rbx), %ecx
testw %cx, %cx
je 0x4979
xorl %edi, %edi
movq %rbx, %rdx
xorl %eax, %eax
leal 0x2000(%rcx), %esi
cmpw $0xf800, %si            # imm = 0xF800
jae 0x4959
movl $0x1, %edx
cmpw $0x80, %cx
jb 0x4944
cmpw $0x800, %cx             # imm = 0x800
movl $0x3, %edx
sbbq $0x0, %rdx
addq %rdx, %rdi
leaq 0x2(%rbx,%rax,2), %rdx
incq %rax
movzwl (%rdx), %ecx
testw %cx, %cx
jne 0x491d
jmp 0x4974
movzwl 0x2(%rdx), %esi
xorl %edx, %edx
testw %si, %si
setne %dl
addq %rdx, %rax
movl $0x4, %edx
testw %si, %si
jne 0x4944
jmp 0x4936
incq %rdi
jmp 0x497e
movl $0x1, %edi
movl $0x1, %esi
callq 0x20e0
movq %rax, %rsi
vmovd 0x688d(%rip), %xmm0     # 0xb220
leaq 0x3(%rsi), %rax
xorl %ecx, %ecx
xorl %edx, %edx
movzwl (%rbx,%rdx,2), %edi
leal 0x2000(%rdi), %r8d
cmpw $0xf800, %r8w           # imm = 0xF800
jae 0x49d4
leaq (%rsi,%rcx), %r8
cmpw $0x7f, %di
ja 0x4a54
movb %dil, (%r8)
testl %edi, %edi
je 0x4ac6
incq %r8
movl $0x1, %edi
jmp 0x4ab7
movzwl 0x2(%rbx,%rdx,2), %r8d
xorl %r9d, %r9d
testl %r8d, %r8d
setne %r9b
addq %r9, %rdx
testl %r8d, %r8d
je 0x4a7f
andl $0x3ff, %edi            # imm = 0x3FF
movl %r8d, %r9d
andl $0x3c0, %r9d            # imm = 0x3C0
andb $0x3f, %r8b
shll $0xa, %edi
leal 0x10000(%rdi), %r10d
orl %edi, %r9d
movl %r10d, %edi
shrl $0xc, %edi
shrl $0x12, %r10d
shrl $0x6, %r9d
andb $0x3f, %dil
vmovd %r10d, %xmm1
andb $0x3f, %r9b
vpinsrb $0x1, %edi, %xmm1, %xmm1
movl $0x4, %edi
vpinsrb $0x2, %r9d, %xmm1, %xmm1
vpinsrb $0x3, %r8d, %xmm1, %xmm1
leaq 0x4(%rsi,%rcx), %r8
vpor %xmm0, %xmm1, %xmm1
vmovd %xmm1, -0x4(%r8)
jmp 0x4ab7
cmpw $0x800, %di             # imm = 0x800
jae 0x4a7f
movl %edi, %r9d
shrl $0x6, %edi
andb $0x3f, %r9b
orb $-0x40, %dil
orb $-0x80, %r9b
movb %r9b, 0x1(%r8)
movb %dil, (%r8)
addq $0x2, %r8
movl $0x2, %edi
jmp 0x4ab7
movl %edi, %r8d
andb $0x3f, %r8b
orb $-0x80, %r8b
movb %r8b, 0x2(%rsi,%rcx)
movl %edi, %r8d
shrl $0x6, %r8d
shrl $0xc, %edi
andb $0x3f, %r8b
orb $-0x20, %dil
orb $-0x80, %r8b
movb %r8b, 0x1(%rsi,%rcx)
movb %dil, (%rsi,%rcx)
leaq (%rax,%rcx), %r8
movl $0x3, %edi
movb $0x0, (%r8)
addq %rdi, %rcx
incq %rdx
jmp 0x499b
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/WojciechMula[P]utf16utf8/tests/unittest.cpp
// Function: validate_no_surrogates()
bool validate_no_surrogates() {
    puts("Test transcoding random string (without surrogates)");
    std::random_device rd{};
    RandomUTF16 generator(rd,
        /* 1 byte */  1,
        /* 2 bytes */ 1,
        /* 3 bytes */ 1,
        /* 4 bytes */ 0
    );
    for(size_t t = 0; t < 10000; t++) {
      const auto UTF16 = generator.generate(512);
      const size_t size = UTF16.size() - 1;
      if(!validate(UTF16, size)) {
          return false;
      }
      if(!validate_hybrid(UTF16, size)) {
          return false;
      }
    }
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2788, %rsp           # imm = 0x2788
leaq 0x66c1(%rip), %rdi      # 0xb32e
callq 0x21d0
leaq 0x1400(%rsp), %rbx
movq %rbx, %rdi
callq 0x5832
leaq 0x20(%rsp), %rdi
movl $0x1, %edx
movl $0x1, %ecx
movl $0x1, %r8d
movq %rbx, %rsi
xorl %r9d, %r9d
callq 0x23fc
leaq 0x8(%rsp), %r14
leaq 0x20(%rsp), %r15
xorl %ebx, %ebx
xorl %r13d, %r13d
movl $0x200, %edx            # imm = 0x200
movq %r14, %rdi
movq %r15, %rsi
callq 0x250a
movq 0x10(%rsp), %r12
subq 0x8(%rsp), %r12
sarq %r12
decq %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x476f
testb %al, %al
je 0x4d24
movq %r14, %rdi
movq %r12, %rsi
callq 0x4ac8
movq 0x8(%rsp), %rdi
movl %eax, %ebp
testq %rdi, %rdi
je 0x4d04
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
testb %bpl, %bpl
je 0x4d3b
cmpq $0x270f, %r13           # imm = 0x270F
leaq 0x1(%r13), %rax
setae %bl
movq %rax, %r13
cmpq $0x2710, %rax           # imm = 0x2710
jne 0x4cb1
jmp 0x4d3b
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x4d3b
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
movq 0x13c0(%rsp), %rdi
testq %rdi, %rdi
je 0x4d58
movq 0x13d0(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
movq 0x13a8(%rsp), %rdi
testq %rdi, %rdi
je 0x4d75
movq 0x13b8(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
leaq 0x1400(%rsp), %rdi
callq 0x2150
andb $0x1, %bl
movl %ebx, %eax
addq $0x2788, %rsp           # imm = 0x2788
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4dde
movq %rax, %rbx
jmp 0x4dc9
movq %rax, %rbx
jmp 0x4dbf
movq 0x8(%rsp), %rdi
movq %rax, %rbx
testq %rdi, %rdi
je 0x4dbf
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
leaq 0x20(%rsp), %rdi
callq 0x58ac
leaq 0x1400(%rsp), %rdi
callq 0x2150
movq %rbx, %rdi
callq 0x2210
movq %rax, %rdi
callq 0x5a3f
// File: /workspace/github_cpp_makefile_star2_O3/WojciechMula[P]utf16utf8/tests/unittest.cpp
// Function: validate_surrogates()
bool validate_surrogates() {
    puts("Test transcoding random string (only surrogates)");
    std::random_device rd{};
    RandomUTF16 generator(rd,
        /* 1 byte */  0,
        /* 2 bytes */ 0,
        /* 3 bytes */ 0,
        /* 4 bytes */ 1
    );
    for(size_t t = 0; t < 10000; t++) {
      const long seed = 1;
      const auto UTF16 = generator.generate(512, seed);
      const size_t size = UTF16.size() - 1;

      return validate(UTF16, size) && validate_hybrid(UTF16, size);
    }
    return true;
}

// Assembly:
pushq %rbx
subq $0x2780, %rsp           # imm = 0x2780
leaq 0x656d(%rip), %rdi      # 0xb362
callq 0x21d0
leaq 0x13f8(%rsp), %rbx
movq %rbx, %rdi
callq 0x5832
leaq 0x18(%rsp), %rdi
movl $0x1, %r9d
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x23fc
leaq 0x18(%rsp), %rsi
movl $0x200, %edx            # imm = 0x200
movl $0x1, %ecx
movq %rsp, %rdi
callq 0x264c
movq %rsp, %rdi
movq 0x8(%rdi), %rbx
subq (%rdi), %rbx
sarq %rbx
decq %rbx
movq %rbx, %rsi
callq 0x476f
testb %al, %al
je 0x4e66
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x4ac8
movl %eax, %ebx
jmp 0x4e68
xorl %ebx, %ebx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4e7e
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
movq 0x13b8(%rsp), %rdi
testq %rdi, %rdi
je 0x4e9b
movq 0x13c8(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
movq 0x13a0(%rsp), %rdi
testq %rdi, %rdi
je 0x4eb8
movq 0x13b0(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
leaq 0x13f8(%rsp), %rdi
callq 0x2150
movl %ebx, %eax
addq $0x2780, %rsp           # imm = 0x2780
popq %rbx
retq
jmp 0x4f14
movq %rax, %rbx
jmp 0x4ef5
movq %rax, %rbx
jmp 0x4eff
movq (%rsp), %rdi
movq %rax, %rbx
testq %rdi, %rdi
je 0x4ef5
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
leaq 0x18(%rsp), %rdi
callq 0x58ac
leaq 0x13f8(%rsp), %rdi
callq 0x2150
movq %rbx, %rdi
callq 0x2210
movq %rax, %rdi
callq 0x5a3f
// File: /workspace/github_cpp_makefile_star2_O3/WojciechMula[P]utf16utf8/tests/unittest.cpp
// Function: validate_all()
bool validate_all() {
    puts("Validate all input values");
    std::vector<uint16_t> input;
    input.resize(8 + 1);

    for (uint16_t value=1; value <= 0x0800; value++) {
        if (value >= 0xd800 && value <= 0xdfff) // skip reserved values
            continue;

        for (int i=0; i < 8; i++)
            input[i] = value;

        if (!validate(input, 8)) {
            printf("Failed for %04x\n", value);
            return false;
        }
        if (!validate_hybrid(input, 8)) {
            printf("Failed for %04x\n", value);
            return false;
        }
    }

    return true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
leaq 0x6468(%rip), %rdi      # 0xb393
callq 0x21d0
vpxor %xmm0, %xmm0, %xmm0
movq %rsp, %rdi
movq $0x0, 0x10(%rdi)
vmovdqa %xmm0, (%rdi)
movl $0x9, %esi
callq 0x58ea
movl $0x1, %ebp
xorl %ebx, %ebx
movq %rsp, %r14
movq (%rsp), %rax
vpbroadcastw %ebp, %xmm0
vmovdqu %xmm0, (%rax)
movl $0x8, %esi
movq %r14, %rdi
callq 0x476f
testb %al, %al
je 0x4f9c
movl $0x8, %esi
movq %r14, %rdi
callq 0x4ac8
testb %al, %al
je 0x4f9c
cmpw $0x800, %bp             # imm = 0x800
setae %bl
incl %ebp
cmpw $0x801, %bp             # imm = 0x801
jne 0x4f57
movb $0x1, %bl
jmp 0x4fac
leaq 0x640a(%rip), %rdi      # 0xb3ad
movl %ebp, %esi
xorl %eax, %eax
callq 0x2030
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4fc2
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
andb $0x1, %bl
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x4fd2
movq (%rsp), %rdi
movq %rax, %rbx
testq %rdi, %rdi
je 0x4feb
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O3/WojciechMula[P]utf16utf8/tests/unittest.cpp
// Function: validate_no_surrogates_from_utf8()
bool validate_no_surrogates_from_utf8() {
    puts("Test transcoding random string from utf8 (without surrogates)");
    std::random_device rd{};
    RandomUTF8 generator(rd,
        /* 1 byte */  1,
        /* 2 bytes */ 1,
        /* 3 bytes */ 1,
        /* 4 bytes */ 0
    );
    for(size_t t = 0; t < 10000; t++) {
      auto UTF8 = generator.generate(512);
      if(!validate_from_utf8(UTF8)) {
          return false;
      }
    }
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2770, %rsp           # imm = 0x2770
leaq 0x602e(%rip), %rdi      # 0xb3d3
callq 0x21d0
leaq 0x13e8(%rsp), %rbx
movq %rbx, %rdi
callq 0x5832
leaq 0x20(%rsp), %rdi
movl $0x1, %edx
movl $0x1, %ecx
movl $0x1, %r8d
movq %rbx, %rsi
xorl %r9d, %r9d
callq 0x31cc
leaq 0x8(%rsp), %r14
leaq 0x20(%rsp), %r15
xorl %ebx, %ebx
xorl %r12d, %r12d
movl $0x200, %edx            # imm = 0x200
movq %r14, %rdi
movq %r15, %rsi
callq 0x3282
movq %r14, %rdi
callq 0x4ff3
movq 0x8(%rsp), %rdi
movl %eax, %ebp
testq %rdi, %rdi
je 0x541a
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
testb %bpl, %bpl
je 0x5439
cmpq $0x270f, %r12           # imm = 0x270F
leaq 0x1(%r12), %rax
setae %bl
movq %rax, %r12
cmpq $0x2710, %rax           # imm = 0x2710
jne 0x53e9
movq 0x13c0(%rsp), %rdi
testq %rdi, %rdi
je 0x5456
movq 0x13d0(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
movq 0x13a8(%rsp), %rdi
testq %rdi, %rdi
je 0x5473
movq 0x13b8(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
leaq 0x13e8(%rsp), %rdi
callq 0x2150
andb $0x1, %bl
movl %ebx, %eax
addq $0x2770, %rsp           # imm = 0x2770
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x54da
movq %rax, %rbx
jmp 0x54c5
movq %rax, %rbx
jmp 0x54bb
movq 0x8(%rsp), %rdi
movq %rax, %rbx
testq %rdi, %rdi
je 0x54bb
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
leaq 0x20(%rsp), %rdi
callq 0x5a02
leaq 0x13e8(%rsp), %rdi
callq 0x2150
movq %rbx, %rdi
callq 0x2210
movq %rax, %rdi
callq 0x5a3f
// File: /workspace/github_cpp_makefile_star2_O3/WojciechMula[P]utf16utf8/tests/unittest.cpp
// Function: validate_with_surrogates_from_utf8()
bool validate_with_surrogates_from_utf8() {
    puts("Test transcoding random string from utf8 (with surrogates)");
    std::random_device rd{};
    RandomUTF8 generator(rd,
        /* 1 byte */  1,
        /* 2 bytes */ 1,
        /* 3 bytes */ 1,
        /* 4 bytes */ 1
    );
    for(size_t t = 0; t < 10000; t++) {
      auto UTF8 = generator.generate(512);
      if(!validate_from_utf8(UTF8)) {
          return false;
      }
    }
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2770, %rsp           # imm = 0x2770
leaq 0x5f19(%rip), %rdi      # 0xb411
callq 0x21d0
leaq 0x13e8(%rsp), %rbx
movq %rbx, %rdi
callq 0x5832
leaq 0x20(%rsp), %rdi
movl $0x1, %edx
movl $0x1, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
movq %rbx, %rsi
callq 0x31cc
leaq 0x8(%rsp), %r14
leaq 0x20(%rsp), %r15
xorl %ebx, %ebx
xorl %r12d, %r12d
movl $0x200, %edx            # imm = 0x200
movq %r14, %rdi
movq %r15, %rsi
callq 0x3282
movq %r14, %rdi
callq 0x4ff3
movq 0x8(%rsp), %rdi
movl %eax, %ebp
testq %rdi, %rdi
je 0x5570
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
testb %bpl, %bpl
je 0x558f
cmpq $0x270f, %r12           # imm = 0x270F
leaq 0x1(%r12), %rax
setae %bl
movq %rax, %r12
cmpq $0x2710, %rax           # imm = 0x2710
jne 0x553f
movq 0x13c0(%rsp), %rdi
testq %rdi, %rdi
je 0x55ac
movq 0x13d0(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
movq 0x13a8(%rsp), %rdi
testq %rdi, %rdi
je 0x55c9
movq 0x13b8(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
leaq 0x13e8(%rsp), %rdi
callq 0x2150
andb $0x1, %bl
movl %ebx, %eax
addq $0x2770, %rsp           # imm = 0x2770
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5630
movq %rax, %rbx
jmp 0x561b
movq %rax, %rbx
jmp 0x5611
movq 0x8(%rsp), %rdi
movq %rax, %rbx
testq %rdi, %rdi
je 0x5611
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
leaq 0x20(%rsp), %rdi
callq 0x5a02
leaq 0x13e8(%rsp), %rdi
callq 0x2150
movq %rbx, %rdi
callq 0x2210
movq %rax, %rdi
callq 0x5a3f
// File: /workspace/github_cpp_makefile_star2_O3/WojciechMula[P]utf16utf8/tests/unittest.cpp
// Function: main
int main() {

    if(!validate_no_surrogates_from_utf8())
        return EXIT_FAILURE;

    if(!validate_with_surrogates_from_utf8())
        return EXIT_FAILURE;

    if (!validate_all())
        return EXIT_FAILURE;

    if (!validate_no_surrogates())
        return EXIT_FAILURE;

    if (!validate_surrogates())
        return EXIT_FAILURE;

    puts("All OK");
    return EXIT_SUCCESS;
}

// Assembly:
pushq %rbx
movl $0x1, %ebx
callq 0x538f
testb %al, %al
je 0x5679
callq 0x54e2
testb %al, %al
je 0x5679
callq 0x4f1c
testb %al, %al
je 0x5679
callq 0x4c55
testb %al, %al
je 0x5679
callq 0x4de6
testb %al, %al
je 0x5679
leaq 0x5dda(%rip), %rdi      # 0xb44c
callq 0x21d0
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
retq