LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/EverybodyHops[P]Permutations/./permutations.hpp
// Function: increase_carry_order<int>::get_permutation()
vector<T> get_permutation() override{
        int len = this->ordered_element.size();
        bool *can_put = new bool[len];
        for(int i = 0; i < this->ordered_element.size(); i++){
            can_put[i] = true;
        }

        vector<int> m_num = this->media_num->get_num();
        m_num.insert(m_num.begin(), 0);

        vector<T> res(len);
        int temp;
        for(int i = m_num.size() - 1; i >= 0; i--){
            temp = m_num[i];
            for(int j = 0; j < len; j++){
                if(can_put[j]){
                    if(temp == 0){
                        res[j] = this->ordered_element[i];
                        can_put[j] = false;
                        break; 
                    }else{
                        temp -= 1;
                    }
                }
            }
        }
        delete[] can_put;
        reverse(res.begin(), res.end());
        return res;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %r13
movq 0x18(%rsi), %rax
subq 0x10(%rsi), %rax
movq %rax, %rbx
sarq $0x2, %rbx
shrq $0x2, %rax
movslq %eax, %r12
testq %r12, %r12
pushq $-0x1
popq %rdi
cmovnsq %r12, %rdi
callq 0x1030
movq %rax, %r14
xorl %eax, %eax
cmpq %rax, %rbx
je 0x28d0
movb $0x1, (%r14,%rax)
incq %rax
jmp 0x28c1
movq %r13, -0x38(%rbp)
movq 0x8(%r15), %rsi
leaq -0x50(%rbp), %r13
movq %r13, %rdi
callq 0x129c
movq (%r13), %rsi
leaq -0x2c(%rbp), %rdx
andl $0x0, (%rdx)
movq %r13, %rdi
callq 0x39b0
leaq -0x2c(%rbp), %rdx
movq -0x38(%rbp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x3a46
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rsi
subq %rax, %rsi
shrq $0x2, %rsi
movq 0x10(%r15), %rcx
movq (%r13), %rdx
xorl %edi, %edi
testl %ebx, %ebx
cmovlel %edi, %ebx
movl %esi, %esi
decq %rsi
testl %esi, %esi
js 0x2967
movl %esi, %edi
andl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
movl (%rax,%rdi,4), %r9d
xorl %r8d, %r8d
cmpq %r8, %rbx
je 0x292a
cmpb $0x1, (%r14,%r8)
jne 0x2954
testl %r9d, %r9d
je 0x2959
decl %r9d
incq %r8
jmp 0x2940
movl (%rcx,%rdi,4), %edi
movl %edi, (%rdx,%r8,4)
movb $0x0, (%r14,%r8)
jmp 0x292a
movq %r14, %rdi
callq 0x10e0
movq (%r13), %rdi
movq 0x8(%r13), %rsi
callq 0x398e
leaq -0x50(%rbp), %rdi
callq 0x1a6e
movq %r13, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2999
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x1a6e
movq %rbx, %rdi
callq 0x1120
nop
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH19_SpecializedToolsAndTechniques/examples/tok2.cc
// Function: main
int main()
{
	Token token;
	Token t2;
	Token t3;
	cout << t2 << " " << t3 << endl;
	t2 = string("hi mom!");
	t3 = "good bye";
	token = t2;
	token = "boo";
	cout << token << endl;
	t2 = t3;
	cout << t2 << endl;

	token = 42;
	cout << token << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xa8, %rsp
andl $0x0, -0x58(%rbp)
andl $0x0, -0x50(%rbp)
leaq -0xa8(%rbp), %rsi
andl $0x0, (%rsi)
andl $0x0, 0x8(%rsi)
andl $0x0, -0x80(%rbp)
andl $0x0, -0x78(%rbp)
movq 0x2d6b(%rip), %rdi      # 0x3fd8
callq 0x13fa
leaq 0xdab(%rip), %rsi       # 0x2024
movq %rax, %rdi
callq 0x1090
leaq -0x80(%rbp), %rsi
movq %rax, %rdi
callq 0x13fa
movq %rax, %rdi
callq 0x1050
leaq 0xd8a(%rip), %rsi       # 0x2026
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x1030
leaq -0xa8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1436
leaq -0x30(%rbp), %rdi
callq 0x1040
leaq 0xd65(%rip), %rsi       # 0x202e
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x1030
leaq -0x80(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1436
leaq -0x30(%rbp), %rdi
callq 0x1040
leaq -0x58(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x1464
leaq 0xd34(%rip), %rsi       # 0x2037
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x1030
leaq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1436
leaq -0x30(%rbp), %rdi
callq 0x1040
movq 0x2cab(%rip), %rdi      # 0x3fd8
leaq -0x58(%rbp), %rsi
callq 0x13fa
movq %rax, %rdi
callq 0x1050
leaq -0xa8(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x1464
movq 0x2c83(%rip), %rdi      # 0x3fd8
leaq -0xa8(%rbp), %rsi
callq 0x13fa
movq %rax, %rdi
callq 0x1050
leaq -0x58(%rbp), %rbx
pushq $0x2a
popq %rsi
movq %rbx, %rdi
callq 0x14c6
movq 0x2c59(%rip), %rdi      # 0x3fd8
movq %rbx, %rsi
callq 0x13fa
movq %rax, %rdi
callq 0x1050
leaq -0x80(%rbp), %rdi
callq 0x14f0
leaq -0xa8(%rbp), %rdi
callq 0x14f0
leaq -0x58(%rbp), %rdi
callq 0x14f0
xorl %eax, %eax
addq $0xa8, %rsp
popq %rbx
popq %rbp
retq
jmp 0x13c1
jmp 0x13d1
jmp 0x13c1
jmp 0x13d1
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x1040
jmp 0x13d4
jmp 0x13d1
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x14f0
leaq -0xa8(%rbp), %rdi
callq 0x14f0
leaq -0x58(%rbp), %rdi
callq 0x14f0
movq %rbx, %rdi
callq 0x10f0
// File: /workspace/github_cpp_makefile_star2_O2/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
movl (%rsi), %eax
addq $0x8, %rsi
leaq 0xbf9(%rip), %rcx       # 0x2004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl (%rsi), %esi
popq %rbp
jmp 0x10e0
movsd (%rsi), %xmm0
popq %rbp
jmp 0x10d0
popq %rbp
jmp 0x1080
movsbl (%rsi), %esi
popq %rbp
jmp 0x10a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x8, %rdi
cmpl $0x3, (%rbx)
jne 0x144f
callq 0x1060
jmp 0x1454
callq 0x10b0
movl $0x3, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdi), %ecx
cmpl $0x3, %ecx
setne %dl
movl (%rsi), %eax
cmpl $0x3, %eax
sete %sil
orb %dl, %sil
jne 0x1495
leaq 0x8(%rbx), %rdi
callq 0x1040
movl (%rbx), %ecx
movl (%r14), %eax
cmpl $0x3, %ecx
jne 0x14ae
cmpl $0x3, %eax
jne 0x14ae
leaq 0x8(%r14), %rsi
leaq 0x8(%rbx), %rdi
callq 0x1060
jmp 0x14b9
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1506
movl (%r14), %eax
movl %eax, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
cmpl $0x3, (%rdi)
jne 0x14e1
leaq 0x8(%rbx), %rdi
callq 0x1040
movl %r14d, 0x8(%rbx)
andl $0x0, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movl (%rsi), %eax
cmpq $0x3, %rax
ja 0x154a
leaq 0xafb(%rip), %rcx       # 0x2014
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rdi)
jmp 0x154a
movsd 0x8(%rsi), %xmm0
movsd %xmm0, 0x8(%rdi)
jmp 0x154a
addq $0x8, %rdi
addq $0x8, %rsi
popq %rbp
jmp 0x10b0
movb 0x8(%rsi), %al
movb %al, 0x8(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movl %esi, %ebp
movl %edi, %ebx
leaq 0x80(%rsp), %r14
movq %r14, %rdi
callq 0x169a
xorl %r13d, %r13d
leaq 0x40(%rsp), %r15
leaq 0x20(%rsp), %r12
cmpl %r13d, %ebx
je 0x163b
movl %ebp, %edi
callq 0x132c
movl %eax, %ebp
movl %ebx, %edi
movl %eax, %esi
callq 0x1357
movl %eax, 0x20(%rsp)
movl %r13d, 0x24(%rsp)
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x1b56
cmpb $0x0, 0x58(%rsp)
jne 0x1636
movq 0x50(%rsp), %rax
movaps 0x40(%rsp), %xmm0
movaps %xmm0, 0x20(%rsp)
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x68(%rsp), %rdi
movq %r14, %rsi
callq 0x2666
incl %r13d
jmp 0x15cd
movq 0x4996(%rip), %rax      # 0x5fd8
movq (%rax), %rdi
leaq 0x80(%rsp), %rbx
movq 0x58(%rbx), %rdx
leaq 0x1a2d(%rip), %rsi      # 0x3085
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1180
movl 0x58(%rbx), %ebp
movq %rbx, %rdi
callq 0x16b8
movl %ebp, %eax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1682
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x16b8
movq %rbx, %rdi
callq 0x11d0
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tsl_hopscotch_map/./hopscotch_hash.h
// Function: std::pair<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>, bool> 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_impl<std::pair<unsigned int const, unsigned int>>(std::pair<unsigned int const, unsigned int>&&)
std::pair<iterator, bool> insert_impl(P&& value) {
        const std::size_t hash = hash_key(KeySelect()(value));
        const std::size_t ibucket_for_hash = bucket_for_hash(hash);
        
        // Check if already presents
        auto it_find = find_impl(KeySelect()(value), hash, m_buckets + ibucket_for_hash);
        if(it_find != end()) {
            return std::make_pair(it_find, false);
        }
        
        
        return insert_value(ibucket_for_hash, hash, std::forward<P>(value));
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl (%rdx), %r12d
movl (%rsi), %r13d
andl %r12d, %r13d
movq %r13, %r8
shlq $0x4, %r8
addq 0x50(%rsi), %r8
movq %rsp, %rbp
movq %rbp, %rdi
movq %r12, %rcx
callq 0x1c02
movq (%rbp), %rax
cmpq 0x10(%r15), %rax
jne 0x1bdc
leaq 0x28(%r15), %rax
cmpq %rax, 0x10(%rsp)
jne 0x1bdc
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %r14, %r8
callq 0x1c8a
jmp 0x1bf0
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rbx)
movups (%rsp), %xmm0
movups %xmm0, (%rbx)
movb $0x0, 0x18(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
leaq 0x2e8(%rsi), %rcx
movq 0x10(%rdi), %rax
subq 0x8(%rdi), %rax
sarq $0x4, %rax
cmpq %rcx, %rax
cmovbq %rax, %rcx
movq %rsi, %rdx
shlq $0x4, %rdx
addq 0x50(%rdi), %rdx
cmpq %rcx, %rsi
jae 0x1f3b
testb $0x1, (%rdx)
je 0x1f38
incq %rsi
addq $0x10, %rdx
jmp 0x1f25
movq %rsi, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq 0x50(%rdi), %rcx
movq %rsi, %rax
shlq $0x4, %rax
movq (%r8), %r8
movq %r8, 0x8(%rcx,%rax)
orb $0x1, (%rcx,%rax)
movq 0x50(%rdi), %r8
subl %edx, %esi
leal 0x2(%rsi), %ecx
pushq $0x1
popq %rsi
shlq %cl, %rsi
shlq $0x4, %rdx
xorq %rsi, (%r8,%rdx)
incq 0x58(%rdi)
addq 0x8(%rdi), %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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>>>>::will_neighborhood_change_on_rehash(unsigned long) const
bool will_neighborhood_change_on_rehash(size_t ibucket_neighborhood_check) const {
        std::size_t expand_bucket_count = GrowthPolicy::next_bucket_count();
        GrowthPolicy expand_growth_policy(expand_bucket_count);
        
        const bool use_stored_hash = USE_STORED_HASH_ON_REHASH(expand_bucket_count);
        for(size_t ibucket = ibucket_neighborhood_check; 
            ibucket < m_buckets_data.size() && (ibucket - ibucket_neighborhood_check) < NeighborhoodSize; 
            ++ibucket)
        {
            tsl_hh_assert(!m_buckets[ibucket].empty());
            
            const size_t hash = use_stored_hash?
                                    m_buckets[ibucket].truncated_bucket_hash():
                                    hash_key(KeySelect()(m_buckets[ibucket].value()));
            if(bucket_for_hash(hash) != expand_growth_policy.bucket_for_hash(hash)) {
                return true;
            }
        }
        
        return false;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1e90
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rsp, %r15
movq %r15, %rdi
callq 0x245c
movq 0x10(%r14), %rcx
movq 0x50(%r14), %rax
subq 0x8(%r14), %rcx
sarq $0x4, %rcx
movq (%r15), %rdx
xorq (%r14), %rdx
movq %rbx, %rsi
shlq $0x4, %rsi
leaq (%rsi,%rax), %rdi
addq $0x8, %rdi
xorl %esi, %esi
leaq (%rbx,%rsi), %rax
cmpq %rcx, %rax
setb %r8b
cmpq $0x3e, %rsi
setb %al
andb %r8b, %al
cmpb $0x1, %al
jne 0x20a5
leaq 0x10(%rdi), %r8
incq %rsi
testl %edx, (%rdi)
movq %r8, %rdi
je 0x207e
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x20, %rdi
movq %rdx, %rsi
callq 0x24da
movq 0x50(%r14), %rcx
shlq $0x4, %rbx
orq $0x2, (%rcx,%rbx)
incq 0x58(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq %rsi, %rcx
movq 0x8(%rdi), %rax
movq (%rsi), %rsi
testb $0x1, %sil
je 0x22b3
andq $-0x2, %rsi
movq %rsi, (%rcx)
subl %eax, %ecx
shrl $0x4, %ecx
movq 0x50(%rdi), %rax
movq %rdx, %rsi
subl %edx, %ecx
addb $0x2, %cl
pushq $0x1
popq %rdx
shlq %cl, %rdx
shlq $0x4, %rsi
xorq %rdx, (%rax,%rsi)
decq 0x58(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rdi
movabsq $-0x7fffffffffffffff, %rax # imm = 0x8000000000000001
cmpq %rax, %rdi
jae 0x2497
testq %rdi, %rdi
je 0x248a
movq %rsi, %r14
callq 0x195e
movq %rax, (%r14)
decq %rax
jmp 0x248c
xorl %eax, %eax
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x1090
movq %rax, %rbx
leaq 0xc21(%rip), %rsi       # 0x30ca
movq %rax, %rdi
callq 0x1160
movq 0x3b28(%rip), %rsi      # 0x5fe0
movq 0x3b11(%rip), %rdx      # 0x5fd0
movq %rbx, %rdi
callq 0x11c0
movq %rax, %r14
movq %rbx, %rdi
callq 0x1100
movq %r14, %rdi
callq 0x11d0
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
cmpq %rax, %rcx
je 0x271c
addq $0x10, %rcx
movq %rcx, %rdx
cmpq %rax, %rcx
je 0x2717
leaq 0x10(%rdx), %rcx
testb $0x1, (%rdx)
je 0x2706
movq %rdx, (%rbx)
jmp 0x2725
leaq 0x10(%rbx), %rdi
callq 0x2288
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x20(%rdi), %r15
callq 0x2794
movq %r15, %rdi
movq %rax, %rsi
callq 0x27ae
decq 0x58(%r14)
movq %rax, %r15
movq (%r14), %r12
movq 0x38(%r14), %rax
leaq 0x28(%r14), %r13
cmpq %r13, %rax
je 0x2779
movl 0x20(%rax), %ecx
andl %r12d, %ecx
cmpq %rbx, %rcx
je 0x2786
movq %rax, %rdi
callq 0x10f0
jmp 0x275f
movq 0x50(%r14), %rax
shlq $0x4, %rbx
andq $-0x3, (%rax,%rbx)
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movl %edx, %ebp
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x28(%rsp), %rdi
pushq $0x8
popq %rdx
callq 0x2270
movsbl %bpl, %ebp
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl %ebp, %edx
callq 0x22b0
leaq 0x8(%rsp), %r14
leaq 0x28(%rsp), %r15
movq 0x28(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x48(%rsp,%rax)
jne 0x251f
movq 0x8(%rbx), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x314e
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x22b0
jmp 0x24f1
leaq 0x1c16(%rip), %rsi      # 0x413c
leaq 0x8(%rsp), %rdi
callq 0x31e6
testb %al, %al
je 0x2545
movq 0x8(%rbx), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x314e
leaq 0x28(%rsp), %rdi
callq 0x20f0
leaq 0x8(%rsp), %rdi
callq 0x2308
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2575
movq %rax, %r14
jmp 0x2582
jmp 0x2575
jmp 0x2575
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x20f0
leaq 0x8(%rsp), %rdi
callq 0x2308
movq %rbx, %rdi
callq 0x31f0
movq %r14, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O2/wekan[P]sps/sps.cxx
// Function: remote_execution(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
int remote_execution(std::string & host, std::string & exec_cmd)
{
	int result = EXIT_FAILURE;
	char temp[] = "/tmp/exec-XXXXXX";
	int fd = mkstemp(temp);

	if (fd > -1)
	{
		write(fd, exec_cmd.c_str(), exec_cmd.length());
		close(fd);
		std::string cmd = std::string("") + "ssh -T " + SSH_OPTS + " root@" + host + " 'bash --login' < " + temp;
		result = system(cmd.c_str());
		unlink(temp);
		return exit_status(result);
	}
	else
	{
		return EX_TEMPFAIL; // 75
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rsi, %r14
movq %rdi, %rbx
movaps 0x1c5c(%rip), %xmm0     # 0x4210
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
movb $0x0, 0x10(%rdi)
callq 0x2090
testl %eax, %eax
js 0x2706
movl %eax, %ebp
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movl %eax, %edi
callq 0x20a0
movl %ebp, %edi
callq 0x22f0
leaq 0x1b51(%rip), %rsi      # 0x413c
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x3112
leaq 0x1b3c(%rip), %rdx      # 0x413d
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x3211
leaq 0x4b91(%rip), %rdx      # 0x71a8
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x3230
leaq 0x1b48(%rip), %rdx      # 0x4175
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x3211
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
movq %rbx, %rdx
callq 0x3230
leaq 0x1ae7(%rip), %rdx      # 0x4145
leaq 0xd0(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x3211
leaq 0xf0(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x3211
leaq 0xd0(%rsp), %rdi
callq 0x2308
leaq 0xb0(%rsp), %rdi
callq 0x2308
leaq 0x90(%rsp), %rdi
callq 0x2308
leaq 0x70(%rsp), %rdi
callq 0x2308
leaq 0x50(%rsp), %rdi
callq 0x2308
leaq 0x30(%rsp), %rdi
callq 0x2308
movq 0xf0(%rsp), %rdi
callq 0x2190
movl %eax, %ebx
leaq 0x10(%rsp), %rdi
callq 0x2100
testb $0x7f, %bl
movzbl %bh, %eax
pushq $0x1
popq %rbx
cmovel %eax, %ebx
leaq 0xf0(%rsp), %rdi
callq 0x2308
jmp 0x2709
pushq $0x4b
popq %rbx
movl %ebx, %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0xf0(%rsp), %rdi
jmp 0x277b
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0x2308
jmp 0x2739
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0x2308
jmp 0x274b
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x2308
jmp 0x275d
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x2308
jmp 0x276c
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x2308
leaq 0x30(%rsp), %rdi
callq 0x2308
movq %rbx, %rdi
callq 0x2280
movq %rax, %rbx
jmp 0x2776
movq %rax, %rbx
jmp 0x2780
// File: /workspace/github_cpp_makefile_star2_O2/wekan[P]sps/sps.cxx
// Function: get_transfert(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int get_transfert(std::string host, std::string exec_cmd)
{
	vector_string_t param = tokenize_string(exec_cmd, '`');
	if (param.size() == 4)
	{
		std::string cmd = "scp -T -p " + SSH_OPTS + " root@" + host + ":\"'" + param[1] + "'\" '" + param[3] + "'";
		return exit_status(system(cmd.c_str()));
	}
	else
	{
		return EX_USAGE; // 64
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rdi, %rbx
movq %rsp, %r14
pushq $0x60
popq %rdx
movq %r14, %rdi
callq 0x2497
movq 0x8(%r14), %rax
subq (%r14), %rax
cmpq $0x80, %rax
jne 0x2911
leaq 0x197b(%rip), %rsi      # 0x4158
leaq 0x49c4(%rip), %rdx      # 0x71a8
leaq 0x18(%rsp), %rdi
callq 0x324f
leaq 0x1980(%rip), %rdx      # 0x4175
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x3211
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rsi
movq %rbx, %rdx
callq 0x3230
leaq 0x1946(%rip), %rdx      # 0x4163
leaq 0x78(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x3211
movq (%rsp), %rdx
addq $0x20, %rdx
leaq 0x98(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x3230
leaq 0x191a(%rip), %rdx      # 0x4167
leaq 0xb8(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0x3211
movq (%rsp), %rdx
addq $0x60, %rdx
leaq 0xd8(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x3230
leaq 0x18e4(%rip), %rdx      # 0x416a
leaq 0xf8(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
callq 0x3211
leaq 0xd8(%rsp), %rdi
callq 0x2308
leaq 0xb8(%rsp), %rdi
callq 0x2308
leaq 0x98(%rsp), %rdi
callq 0x2308
leaq 0x78(%rsp), %rdi
callq 0x2308
leaq 0x58(%rsp), %rdi
callq 0x2308
leaq 0x38(%rsp), %rdi
callq 0x2308
leaq 0x18(%rsp), %rdi
callq 0x2308
movq 0xf8(%rsp), %rdi
callq 0x2190
testb $0x7f, %al
movzbl %ah, %eax
pushq $0x1
popq %rbx
cmovel %eax, %ebx
leaq 0xf8(%rsp), %rdi
callq 0x2308
jmp 0x2914
pushq $0x40
popq %rbx
movq %rsp, %rdi
callq 0x31f0
movl %ebx, %eax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0xf8(%rsp), %rdi
jmp 0x2997
movq %rax, %rbx
leaq 0xd8(%rsp), %rdi
callq 0x2308
jmp 0x294b
movq %rax, %rbx
leaq 0xb8(%rsp), %rdi
callq 0x2308
jmp 0x295d
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0x2308
jmp 0x296f
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x2308
jmp 0x297e
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x2308
leaq 0x38(%rsp), %rdi
callq 0x2308
leaq 0x18(%rsp), %rdi
callq 0x2308
movq %rsp, %rdi
callq 0x31f0
movq %rbx, %rdi
callq 0x2280
movq %rax, %rbx
jmp 0x2988
movq %rax, %rbx
jmp 0x2992
movq %rax, %rbx
jmp 0x299c
// File: /workspace/github_cpp_makefile_star2_O2/wekan[P]sps/sps.cxx
// Function: put_transfert(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int put_transfert(std::string host, std::string exec_cmd)
{
	vector_string_t param = tokenize_string(exec_cmd, '`');
	if (param.size() == 4)
	{
		std::string cmd = "scp -p " + SSH_OPTS + " '" + param[1] + "' root@" + host + ":\"'" + param[3] + "'\"";
		return exit_status(system(cmd.c_str()));
	}
	else
	{
		return EX_USAGE; // 64
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rdi, %rbx
movq %rsp, %r14
pushq $0x60
popq %rdx
movq %r14, %rdi
callq 0x2497
movq 0x8(%r14), %rax
subq (%r14), %rax
cmpq $0x80, %rax
jne 0x2b24
leaq 0x177c(%rip), %rsi      # 0x416c
leaq 0x47b1(%rip), %rdx      # 0x71a8
leaq 0x18(%rsp), %rdi
callq 0x324f
leaq 0x1761(%rip), %rdx      # 0x4169
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x3211
movq (%rsp), %rdx
addq $0x20, %rdx
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x3230
leaq 0x173f(%rip), %rdx      # 0x4174
leaq 0x78(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x3211
leaq 0x98(%rsp), %rdi
leaq 0x78(%rsp), %rsi
movq %rbx, %rdx
callq 0x3230
leaq 0x1703(%rip), %rdx      # 0x4163
leaq 0xb8(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0x3211
movq (%rsp), %rdx
addq $0x60, %rdx
leaq 0xd8(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x3230
leaq 0x16e3(%rip), %rdx      # 0x417c
leaq 0xf8(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
callq 0x3211
leaq 0xd8(%rsp), %rdi
callq 0x2308
leaq 0xb8(%rsp), %rdi
callq 0x2308
leaq 0x98(%rsp), %rdi
callq 0x2308
leaq 0x78(%rsp), %rdi
callq 0x2308
leaq 0x58(%rsp), %rdi
callq 0x2308
leaq 0x38(%rsp), %rdi
callq 0x2308
leaq 0x18(%rsp), %rdi
callq 0x2308
movq 0xf8(%rsp), %rdi
callq 0x2190
testb $0x7f, %al
movzbl %ah, %eax
pushq $0x1
popq %rbx
cmovel %eax, %ebx
leaq 0xf8(%rsp), %rdi
callq 0x2308
jmp 0x2b27
pushq $0x40
popq %rbx
movq %rsp, %rdi
callq 0x31f0
movl %ebx, %eax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0xf8(%rsp), %rdi
jmp 0x2baa
movq %rax, %rbx
leaq 0xd8(%rsp), %rdi
callq 0x2308
jmp 0x2b5e
movq %rax, %rbx
leaq 0xb8(%rsp), %rdi
callq 0x2308
jmp 0x2b70
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0x2308
jmp 0x2b82
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x2308
jmp 0x2b91
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x2308
leaq 0x38(%rsp), %rdi
callq 0x2308
leaq 0x18(%rsp), %rdi
callq 0x2308
movq %rsp, %rdi
callq 0x31f0
movq %rbx, %rdi
callq 0x2280
movq %rax, %rbx
jmp 0x2b9b
movq %rax, %rbx
jmp 0x2ba5
movq %rax, %rbx
jmp 0x2baf
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %rax
cmpq $-0x1, %rax
je 0xf304
cmpq $0x1, %rax
je 0xf2ff
testq %rax, %rax
jne 0xf30d
fld1
jmp 0xf35d
fldt (%r14)
jmp 0xf35d
fldt (%r14)
fld1
fdivp %st, %st(1)
jmp 0xf35d
testb $0x1, %al
jne 0xf331
fldt (%r14)
fmul %st, %st(0)
fstpt (%rsp)
shrq %rax
leaq 0x10(%rsp), %rdx
movq %rax, (%rdx)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xf2da
jmp 0xf35f
fldt (%r14)
fmul %st, %st(0)
fstpt 0x10(%rsp)
decq %rax
shrq %rax
leaq 0x20(%rsp), %rdx
movq %rax, (%rdx)
movq %rsp, %rdi
leaq 0x10(%rsp), %rsi
callq 0xf2da
fldt (%r14)
fldt (%rsp)
fmulp %st, %st(1)
fstpt (%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0xf656
movq (%rbx), %rax
testq %rax, %rax
js 0xf618
leaq 0x8(%rbx), %rsi
movq %rbx, %rdi
jmp 0xf627
negq %rax
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x8(%rbx), %rsi
callq 0xf66b
movq %rax, %rcx
cmpq $0x2, %rax
jb 0xf650
movq (%rbx), %rax
movq 0x8(%rbx), %rsi
cqto
idivq %rcx
movq %rax, (%rbx)
movq %rsi, %rax
cqto
idivq %rcx
movq %rax, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/Sooryakiran[P]dotV/src/main.cpp
// Function: generate_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int generate_file(string file_name, string contents){
    /*------------------------------------------------------------------------------------------
    Writes/Rewrites the given contents to the given file. 

    Param : file_name (string), file_name of the output file.
    Param : contents (string), contents of the file to be written.

    Return : 1 if successful, 0 if not.
    ------------------------------------------------------------------------------------------*/
    ofstream fout; 
    fout.open(file_name);
    if(fout){
        fout << contents << endl; 
        fout.close();
        cout<<"[INFO] Code "<<file_name<<" written successfully!"<<endl;
    }
    else{
        cout<<"[ERROR] Unable to write file!"<<endl;
        return 0;
    } 
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x218(%rbp), %r15
movq %r15, %rdi
callq 0x3230
pushq $0x10
popq %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x30b0
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x1f8(%rbp,%rax)
je 0x3433
movq 0x3bb5(%rip), %rdi      # 0x6fd0
leaq 0x1c06(%rip), %rsi      # 0x5028
callq 0x3150
xorl %ebx, %ebx
movq %rax, %rdi
callq 0x30c0
jmp 0x348e
leaq -0x218(%rbp), %rdi
movq %r14, %rsi
callq 0x3130
movq %rax, %rdi
callq 0x30c0
leaq -0x218(%rbp), %rdi
callq 0x31c0
movq 0x3b73(%rip), %rdi      # 0x6fd0
leaq 0x1ba0(%rip), %rsi      # 0x5004
callq 0x3150
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3130
leaq 0x1b96(%rip), %rsi      # 0x5011
movq %rax, %rdi
callq 0x3150
movq %rax, %rdi
callq 0x30c0
pushq $0x1
popq %rbx
leaq -0x218(%rbp), %rdi
callq 0x31f0
movl %ebx, %eax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x218(%rbp), %rdi
callq 0x31f0
movq %rbx, %rdi
callq 0x3240
// File: /workspace/github_cpp_makefile_star2_O2/CYLMos[P]Read_the_tar_file/main.cpp
// Function: main
int main(int argc, char *argv[])
{
    /// If the number of the params is wrong
    if(argc >= 3){
        cout << "Too many params" << endl;
        exit(0);
    }
    else if(argc <= 1){
        cout << "Too less params" << endl;
        exit(0);
    }

    MyTar myTar(argv[1]);

    if(!myTar.startRead()){
	cout << "Not USTART file!" << endl;
	exit(0);
    }
    myTar.showContent();

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
cmpl $0x3, %edi
jge 0x2465
cmpl $0x2, %edi
jne 0x2475
movq 0x8(%rsi), %rsi
leaq -0x230(%rbp), %rbx
movq %rbx, %rdi
callq 0x24cc
movq %rbx, %rdi
callq 0x2658
testl %eax, %eax
je 0x2497
leaq -0x230(%rbp), %rdi
callq 0x27ca
leaq -0x230(%rbp), %rdi
callq 0x256e
xorl %eax, %eax
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %rbp
retq
movq 0x3b6c(%rip), %rdi      # 0x5fd8
leaq 0x1b91(%rip), %rsi      # 0x4004
jmp 0x2483
movq 0x3b5c(%rip), %rdi      # 0x5fd8
leaq 0x1b91(%rip), %rsi      # 0x4014
callq 0x2170
movq %rax, %rdi
callq 0x20d0
xorl %edi, %edi
callq 0x21b0
movq 0x3b3a(%rip), %rdi      # 0x5fd8
leaq 0x1b7f(%rip), %rsi      # 0x4024
callq 0x2170
movq %rax, %rdi
callq 0x20d0
jmp 0x2490
movq %rax, %rbx
leaq -0x230(%rbp), %rdi
callq 0x256e
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/CYLMos[P]Read_the_tar_file/MyTar.cpp
// Function: MyTar::MyTar(char const*)
MyTar::MyTar(const char *file){
    this->usBlockSize = 512;  /// Every block in USTAR format is 512 bytes.
    this->fileNum = -1;
    this->inputStream.open(file, ifstream::in | ifstream::binary);

    /// If failed, close the program.
    if(!this->inputStream.is_open()){
        cout << "Open failed!" << endl;
        exit(0);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
callq 0x21a0
leaq 0x208(%rbx), %r14
andq $0x0, 0x218(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x208(%rbx)
movabsq $-0xfffffe00, %rax      # imm = 0xFFFFFFFF00000200
movq %rax, 0x220(%rbx)
pushq $0xc
popq %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x20f0
leaq 0x78(%rbx), %rdi
callq 0x2050
testb %al, %al
je 0x2531
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x3aa0(%rip), %rdi      # 0x5fd8
leaq 0x1b09(%rip), %rsi      # 0x4048
callq 0x2170
movq %rax, %rdi
callq 0x20d0
xorl %edi, %edi
callq 0x21b0
movq %rax, %r15
movq %r14, %rdi
callq 0x2e44
movq %rbx, %rdi
callq 0x2060
movq %r15, %rdi
callq 0x2260