LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: npazosmendez[P]branchsearch/branchsearch.cpp
// Function: args_t::args_t(int, char**)
args_t(int argc, char** argv) {
        for (int i = 1; i < argc; i++) {
            string arg = argv[i];
            if (arg[0] != '-') fast_switch = argv[i];
            if (arg == "-u") fetch_before = true;
            if (arg == "-p") pull_after = true;
            if (arg == "-l") locals_only = true;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq $0x0, (%rax)
movb $0x0, 0x8(%rax)
movb $0x0, 0x9(%rax)
movb $0x0, 0xa(%rax)
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x811e
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x70(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x5790
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x7330
jmp 0x8024
leaq -0x41(%rbp), %rdi
callq 0x54b0
xorl %eax, %eax
movl %eax, %esi
leaq -0x40(%rbp), %rdi
callq 0x5840
movq %rax, -0x78(%rbp)
jmp 0x8040
movq -0x78(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x8095
movq -0x60(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq %rcx, (%rax)
jmp 0x8095
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x41(%rbp), %rdi
callq 0x54b0
jmp 0x8127
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x52c0
jmp 0x8127
leaq 0x2f1b7(%rip), %rsi     # 0x37253
leaq -0x40(%rbp), %rdi
callq 0x8c00
movb %al, -0x79(%rbp)
jmp 0x80aa
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0x80b3
jmp 0x80bb
movq -0x60(%rbp), %rax
movb $0x1, 0x9(%rax)
leaq 0x2f194(%rip), %rsi     # 0x37256
leaq -0x40(%rbp), %rdi
callq 0x8c00
movb %al, -0x7a(%rbp)
jmp 0x80d0
movb -0x7a(%rbp), %al
testb $0x1, %al
jne 0x80d9
jmp 0x80e1
movq -0x60(%rbp), %rax
movb $0x1, 0x8(%rax)
leaq 0x2f0c8(%rip), %rsi     # 0x371b0
leaq -0x40(%rbp), %rdi
callq 0x8c00
movb %al, -0x7b(%rbp)
jmp 0x80f6
movb -0x7b(%rbp), %al
testb $0x1, %al
jne 0x80ff
jmp 0x8107
movq -0x60(%rbp), %rax
movb $0x1, 0xa(%rax)
leaq -0x40(%rbp), %rdi
callq 0x52c0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7fe8
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x5780
// File: JohnCGriffin[P]BrainForked/bf_main.cpp
// Function: bf::load_instructions(std::istream&)
static Instructions load_instructions(std::istream& is)
    {
	auto instructions = read_instructions(is);

	instructions = optimizations(instructions);

	patch_while_loops(instructions);

	instructions.push_back({ TERMINATE });

	return instructions;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rsi
callq 0x7fb0
movq -0x58(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movl $0x1, %edx
callq 0xada0
jmp 0x298c
movq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movq %rsi, -0x68(%rbp)
callq 0x3e10
movq -0x68(%rbp), %rdi
callq 0x3db0
movq -0x58(%rbp), %rdi
callq 0x3bf0
jmp 0x29b1
movq -0x58(%rbp), %rdi
movl $0xf, -0x50(%rbp)
movw $0x0, -0x4c(%rbp)
movq $0x0, -0x48(%rbp)
leaq -0x50(%rbp), %rsi
callq 0x3e40
jmp 0x29d5
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x2a01
jmp 0x29f8
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x3db0
jmp 0x2a0b
movq -0x58(%rbp), %rdi
callq 0x3db0
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x2330
nopw %cs:(%rax,%rax)
// File: JohnCGriffin[P]BrainForked/bf_main.cpp
// Function: bf::patch_while_loops(std::vector<bf::Instruction, std::allocator<bf::Instruction>>&)
static void patch_while_loops(Instructions& instructions)
    {
	std::vector<int> while_stack;
	for(size_t i=0; i<instructions.size(); i++){

	    if(instructions.at(i).action == FALSEJUMP){
		while_stack.push_back(i);
	    }

	    if(instructions.at(i).action == TRUEJUMP){
		int start = while_stack.back();
		instructions.at(start).val = (i - start);
		instructions.at(i).val = (start - i);
		while_stack.pop_back();
	    }
	}
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x4150
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3d40
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x3d18
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x4170
movq %rax, -0x50(%rbp)
jmp 0x3c44
movq -0x50(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x3c7e
movl -0x28(%rbp), %eax
movl %eax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x41b0
jmp 0x3c62
jmp 0x3c7e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x4250
jmp 0x3d2a
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x4170
movq %rax, -0x58(%rbp)
jmp 0x3c91
movq -0x58(%rbp), %rax
cmpl $0x10, (%rax)
jne 0x3d05
leaq -0x20(%rbp), %rdi
callq 0x41e0
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
movl -0x28(%rbp), %eax
movslq -0x3c(%rbp), %rsi
movl %esi, %ecx
subl %ecx, %eax
movw %ax, -0x62(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4170
movq %rax, -0x60(%rbp)
jmp 0x3cc6
movq -0x60(%rbp), %rax
movw -0x62(%rbp), %cx
movw %cx, 0x4(%rax)
movl -0x3c(%rbp), %eax
movq -0x28(%rbp), %rsi
movl %esi, %ecx
subl %ecx, %eax
movw %ax, -0x72(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4170
movq %rax, -0x70(%rbp)
jmp 0x3cf0
movq -0x70(%rbp), %rax
movw -0x72(%rbp), %cx
movw %cx, 0x4(%rax)
leaq -0x20(%rbp), %rdi
callq 0x4220
jmp 0x3d07
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x3c10
leaq -0x20(%rbp), %rdi
callq 0x4250
addq $0x80, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x2330
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: JohnCGriffin[P]BrainForked/bf_optimizations.cpp
// Function: bf::matches(std::vector<bf::Instruction, std::allocator<bf::Instruction>> const&, int, std::initializer_list<bf::Action>)
static bool matches(const Instructions& instrs, int offset, Actions actions)
    {
	const int sz = instrs.size();
	for(auto a : actions){
	    if(offset >= sz || a != instrs.at(offset++).action){
		return false;
	    }
	}
	return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdx, -0x18(%rbp)
movq %rcx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movl %esi, -0x24(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3d40
movl %eax, -0x28(%rbp)
leaq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x57a0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x57c0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
je 0xc8bd
movq -0x38(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x44(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0xc8a7
movl -0x44(%rbp), %eax
movl %eax, -0x48(%rbp)
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x24(%rbp)
movslq %eax, %rsi
callq 0xc8d0
movq %rax, %rcx
movl -0x48(%rbp), %eax
cmpl (%rcx), %eax
je 0xc8ad
movb $0x0, -0x1(%rbp)
jmp 0xc8c1
jmp 0xc8af
movq -0x38(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x38(%rbp)
jmp 0xc865
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: wichtounet[P]articles/include/bench.hpp
// Function: tag(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string tag(std::string name){
    std::replace_if(begin(name), end(name), [](char c){ return !is_tag(c); }, '_');
    std::string res;
    res.swap(name);
    return res;
}

// Assembly:
subq $0x48, %rsp
movq %rsi, 0x18(%rsp)
movq %rdi, %rax
movq 0x18(%rsp), %rdi
movq %rax, 0x10(%rsp)
movq %rax, %rcx
movq %rcx, 0x8(%rsp)
movq %rax, 0x40(%rsp)
movq %rdi, 0x38(%rsp)
callq 0x11990
movq 0x18(%rsp), %rdi
movq %rax, 0x30(%rsp)
callq 0x119c0
movq %rax, 0x28(%rsp)
movb $0x5f, 0x26(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
leaq 0x26(%rsp), %rdx
callq 0x9640
movq 0x10(%rsp), %rdi
movb $0x0, 0x25(%rsp)
callq 0x52b0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x5180
movb $0x1, 0x25(%rsp)
testb $0x1, 0x25(%rsp)
jne 0x962e
movq 0x10(%rsp), %rdi
callq 0x5150
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: wichtounet[P]articles/src/vector_list_update_1/bench.cpp
// Function: void bench_all<Trivial<8>, Trivial<32>, Trivial<128>, Trivial<1024>, Trivial<4096>, NonTrivialStringMovable, NonTrivialStringMovableNoExcept, NonTrivialArray<32>>()
void bench_all(){
    bench_types<bench_fill_back,        Types...>();
    bench_types<bench_emplace_back,     Types...>();
    bench_types<bench_fill_front,       Types...>();
    bench_types<bench_emplace_front,    Types...>();
    bench_types<bench_linear_search,    Types...>();
    bench_types<bench_write,            Types...>();
    bench_types<bench_random_insert,    Types...>();
    bench_types<bench_random_remove,    Types...>();
    bench_types<bench_sort,             Types...>();
    bench_types<bench_destruction,      Types...>();
    bench_types<bench_erase_1,          Types...>();
    bench_types<bench_erase_10,         Types...>();
    bench_types<bench_erase_25,         Types...>();
    bench_types<bench_erase_50,         Types...>();

    // The following are really slow so run only for limited set of data
    bench_types<bench_find,             TrivialSmall, TrivialMedium, TrivialLarge>();
    bench_types<bench_number_crunching, TrivialSmall, TrivialMedium>();
}

// Assembly:
pushq %rax
callq 0x12090
callq 0x120a0
callq 0x120b0
callq 0x120c0
callq 0x120d0
callq 0x120e0
callq 0x120f0
callq 0x12100
callq 0x12110
callq 0x12120
callq 0x12130
callq 0x12140
callq 0x12150
callq 0x12160
callq 0x12170
callq 0x12180
popq %rax
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: wichtounet[P]articles/include/bench.hpp
// Function: void bench<std::vector<Trivial<8>, std::allocator<Trivial<8>>>, std::chrono::duration<long, std::ratio<1l, 1000000l>>, Empty, FillBack>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::initializer_list<int> const&)
void bench(const std::string& type, const std::initializer_list<int> &sizes){
    // create an element to copy so the temporary creation
    // and initialization will not be accounted in a benchmark
    for(auto size : sizes) {
        std::size_t duration = 0;

        for(std::size_t i=0; i<REPEAT; ++i) {
            auto container = CreatePolicy<Container>::make(size);

            Clock::time_point t0 = Clock::now();

            run<TestPolicy...>(container, size);

            Clock::time_point t1 = Clock::now();
            duration += std::chrono::duration_cast<DurationUnit>(t1 - t0).count();
        }

        graphs::new_result(type, std::to_string(size), duration / REPEAT);
    }

    CreatePolicy<Container>::clean();
}

// Assembly:
subq $0xe8, %rsp
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq 0xd8(%rsp), %rax
movq %rax, 0xd0(%rsp)
movq 0xd0(%rsp), %rdi
callq 0x13d60
movq %rax, 0xc8(%rsp)
movq 0xd0(%rsp), %rdi
callq 0x13d70
movq %rax, 0xc0(%rsp)
movq 0xc8(%rsp), %rax
cmpq 0xc0(%rsp), %rax
je 0x12bd3
movq 0xc8(%rsp), %rax
movl (%rax), %eax
movl %eax, 0xbc(%rsp)
movq $0x0, 0xb0(%rsp)
movq $0x0, 0xa8(%rsp)
cmpq $0x7, 0xa8(%rsp)
jae 0x12b31
movslq 0xbc(%rsp), %rsi
leaq 0x90(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x13db0
callq 0x5050
movq 0x38(%rsp), %rdi
movq %rax, 0x88(%rsp)
movslq 0xbc(%rsp), %rsi
callq 0x9710
jmp 0x12a7a
callq 0x5050
movq %rax, 0x70(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x13e20
movq %rax, 0x30(%rsp)
jmp 0x12a9d
movq 0x30(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x13df0
movq %rax, 0x28(%rsp)
jmp 0x12ab8
movq 0x28(%rsp), %rax
movq %rax, 0x68(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x13e70
movq %rax, 0x20(%rsp)
jmp 0x12ad3
movq 0x20(%rsp), %rax
addq 0xb0(%rsp), %rax
movq %rax, 0xb0(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x11ba0
movq 0xa8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xa8(%rsp)
jmp 0x12a30
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x11ba0
jmp 0x12be0
movq 0xe0(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0xbc(%rsp), %esi
leaq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x13e80
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0xb0(%rsp), %rdx
movq %rdx, 0x18(%rsp)
movabsq $0x2492492492492493, %rax # imm = 0x2492492492492493
mulxq %rax, %rax, %rax
movq 0x18(%rsp), %rdx
subq %rax, %rdx
shrq %rdx
addq %rax, %rdx
shrq $0x2, %rdx
callq 0x1749c0
jmp 0x12b93
leaq 0x40(%rsp), %rdi
callq 0x5150
movq 0xc8(%rsp), %rax
addq $0x4, %rax
movq %rax, 0xc8(%rsp)
jmp 0x129f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x5150
jmp 0x12be0
callq 0x13fc0
addq $0xe8, %rsp
retq
movq 0x80(%rsp), %rdi
callq 0x5360
nopl (%rax)
// File: wichtounet[P]articles/plf_colony_alpha/plf_colony.h
// Function: plf::colony<Trivial<8>, std::allocator<Trivial<8>>, unsigned short>::reduced_stack::pop()
void pop() PLF_COLONY_NOEXCEPT
		{
			#ifdef PLF_COLONY_TYPE_TRAITS_SUPPORT
				if (!(std::is_trivially_destructible<stack_element_type>::value)) // This if-statement should be removed by the compiler on resolution of stack_element_type
			#endif
			{
				PLF_COLONY_DESTROY(element_pointer_allocator_type, (*this), top_element);
			}

			// ie. if total_number_of_elements != 0 after decrement, or we were not already at the start of a non-first group
			if (total_number_of_elements-- == 1 || top_element != start_element) // If total_number_of_elements is now 0 after decrement, this essentially moves top_element back to it's initial position (start_element - 1). But otherwise, this is just a regular pop
			{
				--top_element;
			}
			else
			{ // ie. is start element, but not first group in stack (if it were, totalsize would be 0 after decrement)
				current_group = current_group->previous_group;
				start_element = current_group->elements;
				end_element = top_element = current_group->end;
			}
		}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rcx
movq %rcx, -0x10(%rsp)
movq 0x28(%rcx), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, 0x28(%rcx)
cmpq $0x1, %rax
je 0x17093
movq -0x10(%rsp), %rcx
movq 0x10(%rcx), %rax
cmpq 0x18(%rcx), %rax
je 0x170a6
movq -0x10(%rsp), %rax
movq 0x10(%rax), %rcx
addq $-0x8, %rcx
movq %rcx, 0x10(%rax)
jmp 0x170ce
movq -0x10(%rsp), %rax
movq (%rax), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, (%rax)
movq (%rax), %rcx
movq (%rcx), %rcx
movq %rcx, 0x18(%rax)
movq (%rax), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq %rcx, 0x20(%rax)
retq
nop
// File: wichtounet[P]articles/plf_colony_alpha/plf_colony.h
// Function: plf::colony<Trivial<8>, std::allocator<Trivial<8>>, unsigned short>::colony_iterator<std::allocator<Trivial<8>>, false>::operator=(plf::colony<Trivial<8>, std::allocator<Trivial<8>>, unsigned short>::colony_iterator<std::allocator<Trivial<8>>, false> const&)
inline colony_iterator & operator = (const colony_iterator &source) PLF_COLONY_NOEXCEPT
		{
			group_pointer = source.group_pointer;
			element_pointer = source.element_pointer;
			skipfield_pointer = source.skipfield_pointer;
			return *this;
		}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq -0x10(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
retq
nopw %cs:(%rax,%rax)
nop
// File: wichtounet[P]articles/plf_colony_alpha/plf_colony.h
// Function: plf::colony<Trivial<8>, std::allocator<Trivial<8>>, unsigned short>::initialize(unsigned short)
void initialize(const skipfield_type first_group_size)
	{
		first_group = PLF_COLONY_ALLOCATE(group_allocator_type, group_allocator_pair, 1, 0);

		try
		{
			#ifdef PLF_COLONY_VARIADICS_SUPPORT
				PLF_COLONY_CONSTRUCT(group_allocator_type, group_allocator_pair, first_group, first_group_size);
			#else
				PLF_COLONY_CONSTRUCT(group_allocator_type, group_allocator_pair, first_group, group(first_group_size));
			#endif
		}
		catch (...)
		{
			PLF_COLONY_DEALLOCATE(group_allocator_type, group_allocator_pair, first_group, 1);
			first_group = NULL;
			throw;
		}

		begin_iterator.group_pointer = first_group;
		begin_iterator.element_pointer = first_group->elements;
		begin_iterator.skipfield_pointer = first_group->skipfield;
		end_iterator = begin_iterator;
	}

// Assembly:
subq $0x38, %rsp
movw %si, %ax
movq %rdi, 0x30(%rsp)
movw %ax, 0x2e(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x42, %rdi
movq %rdi, 0x8(%rsp)
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %esi
callq 0x16f80
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x30(%rax), %rsi
leaq 0x2e(%rsp), %rdx
callq 0x17520
jmp 0x17163
jmp 0x171c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
callq 0x50b0
movq 0x10(%rsp), %rax
movq %rax, %rdi
addq $0x42, %rdi
movq 0x30(%rax), %rsi
movl $0x1, %edx
callq 0x16ff0
jmp 0x17199
movq 0x10(%rsp), %rax
movq $0x0, 0x30(%rax)
callq 0x52d0
jmp 0x1720c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x5350
jmp 0x171c2
jmp 0x171fa
movq 0x10(%rsp), %rdi
movq 0x30(%rdi), %rax
movq %rax, 0x18(%rdi)
movq 0x30(%rdi), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rdi)
movq 0x30(%rdi), %rax
movq 0x18(%rax), %rax
movq %rax, 0x28(%rdi)
movq %rdi, %rsi
addq $0x18, %rsi
callq 0x170d0
addq $0x38, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x5360
movq %rax, %rdi
callq 0x14670
nopl (%rax)
// File: wichtounet[P]articles/plf_colony_alpha/plf_colony.h
// Function: plf::colony<Trivial<8>, std::allocator<Trivial<8>>, unsigned short>::reserve(unsigned short)
void reserve(skipfield_type reserve_amount)
	{
		assert(reserve_amount > 2);

		if (reserve_amount > group_allocator_pair.max_elements_per_group)
		{
			reserve_amount = group_allocator_pair.max_elements_per_group;
		}
		else if (reserve_amount < min_elements_per_group)
		{
			reserve_amount = min_elements_per_group;
		}
		else if (reserve_amount > max_size())
		{
			reserve_amount = static_cast<skipfield_type>(max_size());
		}

		if (total_number_of_elements == 0) // Most common scenario
		{
			if (first_group != NULL) // Edge case - empty colony but first group is initialized ie. did have some insertions but all got erased
			{
				PLF_COLONY_DESTROY(group_allocator_type, group_allocator_pair, first_group);
				PLF_COLONY_DEALLOCATE(group_allocator_type, group_allocator_pair, first_group, 1);
			} // else: Empty colony, no inserts as yet, time to allocate

			initialize(reserve_amount);
			first_group->last_endpoint = first_group->elements; // elements + 1 by default
			first_group->number_of_elements = 0; // 1 by default
		}
		else if (reserve_amount <= capacity())
		{
			return;
		}
		else
		{
			const skipfield_type original_min_elements = min_elements_per_group;
			min_elements_per_group = reserve_amount;
			consolidate();
			min_elements_per_group = original_min_elements;
		}
	}

// Assembly:
subq $0x28, %rsp
movw %si, %ax
movq %rdi, 0x20(%rsp)
movw %ax, 0x1e(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movzwl 0x1e(%rsp), %eax
movzwl 0x42(%rcx), %ecx
cmpl %ecx, %eax
jle 0x17c48
movq 0x10(%rsp), %rax
movw 0x42(%rax), %ax
movw %ax, 0x1e(%rsp)
jmp 0x17c9e
movq 0x10(%rsp), %rcx
movzwl 0x1e(%rsp), %eax
movzwl 0x40(%rcx), %ecx
cmpl %ecx, %eax
jge 0x17c6a
movq 0x10(%rsp), %rax
movw 0x40(%rax), %ax
movw %ax, 0x1e(%rsp)
jmp 0x17c9c
movq 0x10(%rsp), %rdi
movzwl 0x1e(%rsp), %eax
movq %rax, 0x8(%rsp)
callq 0x17d70
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jbe 0x17c9a
movq 0x10(%rsp), %rdi
callq 0x17d70
movw %ax, 0x1e(%rsp)
jmp 0x17c9c
jmp 0x17c9e
movq 0x10(%rsp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x17d14
movq 0x10(%rsp), %rax
cmpq $0x0, 0x30(%rax)
je 0x17ce5
movq 0x10(%rsp), %rax
movq %rax, %rdi
addq $0x42, %rdi
movq 0x30(%rax), %rsi
callq 0x177b0
movq 0x10(%rsp), %rax
movq %rax, %rdi
addq $0x42, %rdi
movq 0x30(%rax), %rsi
movl $0x1, %edx
callq 0x16ff0
movq 0x10(%rsp), %rdi
movzwl 0x1e(%rsp), %esi
callq 0x17110
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rcx
movq 0x10(%rcx), %rdx
movq 0x30(%rax), %rcx
movq %rdx, (%rcx)
movq 0x30(%rax), %rax
movw $0x0, 0x30(%rax)
jmp 0x17d61
movq 0x10(%rsp), %rdi
movzwl 0x1e(%rsp), %eax
movq %rax, (%rsp)
callq 0x17d80
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
ja 0x17d35
jmp 0x17d61
movq 0x10(%rsp), %rdi
movw 0x40(%rdi), %ax
movw %ax, 0x1c(%rsp)
movw 0x1e(%rsp), %ax
movw %ax, 0x40(%rdi)
callq 0x17dd0
movq 0x10(%rsp), %rax
movw 0x1c(%rsp), %cx
movw %cx, 0x40(%rax)
jmp 0x17d61
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: wichtounet[P]articles/plf_colony_alpha/plf_colony.h
// Function: plf::colony<Trivial<8>, std::allocator<Trivial<8>>, unsigned short>::operator=(plf::colony<Trivial<8>, std::allocator<Trivial<8>>, unsigned short>&&)
colony & operator = (colony &&source)
		{
			assert (&source != this);

			destroy_all_data();

			// Move source values across:
			end_iterator = std::move(source.end_iterator);
			begin_iterator = std::move(source.begin_iterator);
			first_group = std::move(source.first_group);
			total_number_of_elements = source.total_number_of_elements;
			min_elements_per_group = source.min_elements_per_group;
			group_allocator_pair.max_elements_per_group = source.group_allocator_pair.max_elements_per_group;

			erased_locations = std::move(source.erased_locations);

			source.first_group = NULL;
			source.total_number_of_elements = 0; // Nullifying the other data members is unnecessary - technically all can be removed except first_group NULL and total_number_of_elements 0, to allow for clean destructor usage
			return *this;
		}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x17580
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x18350
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x18, %rsi
addq $0x18, %rdi
callq 0x18350
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x30(%rdi)
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x38(%rdi)
movq 0x8(%rsp), %rax
movw 0x40(%rax), %ax
movw %ax, 0x40(%rdi)
movq 0x8(%rsp), %rax
movw 0x42(%rax), %ax
movw %ax, 0x42(%rdi)
movq 0x8(%rsp), %rsi
addq $0x48, %rsi
addq $0x48, %rdi
callq 0x18390
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq $0x0, 0x30(%rcx)
movq 0x8(%rsp), %rcx
movq $0x0, 0x38(%rcx)
addq $0x18, %rsp
retq
nopl (%rax)
// File: wichtounet[P]articles/plf_colony_alpha/plf_colony.h
// Function: plf::colony<Trivial<8>, std::allocator<Trivial<8>>, unsigned short>::colony_iterator<std::allocator<Trivial<8>>, false> plf::colony<Trivial<8>, std::allocator<Trivial<8>>, unsigned short>::insert<plf::colony<Trivial<8>, std::allocator<Trivial<8>>, unsigned short>::colony_iterator<std::allocator<Trivial<8>>, false>>(plf::colony<Trivial<8>, std::allocator<Trivial<8>>, unsigned short>::plf_enable_if_c<!std::numeric_limits<plf::colony<Trivial<8>, std::allocator<Trivial<8>>, unsigned short>::colony_iterator<std::allocator<Trivial<8>>, false>>::is_integer, plf::colony<Trivial<8>, std::allocator<Trivial<8>>, unsigned short>::colony_iterator<std::allocator<Trivial<8>>, false>>::type, plf::colony<Trivial<8>, std::allocator<Trivial<8>>, unsigned short>::colony_iterator<std::allocator<Trivial<8>>, false>)
iterator insert (const typename plf_enable_if_c<!std::numeric_limits<iterator_type>::is_integer, iterator_type>::type first, const iterator_type last)
	{
		if (first == last)
		{
			return end_iterator;
		}

		const iterator return_iterator = insert(*first);
		iterator_type current_element = first;

		while (++current_element != last)
		{
			insert(*current_element);
		}

		return return_iterator;
	}

// Assembly:
subq $0x78, %rsp
movq %rcx, (%rsp)
movq %rdx, 0x8(%rsp)
movq %rsi, %rax
movq (%rsp), %rsi
movq %rdi, %rcx
movq 0x8(%rsp), %rdi
movq %rcx, 0x10(%rsp)
movq %rcx, %rdx
movq %rdx, 0x18(%rsp)
movq %rcx, 0x70(%rsp)
movq %rax, 0x68(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x20(%rsp)
callq 0x18220
testb $0x1, %al
jne 0x18192
jmp 0x181a3
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdi
callq 0x16f40
jmp 0x1820a
movq 0x8(%rsp), %rdi
callq 0x18250
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq %rax, %rdx
callq 0x169c0
movq 0x8(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x16f40
leaq 0x40(%rsp), %rdi
callq 0x18260
movq (%rsp), %rsi
movq %rax, %rdi
callq 0x18320
testb $0x1, %al
jne 0x181ea
jmp 0x18208
leaq 0x40(%rsp), %rdi
callq 0x18250
movq 0x20(%rsp), %rsi
movq %rax, %rdx
leaq 0x28(%rsp), %rdi
callq 0x169c0
jmp 0x181ce
jmp 0x1820a
movq 0x18(%rsp), %rax
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: wichtounet[P]articles/plf_colony_alpha/plf_colony.h
// Function: plf::colony<Trivial<8>, std::allocator<Trivial<8>>, unsigned short>::colony_iterator<std::allocator<Trivial<8>>, false>::operator++()
inline colony_iterator & operator ++ ()
#endif
		{
			assert(group_pointer != NULL); // covers uninitialised colony_iterator
			assert(!(element_pointer == group_pointer->last_endpoint && group_pointer->next_group != NULL)); // Assert that iterator is not already at end()

			++skipfield_pointer;
			element_pointer += 1 + *skipfield_pointer;
			skipfield_pointer += *skipfield_pointer;

			if (element_pointer == group_pointer->last_endpoint && group_pointer->next_group != NULL) // ie. beyond end of available data
			{
				group_pointer = group_pointer->next_group;
				element_pointer = group_pointer->elements + *(group_pointer->skipfield);
				skipfield_pointer = group_pointer->skipfield + *(group_pointer->skipfield);
			}

			return *this;
		}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rcx
movq %rcx, -0x10(%rsp)
movq 0x10(%rcx), %rax
addq $0x2, %rax
movq %rax, 0x10(%rcx)
movq 0x10(%rcx), %rax
movzwl (%rax), %edx
addl $0x1, %edx
movq 0x8(%rcx), %rax
movslq %edx, %rdx
shlq $0x3, %rdx
addq %rdx, %rax
movq %rax, 0x8(%rcx)
movq 0x10(%rcx), %rax
movzwl (%rax), %edx
movq 0x10(%rcx), %rax
movslq %edx, %rdx
shlq %rdx
addq %rdx, %rax
movq %rax, 0x10(%rcx)
movq 0x8(%rcx), %rax
movq (%rcx), %rcx
cmpq (%rcx), %rax
jne 0x18316
movq -0x10(%rsp), %rax
movq (%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0x18316
movq -0x10(%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, (%rax)
movq (%rax), %rcx
movq 0x10(%rcx), %rcx
movq (%rax), %rdx
movq 0x18(%rdx), %rdx
movzwl (%rdx), %edx
movslq %edx, %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
movq %rcx, 0x8(%rax)
movq (%rax), %rcx
movq 0x18(%rcx), %rcx
movq (%rax), %rdx
movq 0x18(%rdx), %rdx
movzwl (%rdx), %edx
movslq %edx, %rdx
shlq %rdx
addq %rdx, %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rsp), %rax
retq
nopl (%rax)
// File: wichtounet[P]articles/plf_colony_alpha/plf_colony.h
// Function: plf::colony<Trivial<8>, std::allocator<Trivial<8>>, unsigned short>::reduced_stack::operator=(plf::colony<Trivial<8>, std::allocator<Trivial<8>>, unsigned short>::reduced_stack&&)
reduced_stack & operator = (reduced_stack &&source) PLF_COLONY_NOEXCEPT
			{
				destroy_all_data();

				current_group = std::move(source.current_group);
				first_group = std::move(source.first_group);
				top_element = std::move(source.top_element);
				start_element = std::move(source.start_element);
				end_element = std::move(source.end_element);
				total_number_of_elements = source.total_number_of_elements;
				group_allocator_pair.min_elements_per_group = source.group_allocator_pair.min_elements_per_group;

				// Nullify source object's contents - only first_group and total_number_of_elements required to be altered for destructor to work on it:
				source.first_group = NULL;
				source.total_number_of_elements = 0;

				return *this;
			}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x178c0
jmp 0x183ae
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rcx
movq 0x20(%rcx), %rcx
movq %rcx, 0x20(%rax)
movq 0x8(%rsp), %rcx
movq 0x28(%rcx), %rcx
movq %rcx, 0x28(%rax)
movq 0x8(%rsp), %rcx
movq 0x30(%rcx), %rcx
movq %rcx, 0x30(%rax)
movq 0x8(%rsp), %rcx
movq $0x0, 0x8(%rcx)
movq 0x8(%rsp), %rcx
movq $0x0, 0x28(%rcx)
addq $0x18, %rsp
retq
movq %rax, %rdi
callq 0x14670
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: wichtounet[P]articles/plf_colony_alpha/plf_colony.h
// Function: plf::colony<NonTrivialStringMovable, std::allocator<NonTrivialStringMovable>, unsigned short>::clear()
void clear()
	{
		destroy_all_data();
		erased_locations.clear();
		total_number_of_elements = 0;
		begin_iterator.group_pointer = NULL;
		begin_iterator.element_pointer = NULL;
		begin_iterator.skipfield_pointer = NULL;
		end_iterator = begin_iterator;
	}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x3cb00
movq 0x8(%rsp), %rdi
addq $0x48, %rdi
callq 0x3ccb0
movq 0x8(%rsp), %rdi
movq $0x0, 0x38(%rdi)
movq $0x0, 0x18(%rdi)
movq $0x0, 0x20(%rdi)
movq $0x0, 0x28(%rdi)
movq %rdi, %rsi
addq $0x18, %rsi
callq 0x3c660
addq $0x18, %rsp
retq
nopl (%rax)
// File: wichtounet[P]articles/plf_colony_alpha/plf_colony.h
// Function: plf::colony<NonTrivialStringMovable, std::allocator<NonTrivialStringMovable>, unsigned short>::reduced_stack::clear()
void clear()
		{
			destroy_all_data(); // may throw exception if destructor of pointer type throws exception
			top_element = NULL;
			start_element = NULL;
			end_element = NULL;
		}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x3ccf0
movq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq $0x0, 0x20(%rax)
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: wichtounet[P]articles/include/policies.hpp
// Function: FilledRandom<std::vector<NonTrivialStringMovable, std::allocator<NonTrivialStringMovable>>>::make(unsigned long)
inline static Container make(std::size_t size){
        // prepare randomized data that will have all the integers from the range
        if(v.size() != size){
            v.clear();
            v.reserve(size);
            for(std::size_t i = 0; i < size; ++i){
                v.push_back({i});
            }
            std::shuffle(begin(v), end(v), std::mt19937());
        }

        // fill with randomized data
        Container container;
        for(std::size_t i = 0; i < size; ++i){
            container.push_back(v[i]);
        }

        return container;
    }

// Assembly:
subq $0x1418, %rsp           # imm = 0x1418
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x1410(%rsp)
movq %rsi, 0x1408(%rsp)
leaq 0x172df5(%rip), %rdi    # 0x1f08c0
callq 0x39930
cmpq 0x1408(%rsp), %rax
je 0x7dbde
leaq 0x172ddb(%rip), %rdi    # 0x1f08c0
callq 0x7dcb0
movq 0x1408(%rsp), %rsi
leaq 0x172dc7(%rip), %rdi    # 0x1f08c0
callq 0x3b7a0
movq $0x0, 0x1400(%rsp)
movq 0x1400(%rsp), %rax
cmpq 0x1408(%rsp), %rax
jae 0x7db92
movq 0x1400(%rsp), %rsi
leaq 0x13d8(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x7dd00
movq 0x8(%rsp), %rsi
leaq 0x172d7e(%rip), %rdi    # 0x1f08c0
callq 0x7dcd0
jmp 0x7db49
leaq 0x13d8(%rsp), %rdi
callq 0x11ad0
movq 0x1400(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x1400(%rsp)
jmp 0x7db0a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x13d0(%rsp)
movl %eax, 0x13cc(%rsp)
leaq 0x13d8(%rsp), %rdi
callq 0x11ad0
jmp 0x7dc7a
leaq 0x172d27(%rip), %rdi    # 0x1f08c0
callq 0x7e070
movq %rax, 0x13c0(%rsp)
leaq 0x172d13(%rip), %rdi    # 0x1f08c0
callq 0x7e0a0
movq %rax, 0x13b8(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x11fe0
movq 0x13c0(%rsp), %rdi
movq 0x13b8(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x7dd80
movq 0x10(%rsp), %rdi
movb $0x0, 0x2f(%rsp)
callq 0x11dc0
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x1408(%rsp), %rax
jae 0x7dc57
movq 0x20(%rsp), %rsi
leaq 0x172caf(%rip), %rdi    # 0x1f08c0
callq 0x7e0d0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x391e0
jmp 0x7dc25
jmp 0x7dc27
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x7dbf6
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x13d0(%rsp)
movl %eax, 0x13cc(%rsp)
callq 0x11dd0
jmp 0x7dc7a
movb $0x1, 0x2f(%rsp)
testb $0x1, 0x2f(%rsp)
jne 0x7dc6d
movq 0x10(%rsp), %rdi
callq 0x11dd0
movq 0x18(%rsp), %rax
addq $0x1418, %rsp           # imm = 0x1418
retq
movq 0x13d0(%rsp), %rdi
callq 0x5360
nopw (%rax,%rax)
// File: wichtounet[P]articles/include/policies.hpp
// Function: Find<std::vector<Trivial<8>, std::allocator<Trivial<8>>>>::run(std::vector<Trivial<8>, std::allocator<Trivial<8>>>&, unsigned long)
inline static void run(Container &c, std::size_t size){
        for(std::size_t i=0; i<size; ++i) {
            // hand written comparison to eliminate temporary object creation
            if(std::find_if(std::begin(c), std::end(c), [&](decltype(*std::begin(c)) v){ return v.a == i; }) == std::end(c)){
                ++X;
            }
        }
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x38(%rsp), %rax
jae 0x6bf63
movq 0x40(%rsp), %rdi
callq 0x5ed00
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rdi
callq 0x6b320
movq %rax, 0x18(%rsp)
leaq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x6bf70
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rdi
callq 0x6b320
movq %rax, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x6b6a0
testb $0x1, %al
jne 0x6bf3c
jmp 0x6bf4e
movq 0x27b5b5(%rip), %rax    # 0x2e74f8
addq $0x1, %rax
movq %rax, 0x27b5aa(%rip)    # 0x2e74f8
jmp 0x6bf50
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x6bec7
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: wichtounet[P]articles/include/policies.hpp
// Function: FilledRandomInsert<plf::colony<NonTrivialStringMovable, std::allocator<NonTrivialStringMovable>, unsigned short>>::make(unsigned long)
inline static Container make(std::size_t size){
        // prepare randomized data that will have all the integers from the range
        if(v.size() != size){
            v.clear();
            v.reserve(size);
            for(std::size_t i = 0; i < size; ++i){
                v.push_back({i});
            }
            std::shuffle(begin(v), end(v), std::mt19937());
        }

        // fill with randomized data
        Container container;
        for(std::size_t i = 0; i < size; ++i){
            container.insert(v[i]);
        }

        return container;
    }

// Assembly:
subq $0x1428, %rsp           # imm = 0x1428
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x1420(%rsp)
movq %rsi, 0x1418(%rsp)
leaq 0x170655(%rip), %rdi    # 0x1f0920
callq 0x39930
cmpq 0x1418(%rsp), %rax
je 0x803dc
leaq 0x17063b(%rip), %rdi    # 0x1f0920
callq 0x7dcb0
movq 0x1418(%rsp), %rsi
leaq 0x170627(%rip), %rdi    # 0x1f0920
callq 0x3b7a0
movq $0x0, 0x1410(%rsp)
movq 0x1410(%rsp), %rax
cmpq 0x1418(%rsp), %rax
jae 0x80390
movq 0x1410(%rsp), %rsi
leaq 0x13e8(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x7dd00
movq (%rsp), %rsi
leaq 0x1705e0(%rip), %rdi    # 0x1f0920
callq 0x7dcd0
jmp 0x80347
leaq 0x13e8(%rsp), %rdi
callq 0x11ad0
movq 0x1410(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x1410(%rsp)
jmp 0x8030a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x13e0(%rsp)
movl %eax, 0x13dc(%rsp)
leaq 0x13e8(%rsp), %rdi
callq 0x11ad0
jmp 0x8047d
leaq 0x170589(%rip), %rdi    # 0x1f0920
callq 0x7e070
movq %rax, 0x13d0(%rsp)
leaq 0x170575(%rip), %rdi    # 0x1f0920
callq 0x7e0a0
movq %rax, 0x13c8(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x11fe0
movq 0x13d0(%rsp), %rdi
movq 0x13c8(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0x7dd80
movq 0x8(%rsp), %rdi
movb $0x0, 0x3f(%rsp)
callq 0x3ba70
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x1418(%rsp), %rax
jae 0x8045a
movq 0x30(%rsp), %rsi
leaq 0x170511(%rip), %rdi    # 0x1f0920
callq 0x7e0d0
movq 0x8(%rsp), %rsi
movq %rax, %rdx
leaq 0x18(%rsp), %rdi
callq 0x3be10
jmp 0x80428
jmp 0x8042a
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x803f4
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x13e0(%rsp)
movl %eax, 0x13dc(%rsp)
callq 0x3ba10
jmp 0x8047d
movb $0x1, 0x3f(%rsp)
testb $0x1, 0x3f(%rsp)
jne 0x80470
movq 0x8(%rsp), %rdi
callq 0x3ba10
movq 0x10(%rsp), %rax
addq $0x1428, %rsp           # imm = 0x1428
retq
movq 0x13e0(%rsp), %rdi
callq 0x5360
nopw (%rax,%rax)
// File: wichtounet[P]articles/include/policies.hpp
// Function: Write<std::vector<Trivial<8>, std::allocator<Trivial<8>>>>::run(std::vector<Trivial<8>, std::allocator<Trivial<8>>>&, unsigned long)
inline static void run(Container &c, std::size_t){
        auto it = std::begin(c);
        auto end = std::end(c);

        for(; it != end; ++it){
            ++(it->a);
        }
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x5ed00
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x6b320
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x6b7b0
testb $0x1, %al
jne 0x88b91
jmp 0x88bb1
leaq 0x10(%rsp), %rdi
callq 0x88bc0
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
leaq 0x10(%rsp), %rdi
callq 0x6bab0
jmp 0x88b7c
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: wichtounet[P]articles/include/policies.hpp
// Function: Insert<std::vector<Trivial<8>, std::allocator<Trivial<8>>>>::run(std::vector<Trivial<8>, std::allocator<Trivial<8>>>&, unsigned long)
inline static void run(Container &c, std::size_t){
        for(std::size_t i=0; i<1000; ++i) {
            // hand written comparison to eliminate temporary object creation
            auto it = std::find_if(std::begin(c), std::end(c), [&](decltype(*std::begin(c)) v){ return v.a == i; });
            c.insert(it, values[i]);
        }
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq $0x0, 0x40(%rsp)
cmpq $0x3e8, 0x40(%rsp)      # imm = 0x3E8
jae 0x9027b
movq 0x50(%rsp), %rdi
callq 0x5ed00
movq %rax, 0x30(%rsp)
movq 0x50(%rsp), %rdi
callq 0x6b320
movq %rax, 0x28(%rsp)
leaq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x90280
movq %rax, 0x38(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x5ed30
movq 0x40(%rsp), %rsi
leaq 0x2573ac(%rip), %rdi    # 0x2e75f8
callq 0x902f0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movq 0x18(%rsp), %rsi
callq 0x5eae0
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x40(%rsp)
jmp 0x901d7
addq $0x58, %rsp
retq
// File: wichtounet[P]articles/plf_colony_alpha/plf_colony.h
// Function: plf::colony<Trivial<8>, std::allocator<Trivial<8>>, unsigned short>::colony_iterator<std::allocator<Trivial<8>>, false>::check_for_end_of_group_and_progress()
inline PLF_COLONY_FORCE_INLINE void check_for_end_of_group_and_progress() // used by erase
		{
			if (element_pointer == group_pointer->last_endpoint && group_pointer->next_group != NULL)
			{
				group_pointer = group_pointer->next_group;
				element_pointer = group_pointer->elements + *(group_pointer->skipfield);
				skipfield_pointer = group_pointer->skipfield + *(group_pointer->skipfield);
			}
		}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rcx
movq %rcx, -0x10(%rsp)
movq 0x8(%rcx), %rax
movq (%rcx), %rcx
cmpq (%rcx), %rax
jne 0xad186
movq -0x10(%rsp), %rax
movq (%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0xad186
movq -0x10(%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, (%rax)
movq (%rax), %rcx
movq 0x10(%rcx), %rcx
movq (%rax), %rdx
movq 0x18(%rdx), %rdx
movzwl (%rdx), %edx
movslq %edx, %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
movq %rcx, 0x8(%rax)
movq (%rax), %rcx
movq 0x18(%rcx), %rcx
movq (%rax), %rdx
movq 0x18(%rdx), %rdx
movzwl (%rdx), %edx
movslq %edx, %rdx
shlq %rdx
addq %rdx, %rcx
movq %rcx, 0x10(%rax)
retq
nopw (%rax,%rax)
// File: wichtounet[P]articles/plf_colony_alpha/plf_colony.h
// Function: plf::colony<Trivial<8>, std::allocator<Trivial<8>>, unsigned short>::reduced_stack::initialize(unsigned long)
void initialize(const size_type first_group_size)
		{
			first_group = current_group = PLF_COLONY_ALLOCATE(stack_group_allocator_type, group_allocator_pair, 1, 0);

			try
			{
				#ifdef PLF_COLONY_VARIADICS_SUPPORT
					PLF_COLONY_CONSTRUCT(stack_group_allocator_type, group_allocator_pair, first_group, first_group_size);
				#else
					PLF_COLONY_CONSTRUCT(stack_group_allocator_type, group_allocator_pair, first_group, group(first_group_size));
				#endif
			}
			catch (...)
			{
				PLF_COLONY_DEALLOCATE(stack_group_allocator_type, group_allocator_pair, first_group, 1);
				first_group = current_group = NULL;
				throw;
			}

			top_element = start_element = first_group->elements;
			end_element = first_group->end;
		}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x30, %rdi
movq %rdi, 0x8(%rsp)
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %esi
callq 0xada80
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rsi
leaq 0x28(%rsp), %rdx
callq 0xaddc0
jmp 0xadb43
jmp 0xadbab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
callq 0x50b0
movq 0x10(%rsp), %rax
movq %rax, %rdi
addq $0x30, %rdi
movq 0x8(%rax), %rsi
movl $0x1, %edx
callq 0x17ae0
jmp 0xadb79
movq 0x10(%rsp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
callq 0x52d0
jmp 0xadbe2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x5350
jmp 0xadba9
jmp 0xadbd0
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
movq (%rcx), %rcx
movq %rcx, 0x18(%rax)
movq %rcx, 0x10(%rax)
movq 0x8(%rax), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, 0x20(%rax)
addq $0x38, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x5360
movq %rax, %rdi
callq 0x14670
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: wichtounet[P]articles/plf_colony_alpha/plf_colony.h
// Function: plf::colony<Trivial<8>, std::allocator<Trivial<8>>, unsigned short>::change_group_sizes(unsigned short, unsigned short)
void change_group_sizes(const skipfield_type min_allocation_amount, const skipfield_type max_allocation_amount)
	{
		assert((min_allocation_amount > 2) & (min_allocation_amount <= max_allocation_amount));

		min_elements_per_group = min_allocation_amount;
		group_allocator_pair.max_elements_per_group = max_allocation_amount;

		// The following will only have an effect if the erased_locations becomes empty or is already empty
		erased_locations.group_allocator_pair.min_elements_per_group = ((min_allocation_amount < 8) ? min_allocation_amount : (min_allocation_amount >> 7) + 8);

		if (first_group != NULL && (first_group->size < min_allocation_amount || end_iterator.group_pointer->size > max_allocation_amount))
		{
			consolidate();
		}
	}

// Assembly:
subq $0x28, %rsp
movw %dx, %ax
movw %si, %cx
movq %rdi, 0x20(%rsp)
movw %cx, 0x1e(%rsp)
movw %ax, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movw 0x1e(%rsp), %cx
movw %cx, 0x40(%rax)
movw 0x1c(%rsp), %cx
movw %cx, 0x42(%rax)
movzwl 0x1e(%rsp), %eax
cmpl $0x8, %eax
jge 0xe3d9a
movzwl 0x1e(%rsp), %eax
movl %eax, 0xc(%rsp)
jmp 0xe3da9
movzwl 0x1e(%rsp), %eax
sarl $0x7, %eax
addl $0x8, %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
movslq %ecx, %rcx
movq %rcx, 0x78(%rax)
cmpq $0x0, 0x30(%rax)
je 0xe3df5
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movzwl 0x32(%rax), %eax
movzwl 0x1e(%rsp), %ecx
cmpl %ecx, %eax
jl 0xe3deb
movq 0x10(%rsp), %rax
movq (%rax), %rax
movzwl 0x32(%rax), %eax
movzwl 0x1c(%rsp), %ecx
cmpl %ecx, %eax
jle 0xe3df5
movq 0x10(%rsp), %rdi
callq 0x17dd0
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: wichtounet[P]articles/plf_colony_alpha/plf_timsort.h
// Function: plf::TimSort<Trivial<8>**, plf::colony<Trivial<8>, std::allocator<Trivial<8>>, unsigned short>::sort_dereferencer<plf::colony<Trivial<8>, std::allocator<Trivial<8>>, unsigned short>::less>>::countRunAndMakeAscending(Trivial<8>**, Trivial<8>**, plf::Compare<Trivial<8>* const&, plf::colony<Trivial<8>, std::allocator<Trivial<8>>, unsigned short>::sort_dereferencer<plf::colony<Trivial<8>, std::allocator<Trivial<8>>, unsigned short>::less>>)
static diff_t countRunAndMakeAscending(iter_t const lo, iter_t const hi, compare_t compare)
	{
		assert(lo < hi);

		iter_t runHi = lo + 1;
		if (runHi == hi)
		{
			return 1;
		}

		if (compare.lt(*(runHi++), *lo))   // descending
		{
			while (runHi < hi && compare.lt(*runHi, *(runHi - 1)))
			{
				++runHi;
			}
			
			std::reverse(lo, runHi);
		}
		else     // ascending
		{
			while (runHi < hi && compare.ge(*runHi, *(runHi - 1)))
			{
				++runHi;
			}
		}

		return runHi - lo;
	}

// Assembly:
subq $0x38, %rsp
movq %rdx, 0x8(%rsp)
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x20(%rsp), %rax
jne 0xe5870
movq $0x1, 0x30(%rsp)
jmp 0xe5953
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rsi, %rax
addq $0x8, %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdx
callq 0xe5e40
testb $0x1, %al
jne 0xe5896
jmp 0xe58f1
jmp 0xe5898
movq 0x10(%rsp), %rcx
xorl %eax, %eax
cmpq 0x20(%rsp), %rcx
movb %al, 0x7(%rsp)
jae 0xe58c6
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq $-0x8, %rdx
callq 0xe5e40
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0xe58d0
jmp 0xe58e0
movq 0x10(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x10(%rsp)
jmp 0xe5898
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xe5e80
jmp 0xe593d
jmp 0xe58f3
movq 0x10(%rsp), %rcx
xorl %eax, %eax
cmpq 0x20(%rsp), %rcx
movb %al, 0x6(%rsp)
jae 0xe5921
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq $-0x8, %rdx
callq 0xe5ec0
movb %al, 0x6(%rsp)
movb 0x6(%rsp), %al
testb $0x1, %al
jne 0xe592b
jmp 0xe593b
movq 0x10(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x10(%rsp)
jmp 0xe58f3
jmp 0xe593d
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: wichtounet[P]articles/plf_colony_alpha/plf_timsort.h
// Function: plf::TimSort<Trivial<8>**, plf::colony<Trivial<8>, std::allocator<Trivial<8>>, unsigned short>::sort_dereferencer<plf::colony<Trivial<8>, std::allocator<Trivial<8>>, unsigned short>::less>>::binarySort(Trivial<8>**, Trivial<8>**, Trivial<8>**, plf::Compare<Trivial<8>* const&, plf::colony<Trivial<8>, std::allocator<Trivial<8>>, unsigned short>::sort_dereferencer<plf::colony<Trivial<8>, std::allocator<Trivial<8>>, unsigned short>::less>>)
static void binarySort(iter_t const lo, iter_t const hi, iter_t start, compare_t compare)
	{
		assert(lo <= start && start <= hi);
		if (start == lo)
		{
			++start;
		}
		for (; start < hi; ++start)
		{
			assert(lo <= start);
			/*const*/ value_t pivot = PLF_TIMSORT_MOVE(*start);

			iter_t const pos = std::upper_bound(lo, start, pivot, compare.less_function());
			for (iter_t p = start; p > pos; --p)
			{
				*p = PLF_TIMSORT_MOVE(*(p - 1));
			}
			*pos = PLF_TIMSORT_MOVE(pivot);
		}
	}

// Assembly:
subq $0x58, %rsp
movq %rcx, 0x10(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq 0x40(%rsp), %rax
cmpq 0x50(%rsp), %rax
jne 0xe59b7
movq 0x40(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x40(%rsp)
jmp 0xe59b9
movq 0x40(%rsp), %rax
cmpq 0x48(%rsp), %rax
jae 0xe5a68
movq 0x10(%rsp), %rdi
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0xe5fd0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movb (%rax), %al
movb %al, 0x27(%rsp)
leaq 0x30(%rsp), %rdx
callq 0xe5f70
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x28(%rsp), %rax
jbe 0xe5a48
movq 0x18(%rsp), %rax
movq -0x8(%rax), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
addq $-0x8, %rax
movq %rax, 0x18(%rsp)
jmp 0xe5a1b
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, (%rax)
movq 0x40(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x40(%rsp)
jmp 0xe59b9
addq $0x58, %rsp
retq
nopl (%rax)