LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: EverybodyHops[P]Permutations/media_number.cpp
// Function: media_number::sub_vector(std::vector<int, std::allocator<int>>)
bool media_number::sub_vector(vector<int> v){
    if(!if_vector_legal(v)){
        return false;
    }

    for(int i = 0; i < num.size() - 1; i++){
        if(i < v.size()){  
            num[i] -= v[i];
        }
        if(num[i] < 0){
            num[i] += carry[i];
            num[i + 1] -= 1;
        }
    }

    if(num[num.size() - 1] < 0){
        #ifdef DEBUG
            cout << "Underflow!" << endl;
            print_num();
        #endif
        add_vector(v);
        #ifdef DEBUG
            cout << "After handle unferflow." << endl;
            print_num();
        #endif
        return false;
    }

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x70(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2f70
movq -0x68(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2690
xorb $-0x1, %al
movb %al, -0x5d(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3090
movb -0x5d(%rbp), %al
testb $0x1, %al
jne 0x298c
jmp 0x2995
movb $0x0, -0x1(%rbp)
jmp 0x2ae5
movl $0x0, -0x34(%rbp)
movq -0x68(%rbp), %rdi
movslq -0x34(%rbp), %rax
movq %rax, -0x78(%rbp)
callq 0x30f0
movq %rax, %rcx
movq -0x78(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x2a77
movq -0x70(%rbp), %rdi
movslq -0x34(%rbp), %rax
movq %rax, -0x80(%rbp)
callq 0x30f0
movq %rax, %rcx
movq -0x80(%rbp), %rax
cmpq %rcx, %rax
jae 0x2a0c
movq -0x70(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0x3110
movq -0x68(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x84(%rbp)
movslq -0x34(%rbp), %rsi
callq 0x3110
movl -0x84(%rbp), %edx
movl (%rax), %ecx
subl %edx, %ecx
movl %ecx, (%rax)
movq -0x68(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0x3110
cmpl $0x0, (%rax)
jge 0x2a67
movq -0x68(%rbp), %rdi
addq $0x18, %rdi
movslq -0x34(%rbp), %rsi
callq 0x3110
movq -0x68(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x88(%rbp)
movslq -0x34(%rbp), %rsi
callq 0x3110
movl -0x88(%rbp), %ecx
movq -0x68(%rbp), %rdi
addl (%rax), %ecx
movl %ecx, (%rax)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x3110
movl (%rax), %ecx
subl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x2a69
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x299c
movq -0x68(%rbp), %rdi
callq 0x30f0
movq -0x68(%rbp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0x3110
cmpl $0x0, (%rax)
jge 0x2ae1
movq -0x70(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x2f70
movq -0x68(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0x2760
jmp 0x2abb
leaq -0x50(%rbp), %rdi
callq 0x3090
movb $0x0, -0x1(%rbp)
jmp 0x2ae5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3090
jmp 0x2af3
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x21b0
nopl (%rax)
// File: EverybodyHops[P]Permutations/media_number.cpp
// Function: increase_carry::increase_carry(int)
increase_carry::increase_carry(int digit){
    for(int i = 0; i < digit; i++){
        num.push_back(0);
        carry.push_back(i + 2);
    }
    num.push_back(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x31f0
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x2cc1
movq -0x38(%rbp), %rdi
movl $0x0, -0x14(%rbp)
leaq -0x14(%rbp), %rsi
callq 0x31c0
jmp 0x2c81
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
movl -0x10(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x31c0
jmp 0x2c9d
jmp 0x2c9f
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2c63
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x3220
jmp 0x2cdd
movq -0x38(%rbp), %rdi
movl $0x0, -0x2c(%rbp)
leaq -0x2c(%rbp), %rsi
callq 0x31c0
jmp 0x2cd7
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x21b0
nopw %cs:(%rax,%rax)
// File: EverybodyHops[P]Permutations/media_number.cpp
// Function: increase_carry::increase_carry(std::vector<int, std::allocator<int>>)
increase_carry::increase_carry(vector<int> _num){
    num.assign(_num.begin(), _num.end());
    for(int i = 0; i < num.size(); i++){
        carry.push_back(i + 2);
    }
    num.push_back(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x31f0
movq -0x48(%rbp), %rdi
callq 0x3290
movq -0x48(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x32c0
movq -0x40(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3250
jmp 0x2d3e
movl $0x0, -0x30(%rbp)
movq -0x40(%rbp), %rdi
movslq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x30f0
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x2da2
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
movl -0x30(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x34(%rbp)
leaq -0x34(%rbp), %rsi
callq 0x31c0
jmp 0x2d7e
jmp 0x2d80
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x2d45
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x3220
jmp 0x2dbe
movq -0x40(%rbp), %rdi
movl $0x0, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x31c0
jmp 0x2db8
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x21b0
nopw (%rax,%rax)
// File: EverybodyHops[P]Permutations/media_number.cpp
// Function: decrease_carry::decrease_carry(int)
decrease_carry::decrease_carry(int digit){
    for(int i = 0; i < digit; i++){
        num.push_back(0);
        carry.push_back(digit + 1 - i);
    }
    num.push_back(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x31f0
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x2e55
movq -0x38(%rbp), %rdi
movl $0x0, -0x14(%rbp)
leaq -0x14(%rbp), %rsi
callq 0x31c0
jmp 0x2e11
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
movl -0xc(%rbp), %eax
movl -0x10(%rbp), %ecx
subl %ecx, %eax
incl %eax
movl %eax, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x31c0
jmp 0x2e31
jmp 0x2e33
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2df3
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x3220
jmp 0x2e71
movq -0x38(%rbp), %rdi
movl $0x0, -0x2c(%rbp)
leaq -0x2c(%rbp), %rsi
callq 0x31c0
jmp 0x2e6b
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x21b0
nopw (%rax,%rax)
// File: EverybodyHops[P]Permutations/media_number.cpp
// Function: decrease_carry::decrease_carry(std::vector<int, std::allocator<int>>)
decrease_carry::decrease_carry(vector<int> _num){
    num.assign(_num.begin(), _num.end());
    for(int i = 0; i < num.size(); i++){
        carry.push_back(num.size() - i + 1);
    }
    num.push_back(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x31f0
movq -0x48(%rbp), %rdi
callq 0x3290
movq -0x48(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x32c0
movq -0x40(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3250
jmp 0x2ece
movl $0x0, -0x30(%rbp)
movq -0x40(%rbp), %rdi
movslq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x30f0
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x2f43
movq -0x40(%rbp), %rdi
movq %rdi, %rax
addq $0x18, %rax
movq %rax, -0x58(%rbp)
callq 0x30f0
movq -0x58(%rbp), %rdi
movl -0x30(%rbp), %ecx
subl %ecx, %eax
incl %eax
movl %eax, -0x34(%rbp)
leaq -0x34(%rbp), %rsi
callq 0x31c0
jmp 0x2f1f
jmp 0x2f21
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x2ed5
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x3220
jmp 0x2f5f
movq -0x40(%rbp), %rdi
movl $0x0, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x31c0
jmp 0x2f59
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x21b0
nopl (%rax,%rax)
// File: EverybodyHops[P]Permutations/./debug.h
// Function: void print_vector<int>(std::vector<int, std::allocator<int>>, bool)
void print_vector(vector<T> a, bool if_reverse=false){
    if(if_reverse){
        reverse(a.begin(), a.end());
    }
    for(auto x: a){
        cout << x << " ";
    }
    cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
je 0x57d5
movq -0x48(%rbp), %rdi
callq 0x3290
movq -0x48(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x32c0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x7fb0
movq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3290
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x32c0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x84b0
testb $0x1, %al
jne 0x580a
jmp 0x5841
leaq -0x30(%rbp), %rdi
callq 0x8aa0
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %esi
movq 0xd7b6(%rip), %rdi      # 0x12fd8
callq 0x21a0
movq %rax, %rdi
leaq 0x77db(%rip), %rsi      # 0xd00c
callq 0x20e0
leaq -0x30(%rbp), %rdi
callq 0x4a90
jmp 0x57f7
movq 0xd790(%rip), %rdi      # 0x12fd8
movq 0xd779(%rip), %rsi      # 0x12fc8
callq 0x2100
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH19_SpecializedToolsAndTechniques/examples/./Token.h
// Function: operator<<(std::ostream&, Token const&)
inline
std::ostream &operator<<(std::ostream &os, const Token &t)
{
	switch (t.tok) {
		case Token::INT: return os << t.ival;
		case Token::CHAR: return os << t.cval;
		case Token::DBL: return os << t.dval;
		case Token::STR: return os << t.sval;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x20(%rbp)
subq $0x3, %rax
ja 0x1690
movq -0x20(%rbp), %rax
leaq 0x9d9(%rip), %rcx       # 0x2004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x10e0
movq %rax, -0x8(%rbp)
jmp 0x1692
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movsbl 0x8(%rax), %esi
callq 0x10b0
movq %rax, -0x8(%rbp)
jmp 0x1692
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm0
callq 0x1110
movq %rax, -0x8(%rbp)
jmp 0x1692
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
callq 0x1070
movq %rax, -0x8(%rbp)
jmp 0x1692
ud2
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH19_SpecializedToolsAndTechniques/examples/./Token.h
// Function: Token::operator=(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline
Token &Token::operator=(const std::string &s)
{
	if (tok == STR)  // if we already hold a string, just do an assignment
		sval = s;
	else
		new(&sval) std::string(s);  // otherwise construct a string
	tok = STR;                 // update the discriminant
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x3, (%rax)
jne 0x16d0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rdi
callq 0x1030
jmp 0x16e1
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0x1040
movq -0x18(%rbp), %rax
movl $0x3, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH19_SpecializedToolsAndTechniques/examples/./Token.h
// Function: Token::operator=(Token const&)
inline
Token &Token::operator=(const Token &t)
{
	// if this object holds a string and t doesn't, we have to free the old string
	if (tok == STR && t.tok != STR) sval.~string();
	if (tok == STR && t.tok == STR)
		sval = t.sval;  // no need to construct a new string
	else
		copyUnion(t);   // will construct a string if t.tok is STR
	tok = t.tok;
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x3, (%rax)
jne 0x1733
movq -0x10(%rbp), %rax
cmpl $0x3, (%rax)
je 0x1733
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x1050
movq -0x18(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x175c
movq -0x10(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x175c
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
addq $0x8, %rdi
callq 0x1030
jmp 0x1769
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x17f0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH19_SpecializedToolsAndTechniques/examples/./Token.h
// Function: Token::operator=(int)
inline
Token &Token::operator=(int i)
{
	if (tok == STR) sval.~string();  // if we have a string, free it
	ival = i;                        // assign to the appropriate member
	tok = INT;                       // update the discriminant
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x3, (%rax)
jne 0x17a9
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x1050
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: iZhangHui[P]CppPrimer/CH19_SpecializedToolsAndTechniques/examples/./Token.h
// Function: Token::copyUnion(Token const&)
inline
void Token::copyUnion(const Token &t)
{
	switch (t.tok) {
		case Token::INT: ival = t.ival; break;
		case Token::CHAR: cval = t.cval; break;
		case Token::DBL: dval = t.dval; break;
		// to copy a string, construct it using placement new; see (XREF(placenew)) 
		case Token::STR: new(&sval) std::string(t.sval); break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x18(%rbp)
subq $0x3, %rax
ja 0x1875
movq -0x18(%rbp), %rax
leaq 0x7f1(%rip), %rcx       # 0x2014
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
jmp 0x1875
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movb 0x8(%rcx), %cl
movb %cl, 0x8(%rax)
jmp 0x1875
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
movsd %xmm0, 0x8(%rax)
jmp 0x1875
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x1040
addq $0x20, %rsp
popq %rbp
retq
// File: attractivechaos[P]udb2/tsl_hopscotch_map/test-1.cpp
// Function: test_int(unsigned int, unsigned int)
uint32_t test_int(uint32_t n, uint32_t x0)
{
	uint32_t i, x, z = 0;
	tsl::bhopscotch_map<uint32_t, uint32_t, Hash32> h;
	for (i = 0, x = x0; i < n; ++i) {
		x = hash32(x);
#ifndef UDB2_TEST_DEL
		z += ++h[get_key(n, x)];
#else
		auto p = h.insert(std::pair<uint32_t, uint32_t>(get_key(n, x), i));
		if (p.second == false) h.erase(p.first);
#endif
	}
	fprintf(stderr, "# unique keys: %ld; checksum: %u\n", h.size(), z);
	return h.size();
}

// Assembly:
subq $0x138, %rsp            # imm = 0x138
movl %edi, 0x134(%rsp)
movl %esi, 0x130(%rsp)
movl $0x0, 0x124(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0x28b0
movl $0x0, 0x12c(%rsp)
movl 0x130(%rsp), %eax
movl %eax, 0x128(%rsp)
movl 0x12c(%rsp), %eax
cmpl 0x134(%rsp), %eax
jae 0x2827
movl 0x128(%rsp), %edi
callq 0x2370
movl %eax, 0x34(%rsp)
jmp 0x273c
movl 0x34(%rsp), %eax
movl %eax, 0x128(%rsp)
movl 0x134(%rsp), %edi
movl 0x128(%rsp), %esi
callq 0x23e0
movl %eax, 0x30(%rsp)
jmp 0x2760
movl 0x30(%rsp), %eax
movl %eax, 0x6c(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0x6c(%rsp), %rsi
leaq 0x12c(%rsp), %rdx
callq 0x2960
jmp 0x2781
leaq 0x78(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
leaq 0x70(%rsp), %rdx
callq 0x2930
jmp 0x279a
movb 0x90(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x280f
movq 0x88(%rsp), %rax
movq %rax, 0x60(%rsp)
movups 0x78(%rsp), %xmm0
movaps %xmm0, 0x50(%rsp)
movq 0x60(%rsp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
movaps 0x50(%rsp), %xmm0
movups %xmm0, (%rax)
leaq 0x38(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0x2990
jmp 0x27ea
jmp 0x280f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0x2a10
jmp 0x288a
jmp 0x2811
movl 0x12c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x12c(%rsp)
jmp 0x2716
movq 0xa7aa(%rip), %rax      # 0xcfd8
movq (%rax), %rax
movq %rax, 0x20(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0x2a00
movq 0x20(%rsp), %rdi
movq %rax, %rdx
movl 0x124(%rsp), %ecx
leaq 0x6828(%rip), %rsi      # 0x9081
movb $0x0, %al
callq 0x2190
leaq 0xa8(%rsp), %rdi
callq 0x2a00
movl %eax, 0x2c(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0x2a10
movl 0x2c(%rsp), %eax
addq $0x138, %rsp            # imm = 0x138
retq
movq 0xa0(%rsp), %rdi
callq 0x21e0
nopw (%rax,%rax)
// File: attractivechaos[P]udb2/tsl_hopscotch_map/./hopscotch_growth_policy.h
// Function: tsl::hh::power_of_two_growth_policy<2ul>::round_up_to_power_of_two(unsigned long)
static std::size_t round_up_to_power_of_two(std::size_t value) {
        if(is_power_of_two(value)) {
            return value;
        }
        
        if(value == 0) {
            return 1;
        }
            
        --value;
        for(std::size_t i = 1; i < sizeof(std::size_t) * CHAR_BIT; i *= 2) {
            value |= value >> i;
        }
        
        return value + 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x36e0
testb $0x1, %al
jne 0x3659
jmp 0x3665
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x36c6
cmpq $0x0, 0x8(%rsp)
jne 0x3678
movq $0x1, 0x10(%rsp)
jmp 0x36c6
movq 0x8(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x8(%rsp)
movq $0x1, (%rsp)
cmpq $0x40, (%rsp)
jae 0x36b8
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
shrq %cl, %rax
orq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
movq (%rsp), %rax
shlq %rax
movq %rax, (%rsp)
jmp 0x368e
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
// File: attractivechaos[P]udb2/tsl_hopscotch_map/./hopscotch_hash.h
// Function: tsl::detail_hopscotch_hash::hopscotch_hash<std::pair<unsigned int const, unsigned int>, tsl::bhopscotch_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 62u, false, tsl::hh::power_of_two_growth_policy<2ul>>::KeySelect, tsl::bhopscotch_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 62u, false, tsl::hh::power_of_two_growth_policy<2ul>>::ValueSelect, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 62u, false, tsl::hh::power_of_two_growth_policy<2ul>, std::map<unsigned int, unsigned int, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>>>::bucket_count() const
size_type bucket_count() const {
        /*
         * So that the last bucket can have NeighborhoodSize neighbors, the size of the bucket array is a little
         * bigger than the real number of buckets when not empty. 
         * We could use some of the buckets at the beginning, but it is faster this way as we avoid extra checks.
         */
        if(m_buckets_data.empty()) {
            return 0;
        }
        
        return m_buckets_data.size() - NeighborhoodSize + 1; 
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x8, %rdi
callq 0x44b0
testb $0x1, %al
jne 0x4481
jmp 0x448c
movq $0x0, 0x10(%rsp)
jmp 0x44a6
movq (%rsp), %rdi
addq $0x8, %rdi
callq 0x3ab0
subq $0x3e, %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
// File: attractivechaos[P]udb2/tsl_hopscotch_map/./hopscotch_hash.h
// Function: tsl::detail_hopscotch_hash::hopscotch_hash<std::pair<unsigned int const, unsigned int>, tsl::bhopscotch_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 62u, false, tsl::hh::power_of_two_growth_policy<2ul>>::KeySelect, tsl::bhopscotch_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 62u, false, tsl::hh::power_of_two_growth_policy<2ul>>::ValueSelect, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 62u, false, tsl::hh::power_of_two_growth_policy<2ul>, std::map<unsigned int, unsigned int, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>>>::find_empty_bucket(unsigned long) const
std::size_t find_empty_bucket(std::size_t ibucket_start) const {
        const std::size_t limit = std::min(ibucket_start + MAX_PROBES_FOR_EMPTY_BUCKET, m_buckets_data.size());
        for(; ibucket_start < limit; ibucket_start++) {
            if(m_buckets[ibucket_start].empty()) {
                return ibucket_start;
            }
        }
        
        return m_buckets_data.size();
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x20(%rsp), %rax
addq $0x2e8, %rax            # imm = 0x2E8
movq %rax, 0x10(%rsp)
addq $0x8, %rdi
callq 0x3ab0
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x39d0
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x56f5
movq (%rsp), %rax
movq 0x50(%rax), %rdi
movq 0x20(%rsp), %rax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x2ed0
testb $0x1, %al
jne 0x56d7
jmp 0x56e3
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x5707
jmp 0x56e5
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x56ac
movq (%rsp), %rdi
addq $0x8, %rdi
callq 0x3ab0
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: attractivechaos[P]udb2/tsl_hopscotch_map/./hopscotch_hash.h
// Function: _gnu_cxx::__normal_iterator<tsl::detail_hopscotch_hash::hopscotch_bucket<std::pair<unsigned int const, unsigned int>, 62u, false>*, std::vector<tsl::detail_hopscotch_hash::hopscotch_bucket<std::pair<unsigned int const, unsigned int>, 62u, false>, std::allocator<tsl::detail_hopscotch_hash::hopscotch_bucket<std::pair<unsigned int const, unsigned int>, 62u, false>>>> tsl::detail_hopscotch_hash::hopscotch_hash<std::pair<unsigned int const, unsigned int>, tsl::bhopscotch_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 62u, false, tsl::hh::power_of_two_growth_policy<2ul>>::KeySelect, tsl::bhopscotch_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 62u, false, tsl::hh::power_of_two_growth_policy<2ul>>::ValueSelect, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 62u, false, tsl::hh::power_of_two_growth_policy<2ul>, std::map<unsigned int, unsigned int, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>>>::insert_in_bucket<std::pair<unsigned int const, unsigned int>>(unsigned long, unsigned long, unsigned long, std::pair<unsigned int const, unsigned int>&&)
iterator_buckets insert_in_bucket(std::size_t ibucket_empty, std::size_t ibucket_for_hash,
                                      std::size_t hash, Args&&... value_type_args) 
    {
        tsl_hh_assert(ibucket_empty >= ibucket_for_hash );
        tsl_hh_assert(m_buckets[ibucket_empty].empty());
        m_buckets[ibucket_empty].set_value_of_empty_bucket(hopscotch_bucket::truncate_hash(hash), std::forward<Args>(value_type_args)...);
        
        tsl_hh_assert(!m_buckets[ibucket_for_hash].empty());
        m_buckets[ibucket_for_hash].toggle_neighbor_presence(ibucket_empty - ibucket_for_hash);
        m_nb_elements++;
        
        return m_buckets_data.begin() + ibucket_empty;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rax), %rax
movq 0x30(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
callq 0x6df0
movq (%rsp), %rdi
movl %eax, %esi
movq 0x18(%rsp), %rdx
callq 0x6da0
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rdi
movq 0x28(%rsp), %rax
shlq $0x4, %rax
addq %rax, %rdi
movq 0x30(%rsp), %rsi
subq 0x28(%rsp), %rsi
callq 0x6a40
movq 0x8(%rsp), %rdi
movq 0x58(%rdi), %rax
addq $0x1, %rax
movq %rax, 0x58(%rdi)
addq $0x8, %rdi
callq 0x4d60
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x4d90
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/tsl_hopscotch_map/./hopscotch_hash.h
// Function: std::_Rb_tree_iterator<std::pair<unsigned int const, unsigned int>> tsl::detail_hopscotch_hash::hopscotch_hash<std::pair<unsigned int const, unsigned int>, tsl::bhopscotch_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 62u, false, tsl::hh::power_of_two_growth_policy<2ul>>::KeySelect, tsl::bhopscotch_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 62u, false, tsl::hh::power_of_two_growth_policy<2ul>>::ValueSelect, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 62u, false, tsl::hh::power_of_two_growth_policy<2ul>, std::map<unsigned int, unsigned int, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>>>::insert_in_overflow<std::pair<unsigned int const, unsigned int>, std::map<unsigned int, unsigned int, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>>, (void*)0>(unsigned long, std::pair<unsigned int const, unsigned int>&&)
iterator_overflow insert_in_overflow(std::size_t ibucket_for_hash, Args&&... value_type_args) {
        auto it = m_overflow_elements.emplace(std::forward<Args>(value_type_args)...).first;
        
        m_buckets[ibucket_for_hash].set_overflow(true);
        m_nb_elements++;
        
        return it;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x20, %rdi
movq 0x28(%rsp), %rsi
callq 0x6fc0
movq %rax, %rcx
movq (%rsp), %rax
movb %dl, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq %rcx, 0x18(%rsp)
movb 0x10(%rsp), %cl
movb %cl, 0x20(%rsp)
movq 0x18(%rsp), %rcx
movq %rcx, 0x40(%rsp)
movq 0x50(%rax), %rdi
movq 0x30(%rsp), %rax
shlq $0x4, %rax
addq %rax, %rdi
movl $0x1, %esi
callq 0x62e0
movq (%rsp), %rax
movq 0x58(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x58(%rax)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: attractivechaos[P]udb2/tsl_hopscotch_map/./hopscotch_hash.h
// Function: tsl::detail_hopscotch_hash::hopscotch_bucket<std::pair<unsigned int const, unsigned int>, 62u, false>::set_overflow(bool)
void set_overflow(bool has_overflow) noexcept {
        if(has_overflow) {
            m_neighborhood_infos = neighborhood_bitmap(m_neighborhood_infos | 2);
        }
        else {
            m_neighborhood_infos = neighborhood_bitmap(m_neighborhood_infos & ~2);
        }
    }

// Assembly:
movb %sil, %al
movq %rdi, -0x8(%rsp)
andb $0x1, %al
movb %al, -0x9(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
testb $0x1, -0x9(%rsp)
je 0x6310
movq -0x18(%rsp), %rax
movq (%rax), %rcx
orq $0x2, %rcx
movq %rcx, (%rax)
jmp 0x631f
movq -0x18(%rsp), %rax
movq (%rax), %rcx
andq $-0x3, %rcx
movq %rcx, (%rax)
retq
// File: attractivechaos[P]udb2/tsl_hopscotch_map/./hopscotch_hash.h
// Function: tsl::detail_hopscotch_hash::hopscotch_hash<std::pair<unsigned int const, unsigned int>, tsl::bhopscotch_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 62u, false, tsl::hh::power_of_two_growth_policy<2ul>>::KeySelect, tsl::bhopscotch_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 62u, false, tsl::hh::power_of_two_growth_policy<2ul>>::ValueSelect, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 62u, false, tsl::hh::power_of_two_growth_policy<2ul>, std::map<unsigned int, unsigned int, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>>>::erase_from_bucket(tsl::detail_hopscotch_hash::hopscotch_bucket<std::pair<unsigned int const, unsigned int>, 62u, false>&, unsigned long)
void erase_from_bucket(hopscotch_bucket& bucket_for_value, std::size_t ibucket_for_hash) noexcept {
        const std::size_t ibucket_for_value = std::distance(m_buckets_data.data(), &bucket_for_value);
        tsl_hh_assert(ibucket_for_value >= ibucket_for_hash);
        
        bucket_for_value.remove_value();
        m_buckets[ibucket_for_hash].toggle_neighbor_presence(ibucket_for_value - ibucket_for_hash);
        m_nb_elements--;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x8, %rdi
callq 0x34a0
movq %rax, %rdi
movq 0x28(%rsp), %rsi
callq 0x4dd0
movq %rax, 0x10(%rsp)
jmp 0x63fa
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
callq 0x6a00
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rdi
movq 0x20(%rsp), %rax
shlq $0x4, %rax
addq %rax, %rdi
movq 0x18(%rsp), %rsi
subq 0x20(%rsp), %rsi
callq 0x6a40
movq 0x8(%rsp), %rax
movq 0x58(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x58(%rax)
addq $0x38, %rsp
retq
movq %rax, %rdi
callq 0x2b80
// File: attractivechaos[P]udb2/tsl_hopscotch_map/./hopscotch_hash.h
// Function: tsl::detail_hopscotch_hash::hopscotch_bucket<std::pair<unsigned int const, unsigned int>, 62u, false>::set_empty(bool)
void set_empty(bool is_empty) noexcept {
        if(is_empty) {
            m_neighborhood_infos = neighborhood_bitmap(m_neighborhood_infos & ~1);
        }
        else {
            m_neighborhood_infos = neighborhood_bitmap(m_neighborhood_infos | 1);
        }
    }

// Assembly:
movb %sil, %al
movq %rdi, -0x8(%rsp)
andb $0x1, %al
movb %al, -0x9(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
testb $0x1, -0x9(%rsp)
je 0x6ab0
movq -0x18(%rsp), %rax
movq (%rax), %rcx
andq $-0x2, %rcx
movq %rcx, (%rax)
jmp 0x6abf
movq -0x18(%rsp), %rax
movq (%rax), %rcx
orq $0x1, %rcx
movq %rcx, (%rax)
retq
// File: attractivechaos[P]udb2/tsl_hopscotch_map/./hopscotch_hash.h
// Function: void tsl::detail_hopscotch_hash::hopscotch_bucket<std::pair<unsigned int const, unsigned int>, 62u, false>::set_value_of_empty_bucket<std::pair<unsigned int const, unsigned int>>(unsigned int, std::pair<unsigned int const, unsigned int>&&)
void set_value_of_empty_bucket(truncated_hash_type hash, Args&&... value_type_args) {
        tsl_hh_assert(empty());
        
        ::new (static_cast<void*>(std::addressof(m_value))) value_type(std::forward<Args>(value_type_args)...);
        set_empty(false);
        this->set_hash(hash);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rdi)
xorl %esi, %esi
callq 0x6a80
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x6e00
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: attractivechaos[P]udb2/tsl_hopscotch_map/./hopscotch_hash.h
// Function: tsl::detail_hopscotch_hash::hopscotch_bucket<std::pair<unsigned int const, unsigned int>, 62u, false>::swap_value_into_empty_bucket(tsl::detail_hopscotch_hash::hopscotch_bucket<std::pair<unsigned int const, unsigned int>, 62u, false>&)
void swap_value_into_empty_bucket(hopscotch_bucket& empty_bucket) {
        tsl_hh_assert(empty_bucket.empty());
        if(!empty()) {
            ::new (static_cast<void*>(std::addressof(empty_bucket.m_value))) value_type(std::move(value()));
            empty_bucket.copy_hash(*this);
            empty_bucket.set_empty(false);
            
            destroy_value();
            set_empty(true);
        }
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x2ed0
testb $0x1, %al
jne 0x6ec8
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x2f00
movq 0x10(%rsp), %rsi
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq (%rcx), %rcx
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rdi
callq 0x6ed0
movq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x6a80
movq 0x10(%rsp), %rdi
callq 0x2ef0
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x6a80
addq $0x28, %rsp
retq
nopl (%rax)
// File: attractivechaos[P]udb2/tsl_hopscotch_map/./hopscotch_growth_policy.h
// Function: tsl::hh::power_of_two_growth_policy<2ul>::power_of_two_growth_policy(unsigned long&)
explicit power_of_two_growth_policy(std::size_t& min_bucket_count_in_out) {
        if(min_bucket_count_in_out > max_bucket_count()) {
            throw std::length_error("The hash table exceeds its maxmimum size.");
        }
        
        if(min_bucket_count_in_out > 0) {
            min_bucket_count_in_out = round_up_to_power_of_two(min_bucket_count_in_out);
            m_mask = min_bucket_count_in_out - 1;
        }
        else {
            m_mask = 0;
        }
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x3620
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jbe 0x6f69
movl $0x10, %edi
callq 0x2090
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
leaq 0x2194(%rip), %rsi      # 0x90c6
callq 0x2170
jmp 0x6f39
movq (%rsp), %rdi
movq 0x609c(%rip), %rsi      # 0xcfe0
movq 0x6085(%rip), %rdx      # 0xcfd0
callq 0x21d0
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x2100
jmp 0x6fb3
movq 0x28(%rsp), %rax
cmpq $0x0, (%rax)
jbe 0x6fa2
movq 0x28(%rsp), %rax
movq (%rax), %rdi
callq 0x3640
movq %rax, %rdx
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rdx, (%rcx)
movq 0x28(%rsp), %rcx
movq (%rcx), %rcx
subq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x6fae
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
addq $0x38, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x21e0
nopl (%rax)
// File: attractivechaos[P]udb2/tsl_hopscotch_map/./hopscotch_hash.h
// Function: tsl::detail_hopscotch_hash::hopscotch_hash<std::pair<unsigned int const, unsigned int>, tsl::bhopscotch_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 62u, false, tsl::hh::power_of_two_growth_policy<2ul>>::KeySelect, tsl::bhopscotch_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 62u, false, tsl::hh::power_of_two_growth_policy<2ul>>::ValueSelect, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 62u, false, tsl::hh::power_of_two_growth_policy<2ul>, std::map<unsigned int, unsigned int, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>>>::hopscotch_iterator<false>::operator++()
hopscotch_iterator& operator++() {
            if(m_buckets_iterator == m_buckets_end_iterator) {
                ++m_overflow_iterator;
                return *this;
            }
            
            do {
                ++m_buckets_iterator;
            } while(m_buckets_iterator != m_buckets_end_iterator && m_buckets_iterator->empty());
            
            return *this; 
        }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq %rdi, %rsi
addq $0x8, %rsi
callq 0x5400
testb $0x1, %al
jne 0x7a55
jmp 0x7a6f
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
callq 0x6320
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x7ac3
jmp 0x7a71
movq 0x10(%rsp), %rdi
callq 0x6460
movq 0x10(%rsp), %rdi
movq %rdi, %rsi
addq $0x8, %rsi
callq 0x6360
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xf(%rsp)
jne 0x7a9b
jmp 0x7ab1
movq 0x10(%rsp), %rdi
callq 0x63a0
movq %rax, %rdi
callq 0x2ed0
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x7a71
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: attractivechaos[P]udb2/tsl_hopscotch_map/./hopscotch_hash.h
// Function: tsl::detail_hopscotch_hash::hopscotch_hash<std::pair<unsigned int const, unsigned int>, tsl::bhopscotch_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 62u, false, tsl::hh::power_of_two_growth_policy<2ul>>::KeySelect, tsl::bhopscotch_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 62u, false, tsl::hh::power_of_two_growth_policy<2ul>>::ValueSelect, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 62u, false, tsl::hh::power_of_two_growth_policy<2ul>, std::map<unsigned int, unsigned int, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>>>::erase_from_overflow(std::_Rb_tree_const_iterator<std::pair<unsigned int const, unsigned int>>, unsigned long)
iterator_overflow erase_from_overflow(const_iterator_overflow pos, std::size_t ibucket_for_hash) {
#ifdef TSL_HH_NO_RANGE_ERASE_WITH_CONST_ITERATOR        
        auto it_next = m_overflow_elements.erase(mutable_overflow_iterator(pos));
#else
        auto it_next = m_overflow_elements.erase(pos);
#endif
        m_nb_elements--;
        
        
        // Check if we can remove the overflow flag
        tsl_hh_assert(m_buckets[ibucket_for_hash].has_overflow());
        for(const value_type& value: m_overflow_elements) {
            const std::size_t bucket_for_value = bucket_for_hash(hash_key(KeySelect()(value)));
            if(bucket_for_value == ibucket_for_hash) {
                return it_next;
            }
        }
        
        m_buckets[ibucket_for_hash].set_overflow(false);
        return it_next;
    }

// Assembly:
subq $0x78, %rsp
movq %rsi, 0x68(%rsp)
movq %rdi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
addq $0x20, %rax
movq %rax, 0x8(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rsi
callq 0x7cf0
movq 0x8(%rsp), %rdi
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rsi
callq 0x7cb0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x70(%rsp)
movq 0x58(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x58(%rax)
addq $0x20, %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x4e40
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0x5450
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x62a0
testb $0x1, %al
jne 0x7b76
jmp 0x7bcf
leaq 0x38(%rsp), %rdi
callq 0x62c0
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rsi
leaq 0x1f(%rsp), %rdi
callq 0x5010
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x4760
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x47a0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x58(%rsp), %rax
jne 0x7bc1
jmp 0x7beb
jmp 0x7bc3
leaq 0x38(%rsp), %rdi
callq 0x6320
jmp 0x7b61
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rdi
movq 0x58(%rsp), %rax
shlq $0x4, %rax
addq %rax, %rdi
xorl %esi, %esi
callq 0x62e0
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: wekan[P]sps/sps.cxx
// Function: tokenize_string(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char)
vector_string_t tokenize_string(const std::string & source_string, const char separator)
{
	vector_string_t l;
	std::string s;
	std::istringstream i (source_string);

	std::getline(i, s, separator);

	while (!i.eof())
	{
		l.insert (l.end(), s);
		std::getline(i, s, separator);
	}

	if (s != "")
	{
		l.insert (l.end(), s);
	}

	return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movq %rdi, -0x208(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x200(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movb $0x0, -0x12(%rbp)
callq 0x4b30
leaq -0x38(%rbp), %rdi
callq 0x3310
movq -0x10(%rbp), %rsi
leaq -0x1b8(%rbp), %rdi
movl $0x8, %edx
callq 0x3370
jmp 0x36b2
movsbl -0x11(%rbp), %edx
leaq -0x1b8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x33e0
jmp 0x36c8
jmp 0x36ca
movq -0x1b8(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x1b8(%rbp,%rax), %rdi
callq 0x33d0
movb %al, -0x209(%rbp)
jmp 0x36ea
movb -0x209(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x36fb
jmp 0x37a4
movq -0x208(%rbp), %rdi
callq 0x4d60
movq %rax, -0x1d8(%rbp)
leaq -0x1d0(%rbp), %rdi
leaq -0x1d8(%rbp), %rsi
callq 0x4d90
movq -0x208(%rbp), %rdi
movq -0x1d0(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x4b50
movq %rax, -0x218(%rbp)
jmp 0x3741
movq -0x218(%rbp), %rax
movq %rax, -0x1e0(%rbp)
movsbl -0x11(%rbp), %edx
leaq -0x1b8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x33e0
jmp 0x3765
jmp 0x36ca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
jmp 0x383d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x3140
jmp 0x383d
leaq 0x4991(%rip), %rsi      # 0x813c
leaq -0x38(%rbp), %rdi
callq 0x4dd0
movb %al, -0x219(%rbp)
jmp 0x37bc
movb -0x219(%rbp), %al
testb $0x1, %al
jne 0x37c8
jmp 0x381c
movq -0x208(%rbp), %rdi
callq 0x4d60
movq %rax, -0x1f0(%rbp)
leaq -0x1e8(%rbp), %rdi
leaq -0x1f0(%rbp), %rsi
callq 0x4d90
movq -0x208(%rbp), %rdi
movq -0x1e8(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x4b50
movq %rax, -0x228(%rbp)
jmp 0x380e
movq -0x228(%rbp), %rax
movq %rax, -0x1f8(%rbp)
movb $0x1, -0x12(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x3140
leaq -0x38(%rbp), %rdi
callq 0x3438
testb $0x1, -0x12(%rbp)
jne 0x3860
jmp 0x3854
leaq -0x38(%rbp), %rdi
callq 0x3438
movq -0x208(%rbp), %rdi
callq 0x4e00
jmp 0x3870
movq -0x208(%rbp), %rdi
callq 0x4e00
movq -0x200(%rbp), %rax
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
movq -0x1c0(%rbp), %rdi
callq 0x3390
nopl (%rax)
// File: ef-gy[P]libefgy/include/ef.gy/exponential.h
// Function: efgy::math::exponentiate::integral<efgy::math::primitive<long double, unsigned long long>, 0l>::raise(efgy::math::primitive<long double, unsigned long long> const&, unsigned long long const&)
constexpr static Q raise(
      const Q &base, const typename numeric::traits<Q>::integral &exponent) {
    return exponent == typename numeric::traits<Q>::integral(0)
               ? Q(1)
               : exponent == typename numeric::traits<Q>::integral(-1)
                     ? Q(1) / base
                     : exponent == typename numeric::traits<Q>::integral(1)
                           ? base
                           : exponent % typename numeric::traits<Q>::integral(
                                            2) ==
                                     typename numeric::traits<Q>::integral(0)
                                 ? raise(base * base, exponent >> 1)
                                 : base * raise(base * base,
                                                (exponent -
                                                 typename numeric::traits<
                                                     Q>::integral(1)) >>
                                                    1);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x29a2c
movq -0xa8(%rbp), %rdi
fld1
fstpt -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x7060
jmp 0x29b2e
movq -0x18(%rbp), %rax
cmpq $-0x1, (%rax)
jne 0x29a61
fld1
fstpt -0x50(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x7060
movq -0xa8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq -0x40(%rbp), %rsi
callq 0x29b40
jmp 0x29b2c
movq -0x18(%rbp), %rax
cmpq $0x1, (%rax)
jne 0x29a80
movq -0xa8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x29bc0
jmp 0x29b2a
movq -0x18(%rbp), %rax
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x29ac6
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x60(%rbp), %rdi
callq 0x29420
movq -0xa8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
shrq %rax
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0x299e0
jmp 0x29b28
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x90(%rbp), %rdi
callq 0x29420
movq -0x18(%rbp), %rax
movq (%rax), %rax
subq $0x1, %rax
shrq %rax
movq %rax, -0x98(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x90(%rbp), %rsi
leaq -0x98(%rbp), %rdx
callq 0x299e0
movq -0xa8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
leaq -0x80(%rbp), %rdx
callq 0x29420
jmp 0x29b2a
jmp 0x29b2c
jmp 0x29b2e
movq -0xa0(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
nop
// File: ef-gy[P]libefgy/include/ef.gy/fractions.h
// Function: efgy::math::numeric::fractional<long long>::minimise()
void minimise(void) {
    normalise();

    N n = (numerator < zero()) ? gcdP(-numerator, denominator)
                               : gcdP(numerator, denominator);

    if ((n != zero()) && (n != one())) {
      numerator /= n;
      denominator /= n;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x2a140
movq -0x30(%rbp), %rdi
leaq -0x11(%rbp), %rsi
callq 0x2a190
testb $0x1, %al
jne 0x2a08c
jmp 0x2a0ac
movq -0x30(%rbp), %rsi
xorl %eax, %eax
subq (%rsi), %rax
movq %rax, -0x20(%rbp)
addq $0x8, %rsi
leaq -0x20(%rbp), %rdi
callq 0x2a1c0
movq %rax, -0x38(%rbp)
jmp 0x2a0c0
movq -0x30(%rbp), %rdi
movq %rdi, %rsi
addq $0x8, %rsi
callq 0x2a1c0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x21(%rbp), %rsi
callq 0x2a230
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x39(%rbp)
jne 0x2a0e3
jmp 0x2a0f3
leaq -0x10(%rbp), %rdi
leaq -0x22(%rbp), %rsi
callq 0x2a260
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x2a0fc
jmp 0x2a12e
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rax), %rax
cqto
idivq %rcx
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq 0x8(%rax), %rax
cqto
idivq %rcx
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: ef-gy[P]libefgy/include/ef.gy/numeric.h
// Function: long long efgy::math::numeric::gcdP<long long>(long long const&, long long const&)
T gcdP(const T &rA, const T &rB) {
  T t;
  T a = rA;
  T b = rB;

  while (b > zero()) {
    t = b;
    b = a % b;
    a = t;
  }

  return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x29(%rbp), %rsi
callq 0x2a2b0
testb $0x1, %al
jne 0x2a1f9
jmp 0x2a219
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
cqto
idivq -0x28(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x2a1e6
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)