LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0x15448(%rip), %rbx     # 0x1aff0
leaq 0xc613(%rip), %rsi      # 0x121c2
movq %rbx, %rdi
callq 0x4290
leaq 0xc64c(%rip), %rsi      # 0x1220a
movq %rbx, %rdi
callq 0x4290
leaq 0xc66a(%rip), %rsi      # 0x12237
movq %rbx, %rdi
callq 0x4290
leaq 0xc66d(%rip), %rsi      # 0x12249
movq %rbx, %rdi
callq 0x4290
pushq $0x1
popq %rdi
callq 0x4340
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
callq 0x4400
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x6ff6
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x4250
leaq 0x8(%rsp), %rdi
callq 0x4150
leaq 0x28(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
movq $0x2, 0x38(%rsp,%rax)
pushq $0x30
popq %rsi
callq 0x44b0
movq %rax, %r15
movq %r14, %rdi
callq 0x6fe6
movq %r15, %rdi
movl %eax, %esi
callq 0x4540
leaq 0x28(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
movq $0x2, 0x38(%rsp,%rax)
pushq $0x30
popq %rsi
callq 0x44b0
movq %rax, %r15
movq %r14, %rdi
callq 0x6fea
movq %r15, %rdi
movl %eax, %esi
callq 0x4540
leaq 0xc3e0(%rip), %rsi      # 0x12079
leaq 0x28(%rsp), %rdi
callq 0x4290
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x44c0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5e16
leaq 0x8(%rsp), %rdi
callq 0x4150
leaq 0x28(%rsp), %rdi
callq 0x40a0
movq %rbx, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %r15
retq
jmp 0x5ce7
jmp 0x5cf8
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4150
jmp 0x5cfb
jmp 0x5cf8
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x40a0
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4400
leaq 0xc478(%rip), %rsi      # 0x121ab
movq %r15, %rdi
callq 0x4290
leaq 0x28(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
movq $0x2, 0x38(%rsp,%rax)
pushq $0x30
popq %rsi
callq 0x44b0
movq %rax, %r15
movq %r14, %rdi
callq 0x6ff2
movq %r15, %rdi
movl %eax, %esi
callq 0x4540
leaq 0x28(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
movq $0x2, 0x38(%rsp,%rax)
pushq $0x30
popq %rsi
callq 0x44b0
movq %rax, %r15
movq %r14, %rdi
callq 0x6fee
movq %r15, %rdi
movl %eax, %esi
callq 0x4540
leaq 0xc2d3(%rip), %rsi      # 0x12079
leaq 0x28(%rsp), %rdi
callq 0x4290
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x44c0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5e16
leaq 0x8(%rsp), %rdi
callq 0x4150
leaq 0x28(%rsp), %rdi
callq 0x40a0
movq %rbx, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4150
jmp 0x5e04
jmp 0x5e01
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x40a0
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rdi), %r12
leaq 0x18(%rdi), %rbx
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x8(%rdi)
leaq 0xb238(%rip), %rsi      # 0x1217c
movq %rbx, %rdi
callq 0x45b0
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x6c7a
leaq 0xb247(%rip), %rsi      # 0x121a7
movq %rbx, %rdi
callq 0x607c
testb %al, %al
je 0x6fa1
movdqu (%r12), %xmm0
pshufd $0xb1, %xmm0, %xmm1     # xmm1 = xmm0[1,0,3,2]
cmpl $0x0, (%r12)
movdqu %xmm1, (%r12)
jns 0x6f8c
movl $0x3, 0xc(%r14)
pshufd $0xee, %xmm0, %xmm0     # xmm0 = xmm0[2,3,2,3]
movd %xmm0, %eax
testl %eax, %eax
jns 0x6fa1
movl $0x1, 0x14(%r14)
leaq 0xb32c(%rip), %rsi      # 0x122d4
movq %rbx, %rdi
callq 0x607c
testb %al, %al
je 0x6fda
movaps 0xb2f5(%rip), %xmm0     # 0x122b0
movups %xmm0, (%r12)
leaq 0xb1e0(%rip), %rsi      # 0x121a7
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x45b0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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), %r14
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x291c
movl $0x1, 0x3c(%rbx)
movq %r15, %rdi
callq 0x293c
movq 0x278f(%rip), %r12      # 0x4fd8
leaq 0x830(%rip), %rsi       # 0x3080
movq %r12, %rdi
callq 0x2100
movl 0x40(%rbx), %esi
movq %rax, %rdi
callq 0x2190
leaq 0x81e(%rip), %rsi       # 0x3088
movq %rax, %rdi
callq 0x2100
movq %rax, %rdi
callq 0x2080
movq %r15, %rdi
movq %r14, %rsi
callq 0x291c
movl 0x38(%rbx), %r13d
cmpl $0x2, %r13d
jne 0x28ba
movl $0x2, 0x3c(%rbx)
movq %r12, %rdi
leaq 0x7f1(%rip), %rsi       # 0x3091
callq 0x2100
movl 0x40(%rbx), %esi
movq %rax, %rdi
callq 0x2190
movq %rax, %rdi
callq 0x2080
jmp 0x28cb
movq 0x30(%rbx), %rdi
movq %r15, %rsi
movl $0x3e8, %edx            # imm = 0x3E8
callq 0x2956
movq %r15, %rdi
callq 0x293c
cmpl $0x2, %r13d
je 0x28f8
movq %r12, %rdi
leaq 0x7bf(%rip), %rsi       # 0x30a2
callq 0x2100
movl 0x40(%rbx), %esi
movq %rax, %rdi
callq 0x2190
jmp 0x2872
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x293c
movq %rbx, %rdi
callq 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x2e25(%rip), %rbx      # 0x3fe0
leaq 0x4(%rsp), %r14
pushq $0x4
popq %r15
movq 0x2e05(%rip), %r12      # 0x3fd0
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1060
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x1202
testb $0x2, 0x4(%rsp)
je 0x11cb
movq %r12, %rdi
xorl %esi, %esi
callq 0x1040
movq %rax, %rdi
callq 0x1030
jmp 0x11cb
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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), %r12
movq %r12, %rdi
callq 0x232c
xorpd %xmm0, %xmm0
leaq -0x40(%rbp), %r14
movapd %xmm0, (%r14)
andq $0x0, 0x10(%r14)
movq (%r12), %r15
movq 0x8(%r12), %r12
cmpq %r12, %r15
je 0x26ff
movsd 0x40(%r15), %xmm0
ucomisd 0x192a(%rip), %xmm0     # 0x4008
jb 0x26f9
movsd 0x1928(%rip), %xmm1     # 0x4010
ucomisd %xmm0, %xmm1
jb 0x26f9
movq %r14, %rdi
movq %r15, %rsi
callq 0x2b8a
addq $0x48, %r15
jmp 0x26cb
xorpd %xmm0, %xmm0
andq $0x0, 0x10(%rbx)
movupd %xmm0, (%rbx)
movq -0x40(%rbp), %r14
movq -0x38(%rbp), %r12
leaq 0x21d8(%rip), %r15      # 0x48f3
cmpq %r12, %r14
je 0x2745
leaq 0x20(%r14), %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x21b0
cmpq $-0x1, %rax
je 0x273f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2b8a
addq $0x48, %r14
jmp 0x271b
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
leaq 0x221(%rip), %rdx       # 0x2974
callq 0x2db5
leaq -0x40(%rbp), %rdi
callq 0x2948
leaq -0x58(%rbp), %rdi
callq 0x2948
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2781
movq %rax, %r14
jmp 0x278c
movq %rax, %r14
movq %rbx, %rdi
callq 0x2948
leaq -0x40(%rbp), %rdi
callq 0x2948
leaq -0x58(%rbp), %rdi
callq 0x2948
movq %r14, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x78, %rsp
callq 0x20a0
movq %rax, -0x30(%rbp)
leaq -0x50(%rbp), %r14
andq $0x0, 0x10(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
movl $0xf4240, %ebx          # imm = 0xF4240
leaq -0x98(%rbp), %r15
subl $0x1, %ebx
jb 0x27fe
movq %r15, %rdi
callq 0x2692
movq %r14, %rdi
movq %r15, %rsi
callq 0x364e
movq %r15, %rdi
callq 0x2948
jmp 0x27dc
callq 0x20a0
movq %rax, %r14
movq -0x50(%rbp), %r15
movq -0x48(%rbp), %rbx
leaq -0x98(%rbp), %r12
movq 0x47bc(%rip), %r13      # 0x6fd8
cmpq %rbx, %r15
je 0x284d
movq %r12, %rdi
movq %r15, %rsi
callq 0x2988
movq %r13, %rdi
movq %r12, %rsi
callq 0x36bc
movq %rax, %rdi
callq 0x2080
movq %r12, %rdi
callq 0x2928
addq $0x48, %r15
jmp 0x281c
subq -0x30(%rbp), %r14
cvtsi2sd %r14, %xmm0
divsd 0x17ba(%rip), %xmm0     # 0x4018
movsd %xmm0, -0x30(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x2948
movsd -0x30(%rbp), %xmm0
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2882
movq %rax, %rbx
jmp 0x2896
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0x2928
leaq -0x50(%rbp), %rdi
callq 0x2948
movq %rbx, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O2/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
callq 0x27a6
movsd %xmm0, -0x8(%rbp)
movq 0x4718(%rip), %rdi      # 0x6fd8
leaq 0x1fd0(%rip), %rsi      # 0x4897
callq 0x20e0
movq %rax, %rdi
movsd -0x8(%rbp), %xmm0
callq 0x2180
movq %rax, %rdi
callq 0x2080
callq 0x2150
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1221(%rip), %rsi      # 0x48fb
callq 0x20e0
movq %rax, %rdi
movq %r14, %rsi
callq 0x20d0
movq %rax, %rdi
callq 0x2080
leaq 0x20(%r14), %r15
movq 0x28(%r14), %r13
leaq 0x1201(%rip), %rsi      # 0x4902
movq %rbx, %rdi
callq 0x20e0
movq %rax, %r12
cmpq $0x33, %r13
jb 0x3753
leaq -0x48(%rbp), %r13
pushq $0x31
popq %rcx
movq %r13, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x2110
movq %r12, %rdi
movq %r13, %rsi
callq 0x20d0
leaq 0x11d8(%rip), %rsi      # 0x4910
movq %rax, %rdi
callq 0x20e0
movq %rax, %rdi
callq 0x2080
leaq -0x48(%rbp), %rdi
callq 0x2070
jmp 0x3766
movq %r12, %rdi
movq %r15, %rsi
callq 0x20d0
movq %rax, %rdi
callq 0x2080
leaq 0x11a7(%rip), %rsi      # 0x4914
movq %rbx, %rdi
callq 0x20e0
movsd 0x40(%r14), %xmm0
movq %rax, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x2080
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rdi, 0x8(%rsp)
movb $0x0, 0x10(%rdi)
movq 0x5b67(%rip), %rdi      # 0x7fd0
leaq 0x2bb0(%rip), %rsi      # 0x5020
callq 0x2120
movq %rax, %rdi
movq %r14, %rsi
callq 0x2110
leaq 0x2bb3(%rip), %rsi      # 0x503a
movq %rax, %rdi
callq 0x2120
leaq 0x5cb2(%rip), %rsi      # 0x8148
leaq 0x5cc3(%rip), %rdx      # 0x8160
leaq 0x10(%rsp), %rdi
pushq $0x4
popq %r8
movq %r14, %rcx
callq 0x3008
movq 0x5b1b(%rip), %rdi      # 0x7fd0
leaq 0x2b83(%rip), %rsi      # 0x503f
callq 0x2120
movq %rax, %rdi
movq 0x18(%rsp), %rax
subq 0x10(%rsp), %rax
pushq $0x28
popq %r13
cqto
idivq %r13
movq %rax, %rsi
callq 0x20e0
leaq 0x2b5e(%rip), %rsi      # 0x5044
movq %rax, %rdi
callq 0x2120
pushq $0x8
popq %rbp
xorl %ebx, %ebx
leaq 0x2b43(%rip), %r14      # 0x503d
leaq 0x28(%rsp), %r15
movq 0x5aca(%rip), %r12      # 0x7fd0
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rax
subq %rsi, %rax
cqto
idivq %r13
cmpq %rbx, %rax
jbe 0x2547
addq %rbp, %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x2965
movq %r12, %rdi
movq %r15, %rsi
callq 0x2110
movq %r15, %rdi
callq 0x20a0
incq %rbx
addq $0x28, %rbp
jmp 0x2506
leaq 0x10(%rsp), %rdi
callq 0x299e
movq 0x8(%rsp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2569
jmp 0x257d
movq %rax, %r14
jmp 0x258a
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x20a0
jmp 0x2580
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x299e
movq 0x8(%rsp), %rdi
callq 0x20a0
movq %r14, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4483
shrl %esi
incl %ecx
jmp 0x4478
pushq $0x4
popq %rax
shll %cl, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x44f8
subq %rax, %rsi
shrq $0x2, %rsi
movq %rbx, %rdi
callq 0x4450
movq 0x8(%r14), %r15
subq (%r14), %r15
shrq $0x2, %r15
decl %r15d
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x2a2a
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
movl %r15d, %ecx
movq %r12, %r8
callq 0x4520
movq %rsp, %rdi
callq 0x2e06
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
xorl %esi, %esi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4450
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2e06
movq %rbx, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %r8, %r12
movl %ecx, %ebx
movl %ecx, %ebp
subl %edx, %ebp
jne 0x4553
movl %ebx, %eax
movq (%r12), %rcx
movl (%rcx,%rax,4), %ecx
movl %esi, %eax
movq 0x8(%rdi), %rdx
leaq (%rdx,%rax,8), %rax
movl %ecx, (%rax)
jmp 0x4607
movl %edx, %r14d
shrl %ebp
addl %edx, %ebp
movq %rsi, 0x10(%rsp)
leal 0x1(,%rsi,2), %eax
movl %eax, (%rsp)
leaq 0x30(%rsp), %r13
movq %rdi, %r15
movq %r13, %rdi
movq %r12, %rsi
callq 0x2a2a
movq %r15, 0x8(%rsp)
movq %r15, %rdi
movl (%rsp), %esi
movl %r14d, %edx
movl %ebp, %ecx
movq %r13, %r8
callq 0x4520
movq %rax, (%rsp)
movq 0x10(%rsp), %r15
leal (%r15,%r15), %r14d
leaq 0x30(%rsp), %rdi
callq 0x2e06
addl $0x2, %r14d
incl %ebp
leaq 0x18(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x2a2a
movq 0x8(%rsp), %rdi
movl %r14d, %esi
movl %ebp, %edx
movl %ebx, %ecx
movq %r13, %r8
callq 0x4520
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x2e06
movq (%rsp), %rdx
cmpl %ebx, %edx
movl %r15d, %eax
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
leaq (%rcx,%rax,8), %rax
movl %ebx, %ecx
cmoval %edx, %ecx
movl %ecx, (%rax)
cmovaq %rdx, %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
jmp 0x461e
movq %rax, %rbx
movq %r13, %rdi
callq 0x2e06
movq %rbx, %rdi
callq 0x2200
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4440
movq (%r14), %rcx
movq (%rbx), %rdx
xorl %eax, %eax
cmpq %rax, %rsi
je 0x4450
movb (%rcx,%rax), %dil
cmpb (%rdx,%rax), %dil
jne 0x4455
incq %rax
jmp 0x442c
leaq 0x6d0b(%rip), %rdi      # 0xb152
xorl %eax, %eax
callq 0x2030
jmp 0x4466
movb $0x1, %bpl
jmp 0x44a8
leaq 0x6d2f(%rip), %rdi      # 0xb18b
movq %rax, %rsi
xorl %eax, %eax
callq 0x2030
leaq 0x6d04(%rip), %rdi      # 0xb171
xorl %eax, %eax
xorl %ebp, %ebp
callq 0x2030
movq %r14, %rdi
callq 0x43d8
pushq $0xa
popq %r14
movl %r14d, %edi
callq 0x21b0
leaq 0x6ced(%rip), %rdi      # 0xb17e
xorl %eax, %eax
callq 0x2030
movq %rbx, %rdi
callq 0x43d8
movl %r14d, %edi
callq 0x21b0
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x60, %rsp
leaq 0x10(%rsp), %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq (,%rsi,4), %rsi
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %rsp, %rdi
callq 0x2190
movq (%rbx), %rdi
movq (%rsp), %rsi
callq 0x45c3
movq (%rsp), %rsi
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x2060
leaq 0x6c6c(%rip), %rsi      # 0xb170
movq %rsp, %rdi
callq 0x2240
leaq (,%r14,8), %rsi
movq %rsp, %rdi
callq 0x2190
movq (%rsp), %rdx
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x3918
movq (%rsp), %rsi
leaq 0x30(%rsp), %rcx
movq %rcx, -0x10(%rcx)
addq %rsi, %rax
leaq 0x20(%rsp), %rdi
movq %rax, %rdx
callq 0x5340
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x440d
movl %eax, %ebp
testb %al, %al
jne 0x4565
movq %rbx, %rdi
callq 0x513a
leaq 0x20(%rsp), %rdi
callq 0x2090
leaq 0x40(%rsp), %rdi
callq 0x2090
movq %rsp, %rdi
callq 0x2090
movl %ebp, %eax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x20(%rsp), %rdi
movq %rax, %rbx
callq 0x2090
jmp 0x45a9
jmp 0x45a6
jmp 0x45a6
jmp 0x45a1
movq %rax, %rbx
jmp 0x45b3
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x2090
movq %rsp, %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/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 0x46fb
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
jne 0x4627
xorl %eax, %eax
movq %rsp, %r15
xorl %r14d, %r14d
movq %rax, (%rsp)
cmpw $0x0, (%rbx,%rax,2)
je 0x4616
leaq (%rbx,%rax,2), %rdi
movq %r15, %rsi
callq 0x4fbe
movl %eax, %edi
callq 0x5000
movl %eax, %eax
addq %rax, %r14
movq (%rsp), %rax
incq %rax
jmp 0x45ea
incq %r14
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x20e0
movq %rax, %r14
pushq $0x1
popq %rbp
xorl %eax, %eax
movq %rsp, %r15
pushq $0x1
popq %r12
xorl %r13d, %r13d
movq %rax, (%rsp)
testl %ebp, %ebp
je 0x46ed
leaq (%rbx,%rax,2), %rdi
movq %r15, %rsi
callq 0x4fbe
movl %eax, %ebp
leaq (%r14,%r13), %rax
cmpl $0x7f, %ebp
ja 0x4665
movb %bpl, (%rax)
movq %r12, %rdx
testl %ebp, %ebp
jne 0x46d1
jmp 0x46d5
cmpl $0x7ff, %ebp            # imm = 0x7FF
ja 0x4684
movl %ebp, %ecx
andb $0x3f, %cl
orb $-0x80, %cl
movb %cl, 0x1(%rax)
movl %ebp, %ecx
shrl $0x6, %ecx
orb $-0x40, %cl
pushq $0x2
jmp 0x46ce
movl %ebp, %edx
movl %ebp, %esi
shrl $0x6, %esi
movl %ebp, %ecx
shrl $0xc, %ecx
andb $0x3f, %sil
andb $0x3f, %dl
orb $-0x80, %dl
orb $-0x80, %sil
cmpl $0xffff, %ebp           # imm = 0xFFFF
ja 0x46b4
orb $-0x20, %cl
movb %dl, 0x2(%rax)
movb %sil, 0x1(%rax)
pushq $0x3
jmp 0x46ce
andb $0x3f, %cl
movb %dl, 0x3(%rax)
movb %sil, 0x2(%rax)
orb $-0x80, %cl
movb %cl, 0x1(%rax)
movl %ebp, %ecx
shrl $0x12, %ecx
orb $-0x10, %cl
pushq $0x4
popq %rdx
movb %cl, (%rax)
movb $0x0, (%rax,%rdx)
movl %ebp, %edi
callq 0x5000
movl %eax, %eax
addq %rax, %r13
movq (%rsp), %rax
incq %rax
jmp 0x4636
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x2780, %rsp           # imm = 0x2780
leaq 0x6978(%rip), %rdi      # 0xb19e
callq 0x21e0
leaq 0x13f8(%rsp), %rbx
movq %rbx, %rdi
callq 0x51ca
leaq 0x18(%rsp), %rdi
pushq $0x1
popq %rcx
movq %rbx, %rsi
movl %ecx, %edx
movl %ecx, %r8d
xorl %r9d, %r9d
callq 0x239c
leaq 0x18(%rsp), %r14
xorl %eax, %eax
movq %rsp, %rbx
movq %rax, %r12
cmpq $0x2710, %rax           # imm = 0x2710
je 0x48bf
movl $0x200, %edx            # imm = 0x200
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2476
movq 0x8(%rsp), %r15
subq (%rsp), %r15
sarq %r15
decq %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x44af
testb %al, %al
je 0x48b7
movq %rbx, %rdi
movq %r15, %rsi
callq 0x46fc
movq %rbx, %rdi
movl %eax, %ebp
callq 0x2e22
leaq 0x1(%r12), %rax
testb %bpl, %bpl
jne 0x485d
jmp 0x48bf
movq %rsp, %rdi
callq 0x2e22
cmpq $0x2710, %r12           # imm = 0x2710
leaq 0x13a0(%rsp), %rdi
setae %bl
callq 0x532a
leaq 0x13f8(%rsp), %rdi
callq 0x5220
movl %ebx, %eax
addq $0x2780, %rsp           # imm = 0x2780
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x4917
movq %rax, %rbx
jmp 0x490a
movq %rsp, %rdi
movq %rax, %rbx
callq 0x2e22
leaq 0x13a0(%rsp), %rdi
callq 0x532a
leaq 0x13f8(%rsp), %rdi
callq 0x5220
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6897(%rip), %rdi      # 0xb1d2
callq 0x21e0
leaq 0x13f8(%rsp), %rbx
movq %rbx, %rdi
callq 0x51ca
leaq 0x18(%rsp), %rdi
pushq $0x1
popq %r9
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x239c
movq %rsp, %rdi
leaq 0x18(%rsp), %rsi
pushq $0x1
popq %rcx
movl $0x200, %edx            # imm = 0x200
callq 0x252a
movq %rsp, %rdi
movq 0x8(%rdi), %rbx
subq (%rdi), %rbx
sarq %rbx
decq %rbx
movq %rbx, %rsi
callq 0x44af
testb %al, %al
je 0x49a8
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x46fc
movl %eax, %ebx
jmp 0x49aa
xorl %ebx, %ebx
movq %rsp, %rdi
callq 0x2e22
leaq 0x13a0(%rsp), %rdi
callq 0x532a
leaq 0x13f8(%rsp), %rdi
callq 0x5220
movl %ebx, %eax
addq $0x2780, %rsp           # imm = 0x2780
popq %rbx
retq
movq %rax, %rbx
jmp 0x49ec
movq %rax, %rbx
jmp 0x49f9
movq %rsp, %rdi
movq %rax, %rbx
callq 0x2e22
leaq 0x13a0(%rsp), %rdi
callq 0x532a
leaq 0x13f8(%rsp), %rdi
callq 0x5220
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/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 0x67e6(%rip), %rdi      # 0xb203
callq 0x21e0
movq %rsp, %rdi
andq $0x0, 0x10(%rdi)
vxorps %xmm0, %xmm0, %xmm0
vmovaps %xmm0, (%rdi)
pushq $0x9
popq %rsi
callq 0x5230
movw $0x1, %bp
movq %rsp, %rbx
pushq $0x8
popq %r14
cmpw $0x801, %bp             # imm = 0x801
je 0x4a94
movq (%rsp), %rax
xorl %ecx, %ecx
cmpq $0x8, %rcx
je 0x4a61
movw %bp, (%rax,%rcx,2)
incq %rcx
jmp 0x4a52
movq %rbx, %rdi
movq %r14, %rsi
callq 0x44af
testb %al, %al
je 0x4a83
movq %rbx, %rdi
movq %r14, %rsi
callq 0x46fc
testb %al, %al
je 0x4a83
incl %ebp
jmp 0x4a45
movzwl %bp, %esi
leaq 0x6790(%rip), %rdi      # 0xb21d
xorl %eax, %eax
callq 0x2030
cmpw $0x801, %bp             # imm = 0x801
movq %rsp, %rdi
setae %bl
callq 0x2e22
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x4ab1
movq %rsp, %rdi
movq %rax, %rbx
callq 0x2e22
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/WojciechMula[P]utf16utf8/include/reference.h
// Function: strlen_utf8_to_utf16(unsigned char const*)
static inline size_t strlen_utf8_to_utf16(const uint8_t *str)
{
	size_t i, count;
	uint32_t c;

	for (i=0, count=0; ; i++)
	{
		if (str[i]==0)
			return count;

		c = utf8_to_unicode32(&str[i], &i);
		count += codepoint_utf16_size(c);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %edi, %edi
movq %rsp, %r14
pushq $0x1
popq %r12
xorl %r15d, %r15d
movq %rdi, (%rsp)
cmpb $0x0, (%rbx,%rdi)
je 0x4d94
addq %rbx, %rdi
movq %r14, %rsi
callq 0x5033
movq (%rsp), %rdi
xorl %ecx, %ecx
cmpl $0x110000, %eax         # imm = 0x110000
setb %cl
addl %ecx, %ecx
cmpl $0x10000, %eax          # imm = 0x10000
cmovbq %r12, %rcx
addq %rcx, %r15
incq %rdi
jmp 0x4d5e
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x2768, %rsp           # imm = 0x2768
leaq 0x648c(%rip), %rdi      # 0xb243
callq 0x21e0
leaq 0x13e0(%rsp), %rbx
movq %rbx, %rdi
callq 0x51ca
leaq 0x18(%rsp), %rdi
pushq $0x1
popq %rcx
movq %rbx, %rsi
movl %ecx, %edx
movl %ecx, %r8d
xorl %r9d, %r9d
callq 0x3078
leaq 0x18(%rsp), %r14
xorl %eax, %eax
movq %rsp, %rbx
movq %rax, %r15
cmpq $0x2710, %rax           # imm = 0x2710
je 0x4e24
movl $0x200, %edx            # imm = 0x200
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3104
movq %rbx, %rdi
callq 0x4ac4
movq %rbx, %rdi
movl %eax, %ebp
callq 0x34d6
leaq 0x1(%r15), %rax
testb %bpl, %bpl
jne 0x4dee
cmpq $0x2710, %r15           # imm = 0x2710
leaq 0x13a0(%rsp), %rdi
setae %bl
callq 0x532a
leaq 0x13e0(%rsp), %rdi
callq 0x5220
movl %ebx, %eax
addq $0x2768, %rsp           # imm = 0x2768
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x4e7a
movq %rsp, %rdi
movq %rax, %rbx
callq 0x34d6
jmp 0x4e6d
movq %rax, %rbx
leaq 0x13a0(%rsp), %rdi
callq 0x532a
leaq 0x13e0(%rsp), %rdi
callq 0x5220
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x2768, %rsp           # imm = 0x2768
leaq 0x63de(%rip), %rdi      # 0xb281
callq 0x21e0
leaq 0x13e0(%rsp), %rbx
movq %rbx, %rdi
callq 0x51ca
leaq 0x18(%rsp), %rdi
pushq $0x1
popq %rcx
movq %rbx, %rsi
movl %ecx, %edx
movl %ecx, %r8d
movl %ecx, %r9d
callq 0x3078
leaq 0x18(%rsp), %r14
xorl %eax, %eax
movq %rsp, %rbx
movq %rax, %r15
cmpq $0x2710, %rax           # imm = 0x2710
je 0x4f10
movl $0x200, %edx            # imm = 0x200
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3104
movq %rbx, %rdi
callq 0x4ac4
movq %rbx, %rdi
movl %eax, %ebp
callq 0x34d6
leaq 0x1(%r15), %rax
testb %bpl, %bpl
jne 0x4eda
cmpq $0x2710, %r15           # imm = 0x2710
leaq 0x13a0(%rsp), %rdi
setae %bl
callq 0x532a
leaq 0x13e0(%rsp), %rdi
callq 0x5220
movl %ebx, %eax
addq $0x2768, %rsp           # imm = 0x2768
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x4f66
movq %rsp, %rdi
movq %rax, %rbx
callq 0x34d6
jmp 0x4f59
movq %rax, %rbx
leaq 0x13a0(%rsp), %rdi
callq 0x532a
leaq 0x13e0(%rsp), %rdi
callq 0x5220
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x1
popq %rbx
callq 0x4da3
testb %al, %al
je 0x4fba
callq 0x4e8f
testb %al, %al
je 0x4fba
callq 0x4a0e
testb %al, %al
je 0x4fba
callq 0x4810
testb %al, %al
je 0x4fba
callq 0x492c
testb %al, %al
je 0x4fba
leaq 0x6309(%rip), %rdi      # 0xb2bc
callq 0x21e0
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/WojciechMula[P]utf16utf8/include/reference.h
// Function: utf16_to_unicode32(unsigned short const*, unsigned long*)
static inline int utf16_char_size(const uint16_t *c)
{
	if (c[0] <= 0xD7FF || c[0] >= 0xE000)
		return 1;
	else if (c[1] == 0)			// if there's an abrupt mid-character stream end
		return 1;
	else
		return 2;
}

// Assembly:
movzwl (%rdi), %eax
xorl %ecx, %ecx
leal 0x2000(%rax), %edx
cmpw $0xf800, %dx            # imm = 0xF800
jb 0x4fda
xorl %ecx, %ecx
cmpw $0x0, 0x2(%rdi)
setne %cl
testq %rsi, %rsi
je 0x4fe4
movl %ecx, %edx
addq %rdx, (%rsi)
testl %ecx, %ecx
je 0x4fff
movzwl 0x2(%rdi), %edx
movl $0x3ff, %ecx            # imm = 0x3FF
andl %ecx, %eax
shll $0xa, %eax
andl %ecx, %edx
leal 0x10000(%rax,%rdx), %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/WojciechMula[P]utf16utf8/include/reference.h
// Function: codepoint_utf8_size(unsigned int)
static inline  int codepoint_utf8_size(uint32_t c)
{
	if (c < 0x0080) return 1;
	if (c < 0x0800) return 2;
	if (c < 0x10000) return 3;
	if (c < 0x110000) return 4;

	return 0;
}

// Assembly:
cmpl $0x80, %edi
jae 0x500c
pushq $0x1
jmp 0x5022
cmpl $0x800, %edi            # imm = 0x800
jae 0x5018
pushq $0x2
jmp 0x5022
cmpl $0x10000, %edi          # imm = 0x10000
jae 0x5024
pushq $0x3
popq %rax
retq
xorl %eax, %eax
cmpl $0x110000, %edi         # imm = 0x110000
setb %al
shll $0x2, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/icemiliang[P]vot/src/vot/diagram.cc
// Function: vot::Diagram::Diagram(vot::otBBox, int)
Diagram::Diagram(const otBBox bBox, const int numBlocks) {
        mDiagram = new voro::container_poly(bBox.xMin, bBox.xMax,
                                             bBox.yMin, bBox.yMax,
                                             bBox.zMin, bBox.zMax,
                                             numBlocks, numBlocks, numBlocks,
                                             false, false, false, 8);
        mNumEmpiricals = 0;
        mNumDiracs = 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x50(%rdi)
andq $0x0, 0x60(%rdi)
movl $0x198, %edi            # imm = 0x198
callq 0x7380
movq %rax, %r14
leaq 0x40(%rsp), %rax
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
movsd 0x10(%rax), %xmm2
movsd 0x18(%rax), %xmm3
movsd 0x20(%rax), %xmm4
movsd 0x28(%rax), %xmm5
movl $0x8, 0x8(%rsp)
andl $0x0, (%rsp)
movq %r14, %rdi
movl %ebp, %esi
movl %ebp, %edx
movl %ebp, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x20b1c
movq %r14, (%rbx)
andq $0x0, 0x38(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movl $0x198, %esi            # imm = 0x198
movq %r14, %rdi
callq 0x7390
jmp 0xdaae
movq %rax, %r15
leaq 0x8(%rbx), %r14
leaq 0x40(%rbx), %r12
leaq 0x50(%rbx), %rdi
addq $0x20, %rbx
callq 0x12b6a
movq %r12, %rdi
callq 0xf6e4
movq %rbx, %rdi
callq 0x12bda
movq %r14, %rdi
callq 0x12b9e
movq %r15, %rdi
callq 0x76c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/icemiliang[P]vot/src/vot/diagram.cc
// Function: vot::Diagram::add_dirac(double, double, double, double, double, double, bool)
void Diagram::add_dirac(double x, double y, double z, double d, double m, double h, bool fix) {
        mDiagram->put(mNumDiracs, x, y, z, sqrt(h)); // Add a centroid/particle in container
        mDiracs.push_back(Dirac(x,y,z,d,m,fix));
        mHs.push_back(h);
        mNumDiracs++;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movl %esi, %ebp
movsd %xmm4, 0x28(%rsp)
movsd %xmm3, 0x20(%rsp)
movsd %xmm2, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
movsd %xmm5, 0x30(%rsp)
movq (%rdi), %r14
movl 0x38(%rdi), %r15d
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm5
jb 0xdb36
sqrtsd %xmm5, %xmm3
jmp 0xdb43
movapd %xmm5, %xmm0
callq 0x72e0
movapd %xmm0, %xmm3
movq %r14, %rdi
movl %r15d, %esi
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movsd 0x18(%rsp), %xmm2
callq 0x20caa
leaq 0x20(%rbx), %rdi
leaq 0x38(%rsp), %rsi
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rsi)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rsi)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x10(%rsi)
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x18(%rsi)
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x20(%rsi)
movb %bpl, 0x28(%rsi)
callq 0x12c16
leaq 0x50(%rbx), %rdi
leaq 0x30(%rsp), %rsi
callq 0xed94
incl 0x38(%rbx)
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/icemiliang[P]vot/src/vot/diagram.cc
// Function: vot::Diagram::write_dirac_as_input(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Diagram::write_dirac_as_input(std::string pFilename) {
        std::cout << "--> Writing resulting Dirac measures to " << pFilename << std::endl;
        std::ofstream outP(pFilename);
        outP << "Dirac " << mNumDiracs << std::endl;
        for (int i = 0; i < mNumDiracs; i++) {
            // Index starts from 0
            outP << i << " "
                 << mDiracs[i].x() << " " << mDiracs[i].y() << " "
                 << mDiracs[i].z() << " " << mDiracs[i].mass() << " "
                 << "0 " << mHs[i] << std::endl;
        }
        outP.close();
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %r14
movq %rdi, %rbx
movq 0x4d33c(%rip), %rdi     # 0x5af98
leaq 0x30f3b(%rip), %rsi     # 0x3eb9e
callq 0x7360
movq %rax, %rdi
movq %r14, %rsi
callq 0x7330
movq %rax, %rdi
callq 0x71c0
leaq 0x8(%rsp), %r15
pushq $0x10
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x77a0
leaq 0x30f32(%rip), %rsi     # 0x3ebc7
movq %r15, %rdi
callq 0x7360
movl 0x38(%rbx), %esi
movq %rax, %rdi
callq 0x7690
movq %rax, %rdi
callq 0x71c0
xorl %ebp, %ebp
leaq 0x8(%rsp), %r14
leaq 0x36e9a(%rip), %r15     # 0x44b58
leaq 0x30f09(%rip), %r12     # 0x3ebce
xorl %r13d, %r13d
movslq 0x38(%rbx), %rax
cmpq %rax, %r13
jge 0xdd8f
movq %r14, %rdi
movl %r13d, %esi
callq 0x7690
movq %rax, %rdi
movq %r15, %rsi
callq 0x7360
movq 0x20(%rbx), %rcx
movsd (%rcx,%rbp), %xmm0
movq %rax, %rdi
callq 0x7610
movq %rax, %rdi
movq %r15, %rsi
callq 0x7360
movq 0x20(%rbx), %rcx
movsd 0x8(%rcx,%rbp), %xmm0
movq %rax, %rdi
callq 0x7610
movq %rax, %rdi
movq %r15, %rsi
callq 0x7360
movq 0x20(%rbx), %rcx
movsd 0x10(%rcx,%rbp), %xmm0
movq %rax, %rdi
callq 0x7610
movq %rax, %rdi
movq %r15, %rsi
callq 0x7360
movq 0x20(%rbx), %rcx
movsd 0x20(%rcx,%rbp), %xmm0
movq %rax, %rdi
callq 0x7610
movq %rax, %rdi
movq %r15, %rsi
callq 0x7360
movq %rax, %rdi
movq %r12, %rsi
callq 0x7360
movq 0x50(%rbx), %rcx
movsd (%rcx,%r13,8), %xmm0
movq %rax, %rdi
callq 0x7610
movq %rax, %rdi
callq 0x71c0
incq %r13
addq $0x30, %rbp
jmp 0xdcc8
leaq 0x8(%rsp), %rdi
callq 0x7530
leaq 0x8(%rsp), %rdi
callq 0x7570
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xddb7
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x7570
movq %rbx, %rdi
callq 0x76c0
// File: /workspace/github_cpp_makefile_star2_O2/icemiliang[P]vot/src/vot/diagram.cc
// Function: vot::Diagram::write_dirac(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Diagram::write_dirac(std::string pFilename) {
        std::cout << "--> Writing resulting Diract measures to a " << pFilename << std::endl;
        std::ofstream outP(pFilename);
        for (int i = 0; i < mNumDiracs; i++) {
            // Index starts from 0
            outP << mDiracs[i].x() << " " << mDiracs[i].y() << " "
                 << mDiracs[i].z() << " "  << mDiracs[i].dirac() << " "
                 << mDiracs[i].mass() << " "  << mHs[i] << std::endl;
        }
        outP.close();
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rsi, %r15
movq %rdi, %rbx
movq 0x4d1af(%rip), %rdi     # 0x5af98
leaq 0x30de1(%rip), %rsi     # 0x3ebd1
callq 0x7360
movq %rax, %rdi
movq %r15, %rsi
callq 0x7330
movq %rax, %rdi
callq 0x71c0
movq %rsp, %r14
pushq $0x10
popq %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x77a0
xorl %r12d, %r12d
leaq 0x36d35(%rip), %r15     # 0x44b58
xorl %r13d, %r13d
movslq 0x38(%rbx), %rax
cmpq %rax, %r13
jge 0xdeee
movq 0x20(%rbx), %rax
movsd (%rax,%r12), %xmm0
movq %r14, %rdi
callq 0x7610
movq %rax, %rdi
movq %r15, %rsi
callq 0x7360
movq 0x20(%rbx), %rcx
movsd 0x8(%rcx,%r12), %xmm0
movq %rax, %rdi
callq 0x7610
movq %rax, %rdi
movq %r15, %rsi
callq 0x7360
movq 0x20(%rbx), %rcx
movsd 0x10(%rcx,%r12), %xmm0
movq %rax, %rdi
callq 0x7610
movq %rax, %rdi
movq %r15, %rsi
callq 0x7360
movq 0x20(%rbx), %rcx
movsd 0x18(%rcx,%r12), %xmm0
movq %rax, %rdi
callq 0x7610
movq %rax, %rdi
movq %r15, %rsi
callq 0x7360
movq 0x20(%rbx), %rcx
movsd 0x20(%rcx,%r12), %xmm0
movq %rax, %rdi
callq 0x7610
movq %rax, %rdi
movq %r15, %rsi
callq 0x7360
movq 0x50(%rbx), %rcx
movsd (%rcx,%r13,8), %xmm0
movq %rax, %rdi
callq 0x7610
movq %rax, %rdi
callq 0x71c0
incq %r13
addq $0x30, %r12
jmp 0xde26
movq %rsp, %rdi
callq 0x7530
movq %rsp, %rdi
callq 0x7570
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xdf11
movq %rax, %rbx
movq %rsp, %rdi
callq 0x7570
movq %rbx, %rdi
callq 0x76c0
// File: /workspace/github_cpp_makefile_star2_O2/icemiliang[P]vot/src/vot/diagram.cc
// Function: vot::Diagram::total_dirac_mass()
double Diagram::total_dirac_mass() {
        double total = 0;
        for (int i = 0; i < mNumDiracs; i++) {
            total += mDiracs[i].dirac();
        }
        return total;
    }

// Assembly:
movl 0x38(%rdi), %edx
movq 0x20(%rdi), %rax
xorl %ecx, %ecx
testl %edx, %edx
cmovlel %ecx, %edx
imulq $0x30, %rdx, %rdx
xorpd %xmm0, %xmm0
cmpq %rcx, %rdx
je 0xe4fd
addsd 0x18(%rax,%rcx), %xmm0
addq $0x30, %rcx
jmp 0xe4ec
retq
// File: /workspace/github_cpp_makefile_star2_O2/icemiliang[P]vot/src/vot/diagram.cc
// Function: vot::Diagram::total_empirical_mass()
double Diagram::total_empirical_mass() {
        double total = 0;
        for (int i = 0; i < mNumEmpiricals; i++) {
            total += mEmpiricals[i].mass();
        }
        return total;
    }

// Assembly:
movl 0x3c(%rdi), %edx
movq 0x8(%rdi), %rax
xorl %ecx, %ecx
testl %edx, %edx
cmovlel %ecx, %edx
imulq $0x28, %rdx, %rdx
xorpd %xmm0, %xmm0
cmpq %rcx, %rdx
je 0xe525
addsd 0x18(%rax,%rcx), %xmm0
addq $0x28, %rcx
jmp 0xe514
retq