LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/pranavmodx[P]modlang/src/../header/./object.hpp
// Function: Queue::inspect[abi:cxx11]()
std::string inspect()
	{
		if (elements.empty())
			return "queue<> {front: empty}";

		std::string res = "queue<> {front: " + elements.front()->inspect() + "}";

		return res;
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x18(%rsi), %rax
cmpq %rax, 0x38(%rsi)
je 0x2614f
movq (%rax), %rsi
movq (%rsi), %rax
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq *0x8(%rax)
leaq 0x3b4c(%rip), %rcx      # 0x29c62
movl $0x10, %r8d
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x51f0
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x26171
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x26178
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x3aee(%rip), %rsi      # 0x29c4b
leaq 0x3afd(%rip), %rdx      # 0x29c61
movq %rbx, %rdi
callq 0xbe5c
jmp 0x26211
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x3a8a(%rip), %rsi      # 0x29c25
callq 0x5360
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x261c2
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x261c8
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x261f6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x51c0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x26211
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x51c0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x2623b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x51c0
jmp 0x2623b
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x26256
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x51c0
movq %rbx, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O3/pranavmodx[P]modlang/src/../header/./object.hpp
// Function: MaxHeapCompareFn::operator()(Object*, Object*)
bool operator()(Object *obj1, Object *obj2)
	{
		if (obj1->type() == INTEGER_OBJ)
			return ((Integer *)obj1)->value < ((Integer *)obj2)->value;
		else if (obj1->type() == STRING_OBJ)
			return ((String *)obj1)->value < ((String *)obj2)->value;
		
		return true;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq (%rsi), %rax
movq %rsp, %r15
movq %r15, %rdi
callq *(%rax)
movq 0x8(%r15), %rdx
cmpq 0x11266(%rip), %rdx     # 0x38158
jne 0x26f14
movq (%rsp), %r15
testq %rdx, %rdx
je 0x26f1c
movq 0x1124c(%rip), %rsi     # 0x38150
movq %r15, %rdi
callq 0x51d0
testl %eax, %eax
sete %bpl
jmp 0x26f1f
movq (%rsp), %r15
xorl %ebp, %ebp
jmp 0x26f1f
movb $0x1, %bpl
leaq 0x10(%rsp), %r12
cmpq %r12, %r15
je 0x26f39
movq 0x10(%rsp), %rsi
incq %rsi
movq %r15, %rdi
callq 0x51c0
testb %bpl, %bpl
je 0x26f4a
movl 0x8(%r14), %eax
cmpl 0x8(%rbx), %eax
setl %al
jmp 0x26fc2
movq (%r14), %rax
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq *(%rax)
movq 0x8(%r15), %rdx
cmpq 0x11235(%rip), %rdx     # 0x38198
jne 0x26f85
movq (%rsp), %r15
testq %rdx, %rdx
je 0x26f8d
movq 0x1121b(%rip), %rsi     # 0x38190
movq %r15, %rdi
callq 0x51d0
testl %eax, %eax
sete %bpl
jmp 0x26f90
movq (%rsp), %r15
xorl %ebp, %ebp
jmp 0x26f90
movb $0x1, %bpl
cmpq %r12, %r15
je 0x26fa5
movq 0x10(%rsp), %rsi
incq %rsi
movq %r15, %rdi
callq 0x51c0
movb $0x1, %al
testb %bpl, %bpl
je 0x26fc2
addq $0x8, %r14
addq $0x8, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5040
shrl $0x1f, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0xbc55
nop
// File: /workspace/github_cpp_makefile_star2_O3/pranavmodx[P]modlang/src/../header/./object.hpp
// Function: MinHeapCompareFn::operator()(Object*, Object*)
bool operator()(Object *obj1, Object *obj2)
	{
		if (obj1->type() == INTEGER_OBJ)
			return ((Integer *)obj1)->value > ((Integer *)obj2)->value;
		else
			return ((String *)obj1)->value > ((String *)obj2)->value;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq (%rsi), %rax
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq *(%rax)
movq 0x8(%r15), %rdx
cmpq 0x11158(%rip), %rdx     # 0x38158
jne 0x27023
movq 0x8(%rsp), %r15
testq %rdx, %rdx
je 0x2702c
movq 0x1113d(%rip), %rsi     # 0x38150
movq %r15, %rdi
callq 0x51d0
testl %eax, %eax
sete %bpl
jmp 0x2702f
movq 0x8(%rsp), %r15
xorl %ebp, %ebp
jmp 0x2702f
movb $0x1, %bpl
leaq 0x18(%rsp), %rax
cmpq %rax, %r15
je 0x27049
movq 0x18(%rsp), %rsi
incq %rsi
movq %r15, %rdi
callq 0x51c0
addq $0x8, %r14
testb %bpl, %bpl
je 0x2705a
movl (%r14), %eax
cmpl 0x8(%rbx), %eax
jmp 0x2706b
addq $0x8, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5040
testl %eax, %eax
setg %al
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0xbc55
nop
// File: /workspace/github_cpp_makefile_star2_O3/oknenavin[P]cxon/test/../src/cxon/lang/cbor/fundamental.hxx
// Function: bool cxon::write<cxon::CBOR<cxon::cbor::format_traits>, wchar_t, void>::value<std::__cxx11::basic_string<unsigned char, std::char_traits<unsigned char>, std::allocator<unsigned char>>, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>>(std::__cxx11::basic_string<unsigned char, std::char_traits<unsigned char>, std::allocator<unsigned char>>&, wchar_t, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>&)
static bool value(O& o, T t, Cx& cx) {
                    using Q = typename std::make_unsigned<T>::type;
                    auto const p = cbor::imp::power_(t);
                    return Q(t) > 0x17 ?
                        bio::poke<X>(o, bio::byte(X::pint + 0x18 + p), cx) && bio::poke<X>(o, Q(t), 1 << p, cx) :
                        bio::poke<X>(o, bio::byte(X::pint + Q(t)), cx)
                    ;
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r12
cmpl $0x18, %esi
jb 0x3d9bf
movq %rdx, %r14
xorl %eax, %eax
cmpl $0x100, %ebx            # imm = 0x100
setae %al
cmpl $0x10000, %ebx          # imm = 0x10000
movl $0x2, %r15d
cmovbl %eax, %r15d
leal 0x18(%r15), %eax
movzbl %al, %esi
movq %r12, %rdi
callq 0x313ae
movl $0x1, %eax
movl %r15d, %ecx
shll %cl, %eax
cmpl $0x1, %eax
je 0x3d9a7
cmpl $0x2, %eax
je 0x3d9a0
cmpl $0x4, %eax
jne 0x3d9d8
movl %ebx, %ecx
shrl $0x18, %ecx
movb %cl, 0x4(%rsp)
movl %ebx, %ecx
shrl $0x10, %ecx
movb %cl, 0x5(%rsp)
leal -0x2(%rax), %ecx
movb %bh, 0x4(%rsp,%rcx)
leal -0x1(%rax), %ecx
movb %bl, 0x4(%rsp,%rcx)
movl %eax, %edx
leaq 0x4(%rsp), %rsi
movq %r12, %rdi
callq 0x315b8
jmp 0x3d9ca
movzbl %bl, %esi
movq %r12, %rdi
callq 0x313ae
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x3151c
movl $0x1, (%r14)
movq %rax, 0x8(%r14)
xorl %eax, %eax
jmp 0x3d9cc
// File: /workspace/github_cpp_makefile_star2_O3/oknenavin[P]cxon/test/../src/cxon/lang/common/container.hxx
// Function: cxon::cnt::pointer_container<boost::container::basic_string<char, std::char_traits<char>, void>, cxon::alc::basic_allocator<boost::container::basic_string<char, std::char_traits<char>, void>, std::allocator<char>>>::resize(unsigned long)
void resize(std::size_t n) {
                    CXON_ASSERT(n != 0 && n >= std::size_t(e_ - f_), "unexpected");
                    auto const p = a_.create(n);
                        std::move(f_, e_, p);
                        a_.release(f_, l_ - f_);
                    e_ = p + (e_ - f_), l_ = p + n, f_ = p;
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0x4143b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x414e2
jmp 0x41442
xorl %edi, %edi
callq 0x5210
movq %rax, %r15
movq 0x8(%rbx), %r12
movq 0x18(%rbx), %rax
subq %r12, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
testq %rax, %rax
jle 0x41499
mulq %rcx
movq %rdx, %r13
shrq $0x4, %r13
incq %r13
movq %r15, %rbp
movq %rbp, %rdi
movq %r12, %rsi
callq 0x41576
addq $0x18, %r12
addq $0x18, %rbp
decq %r13
cmpq $0x1, %r13
ja 0x4146f
movq 0x8(%rbx), %r12
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
movq 0x10(%rbx), %rdx
subq %r12, %rdx
sarq $0x3, %rdx
imulq %rcx, %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x41512
movq 0x18(%rbx), %rax
subq 0x8(%rbx), %rax
addq %r15, %rax
movq %rax, 0x18(%rbx)
leaq (%r14,%r14,2), %rax
leaq (%r15,%rax,8), %rax
movq %rax, 0x10(%rbx)
movq %r15, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/oknenavin[P]cxon/test/../src/cxon/lang/common/allocator.hxx
// Function: cxon::alc::basic_allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<char>>::create(unsigned long)
T* create(std::size_t n) {
                auto p = tr::allocate(al_, n);
                    if (p) for (T *t = p, *te = t + n; t != te; ++t)
                        construct(t);
                return p;
            }

// Assembly:
pushq %rbx
movq %rsi, %rbx
xorl %edx, %edx
callq 0xca154
testq %rax, %rax
je 0xca109
testq %rbx, %rbx
je 0xca109
shlq $0x5, %rbx
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, -0x10(%rcx)
movq $0x0, -0x8(%rcx)
movb $0x0, (%rcx)
addq $0x20, %rcx
addq $-0x20, %rbx
jne 0xca0f0
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/oknenavin[P]cxon/test/../src/cxon/lang/common/allocator.hxx
// Function: cxon::alc::basic_allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<char>>::release(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, unsigned long)
void release(T* p, std::size_t n) {
                if (p) {
                    for (T *t = p, *te = t + n; t != te; ++t)
                        destroy(t);
                    tr::deallocate(al_, p, n);
                }
            }

// Assembly:
testq %rsi, %rsi
je 0xca152
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
testq %rdx, %rdx
je 0xca145
shlq $0x5, %r14
addq %rbx, %r14
movq %rbx, %r15
movq (%r15), %rdi
addq $0x10, %r15
cmpq %r15, %rdi
je 0xca13c
callq 0x5200
addq $0x10, %r15
cmpq %r14, %r15
jne 0xca12b
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x5200
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/oknenavin[P]cxon/test/../src/cxon/lang/cbor/common/sink.hxx
// Function: bool cxon::cbor::imp::sink_reader_<cxon::CBOR<cxon::cbor::format_traits>, cxon::cbor::sink<void> const>::read_element<unsigned char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>, cxon::CBOR<cxon::cbor::format_traits>>(cxon::cbor::sink<void> const&, unsigned char, unsigned char const*&, unsigned char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>&)
static bool read_element(S& s, bio::byte m, II& i, II e, Cx& cx) {
                    switch (m) {
                        case Y::map:    return  sink_read<Y>(s, i, e, cx) &&
                                                sink_read<Y>(s, i, e, cx);
                        case Y::arr:    return  sink_read<Y>(s, i, e, cx);
                        default:        return  CXON_ASSERT(0, "unexpected"), false; // LCOV_EXCL_LINE
                    }
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
cmpl $0x80, %esi
je 0xa1729
cmpl $0xa0, %esi
jne 0xa1745
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xa1434
testb %al, %al
je 0xa1745
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa1434
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/oknenavin[P]cxon/test/src/cbor/cbor.core-main.cxx
// Function: main
int main() {
    using cxon::test::suite;
    for (auto& c : suite::info::get()) {
        for (auto s : c.second.suites)
            s->test();
        std::fprintf(stdout, "cxon/cbor%-12s: %u of %4u failed\n", c.first.c_str(), suite::info::errors(c.first.c_str()), suite::info::count(c.first.c_str())); std::fflush(stdout);
    }
    return suite::info::errors();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x2f36e
movq %rax, %rbx
movq 0x18(%rax), %r14
addq $0x8, %rbx
cmpq %rbx, %r14
je 0xae9b8
movq 0x64629(%rip), %r15     # 0x112f78
movq 0x40(%r14), %r12
movq 0x48(%r14), %r13
cmpq %r13, %r12
je 0xae96b
movq (%r12), %rdi
movq (%rdi), %rax
callq *(%rax)
addq $0x8, %r12
jmp 0xae957
movq (%r15), %r12
movq 0x20(%r14), %r13
movq %r13, %rdi
callq 0x2f2f8
movl 0x1c(%rax), %ebp
movq 0x20(%r14), %rdi
callq 0x2f2f8
movl 0x18(%rax), %r8d
movq %r12, %rdi
leaq 0x2c3ea(%rip), %rsi     # 0xdad7e
movq %r13, %rdx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x52d0
movq (%r15), %rdi
callq 0x5280
movq %r14, %rdi
callq 0x5160
movq %rax, %r14
cmpq %rbx, %rax
jne 0xae94f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xafbd0
nop
// File: /workspace/github_cpp_makefile_star2_O3/oknenavin[P]cxon/test/../src/cxon/lang/cbor/lib/std/bitset.hxx
// Function: std::enable_if<1ul < 8, bool>::type cxon::cbor::imp::read_bitset_<cxon::CBOR<cxon::cbor::format_traits>, 1ul, unsigned char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>>(std::bitset<1ul>&, unsigned char const*&, unsigned char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>&)
inline auto read_bitset_(std::bitset<N>& t, II& i, II e, Cx& cx) -> enable_if_t<N  < 8, bool> {
                switch (bio::peek(i, e) & X::mjr) {
                    case X::bstr: {
                        auto const M = N / 8 + std::size_t(!!(N % 8));
                        if (!cbor::cnt::read_size_eq<X>(M + 1, i, e, cx))
                            return false;
                        if (i == e)
                            return cx/cbor::read_error::unexpected;
                        if (M * 8 - bio::byte(*i) != N)
                            return cx/cbor::read_error::size_invalid;
                        if (++i == e)
                            return cx/cbor::read_error::unexpected;
                        return t |= std::bitset<N> {*i}, ++i, true;
                    }
                    default:
                        return cx/cbor::read_error::unexpected;
                }
            }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq (%rsi), %r13
cmpq %rdx, %r13
je 0xca86b
movb (%r13), %al
andb $-0x20, %al
cmpb $0x40, %al
jne 0xca86b
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rsp), %rdi
movq %rbx, %rcx
callq 0x3021d
testb %al, %al
je 0xca878
cmpq $0x2, 0x8(%rsp)
jne 0xca887
movq (%r14), %rax
cmpq %r12, %rax
je 0xca86b
cmpb $0x7, (%rax)
jne 0xca88a
leaq 0x1(%rax), %rcx
movq %rcx, (%r14)
cmpq %r12, %rcx
je 0xca86b
movzbl 0x1(%rax), %ecx
andl $0x1, %ecx
orq %rcx, (%r15)
addq $0x2, %rax
movq %rax, (%r14)
movb $0x1, %al
jmp 0xca89b
callq 0x2fe02
movl $0x1, (%rbx)
jmp 0xca895
callq 0x2fe02
movl $0x6, (%rbx)
movq %rax, 0x8(%rbx)
movq %r13, (%r14)
callq 0x2fe02
movl $0x6, (%rbx)
movq %rax, 0x8(%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/oknenavin[P]cxon/test/../src/cxon/lang/cbor/lib/std/complex.hxx
// Function: bool cxon::read<cxon::CBOR<cxon::cbor::format_traits>, std::complex<float>, void>::value<unsigned char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>, cxon::CBOR<cxon::cbor::format_traits>>(std::complex<float>&, unsigned char const*&, unsigned char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>&)
static bool value(std::complex<T>& t, II& i, II e, Cx& cx) {
                    T rl, mg;
                    return  cbor::tag::read<Y>(i, e, cx) &&
                            cbor::cnt::read_size_eq<Y>(2, i, e, cx) &&
                                read_value<Y>(rl, i, e, cx) &&
                                read_value<Y>(mg, i, e, cx) &&
                            (t.real(rl), t.imag(mg), true)
                    ;
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movq (%rsi), %r13
cmpq %rdx, %r13
je 0xcc44f
movzbl (%r13), %ecx
movl %ecx, %eax
andb $-0x20, %al
cmpb $-0x40, %al
jne 0xcc44f
andl $0x1f, %ecx
movl $0x1, %eax
cmpb $0x18, %cl
jae 0xcc4e2
addq %rax, %r13
movq %r13, (%r15)
movq %rsp, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x3021d
testb %al, %al
je 0xcc4b1
cmpq $0x2, (%rsp)
jne 0xcc4c0
movq %rsp, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0xae6be
testb %al, %al
je 0xcc4d2
leaq 0xc(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0xae6be
testb %al, %al
je 0xcc4d2
movss (%rsp), %xmm0
movss %xmm0, (%r14)
movss 0xc(%rsp), %xmm0
movss %xmm0, 0x4(%r14)
movb $0x1, %al
jmp 0xcc4d4
callq 0x2fe02
movl $0x6, (%rbx)
movq %rax, 0x8(%rbx)
movq %r13, (%r15)
callq 0x2fe02
movl $0x6, (%rbx)
movq %rax, 0x8(%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leal -0x1c(%rcx), %eax
cmpl $0x4, %eax
jae 0xcc4f7
callq 0x2fe02
movl $0x8, (%rbx)
jmp 0xcc4ce
addb $-0x18, %cl
movl $0x1, %eax
shll %cl, %eax
incl %eax
movq %r12, %rcx
subq %r13, %rcx
cmpq %rax, %rcx
jae 0xcc449
callq 0x2fe02
movl $0x1, (%rbx)
jmp 0xcc4ce
nop
// File: /workspace/github_cpp_makefile_star2_O3/oknenavin[P]cxon/test/src/cbor/../test.hxx
// Function: cxon::test::match<std::priority_queue<int, std::vector<int, std::allocator<int>>, std::less<int>>>::values(std::priority_queue<int, std::vector<int, std::allocator<int>>, std::less<int>> const&, std::priority_queue<int, std::vector<int, std::allocator<int>>, std::less<int>> const&)
static bool values(const std::priority_queue<T>& t0, const std::priority_queue<T>& t1) {
                auto r0 = t0, r1 = t1;
                    while (!r0.empty() && !r1.empty()) {
                        if (!match<T>::values(r0.top(), r1.top())) return false;
                        r0.pop(); r1.pop();
                    }
                return r0.empty() && r1.empty();
            }

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x8(%rsp), %rdi
callq 0xd30c4
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0xd30c4
leaq 0x8(%rsp), %rbx
leaq 0x28(%rsp), %r14
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rcx
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rdx
cmpq %rcx, %rdi
je 0xd287c
cmpq %rdx, %rax
je 0xd287c
movl (%rdi), %ecx
cmpl (%rax), %ecx
jne 0xd288f
movq %rbx, %rdi
callq 0xd3084
movq %r14, %rdi
callq 0xd3084
jmp 0xd2846
xorq %rax, %rdx
xorq %rdi, %rcx
orq %rdx, %rcx
sete %bl
testq %rax, %rax
jne 0xd2891
jmp 0xd289e
xorl %ebx, %ebx
movq %rax, %rdi
callq 0x5200
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xd28a8
callq 0x5200
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
jmp 0xd28c9
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0xd28c9
callq 0x5200
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xd28d8
callq 0x5200
movq %rbx, %rdi
callq 0x5370
// File: /workspace/github_cpp_makefile_star2_O3/oknenavin[P]cxon/test/../src/cxon/lang/cbor/lib/std/utility.hxx
// Function: bool cxon::read<cxon::CBOR<cxon::cbor::format_traits>, std::pair<int, float>, void>::value<unsigned char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>, cxon::CBOR<cxon::cbor::format_traits>>(std::pair<int, float>&, unsigned char const*&, unsigned char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>&)
static bool value(std::pair<F, S>& t, II& i, II e, Cx& cx) {
                    return  cbor::tag::read<Y>(i, e, cx) &&
                            cbor::cnt::read_size_eq<Y>(2, i, e, cx) &&
                                read_value<Y>(t.first, i, e, cx) &&
                                read_value<Y>(t.second, i, e, cx)
                    ;
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
movq (%rsi), %r13
cmpq %rdx, %r13
je 0xd3e7f
movzbl (%r13), %ecx
movl %ecx, %eax
andb $-0x20, %al
cmpb $-0x40, %al
jne 0xd3e7f
andl $0x1f, %ecx
movl $0x1, %eax
cmpb $0x18, %cl
jae 0xd3efb
addq %rax, %r13
movq %r13, (%r14)
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x3021d
testb %al, %al
je 0xd3eca
cmpq $0x2, 0x8(%rsp)
jne 0xd3ed9
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x30d1a
testb %al, %al
je 0xd3eeb
addq $0x4, %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0xae6be
jmp 0xd3eed
callq 0x2fe02
movl $0x6, (%rbx)
movq %rax, 0x8(%rbx)
movq %r13, (%r14)
callq 0x2fe02
movl $0x6, (%rbx)
movq %rax, 0x8(%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leal -0x1c(%rcx), %eax
cmpl $0x4, %eax
jae 0xd3f10
callq 0x2fe02
movl $0x8, (%rbx)
jmp 0xd3ee7
addb $-0x18, %cl
movl $0x1, %eax
shll %cl, %eax
incl %eax
movq %r15, %rcx
subq %r13, %rcx
cmpq %rax, %rcx
jae 0xd3e79
callq 0x2fe02
movl $0x1, (%rbx)
jmp 0xd3ee7
// File: /workspace/github_cpp_makefile_star2_O3/oknenavin[P]cxon/test/../src/cxon/lang/cbor/lib/std/valarray.hxx
// Function: cxon::cbor::imp::valarray_container_<unsigned char>::grow(unsigned long)
void grow(std::size_t n) {
                        CXON_ASSERT(n > a_.size(), "unexpected");
                        std::valarray<T> a(n);
#                           ifdef _MSC_VER // std::begin/std::end broken for empty std::valarray
                                for (std::size_t i = 0, is = a_.size(); i != is; ++i)
                                    a[i] = a_[i];
#                           else
                                std::copy(std::begin(a_), std::end(a_), std::begin(a));
#                           endif
                        a_.swap(a);
                    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq %rsi, %rdi
callq 0x5210
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x5140
movq (%r15), %r12
movq (%r12), %rax
movq 0x8(%r12), %r15
testq %rax, %rax
movq %r15, %rsi
cmoveq %rax, %rsi
leaq (%r15,%rax), %rdx
cmoveq %rax, %rdx
subq %rsi, %rdx
je 0xd6e98
testq %rbx, %rbx
movq %r14, %rdi
cmoveq %rbx, %rdi
callq 0x5340
movq %rbx, (%r12)
movq %r14, 0x8(%r12)
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x5200
// File: /workspace/github_cpp_makefile_star2_O3/willprice[P]parallel-cpp-workshop/parallel_for.cpp
// Function: main
int main(int argc, char **argv)
{
    std::mutex m;

    auto values = std::vector<double>(10000);

    tbb::parallel_for(tbb::blocked_range<int>(0, values.size()),
      [&](tbb::blocked_range<int> r){
          m.lock();
          std::cout << "Range size " << (r.end() - r.begin())
                    << " from " << r.begin() << " to " << r.end() << std::endl;
          m.unlock();

          for (int i = r.begin(); i < r.end(); i++) {
              values[i] = std::sin(i * 0.001);
          };
    });

    double total = 0;

    for (auto value : values)
    {
        total += value;
    }

    std::cout << total << std::endl;

    return 0;
}

// Assembly:
pushq %rbx
subq $0xf0, %rsp
xorpd %xmm0, %xmm0
movapd %xmm0, 0x30(%rsp)
movapd %xmm0, 0x20(%rsp)
movq $0x0, 0x40(%rsp)
movl $0x13880, %edi          # imm = 0x13880
callq 0x2100
movq %rax, (%rsp)
leaq 0x13880(%rax), %rbx
movq %rbx, 0x10(%rsp)
movl $0x13880, %edx          # imm = 0x13880
movq %rax, %rdi
xorl %esi, %esi
callq 0x20a0
movq %rbx, 0x8(%rsp)
leaq 0x70(%rsp), %rdi
movw $0x401, 0xc(%rdi)       # imm = 0x401
xorpd %xmm0, %xmm0
movupd %xmm0, 0x20(%rdi)
movq $0x1, 0x40(%rdi)
callq 0x2170
leaq 0x18(%rsp), %rdi
movq $0x0, (%rdi)
movl $0x80, %esi
callq 0x2050
movq %rax, %rbx
xorpd %xmm0, %xmm0
movupd %xmm0, 0x28(%rax)
movupd %xmm0, 0x18(%rax)
movupd %xmm0, 0x8(%rax)
movq $0x0, 0x38(%rax)
leaq 0x2961(%rip), %rax      # 0x4d38
movq %rax, (%rbx)
movq $0x2710, 0x40(%rbx)     # imm = 0x2710
movq $0x1, 0x48(%rbx)
leaq 0x20(%rsp), %rax
movq %rax, 0x50(%rbx)
movq %rsp, %rax
movq %rax, 0x58(%rbx)
xorl %edi, %edi
callq 0x21e0
cltq
movl $0x0, 0x70(%rbx)
movb $0x5, 0x74(%rbx)
addq %rax, %rax
movabsq $0x7ffffffffffffffe, %rcx # imm = 0x7FFFFFFFFFFFFFFE
andq %rax, %rcx
movq %rcx, 0x68(%rbx)
movq 0x18(%rsp), %rax
movq %rax, 0x78(%rbx)
leaq 0x60(%rsp), %rdx
movq $0x0, -0x10(%rdx)
movl $0x1, -0x8(%rdx)
movl $0x1, %eax
movq %rax, (%rdx)
movq %rax, 0x8(%rdx)
leaq 0x50(%rsp), %rax
movq %rax, 0x60(%rbx)
leaq 0x70(%rsp), %rcx
movq %rbx, %rdi
movq %rcx, %rsi
callq 0x2150
leaq 0x70(%rsp), %rdi
callq 0x2120
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
xorpd %xmm0, %xmm0
cmpq %rcx, %rax
je 0x248a
addsd (%rax), %xmm0
addq $0x8, %rax
jmp 0x247b
movq 0x2b47(%rip), %rdi      # 0x4fd8
callq 0x2190
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20c0
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x24d6
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2110
xorl %eax, %eax
addq $0xf0, %rsp
popq %rbx
retq
jmp 0x24f4
jmp 0x24fc
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x2120
jmp 0x24ff
movq %rax, %rdi
callq 0x2a52
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x2515
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2110
movq %rbx, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/lagoproject[P]arti/analysis/analysis.cc
// Function: Open(char*)
int Open(char *nfi) {
  char tmpc[256];
  if (strncmp(nfi+strlen(nfi)-4,".bz2",4)==0) {
    if (iverbose)
      fprintf(stderr,"File '%s' ending by bz2, reading it via bzip2\n",nfi);
    snprintf(tmpc,256,"bzip2 -d -c %s",nfi);
    fi=popen(tmpc,"r");
  }
  else if((fi=fopen(nfi,"r")) == NULL) {
    if (iverbose)
      fprintf(stderr,"Can't open file '%s' - Switching to SDTIN\n",nfi);
    fi=stdin;
  }
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdi, %rbx
callq 0x1070
leaq (%rbx,%rax), %rdi
addq $-0x4, %rdi
leaq 0x21d6(%rip), %rsi      # 0x35f3
movl $0x4, %edx
callq 0x1080
testl %eax, %eax
je 0x145b
leaq 0x24c0(%rip), %rsi      # 0x38f2
movq %rbx, %rdi
callq 0x1120
movq %rax, 0x3d27(%rip)      # 0x5168
testq %rax, %rax
jne 0x1496
cmpl $0x0, 0x6847(%rip)      # 0x7c94
jne 0x14c3
movq 0x3b6a(%rip), %rax      # 0x4fc0
movq (%rax), %rax
jmp 0x148f
cmpl $0x0, 0x6832(%rip)      # 0x7c94
jne 0x14a6
leaq 0x1c20(%rip), %rdx      # 0x308b
movq %rsp, %r14
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x11c0
leaq 0x246b(%rip), %rsi      # 0x38f2
movq %r14, %rdi
callq 0x1060
movq %rax, 0x3cd2(%rip)      # 0x5168
movl $0x1, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
retq
movq 0x3b23(%rip), %rax      # 0x4fd0
movq (%rax), %rdi
leaq 0x1ba5(%rip), %rsi      # 0x305c
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1190
jmp 0x1464
movq 0x3b06(%rip), %rax      # 0x4fd0
movq (%rax), %rdi
leaq 0x1bc6(%rip), %rsi      # 0x309a
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1190
jmp 0x144f
// File: /workspace/github_cpp_makefile_star2_O3/lagoproject[P]arti/analysis/analysis.cc
// Function: curved(double, double)
void curved(double xp, double yp) {
	double d = r_earth + h;
	double t = sqrt(xp*xp + yp*yp)/d;
	double f = atan2(yp,xp);
	z = (d*cos(t) - r_earth)*cm2m;
	d *= sin(t);
	x = d*cos(f)*cm2m;
	y = d*sin(f)*cm2m;
}

// Assembly:
subq $0x18, %rsp
movsd 0x39eb(%rip), %xmm4     # 0x5140
addsd 0x656b(%rip), %xmm4     # 0x7cc8
movsd %xmm4, (%rsp)
movapd %xmm0, %xmm2
movapd %xmm1, %xmm0
mulsd %xmm1, %xmm0
movapd %xmm2, %xmm3
mulsd %xmm2, %xmm3
addsd %xmm0, %xmm3
xorps %xmm0, %xmm0
sqrtsd %xmm3, %xmm0
divsd %xmm4, %xmm0
movsd %xmm0, 0x8(%rsp)
movapd %xmm1, %xmm0
movapd %xmm2, %xmm1
callq 0x1040
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x11e0
mulsd (%rsp), %xmm0
subsd 0x398a(%rip), %xmm0     # 0x5140
mulsd 0x398a(%rip), %xmm0     # 0x5148
movsd %xmm0, 0x64fa(%rip)     # 0x7cc0
movsd 0x8(%rsp), %xmm0
callq 0x1050
mulsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x11e0
mulsd (%rsp), %xmm0
mulsd 0x3955(%rip), %xmm0     # 0x5148
movsd %xmm0, 0x64b5(%rip)     # 0x7cb0
movsd 0x10(%rsp), %xmm0
callq 0x1050
mulsd (%rsp), %xmm0
mulsd 0x3935(%rip), %xmm0     # 0x5148
movsd %xmm0, 0x649d(%rip)     # 0x7cb8
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/TheStanian[P]Args/Args/Args.cpp
// Function: ArgsHandler::ArgsHandler(ArgsHandler const&)
ArgsHandler::ArgsHandler(const ArgsHandler &args) {
	arguments = args.arguments;
	flags = args.flags;
	startargs = args.startargs;
	execpath = args.execpath;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
leaq 0x18(%rdi), %r14
leaq 0x20(%rdi), %rcx
movl %eax, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movq %rcx, 0x30(%rdi)
movq %rcx, 0x38(%rdi)
leaq 0x48(%rdi), %r15
leaq 0x60(%rdi), %r13
leaq 0x70(%rdi), %rbp
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x50(%rdi)
movq %rbp, 0x60(%rdi)
movq %rax, 0x68(%rdi)
movb %al, 0x70(%rdi)
leaq 0x80(%rdi), %rcx
movq %rcx, (%rsp)
leaq 0x88(%rdi), %rcx
movl %eax, 0x88(%rdi)
movq %rax, 0x90(%rdi)
movq %rcx, 0x98(%rdi)
movq %rcx, 0xa0(%rdi)
movq %rax, 0xa8(%rdi)
movb %al, 0xb0(%rdi)
callq 0x4a94
leaq 0x18(%r12), %rsi
movq %r14, %rdi
callq 0x4e52
leaq 0x48(%r12), %rsi
movq %r15, %rdi
callq 0x4c2a
addq $0x60, %r12
movq %r13, %rdi
movq %r12, %rsi
callq 0x20d0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movq (%rsp), %rdi
callq 0x2c7c
movq (%r13), %rdi
cmpq %rbp, %rdi
je 0x362d
movq (%rbp), %rsi
incq %rsi
callq 0x2180
movq %r15, %rdi
movq %rbx, %rsi
callq 0x22d5
movq %r14, %rdi
callq 0x2cfe
movq %rbx, %rdi
callq 0x2bce
movq %r12, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O3/TheStanian[P]Args/Args/Args.cpp
// Function: ArgsHandler::getFlagValueString(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::string ArgsHandler::getFlagValueString(std::string flag, std::string dflt) {
	if (hasFlag(flag)) {
		return flags.find(flag)->second.value;
	} else {
		return dflt;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0x5372
movq %r12, %rdi
movq %r13, %rsi
callq 0x3650
movl %eax, %ebp
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x36f3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
testb %bpl, %bpl
je 0x3723
addq $0x18, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x5f8e
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq 0x60(%rax), %rsi
movq 0x68(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x5372
jmp 0x3760
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%r14), %rdx
leaq 0x10(%r14), %rax
cmpq %rax, %rdx
je 0x3742
movq %rdx, (%rbx)
movq (%rax), %rcx
movq %rcx, 0x10(%rbx)
jmp 0x3748
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rbx)
movq %rax, (%r14)
movq $0x0, 0x8(%r14)
movb $0x0, 0x10(%r14)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3791
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
movq %rbx, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O3/TheStanian[P]Args/Args/Args.cpp
// Function: ArgsHandler::getFlagValueInt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
int ArgsHandler::getFlagValueInt(std::string flag, int dflt) {
	if (hasFlag(flag)) {
		std::string flgstr = flags.find(flag)->second.value;
		int ret = dflt;
		try {
			ret = std::stoi(flgstr);
		} catch (std::invalid_argument &e) {
			// ret is still dflt, so all good.
		}
		return ret;
	} else {
		return dflt;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x30(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0x5372
movq %r15, %rdi
movq %r12, %rsi
callq 0x3650
movl %eax, %ebp
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x37f4
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2180
testb %bpl, %bpl
je 0x3888
addq $0x18, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x5f8e
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x60(%rax), %rsi
movq 0x68(%rax), %rdx
addq %rsi, %rdx
movq %rsp, %r14
movq %r14, %rdi
callq 0x5372
movq (%r14), %r15
callq 0x2050
movq %rax, %r14
movl (%rax), %ebp
movl $0x0, (%rax)
leaq 0x40(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
movl $0xa, %edx
callq 0x21f0
cmpq %r15, (%r12)
je 0x3899
movslq %eax, %rcx
cmpq %rax, %rcx
jne 0x38a5
movl (%r14), %ecx
cmpl $0x22, %ecx
je 0x38a5
testl %ecx, %ecx
jne 0x3870
movl %ebp, (%r14)
movl %eax, %ebx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x3888
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2180
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3925(%rip), %rdi      # 0x71c5
callq 0x20e0
leaq 0x3919(%rip), %rdi      # 0x71c5
callq 0x2200
movq %rax, %r15
cmpl $0x0, (%r14)
jne 0x38bd
movl %ebp, (%r14)
cmpl $0x1, %edx
jne 0x38d4
movq %r15, %rdi
callq 0x20a0
callq 0x2270
jmp 0x3872
movq %rax, %r15
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x38fe
movq 0x10(%rsp), %rsi
jmp 0x38f6
movq %rax, %r15
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x38fe
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2180
movq %r15, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O3/TheStanian[P]Args/Args/Args.cpp
// Function: ArgsHandler::getFlagValueDouble(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double)
double ArgsHandler::getFlagValueDouble(std::string flag, double dflt) {
	if (hasFlag(flag)) {
		std::string flgstr = flags.find(flag)->second.value;
		double ret = dflt;
		try {
			ret = std::stod(flgstr);
		} catch (std::invalid_argument &e) {
			// ret is still dflt, so all good.
		}
		return ret;
	} else {
		return dflt;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movsd %xmm0, (%rsp)
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x5372
movq %r14, %rdi
movq %r15, %rsi
callq 0x3650
movl %eax, %ebp
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x3962
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2180
testb %bpl, %bpl
je 0x39fb
addq $0x18, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5f8e
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x60(%rax), %rsi
movq 0x68(%rax), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x5372
movq (%rbx), %rbx
callq 0x2050
movq %rax, %r14
movl (%rax), %ebp
movl $0x0, (%rax)
leaq 0x48(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2120
cmpq %rbx, (%r15)
je 0x3a0d
movl (%r14), %eax
testl %eax, %eax
je 0x39dc
cmpl $0x22, %eax
jne 0x39df
leaq 0x37f3(%rip), %rdi      # 0x71ca
callq 0x2200
movl %ebp, (%r14)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x3a00
movq 0x18(%rsp), %rsi
incq %rsi
movsd %xmm0, (%rsp)
callq 0x2180
movsd (%rsp), %xmm0
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x37b6(%rip), %rdi      # 0x71ca
callq 0x20e0
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x3a25
movl %ebp, (%r14)
cmpl $0x1, %edx
jne 0x3a41
movq %rbx, %rdi
callq 0x20a0
callq 0x2270
movsd (%rsp), %xmm0
jmp 0x39df
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x3a6c
movq 0x18(%rsp), %rsi
jmp 0x3a64
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x3a6c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2180
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O3/TheStanian[P]Args/Args/Args.cpp
// Function: ArgsHandler::getFlagValueBool(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
bool ArgsHandler::getFlagValueBool(std::string flag, bool dflt) {
	if (hasFlag(flag)) {
			std::string flgstr = flags.find(flag)->second.value;
			bool ret = dflt;
			if (flgstr == "true") {
				ret = true;
			} else if (flgstr == "false") {
				ret = false;
			}
			return ret;
		} else {
			return dflt;
		}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x5372
movq %r15, %rdi
movq %r12, %rsi
callq 0x3650
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x3ace
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
testb %bpl, %bpl
je 0x3b4b
addq $0x18, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x5f8e
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x60(%rax), %rsi
movq 0x68(%rax), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x5372
leaq 0x35f8(%rip), %rsi      # 0x7102
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0x3b32
leaq 0x35ea(%rip), %rsi      # 0x7107
leaq 0x28(%rsp), %rdi
callq 0x2080
testl %eax, %eax
setne %al
andb %bl, %al
movl %eax, %ebx
jmp 0x3b34
movb $0x1, %bl
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x3b4b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2180
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x3b76
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O3/TheStanian[P]Args/Args/Args.cpp
// Function: ArgsHandler::getFlagArguments(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::vector<std::string> ArgsHandler::getFlagArguments(std::string flag) {
	std::vector<std::string> flagArguments;
	if (!hasFlag(flag)) {
		return flagArguments;
	}

	for (int arg:(flags.find(flag)->second.arguments)) {
		flagArguments.push_back(arguments[arg]);
	}

	return flagArguments;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x5372
movq %rsp, %rsi
movq %r14, %rdi
callq 0x3650
movl %eax, %ebp
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x3c04
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2180
testb %bpl, %bpl
je 0x3c40
leaq 0x18(%r14), %rdi
movq %r15, %rsi
callq 0x5f8e
movq 0x80(%rax), %r15
movq 0x88(%rax), %r12
cmpq %r12, %r15
je 0x3c40
movslq (%r15), %rsi
shlq $0x5, %rsi
addq (%r14), %rsi
movq %rbx, %rdi
callq 0x49da
addq $0x4, %r15
jmp 0x3c23
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3c6f
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x3c72
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2180
jmp 0x3c72
jmp 0x3c6f
movq %rax, %r14
movq %rbx, %rdi
callq 0x2bce
movq %r14, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O3/TheStanian[P]Args/Args/Args.cpp
// Function: ArgsHandler::getStartArguments[abi:cxx11]() const
std::vector<std::string> ArgsHandler::getStartArguments() const {
	std::vector<std::string> startArguments;

	for (int arg:startargs) {
		startArguments.push_back(arguments[arg]);
	}

	return startArguments;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x48(%rsi), %r15
movq 0x50(%rsi), %r12
cmpq %r12, %r15
je 0x3cc6
movq %rsi, %r14
movslq (%r15), %rsi
shlq $0x5, %rsi
addq (%r14), %rsi
movq %rbx, %rdi
callq 0x49da
addq $0x4, %r15
cmpq %r12, %r15
jne 0x3cab
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2bce
movq %r14, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O3/TheStanian[P]Args/Args/Args.cpp
// Function: ArgsHandler::getFlags[abi:cxx11]() const
std::vector<std::string> ArgsHandler::getFlags() const {
	std::vector<std::string> strflags;
	for (auto pair:flags) {
		strflags.push_back(pair.first);
	}
	return strflags;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x30(%rsi), %r15
addq $0x20, %r14
cmpq %r14, %r15
je 0x3dc1
leaq 0x30(%rsp), %rbp
leaq 0x10(%rsp), %r13
movq %rsp, %r12
leaq 0x20(%r15), %rsi
movq %r12, %rdi
callq 0x4d98
movq %rbx, %rdi
movq %r12, %rsi
callq 0x49da
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x3d64
movq 0x70(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x3d80
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x2180
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x3d97
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2180
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x3dad
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2180
movq %r15, %rdi
callq 0x21c0
movq %rax, %r15
cmpq %r14, %rax
jne 0x3d36
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x3de3
movq %rax, %r14
movq %rsp, %rdi
callq 0x4dee
movq %rbx, %rdi
callq 0x2bce
movq %r14, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O3/TheStanian[P]Args/Args/Args.cpp
// Function: Flag::Flag(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Flag::Flag(std::string input) {
	if (input.find("=") != input.npos) {
	name = input.substr(0, input.find_first_of("="));
	value = input.substr(input.find_first_of("=")+1);
	} else {
		name = input;
		value = "";
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
leaq 0x20(%rdi), %r14
leaq 0x30(%rdi), %rbp
movq %rbp, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movb %al, 0x30(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movq %rax, 0x50(%rdi)
leaq 0x32c3(%rip), %rsi      # 0x7100
movl $0x1, %ecx
movq %r15, %rdi
xorl %edx, %edx
callq 0x2280
cmpq $-0x1, %rax
je 0x3efe
leaq 0x32a3(%rip), %rsi      # 0x7100
movl $0x1, %ecx
movq %r15, %rdi
xorl %edx, %edx
callq 0x2230
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x2190
leaq 0x8(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x21d0
movq (%r12), %rdi
leaq 0x18(%rsp), %r12
cmpq %r12, %rdi
je 0x3ea9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
leaq 0x3250(%rip), %rsi      # 0x7100
movl $0x1, %ecx
movq %r15, %rdi
xorl %edx, %edx
callq 0x2230
leaq 0x1(%rax), %rdx
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
movq $-0x1, %rcx
callq 0x2190
leaq 0x8(%rsp), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21d0
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x3f21
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
jmp 0x3f21
movq %rbx, %rdi
movq %r15, %rsi
callq 0x20d0
movq 0x28(%rbx), %rdx
leaq 0x3217(%rip), %rcx      # 0x712b
movq %r14, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x2250
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3f34
jmp 0x3f34
movq %rax, %r15
leaq 0x40(%rbx), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x3f4f
movq 0x50(%rbx), %rsi
subq %rdi, %rsi
callq 0x2180
movq (%r14), %rdi
cmpq %rbp, %rdi
je 0x3f63
movq (%rbp), %rsi
incq %rsi
callq 0x2180
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x3f77
movq (%r13), %rsi
incq %rsi
callq 0x2180
movq %r15, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O3/brianwu02[P]ImageProcessing/blur.cpp
// Function: main
int main(int argc, char** argv) {
    int xsz, ysz;
    imageP I1, I2, tmp_img;

    xsz = atoi(argv[2]);
    ysz = atoi(argv[3]);

    // bitwise operator to check if xsz & ysz are odd.
    if  (((xsz & 1 ) == 0) or ((ysz & 1) == 0)) {
        // xsz or ysz are even.
        cout << "xsz: " << xsz << endl;
        cout << "ysz: " << ysz << endl;
        cerr << "either xsz or ysz is not odd" << endl;
        exit(1);
    }


    I1 = IP_readImage(argv[1]);
    I2 = NEWIMAGE;
    tmp_img = NEWIMAGE;

    blur(I1, tmp_img, xsz, ysz, I2);

    cout << "done blurring" << endl;

    IP_saveImage(I2, argv[4]);

    IP_freeImage(I1);
    IP_freeImage(I2);
    IP_freeImage(tmp_img);

    cout << "done" << endl;
    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x10(%rsi), %rdi
callq 0x2180
movl %eax, %r14d
movq 0x18(%rbx), %rdi
callq 0x2180
movl %eax, %ebp
testb $0x1, %r14b
je 0x2444
movl %ebp, %eax
andl $0x1, %eax
je 0x2444
movq 0x8(%rbx), %rdi
callq 0x28ec
movq %rax, %r15
movl $0x10, %edi
callq 0x2140
movq %rax, %r12
movl $0x10, %edi
callq 0x2140
movq %rax, %r13
movq %r15, %rdi
movq %rax, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movq %r12, %r8
callq 0x24b3
movq 0x2c3a(%rip), %r14      # 0x4fd0
leaq 0xc90(%rip), %rsi       # 0x302d
movl $0xd, %edx
movq %r14, %rdi
callq 0x20f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x20c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2090
movq 0x20(%rbx), %rsi
movq %r12, %rdi
callq 0x2b12
movq %r15, %rdi
callq 0x2cc3
movq %r12, %rdi
callq 0x2cc3
movq %r13, %rdi
callq 0x2cc3
leaq 0xc3f(%rip), %rsi       # 0x303b
movl $0x4, %edx
movq %r14, %rdi
callq 0x20f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x20c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2090
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2b85(%rip), %rbx      # 0x4fd0
leaq 0xbb2(%rip), %rsi       # 0x3004
movq %rbx, %rdi
callq 0x20d0
movq %rax, %rdi
movl %r14d, %esi
callq 0x2190
movq %rax, %rdi
callq 0x2070
leaq 0xb96(%rip), %rsi       # 0x300a
movq %rbx, %rdi
callq 0x20d0
movq %rax, %rdi
movl %ebp, %esi
callq 0x2190
movq %rax, %rdi
callq 0x2070
movq 0x2b5b(%rip), %rdi      # 0x4ff0
leaq 0xb74(%rip), %rsi       # 0x3010
callq 0x20d0
movq %rax, %rdi
callq 0x2070
movl $0x1, %edi
callq 0x2110