LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/Laakeri[P]maxpre/src/cardinalityconstraint.cpp
// Function: maxPreprocessor::CardinalityConstraint::getBestLessNetwork(int, std::vector<int, std::allocator<int>>)
pair<CardinalityConstraint::Formula, int> CardinalityConstraint::getBestLessNetwork(int freeVar, vector<int> input) {
	auto cLess = getLessNetwork(freeVar, input);
	auto cGreater = getGreaterNetwork(freeVar, input);
	if (cLess.F.size() <= cGreater.F.size()) {
		return cLess;
	}
	else {
		return cGreater;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x20(%rsp), %r13
movq %r13, %rdi
movq %rcx, %rsi
callq 0x1f3de
leaq 0x38(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
movl %ebp, %edx
movq %r13, %rcx
callq 0x33ba4
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x345ae
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x32b0
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x1f3de
leaq 0x60(%rsp), %r15
leaq 0x8(%rsp), %rcx
movq %r15, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x33d62
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x345e9
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x32b0
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %rcx
movq %rcx, %rdx
subq %rax, %rdx
movq 0x60(%rsp), %rsi
movq 0x68(%rsp), %rdi
movq %rdi, %r8
subq %rsi, %r8
cmpq %r8, %rdx
movq %r14, %rdx
cmovaq %r15, %rdx
cmovaq %rsi, %rax
cmovaq %rdi, %rcx
movq 0x10(%rdx), %rsi
xorps %xmm0, %xmm0
movups %xmm0, (%rdx)
movq $0x0, 0x10(%rdx)
movl 0x18(%rdx), %edi
movl 0x20(%rdx), %edx
movq %rax, (%rbx)
movq %rcx, 0x8(%rbx)
movq %rsi, 0x10(%rbx)
movl %edi, 0x18(%rbx)
movl %edx, 0x20(%rbx)
movq %r15, %rdi
callq 0x8f5e
movq %r14, %rdi
callq 0x8f5e
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x34688
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x32b0
jmp 0x34688
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x8f5e
jmp 0x346ae
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x346ae
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x32b0
movq %rbx, %rdi
callq 0x34a0
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/tsl_robin_map/./robin_growth_policy.h
// Function: tsl::rh::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()) {
            TSL_RH_THROW_OR_TERMINATE(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 (%rsi), %rcx
movabsq $-0x7fffffffffffffff, %rax # imm = 0x8000000000000001
cmpq %rax, %rcx
jae 0x199a
testq %rcx, %rcx
je 0x198d
leaq -0x1(%rcx), %rax
testq %rax, %rcx
je 0x1985
movl $0x1, %ecx
movq %rax, %rdx
shrq %cl, %rax
orq %rdx, %rax
leaq (%rcx,%rcx), %rdx
cmpq $0x20, %rcx
movq %rdx, %rcx
jb 0x1969
incq %rax
movq %rax, %rcx
movq %rcx, (%rsi)
decq %rcx
jmp 0x198f
xorl %ecx, %ecx
movq %rcx, (%rdi)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x1060
movq %rax, %rbx
leaq 0x172c(%rip), %rsi      # 0x30da
movq %rax, %rdi
callq 0x1100
movq 0x3623(%rip), %rsi      # 0x4fe0
movq 0x360c(%rip), %rdx      # 0x4fd0
movq %rbx, %rdi
callq 0x1140
movq %rax, %r14
movq %rbx, %rdi
callq 0x10b0
movq %r14, %rdi
callq 0x1150
nop
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/tsl_robin_map/./robin_hash.h
// Function: tsl::detail_robin_hash::robin_hash<std::pair<unsigned int, unsigned int>, tsl::robin_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>, false, tsl::rh::power_of_two_growth_policy<2ul>>::KeySelect, tsl::robin_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>, false, tsl::rh::power_of_two_growth_policy<2ul>>::ValueSelect, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>, false, tsl::rh::power_of_two_growth_policy<2ul>>::rehash_on_extreme_load()
bool rehash_on_extreme_load() {
        if(m_grow_on_next_insert || size() >= m_load_threshold) {
            rehash_impl(GrowthPolicy::next_bucket_count());
            m_grow_on_next_insert = false;
            
            return true;
        }
        
        if(m_try_skrink_on_next_insert) {
            m_try_skrink_on_next_insert = false;
            if(m_min_load_factor != 0.0f && load_factor() < m_min_load_factor) {
                reserve(size() + 1);
                
                return true;
            }
        }
        
        return false;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x0, 0x44(%rdi)
jne 0x1d3a
movq 0x30(%rbx), %rax
cmpq 0x38(%rbx), %rax
jae 0x1d3a
cmpb $0x1, 0x4c(%rbx)
jne 0x1dbb
movb $0x0, 0x4c(%rbx)
movss 0x48(%rbx), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x1d2a
jnp 0x1dbb
movq 0x28(%rbx), %rcx
testq %rax, %rax
js 0x1d55
cvtsi2ss %rax, %xmm3
jmp 0x1d6c
movq %rbx, %rdi
callq 0x1f04
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1e52
movb $0x0, 0x44(%rbx)
movb $0x1, %al
jmp 0x1dbd
movq %rax, %rdx
shrq %rdx
movl %eax, %esi
andl $0x1, %esi
orq %rdx, %rsi
cvtsi2ss %rsi, %xmm3
addss %xmm3, %xmm3
movq %rcx, %rsi
shrq %rsi
movl %ecx, %edx
andl $0x1, %edx
orq %rsi, %rdx
testq %rcx, %rcx
js 0x1d89
xorps %xmm1, %xmm1
cvtsi2ss %rcx, %xmm1
jmp 0x1d95
xorps %xmm1, %xmm1
cvtsi2ss %rdx, %xmm1
addss %xmm1, %xmm1
xorps %xmm2, %xmm2
je 0x1da1
movaps %xmm3, %xmm2
divss %xmm1, %xmm2
ucomiss %xmm2, %xmm0
jbe 0x1dbb
incq %rax
movss %xmm3, 0x4(%rsp)
js 0x1dc5
xorps %xmm0, %xmm0
cvtsi2ss %rax, %xmm0
jmp 0x1ddd
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
xorps %xmm0, %xmm0
cvtsi2ss %rax, %xmm0
addss %xmm0, %xmm0
movss 0x40(%rbx), %xmm1
movss %xmm1, (%rsp)
divss %xmm1, %xmm0
callq 0x1090
cvttss2si %xmm0, %rax
movq %rax, %rcx
subss 0x1230(%rip), %xmm0     # 0x3030
cvttss2si %xmm0, %r14
sarq $0x3f, %rcx
andq %rcx, %r14
orq %rax, %r14
movss 0x4(%rsp), %xmm0
divss (%rsp), %xmm0
callq 0x1090
cvttss2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subss 0x11fd(%rip), %xmm0     # 0x3030
cvttss2si %xmm0, %rsi
andq %rcx, %rsi
orq %rax, %rsi
cmpq %r14, %rsi
cmovbeq %r14, %rsi
movq %rbx, %rdi
callq 0x1e52
jmp 0x1d51
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/tsl_robin_map/./robin_hash.h
// Function: tsl::detail_robin_hash::robin_hash<std::pair<unsigned int, unsigned int>, tsl::robin_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>, false, tsl::rh::power_of_two_growth_policy<2ul>>::KeySelect, tsl::robin_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>, false, tsl::rh::power_of_two_growth_policy<2ul>>::ValueSelect, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>, false, tsl::rh::power_of_two_growth_policy<2ul>>::rehash_impl(unsigned long)
void rehash_impl(size_type count) {
        robin_hash new_table(count, static_cast<Hash&>(*this), static_cast<KeyEqual&>(*this), 
                             get_allocator(), m_min_load_factor, m_max_load_factor);
        
        const bool use_stored_hash = USE_STORED_HASH_ON_REHASH(new_table.bucket_count());
        for(auto& bucket: m_buckets_data) {
            if(bucket.empty()) { 
                continue; 
            }
            
            const std::size_t hash = use_stored_hash?bucket.truncated_hash():
                                                     new_table.hash_key(KeySelect()(bucket.value()));
                                                     
            new_table.insert_value_on_rehash(new_table.bucket_for_hash(hash), 0, 
                                             bucket_entry::truncate_hash(hash), std::move(bucket.value()));
        }
        
        new_table.m_nb_elements = m_nb_elements;
        new_table.swap(*this);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movss 0x40(%rdi), %xmm1
movss 0x48(%rdi), %xmm0
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %r8
movq %rbx, %rdx
movq %rbx, %rcx
callq 0x17ce
movq 0x8(%rbx), %r14
movq 0x10(%rbx), %r12
cmpq %r12, %r14
je 0x1ec3
addq $0x4, %r14
leaq 0x8(%rsp), %r15
cmpw $-0x1, -0x4(%r14)
je 0x1eb3
movl (%r14), %ecx
movl 0x8(%rsp), %esi
andl %ecx, %esi
movq %r15, %rdi
xorl %edx, %edx
movq %r14, %r8
callq 0x1f76
leaq 0xc(%r14), %rax
addq $0x8, %r14
cmpq %r12, %r14
movq %rax, %r14
jne 0x1e95
movq 0x30(%rbx), %rax
leaq 0x8(%rsp), %rdi
movq %rax, 0x30(%rdi)
movq %rbx, %rsi
callq 0x1fd4
leaq 0x10(%rsp), %rdi
callq 0x1792
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1792
movq %rbx, %rdi
callq 0x1150
nop
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/tsl_robin_map/./robin_hash.h
// Function: tsl::detail_robin_hash::robin_hash<std::pair<unsigned int, unsigned int>, tsl::robin_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>, false, tsl::rh::power_of_two_growth_policy<2ul>>::KeySelect, tsl::robin_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>, false, tsl::rh::power_of_two_growth_policy<2ul>>::ValueSelect, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>, false, tsl::rh::power_of_two_growth_policy<2ul>>::insert_value_on_rehash(unsigned long, short, unsigned int, std::pair<unsigned int, unsigned int>&&)
void insert_value_on_rehash(std::size_t ibucket, distance_type dist_from_ideal_bucket, 
                                truncated_hash_type hash, value_type&& value) 
    {
        while(true) {
            if(dist_from_ideal_bucket > m_buckets[ibucket].dist_from_ideal_bucket()) {
                if(m_buckets[ibucket].empty()) {
                    m_buckets[ibucket].set_value_of_empty_bucket(dist_from_ideal_bucket, hash, std::move(value));
                    return;
                }
                else {
                    m_buckets[ibucket].swap_with_value_in_bucket(dist_from_ideal_bucket, hash, value);
                }
            }
            
            dist_from_ideal_bucket++;
            ibucket = next_bucket(ibucket);
        }
    }

// Assembly:
movq (%rdi), %rax
movq 0x20(%rdi), %rcx
leaq (%rsi,%rsi,2), %r9
movzwl (%rcx,%r9,4), %edi
cmpw %di, %dx
jle 0x1fb9
leaq (%rcx,%r9,4), %r9
cmpw $-0x1, %di
je 0x1fc7
movl (%r8), %r10d
movl 0x4(%r9), %r11d
movl %r11d, (%r8)
movl %r10d, 0x4(%r9)
movl 0x4(%r8), %r10d
movl 0x8(%r9), %r11d
movl %r11d, 0x4(%r8)
movl %r10d, 0x8(%r9)
movw %dx, (%r9)
jmp 0x1fbb
movl %edx, %edi
incl %edi
incq %rsi
andq %rax, %rsi
movl %edi, %edx
jmp 0x1f7d
movq (%r8), %rax
movq %rax, 0x4(%r9)
movw %dx, (%r9)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/tsl_robin_map/./robin_hash.h
// Function: tsl::detail_robin_hash::robin_hash<std::pair<unsigned int, unsigned int>, tsl::robin_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>, false, tsl::rh::power_of_two_growth_policy<2ul>>::KeySelect, tsl::robin_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>, false, tsl::rh::power_of_two_growth_policy<2ul>>::ValueSelect, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>, false, tsl::rh::power_of_two_growth_policy<2ul>>::insert_value_impl(unsigned long, short, unsigned int, std::pair<unsigned int, unsigned int>&)
void insert_value_impl(std::size_t ibucket, distance_type dist_from_ideal_bucket,
                           truncated_hash_type hash, value_type& value)
    {
        m_buckets[ibucket].swap_with_value_in_bucket(dist_from_ideal_bucket, hash, value);
        ibucket = next_bucket(ibucket);
        dist_from_ideal_bucket++;
        
        while(!m_buckets[ibucket].empty()) {
            if(dist_from_ideal_bucket > m_buckets[ibucket].dist_from_ideal_bucket()) {
                if(dist_from_ideal_bucket >= bucket_entry::DIST_FROM_IDEAL_BUCKET_LIMIT) {
                    /**
                     * The number of probes is really high, rehash the map on the next insert.
                     * Difficult to do now as rehash may throw an exception.
                     */
                    m_grow_on_next_insert = true;
                }
            
                m_buckets[ibucket].swap_with_value_in_bucket(dist_from_ideal_bucket, hash, value);
            }
            
            ibucket = next_bucket(ibucket);
            dist_from_ideal_bucket++;
        }
        
        m_buckets[ibucket].set_value_of_empty_bucket(dist_from_ideal_bucket, hash, std::move(value));
    }

// Assembly:
pushq %rbx
movq 0x20(%rdi), %rax
leaq (%rsi,%rsi,2), %rcx
movl (%r8), %r9d
movl 0x4(%rax,%rcx,4), %r10d
movl %r10d, (%r8)
movl %r9d, 0x4(%rax,%rcx,4)
movl 0x4(%r8), %r9d
movl 0x8(%rax,%rcx,4), %r10d
movl %r10d, 0x4(%r8)
movl %r9d, 0x8(%rax,%rcx,4)
movzwl (%rax,%rcx,4), %r9d
movw %dx, (%rax,%rcx,4)
movq (%rdi), %rcx
incq %rsi
andq %rcx, %rsi
incl %r9d
leaq (%rsi,%rsi,2), %rdx
leaq (%rax,%rdx,4), %r10
movzwl (%r10), %edx
cmpw $-0x1, %dx
je 0x211f
cmpw %dx, %r9w
jle 0x210f
movswl %r9w, %r11d
cmpl $0x1000, %r11d          # imm = 0x1000
jl 0x20eb
movb $0x1, 0x44(%rdi)
movl (%r8), %r11d
movl 0x4(%r10), %ebx
movl %ebx, (%r8)
movl %r11d, 0x4(%r10)
movl 0x4(%r8), %r11d
movl 0x8(%r10), %ebx
movl %ebx, 0x4(%r8)
movl %r11d, 0x8(%r10)
movw %r9w, (%r10)
jmp 0x2112
movl %r9d, %edx
incq %rsi
andq %rcx, %rsi
incl %edx
movl %edx, %r9d
jmp 0x20c2
movq (%r8), %rax
movq %rax, 0x4(%r10)
movw %r9w, (%r10)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/ashagraev[P]covariation/main.cpp
// Function: void TPrinter::AddToRow<char [9]>(char const (&) [9])
void AddToRow(const TValue& value) {
        std::stringstream ss;
        ss.precision(10);
        ss << value;
        Rows.back().push_back(ss.str());
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x1c0(%rbp), %r15
movq %r15, %rdi
callq 0x20a0
movq (%r15), %rax
movq -0x18(%rax), %rax
movq $0xa, -0x1b8(%rbp,%rax)
leaq -0x1b0(%rbp), %r15
movq %r14, %rdi
callq 0x2070
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2130
movq 0x40(%rbx), %rbx
leaq -0x1a8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x2170
addq $-0x18, %rbx
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x3db8
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2d89
callq 0x2100
movq 0x4228(%rip), %rsi      # 0x6fb8
leaq -0x1c0(%rbp), %rdi
callq 0x20c0
leaq -0x140(%rbp), %rdi
callq 0x2040
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2dd2
callq 0x2100
jmp 0x2dd2
jmp 0x2dcf
movq %rax, %rbx
movq 0x41df(%rip), %rsi      # 0x6fb8
leaq -0x1c0(%rbp), %rdi
callq 0x20c0
leaq -0x140(%rbp), %rdi
callq 0x2040
movq %rbx, %rdi
callq 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/ashagraev[P]covariation/main.cpp
// Function: TPrinter::Print() const::'lambda'(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)::operator()(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&) const
void Print() const {
        auto printRow = [&](const std::vector<std::string>& row){
            const size_t columnWidth = 25;

            std::stringstream rowStream;
            for (const std::string& element : row) {
                PrintNextColumn(rowStream, element, columnWidth);
            }

            printf("%s\n", rowStream.str().c_str());
        };

        printf("%s\n", Title.c_str());
        printRow(Columns);
        for (const std::vector<std::string>& row : Rows) {
            printRow(row);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rsi, %r15
movq (%rdi), %rbx
leaq -0x1c8(%rbp), %rdi
callq 0x20a0
movq (%r15), %r14
movq 0x8(%r15), %r12
cmpq %r12, %r14
je 0x37db
leaq -0x1c8(%rbp), %r15
movl $0x19, %ecx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3862
addq $0x20, %r14
cmpq %r12, %r14
jne 0x37bf
leaq -0x1b0(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x2170
leaq -0x30(%rbp), %rbx
movq -0x10(%rbx), %rdi
callq 0x2160
movq -0x10(%rbx), %rdi
cmpq %rbx, %rdi
je 0x3806
callq 0x2100
movq 0x37ab(%rip), %rsi      # 0x6fb8
leaq -0x1c8(%rbp), %rdi
callq 0x20c0
leaq -0x148(%rbp), %rdi
callq 0x2040
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3837
movq %rax, %rbx
movq 0x3777(%rip), %rsi      # 0x6fb8
leaq -0x1c8(%rbp), %rdi
callq 0x20c0
leaq -0x148(%rbp), %rdi
callq 0x2040
movq %rbx, %rdi
callq 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/ashagraev[P]covariation/main.cpp
// Function: TWelfordCovariationCalculator::Add(double, double)
void Add(const double x, const double y) override {
        ++Count;
        MeanX += (x - MeanX) / Count;
        SumProducts += (x - MeanX) * (y - MeanY);
        MeanY += (y - MeanY) / Count;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rax
incq %rax
movq %rax, 0x8(%rdi)
movsd 0x10(%rdi), %xmm2
movapd %xmm0, %xmm3
subsd %xmm2, %xmm3
movq %rax, %xmm4
punpckldq 0xf8b(%rip), %xmm4 # xmm4 = xmm4[0],mem[0],xmm4[1],mem[1]
subpd 0xf93(%rip), %xmm4      # 0x4050
movapd %xmm4, %xmm5
unpckhpd %xmm4, %xmm5            # xmm5 = xmm5[1],xmm4[1]
addsd %xmm4, %xmm5
divsd %xmm5, %xmm3
addsd %xmm2, %xmm3
movsd %xmm3, 0x10(%rdi)
subsd %xmm3, %xmm0
movsd 0x18(%rdi), %xmm2
subsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
addsd 0x20(%rdi), %xmm0
movsd %xmm0, 0x20(%rdi)
divsd %xmm5, %xmm1
addsd %xmm2, %xmm1
movsd %xmm1, 0x18(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ashagraev[P]covariation/main.cpp
// Function: void TPrinter::PrintNextColumn<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_stringstream<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long) const
void PrintNextColumn(std::stringstream& out, const TValue& value, size_t columnWidth) const {
        const size_t startLength = out.str().size();
        out << value;
        const size_t currentLength = out.str().size();
        for (size_t i = currentLength; i < startLength + columnWidth; ++i) {
            out << " ";
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, -0x30(%rbp)
movq %rdx, %r12
movq %rsi, %rbx
leaq 0x18(%rsi), %r15
leaq -0x50(%rbp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x2170
movq (%r13), %rdi
movq 0x8(%r13), %r13
leaq -0x40(%rbp), %r14
cmpq %r14, %rdi
je 0x38a6
callq 0x2100
addq $0x10, %rbx
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %rbx, %rdi
callq 0x2130
leaq -0x50(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x2170
movq (%r12), %rdi
movq 0x8(%r12), %r15
cmpq %r14, %rdi
je 0x38dd
callq 0x2100
addq -0x30(%rbp), %r13
cmpq %r13, %r15
jae 0x3905
leaq 0x7ac(%rip), %r14       # 0x4099
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2130
incq %r15
cmpq %r13, %r15
jb 0x38ed
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/drarwood[P]gags/Calculator.cpp
// Function: CalcVariance(std::vector<double, std::allocator<double>>&)
double CalcVariance(vector<double>& v) {
    double s;
    double m;
    int    i;
    s=0;
    for (i=0;i<v.size();++i) {
        s+=v[i];
    }
    m=s/(double) v.size();
    s=0;
    for (i=0;i<v.size();++i) {
        s+=(v[i]-m)*(v[i]-m);
    }
    return (s/(v.size()-1)) ;
}

// Assembly:
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
movq %rdx, %rax
subq %rcx, %rax
sarq $0x3, %rax
cmpq %rcx, %rdx
je 0x6a5a
cmpq $0x1, %rax
movq %rax, %rsi
adcq $0x0, %rsi
xorpd %xmm1, %xmm1
xorl %edi, %edi
addsd (%rcx,%rdi,8), %xmm1
incq %rdi
cmpq %rdi, %rsi
jne 0x6a13
cmpq %rcx, %rdx
je 0x6a5a
cvtsi2sd %rax, %xmm0
divsd %xmm0, %xmm1
cmpq $0x1, %rax
movq %rax, %rdx
adcq $0x0, %rdx
xorpd %xmm0, %xmm0
xorl %esi, %esi
movsd (%rcx,%rsi,8), %xmm2
subsd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
incq %rsi
cmpq %rsi, %rdx
jne 0x6a3f
jmp 0x6a5e
xorpd %xmm0, %xmm0
decq %rax
movq %rax, %xmm1
punpckldq 0x5882(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x588a(%rip), %xmm1     # 0xc300
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/drarwood[P]gags/Calculator.cpp
// Function: CalcMean(std::vector<double, std::allocator<double>>&)
double CalcMean(vector<double>& v) {
    double s;
    s=0;
    for (int i=0;i<v.size();++i) {
        s+=v[i];
    }
    return s/v.size();
}

// Assembly:
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
movq %rdx, %rax
subq %rcx, %rax
sarq $0x3, %rax
cmpq %rcx, %rdx
je 0x6abd
cmpq $0x1, %rax
movq %rax, %rdx
adcq $0x0, %rdx
xorpd %xmm0, %xmm0
xorl %esi, %esi
addsd (%rcx,%rsi,8), %xmm0
incq %rsi
cmpq %rsi, %rdx
jne 0x6aae
jmp 0x6ac1
xorpd %xmm0, %xmm0
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/drarwood[P]gags/ExclusionListProcessor.cpp
// Function: ReadExclusionsFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>&)
void ReadExclusionsFile(string f, map<string, int>& m) {
    string line, id;
    ifstream inFile(f.c_str());
    if (inFile.is_open()) {
        while (inFile.good()) {
            getline (inFile, line);
            if (!line.empty()) {
                m[line] = 0;
            }
        }
        inFile.close();
    }
    else {
        cout << "Unable to open " << f << " for reading" << endl;
        exit(EXIT_FAILURE);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x250, %rsp            # imm = 0x250
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
xorl %eax, %eax
movq %rax, -0x8(%r12)
movb %al, (%r12)
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq %rax, -0x8(%r13)
movb %al, (%r13)
movq (%rdi), %rsi
leaq 0x48(%rsp), %rdi
movl $0x8, %edx
callq 0x3470
leaq 0xc0(%rsp), %rdi
callq 0x3080
testb %al, %al
je 0x6c6c
movq 0x48(%rsp), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x68(%rsp,%rax)
jne 0x6c19
leaq (%rsp,%rax), %rdi
addq $0x48, %rdi
leaq 0x48(%rsp), %r14
leaq 0x8(%rsp), %r15
movl $0xa, %esi
callq 0x3260
movsbl %al, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x3480
cmpq $0x0, 0x10(%rsp)
je 0x6c02
movq %rbx, %rdi
movq %r15, %rsi
callq 0x57c4
movl $0x0, (%rax)
movq 0x48(%rsp), %rax
movq -0x18(%rax), %rax
leaq (%rsp,%rax), %rdi
addq $0x48, %rdi
cmpl $0x0, 0x20(%rdi)
je 0x6bd1
leaq 0x48(%rsp), %rdi
callq 0x3070
leaq 0x48(%rsp), %rdi
callq 0x3090
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x6c44
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3280
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x6c5b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3280
addq $0x250, %rsp            # imm = 0x250
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0xa365(%rip), %rdi      # 0x10fd8
leaq 0x56a6(%rip), %rsi      # 0xc320
movl $0xf, %edx
callq 0x32c0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0xa346(%rip), %rdi      # 0x10fd8
callq 0x32c0
movq %rax, %rbx
leaq 0x568f(%rip), %rsi      # 0xc330
movl $0xc, %edx
movq %rax, %rdi
callq 0x32c0
movq %rbx, %rdi
callq 0x3120
movl $0x1, %edi
callq 0x32e0
movq %rax, %rbx
jmp 0x6cd4
jmp 0x6cc7
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x3090
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x6ceb
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3280
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x6d02
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3280
movq %rbx, %rdi
callq 0x3450
nop
// File: /workspace/github_cpp_makefile_star2_O3/drarwood[P]gags/GA.cpp
// Function: DetermineBestSolution(std::vector<double, std::allocator<double>>&, double&, int&)
void DetermineBestSolution(std::vector<double>& v, double& s, int& x) {
    double bestScore = 999999999;
    int    bestScoreIndex;
    for (int i = 0; i < v.size(); ++i) {
        if (v[i] < bestScore) {
            bestScore = v[i];
            bestScoreIndex = i;
        }
    }
    s = bestScore;
    x = bestScoreIndex;
}

// Assembly:
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
je 0x7a4a
sarq $0x3, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
movsd 0x4961(%rip), %xmm1     # 0xc388
xorl %r8d, %r8d
movsd (%rax,%r8,8), %xmm0
ucomisd %xmm0, %xmm1
cmoval %r8d, %edi
minsd %xmm1, %xmm0
incq %r8
movapd %xmm0, %xmm1
cmpq %r8, %rcx
jne 0x7a2a
jmp 0x7a52
movsd 0x4936(%rip), %xmm0     # 0xc388
movsd %xmm0, (%rsi)
movl %edi, (%rdx)
retq
// File: /workspace/github_cpp_makefile_star2_O3/drarwood[P]gags/GA.cpp
// Function: GenerateRouletteWheel(std::vector<double, std::allocator<double>>&, std::vector<double, std::allocator<double>>&)
void GenerateRouletteWheel(vector<double>& r, vector<double>& s) {
    vector<double>s2;
    vector<double>::iterator it = max_element(s.begin(), s.end());
    double worstScore = *it;
    double reqSum = 0;
    double prevProb = 0;    
    for (int i = 0; i < s.size(); ++i) {
        s2.push_back(worstScore-s[i]+1);
        reqSum += (worstScore-s[i]+1);
    }
    for (int i = 0; i < s2.size(); ++i) {
        r.push_back(prevProb + (s2[i] / reqSum));
        prevProb += s2[i] / reqSum;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movapd %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
cmpq %rcx, %rax
sete %sil
leaq 0x8(%rax), %rdx
cmpq %rcx, %rdx
sete %dil
orb %sil, %dil
movq %rax, %rsi
jne 0x7d5e
movsd (%rax), %xmm0
movq %rax, %rsi
movsd (%rdx), %xmm1
ucomisd %xmm0, %xmm1
cmovaq %rdx, %rsi
maxsd %xmm0, %xmm1
addq $0x8, %rdx
movapd %xmm1, %xmm0
cmpq %rcx, %rdx
jne 0x7d41
cmpq %rcx, %rax
je 0x7eb7
movsd (%rsi), %xmm2
xorpd %xmm0, %xmm0
xorl %r13d, %r13d
movsd 0x4626(%rip), %xmm3     # 0xc3a0
movq %rsp, %r15
leaq 0x28(%rsp), %r12
movsd %xmm2, 0x18(%rsp)
movsd %xmm0, 0x20(%rsp)
movapd %xmm2, %xmm0
subsd (%rax,%r13,8), %xmm0
addsd %xmm3, %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0x7dbd
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rsp)
jmp 0x7dcf
movq %r15, %rdi
movq %r12, %rdx
callq 0x8ebe
movq (%r14), %rax
movq 0x8(%r14), %rcx
movsd 0x18(%rsp), %xmm2
movapd %xmm2, %xmm0
subsd (%rax,%r13,8), %xmm0
movsd 0x45b9(%rip), %xmm3     # 0xc3a0
addsd %xmm3, %xmm0
movsd 0x20(%rsp), %xmm1
addsd %xmm0, %xmm1
movapd %xmm1, %xmm0
incq %r13
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %r13, %rdx
ja 0x7d88
movq (%rsp), %rdi
cmpq %rdi, 0x8(%rsp)
je 0x7ea5
xorpd %xmm2, %xmm2
xorl %r15d, %r15d
leaq 0x28(%rsp), %r14
movapd %xmm0, %xmm1
movsd (%rdi,%r15,8), %xmm0
movsd %xmm1, 0x20(%rsp)
divsd %xmm1, %xmm0
movsd %xmm2, 0x18(%rsp)
addsd %xmm2, %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x7e66
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x7e75
movq %rbx, %rdi
movq %r14, %rdx
callq 0x8ebe
movq (%rsp), %rdi
movsd (%rdi,%r15,8), %xmm0
movsd 0x20(%rsp), %xmm1
divsd %xmm1, %xmm0
movsd 0x18(%rsp), %xmm2
addsd %xmm0, %xmm2
incq %r15
movq 0x8(%rsp), %rax
subq %rdi, %rax
sarq $0x3, %rax
cmpq %r15, %rax
ja 0x7e2e
jmp 0x7eaa
testq %rdi, %rdi
je 0x7eb7
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x3280
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x7ec7
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x7ee0
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x3280
movq %rbx, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O3/drarwood[P]gags/GA.cpp
// Function: SpinWheel(std::vector<double, std::allocator<double>>&)
int SpinWheel(vector<double>& r) {
    int i;
    double randomNumber = rand() / (double)RAND_MAX;
    for (i = 0; i < r.size(); ++i) {
        if (randomNumber < r[i]) {
            break;
        }
    }
    return i;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x30a0
movq (%rbx), %rdx
movq 0x8(%rbx), %rcx
subq %rdx, %rcx
je 0x7f2f
cvtsi2sd %eax, %xmm0
divsd 0x449f(%rip), %xmm0     # 0xc3a8
sarq $0x3, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %eax, %eax
movsd (%rdx,%rax,8), %xmm1
ucomisd %xmm0, %xmm1
ja 0x7f31
incq %rax
cmpq %rax, %rcx
jne 0x7f17
movq %rcx, %rax
jmp 0x7f31
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/drarwood[P]gags/GA.cpp
// Function: DetermineWorstSolution(std::vector<double, std::allocator<double>>&, double&, int&)
void DetermineWorstSolution(vector<double>& v, double& s, int& x) {
    double worstScore = 0;
    int    worstScoreIndex;
    for (int i = 0; i < v.size(); ++i) {
        if (v[i] > worstScore) {
            worstScore = v[i];
            worstScoreIndex = i;
        }
    }
    s = worstScore;
    x = worstScoreIndex;
}

// Assembly:
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
je 0x7f72
sarq $0x3, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorpd %xmm1, %xmm1
xorl %r8d, %r8d
movsd (%rax,%r8,8), %xmm0
ucomisd %xmm1, %xmm0
cmoval %r8d, %edi
maxsd %xmm1, %xmm0
incq %r8
movapd %xmm0, %xmm1
cmpq %r8, %rcx
jne 0x7f52
jmp 0x7f76
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsi)
movl %edi, (%rdx)
retq
// File: /workspace/github_cpp_makefile_star2_O3/drarwood[P]gags/GA.cpp
// Function: DetermineX2LeastFit(std::vector<int, std::allocator<int>>&, std::vector<double, std::allocator<double>>)
void DetermineX2LeastFit(vector<int>& c, std::vector<double> s) {
    int index;
    vector<double>::iterator it;
    it  = max_element(s.begin(), s.end());    
    it = find(s.begin(), s.end(), *it);
    index = distance(s.begin(), it);
    c.push_back(index);
    s[index] = -1;
    it = max_element(s.begin(), s.end());    
    it = find(s.begin(), s.end(), *it);
    index = distance(s.begin(), it);
    c.push_back(index);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
movq 0x8(%rsi), %rsi
cmpq %rsi, %rdi
sete %cl
movq %rdi, %rax
addq $0x8, %rax
cmpq %rsi, %rax
sete %dl
orb %cl, %dl
movq %rdi, %rdx
jne 0x8a43
movsd (%rdi), %xmm0
movq %rdi, %rdx
movsd (%rax), %xmm1
ucomisd %xmm0, %xmm1
cmovaq %rax, %rdx
maxsd %xmm0, %xmm1
addq $0x8, %rax
movapd %xmm1, %xmm0
cmpq %rsi, %rax
jne 0x8a26
callq 0x94d1
movq (%r14), %rdi
subq %rdi, %rax
shrq $0x3, %rax
movl %eax, 0xc(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x8a6c
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x8a82
leaq 0xc(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0x61a6
movl (%r15), %eax
movq (%r14), %rdi
cltq
movabsq $-0x4010000000000000, %rcx # imm = 0xBFF0000000000000
movq %rcx, (%rdi,%rax,8)
movq 0x8(%r14), %rsi
cmpq %rsi, %rdi
sete %cl
leaq 0x8(%rdi), %rax
cmpq %rsi, %rax
sete %dl
orb %cl, %dl
movq %rdi, %rdx
jne 0x8ad1
movsd (%rdi), %xmm0
movq %rdi, %rdx
movsd (%rax), %xmm1
ucomisd %xmm0, %xmm1
cmovaq %rax, %rdx
maxsd %xmm0, %xmm1
addq $0x8, %rax
movapd %xmm1, %xmm0
cmpq %rsi, %rax
jne 0x8ab4
callq 0x94d1
subq (%r14), %rax
shrq $0x3, %rax
movl %eax, 0xc(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x8af7
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x8b04
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
callq 0x61a6
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/drarwood[P]gags/InputParser.cpp
// Function: SplitDoubleArgs(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::vector<double, std::allocator<double>>&)
void SplitDoubleArgs(string& s, vector<double>& v) {
    vector<string> vec;
    split(s, ",", vec);
    for (int i = 0; i < vec.size(); ++i) {
        v.push_back(stringToDouble(vec[i]));
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1d40(%rip), %rsi      # 0xc8db
leaq 0x1d3a(%rip), %rdx      # 0xc8dc
leaq 0x48(%rsp), %rdi
callq 0xb004
leaq 0x48(%rsp), %rsi
movq %rsp, %rdx
movq %r14, %rdi
callq 0xb8f0
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0xabd3
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x3280
movq (%rsp), %rax
cmpq %rax, 0x8(%rsp)
je 0xac76
movl $0x8, %r13d
leaq 0x38(%rsp), %r12
xorl %ebp, %ebp
leaq 0x28(%rsp), %r14
leaq 0x20(%rsp), %r15
movq %r12, 0x28(%rsp)
movq -0x8(%rax,%r13), %rsi
movq (%rax,%r13), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x5c48
movq %r14, %rdi
callq 0xb618
movsd %xmm0, 0x20(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xac38
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xac43
movq %rbx, %rdi
movq %r15, %rdx
callq 0x8ebe
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xac5a
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3280
incq %rbp
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
addq $0x20, %r13
cmpq %rbp, %rcx
ja 0xabf9
movq %rsp, %rdi
callq 0x5a9e
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0xacc2
movq 0x58(%rsp), %rsi
jmp 0xacba
jmp 0xaca3
movq %rax, %rbx
jmp 0xacc2
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xacc2
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3280
movq %rsp, %rdi
callq 0x5a9e
movq %rbx, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O3/drarwood[P]gags/InputParser.cpp
// Function: SplitIntArgs(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::vector<int, std::allocator<int>>&)
void SplitIntArgs(string& s, vector<int>& v) {
    vector<string> vec;
    split(s, ",", vec);
    for (int i = 0; i < vec.size(); ++i) {
        v.push_back(stringToInt(vec[i]));
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1bd4(%rip), %rsi      # 0xc8db
leaq 0x1bce(%rip), %rdx      # 0xc8dc
leaq 0x48(%rsp), %rdi
callq 0xb004
leaq 0x48(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0xb8f0
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0xad41
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x3280
movq 0x10(%rsp), %rax
cmpq %rax, 0x18(%rsp)
je 0xade2
movl $0x8, %r13d
leaq 0x38(%rsp), %r12
xorl %ebp, %ebp
leaq 0x28(%rsp), %r14
leaq 0xc(%rsp), %r15
movq %r12, 0x28(%rsp)
movq -0x8(%rax,%r13), %rsi
movq (%rax,%r13), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x5c48
movq %r14, %rdi
callq 0xb6a4
movl %eax, 0xc(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xada3
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xadae
movq %rbx, %rdi
movq %r15, %rdx
callq 0xb09a
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xadc5
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3280
incq %rbp
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
addq $0x20, %r13
cmpq %rbp, %rcx
ja 0xad68
leaq 0x10(%rsp), %rdi
callq 0x5a9e
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0xae30
movq 0x58(%rsp), %rsi
jmp 0xae28
jmp 0xae11
movq %rax, %rbx
jmp 0xae30
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xae30
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3280
leaq 0x10(%rsp), %rdi
callq 0x5a9e
movq %rbx, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O3/drarwood[P]gags/InputParser.cpp
// Function: DetermineDoubleArgsPrecision(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::vector<int, std::allocator<int>>&)
void DetermineDoubleArgsPrecision(string& s, vector<int>& v) {
    vector<string> vec;
    split(s, ",", vec);
    for (int i = 0; i < vec.size(); ++i) {
        if (vec[i].find(".") != -1) {
            v.push_back(vec[i].size() - (vec[i].find(".")+1));
        }
        else {
            v.push_back(0);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1a64(%rip), %rsi      # 0xc8db
leaq 0x1a5e(%rip), %rdx      # 0xc8dc
leaq 0x28(%rsp), %rdi
callq 0xb004
leaq 0x28(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0xb8f0
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0xaeb1
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3280
movq 0x10(%rsp), %rdi
cmpq %rdi, 0x18(%rsp)
je 0xaf78
xorl %r12d, %r12d
leaq 0x126f(%rip), %r14      # 0xc13a
leaq 0xc(%rsp), %r15
xorl %r13d, %r13d
addq %r12, %rdi
movl $0x1, %ecx
movq %r14, %rsi
xorl %edx, %edx
callq 0x3430
cmpq $-0x1, %rax
je 0xaf1d
movq 0x10(%rsp), %rdi
movl 0x8(%rdi,%r12), %ebp
addq %r12, %rdi
movl $0x1, %ecx
movq %r14, %rsi
xorl %edx, %edx
callq 0x3430
notl %eax
addl %ebp, %eax
movl %eax, 0xc(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xaf3f
movl %eax, (%rsi)
jmp 0xaf35
movl $0x0, 0xc(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xaf4c
movl $0x0, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xaf57
movq %rbx, %rdi
movq %r15, %rdx
callq 0xb09a
jmp 0xaf57
movq %rbx, %rdi
movq %r15, %rdx
callq 0xb09a
incq %r13
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
subq %rdi, %rax
sarq $0x5, %rax
addq $0x20, %r12
cmpq %r13, %rax
ja 0xaed3
leaq 0x10(%rsp), %rdi
callq 0x5a9e
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0xafb4
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3280
jmp 0xafb4
jmp 0xafb1
jmp 0xafb1
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5a9e
movq %rbx, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O3/drarwood[P]gags/StringOperations.cpp
// Function: stringToDouble(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
double stringToDouble(string s) {
    double d;
    stringstream ss(s); //turn the string into a stream
    ss >> d; //convert
    return d;
}

// Assembly:
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, %rsi
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
movl $0x18, %edx
callq 0x33d0
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x3190
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x5953(%rip), %rsi      # 0x10fa8
leaq 0x18(%rsp), %rdi
callq 0x31f0
leaq 0x98(%rsp), %rdi
callq 0x30d0
movsd 0x8(%rsp), %xmm0
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
retq
movq %rax, %rbx
movq 0x5923(%rip), %rsi      # 0x10fa8
leaq 0x18(%rsp), %rdi
callq 0x31f0
leaq 0x98(%rsp), %rdi
callq 0x30d0
movq %rbx, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O3/drarwood[P]gags/StringOperations.cpp
// Function: stringToInt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int stringToInt(string s) {
    int i;
    stringstream ss(s); //turn the string into a stream
    ss >> i; //convert
    return i;
}

// Assembly:
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rdi, %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movl $0x18, %edx
callq 0x33d0
leaq 0x4(%rsp), %rsi
movq %rbx, %rdi
callq 0x3180
movl 0x4(%rsp), %ebx
movq 0x58cf(%rip), %rsi      # 0x10fa8
leaq 0x8(%rsp), %rdi
callq 0x31f0
leaq 0x88(%rsp), %rdi
callq 0x30d0
movl %ebx, %eax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
retq
movq %rax, %rbx
movq 0x58a3(%rip), %rsi      # 0x10fa8
leaq 0x8(%rsp), %rdi
callq 0x31f0
leaq 0x88(%rsp), %rdi
callq 0x30d0
movq %rbx, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O3/drarwood[P]gags/StringOperations.cpp
// Function: intToString[abi:cxx11](int)
string intToString(int i) {
    string s;
    ostringstream convert;
    convert << i;
    s = convert.str();
    return s;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x20(%rsp), %rdi
callq 0x3320
leaq 0x20(%rsp), %rdi
movl %ebp, %esi
callq 0x3420
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x33c0
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x32f0
movq (%r14), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xb794
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3280
movq 0x5835(%rip), %rsi      # 0x10fd0
leaq 0x20(%rsp), %rdi
callq 0x3140
leaq 0x90(%rsp), %rdi
callq 0x30d0
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb7c5
movq %rax, %r14
movq 0x5801(%rip), %rsi      # 0x10fd0
leaq 0x20(%rsp), %rdi
callq 0x3140
leaq 0x90(%rsp), %rdi
callq 0x30d0
jmp 0xb7eb
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0xb7fe
movq (%r15), %rsi
incq %rsi
callq 0x3280
movq %r14, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O3/drarwood[P]gags/StringOperations.cpp
// Function: doubleToString[abi:cxx11](double)
string doubleToString(double d) {
    string s;
    ostringstream convert;
    convert << d;
    s = convert.str();
    return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movsd %xmm0, (%rsp)
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x28(%rsp), %rdi
callq 0x3320
leaq 0x28(%rsp), %rdi
movsd (%rsp), %xmm0
callq 0x33e0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x33c0
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x32f0
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xb87f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3280
movq 0x574a(%rip), %rsi      # 0x10fd0
leaq 0x28(%rsp), %rdi
callq 0x3140
leaq 0x98(%rsp), %rdi
callq 0x30d0
movq %rbx, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %r15
retq
jmp 0xb8af
movq %rax, %r14
movq 0x5717(%rip), %rsi      # 0x10fd0
leaq 0x28(%rsp), %rdi
callq 0x3140
leaq 0x98(%rsp), %rdi
callq 0x30d0
jmp 0xb8d5
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0xb8e8
movq (%r15), %rsi
incq %rsi
callq 0x3280
movq %r14, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O3/drarwood[P]gags/StringOperations.cpp
// Function: split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
void split(string& s, string sc, vector<string>& v) {

    string::size_type i = 0;
    string::size_type j = s.find(sc);

    while (j != string::npos) {
        v.push_back(s.substr(i,j-i));
        i = ++j;
        j = s.find(sc,j);
        if (j == string::npos) {
            v.push_back(s.substr(i, s.length()));
        }
    }
    if (v.size() == 0) {
        v.push_back(s);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rsi), %rsi
movq 0x8(%r15), %rcx
xorl %edx, %edx
callq 0x3430
cmpq $-0x1, %rax
je 0xb9c3
movq %rax, %r13
xorl %ebp, %ebp
leaq 0x8(%rsp), %r12
movq %r13, %rcx
subq %rbp, %rcx
movq %r12, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x32a0
movq %rbx, %rdi
movq %r12, %rsi
callq 0xba10
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xb964
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3280
movq %r13, %rbp
incq %rbp
movq (%r15), %rsi
movq 0x8(%r15), %rcx
movq %r14, %rdi
movq %rbp, %rdx
callq 0x3430
movq %rax, %r13
cmpq $-0x1, %rax
jne 0xb929
movq 0x8(%r14), %rcx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x32a0
movq %rbx, %rdi
movq %r15, %rsi
callq 0xba10
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xb9c3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3280
movq 0x8(%rbx), %rax
cmpq (%rbx), %rax
jne 0xb9d7
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8b0e
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb9e8
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xba07
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3280
movq %rbx, %rdi
callq 0x3450
nop
// File: /workspace/github_cpp_makefile_star2_O3/SMT-COMP[P]scrambler/scrambler.cpp
// Function: unquote(char const*)
const char *unquote(const char *n)
{
    if (!n[0] || n[0] != '|') {
        return n;
    }

    static std::string buf;
    buf = n;
    assert(!buf.empty());
    if (buf.size() > 1 && buf[0] == '|' && buf[buf.size()-1] == '|') {
        buf = buf.substr(1, buf.size()-2);
    }
    return buf.c_str();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpb $0x7c, (%rdi)
jne 0x3b5b
movb 0xf869(%rip), %al       # 0x132f8
testb %al, %al
je 0x3b66
movq %rbx, %rdi
callq 0x3100
leaq 0xf84a(%rip), %rdi      # 0x132f0
movq %rbx, %rsi
movq %rax, %rdx
callq 0x32b0
movq 0xf838(%rip), %rbx      # 0x132f0
movq -0x18(%rbx), %rax
cmpq $0x1, %rax
je 0x3b5b
testq %rax, %rax
je 0x3b70
movl -0x8(%rbx), %eax
testl %eax, %eax
js 0x3ae9
leaq 0xf813(%rip), %rdi      # 0x132f0
callq 0x3070
movq 0xf807(%rip), %rbx      # 0x132f0
cmpb $0x7c, (%rbx)
jne 0x3b5b
movq -0x18(%rbx), %r14
movl -0x8(%rbx), %eax
testl %eax, %eax
js 0x3b0c
leaq 0xf7f0(%rip), %rdi      # 0x132f0
callq 0x3070
movq 0xf7e4(%rip), %rbx      # 0x132f0
cmpb $0x7c, -0x1(%rbx,%r14)
jne 0x3b5b
movq -0x18(%rbx), %rcx
addq $-0x2, %rcx
leaq 0xf7cd(%rip), %rbx      # 0x132f0
leaq 0x10(%rsp), %r14
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3400
movq %rbx, %rdi
movq %r14, %rsi
callq 0x33d0
movq (%r14), %rdi
addq $-0x18, %rdi
leaq 0xf(%rsp), %rsi
callq 0x3170
movq 0xf795(%rip), %rbx      # 0x132f0
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0x34a0
jmp 0x3a97
leaq 0x84a9(%rip), %rdi      # 0xc020
leaq 0x84af(%rip), %rsi      # 0xc02d
leaq 0x84b6(%rip), %rcx      # 0xc03b
movl $0xad, %edx
callq 0x31a0
// File: /workspace/github_cpp_makefile_star2_O3/SMT-COMP[P]scrambler/scrambler.cpp
// Function: scrambler::set_new_name(char const*)
void set_new_name(const char *n)
{
    n = unquote(n);

    if (name_ids.find(n) == name_ids.end()) {
        name_ids[n] = next_name_id;
        ++next_name_id;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
callq 0x3a76
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %rax, %rsi
callq 0x3180
leaq 0xf701(%rip), %rdi      # 0x132b8
leaq 0x10(%rsp), %rsi
callq 0x6882
movq %rax, %r14
movq 0x10(%rsp), %rdi
addq $-0x18, %rdi
leaq 0xe(%rsp), %rsi
callq 0x3170
testq %r14, %r14
jne 0x3c23
movq 0xf675(%rip), %r14      # 0x13258
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %rbx, %rsi
callq 0x3180
leaq 0xf6bc(%rip), %rdi      # 0x132b8
leaq 0x10(%rsp), %rsi
callq 0x6998
movq %r14, (%rax)
movq 0x10(%rsp), %rdi
addq $-0x18, %rdi
leaq 0xe(%rsp), %rsi
callq 0x3170
incq 0xf635(%rip)            # 0x13258
addq $0x18, %rsp
popq %rbx
popq %r14
retq
jmp 0x3c2f
jmp 0x3c47
movq %rax, %rbx
movq 0x10(%rsp), %rdi
addq $-0x18, %rdi
leaq 0xe(%rsp), %rsi
callq 0x3170
jmp 0x3c4a
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3410