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

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

		return res;
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x38(%rsi), %rax
cmpq 0x18(%rsi), %rax
je 0x19c61
cmpq 0x40(%rsi), %rax
jne 0x19c11
movq 0x50(%rsi), %rcx
movl $0x200, %eax            # imm = 0x200
addq -0x8(%rcx), %rax
movq -0x8(%rax), %rsi
movq (%rsi), %rax
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq *0x8(%rax)
leaq 0x304e(%rip), %rsi      # 0x1cc78
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0xd257
leaq 0x3023(%rip), %rdx      # 0x1cc61
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xd12a
leaq 0x8(%rsp), %rdi
callq 0x5388
leaq 0x28(%rsp), %rdi
callq 0x5388
jmp 0x19c75
leaq 0x2ffb(%rip), %rsi      # 0x1cc63
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x9da4
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5388
jmp 0x19c92
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x5388
movq %rbx, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O2/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 0x19f6f
movq (%rax), %rsi
movq (%rsi), %rax
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq *0x8(%rax)
leaq 0x2d66(%rip), %rsi      # 0x1cc9e
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0xd257
leaq 0x2d15(%rip), %rdx      # 0x1cc61
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xd12a
leaq 0x8(%rsp), %rdi
callq 0x5388
leaq 0x28(%rsp), %rdi
callq 0x5388
jmp 0x19f83
leaq 0x2d11(%rip), %rsi      # 0x1cc87
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x9da4
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5388
jmp 0x19fa0
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x5388
movq %rbx, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/src/../header/./object.hpp
// Function: Deque::inspect[abi:cxx11]()
std::string inspect()
	{
		if (elements.empty())
			return "deque<> {front: empty, back: empty}";

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

		return res;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
movq 0x18(%rsi), %rax
cmpq %rax, 0x38(%rsi)
je 0x1a0a5
movq %rsi, %r14
movq (%rax), %rsi
movq (%rsi), %rax
leaq 0x80(%rsp), %r15
movq %r15, %rdi
callq *0x8(%rax)
leaq 0x2cd0(%rip), %rsi      # 0x1ccd3
leaq 0x40(%rsp), %rdi
movq %r15, %rdx
callq 0xd257
leaq 0x2ccd(%rip), %rdx      # 0x1cce4
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xd12a
movq 0x38(%r14), %rax
cmpq 0x40(%r14), %rax
jne 0x1a03d
movq 0x50(%r14), %rcx
movl $0x200, %eax            # imm = 0x200
addq -0x8(%rcx), %rax
movq -0x8(%rax), %rsi
movq (%rsi), %rax
leaq 0x20(%rsp), %rdi
callq *0x8(%rax)
movq %rsp, %rdi
leaq 0x60(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0xd149
leaq 0x2bfc(%rip), %rdx      # 0x1cc61
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xd12a
movq %rsp, %rdi
callq 0x5388
leaq 0x20(%rsp), %rdi
callq 0x5388
leaq 0x60(%rsp), %rdi
callq 0x5388
leaq 0x40(%rsp), %rdi
callq 0x5388
leaq 0x80(%rsp), %rdi
callq 0x5388
jmp 0x1a0b7
leaq 0x2c03(%rip), %rsi      # 0x1ccaf
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x9da4
movq %rbx, %rax
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5388
jmp 0x1a0d7
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x5388
jmp 0x1a0e6
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x5388
jmp 0x1a0f5
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x5388
jmp 0x1a104
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x5388
movq %rbx, %rdi
callq 0x5330
nop
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/src/../header/./object.hpp
// Function: MaxHeap::inspect[abi:cxx11]()
std::string inspect()
	{
		TokenType tType = tokenType.substr(0, 3);
		transform(tType.begin(), tType.end(), tType.begin(), ::tolower);

		if (elements.empty())
			return "max_heap <" + tType + "> {top: empty}";

		std::string res = "max_heap <" + tType + "> {top: " + elements.top()->inspect() + "}";

		return res;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x8, %rsi
xorl %r12d, %r12d
leaq 0x20(%rsp), %r15
pushq $0x3
popq %rcx
movq %r15, %rdi
xorl %edx, %edx
callq 0x51f0
movq (%r15), %r13
movq 0x8(%r15), %r15
cmpq %r12, %r15
je 0x1a180
movsbl (%r13,%r12), %edi
callq 0x5290
movb %al, (%r13,%r12)
incq %r12
jmp 0x1a166
movq 0x28(%r14), %rax
cmpq 0x30(%r14), %rax
je 0x1a21c
leaq 0x208d(%rip), %rsi      # 0x1c222
leaq 0x60(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0xd1c2
leaq 0x2ad3(%rip), %rdx      # 0x1cc7e
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0xd12a
movq 0x28(%r14), %rax
movq (%rax), %rsi
movq (%rsi), %rax
leaq 0x40(%rsp), %rdi
callq *0x8(%rax)
movq %rsp, %rdi
leaq 0x80(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0xd149
leaq 0x2a76(%rip), %rdx      # 0x1cc61
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xd12a
movq %rsp, %rdi
callq 0x5388
leaq 0x40(%rsp), %rdi
callq 0x5388
leaq 0x80(%rsp), %rdi
callq 0x5388
leaq 0x60(%rsp), %rdi
jmp 0x1a245
leaq 0x1fff(%rip), %rsi      # 0x1c222
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0xd1c2
leaq 0x2a32(%rip), %rdx      # 0x1cc69
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xd12a
movq %rsp, %rdi
callq 0x5388
leaq 0x20(%rsp), %rdi
callq 0x5388
movq %rbx, %rax
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
jmp 0x1a2a8
jmp 0x1a2af
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5388
jmp 0x1a282
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x5388
jmp 0x1a291
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x5388
jmp 0x1a2a3
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x5388
jmp 0x1a2b2
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x5388
movq %rbx, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/src/../header/./object.hpp
// Function: MinHeap::inspect[abi:cxx11]()
std::string inspect()
	{
		TokenType tType = tokenType.substr(0, 3);
		transform(tType.begin(), tType.end(), tType.begin(), ::tolower);

		if (elements.empty())
			return "min_heap <" + tType + "> {top: empty}";

		std::string res = "min_heap <" + tType + "> {top: " + elements.top()->inspect() + "}";

		return res;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x8, %rsi
xorl %r12d, %r12d
leaq 0x20(%rsp), %r15
pushq $0x3
popq %rcx
movq %r15, %rdi
xorl %edx, %edx
callq 0x51f0
movq (%r15), %r13
movq 0x8(%r15), %r15
cmpq %r12, %r15
je 0x1a32a
movsbl (%r13,%r12), %edi
callq 0x5290
movb %al, (%r13,%r12)
incq %r12
jmp 0x1a310
movq 0x28(%r14), %rax
cmpq 0x30(%r14), %rax
je 0x1a3c6
leaq 0x1ef3(%rip), %rsi      # 0x1c232
leaq 0x60(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0xd1c2
leaq 0x2929(%rip), %rdx      # 0x1cc7e
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0xd12a
movq 0x28(%r14), %rax
movq (%rax), %rsi
movq (%rsi), %rax
leaq 0x40(%rsp), %rdi
callq *0x8(%rax)
movq %rsp, %rdi
leaq 0x80(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0xd149
leaq 0x28cc(%rip), %rdx      # 0x1cc61
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xd12a
movq %rsp, %rdi
callq 0x5388
leaq 0x40(%rsp), %rdi
callq 0x5388
leaq 0x80(%rsp), %rdi
callq 0x5388
leaq 0x60(%rsp), %rdi
jmp 0x1a3ef
leaq 0x1e65(%rip), %rsi      # 0x1c232
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0xd1c2
leaq 0x2888(%rip), %rdx      # 0x1cc69
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xd12a
movq %rsp, %rdi
callq 0x5388
leaq 0x20(%rsp), %rdi
callq 0x5388
movq %rbx, %rax
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
jmp 0x1a452
jmp 0x1a459
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5388
jmp 0x1a42c
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x5388
jmp 0x1a43b
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x5388
jmp 0x1a44d
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x5388
jmp 0x1a45c
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x5388
movq %rbx, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq (%rsi), %rax
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq *(%rax)
leaq 0x12a8c(%rip), %rsi     # 0x2d158
movq %r15, %rdi
callq 0xa7b4
movl %eax, %ebp
movq %r15, %rdi
callq 0x5388
testb %bpl, %bpl
je 0x1a6ef
movl 0x8(%r14), %eax
cmpl 0x8(%rbx), %eax
setl %al
jmp 0x1a732
movq (%r14), %rax
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq *(%rax)
leaq 0x12a92(%rip), %rsi     # 0x2d198
movq %r15, %rdi
callq 0xa7b4
movl %eax, %ebp
movq %r15, %rdi
callq 0x5388
movb $0x1, %al
testb %bpl, %bpl
je 0x1a732
addq $0x8, %r14
addq $0x8, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1a73d
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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)
leaq 0x12950(%rip), %rsi     # 0x2d158
movq %r15, %rdi
callq 0xa7b4
movl %eax, %ebp
movq %r15, %rdi
callq 0x5388
addq $0x8, %r14
testb %bpl, %bpl
je 0x1a82e
movl (%r14), %eax
cmpl 0x8(%rbx), %eax
setg %al
jmp 0x1a83d
addq $0x8, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1a848
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/fabianp[P]ProxASAGA/proxasaga_atomic.cpp
// Function: partial_gradient(double, double)
double inline partial_gradient(double p, double b) {
    // partial gradient of logistic loss
    double phi, exp_t;
    p = p * b;
    if (p > 0)
        phi = 1. / (1. + exp(-p));
    else {
        exp_t = exp(p);
        phi = exp_t / (1. + exp_t);
    }
    return (phi - 1) * b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movsd %xmm1, -0x8(%rbp)
mulsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x3fb9
xorpd 0x105a(%rip), %xmm0     # 0x5000
callq 0x3400
movapd %xmm0, %xmm1
movsd 0x1069(%rip), %xmm0     # 0x5020
jmp 0x3fc2
callq 0x3400
movapd %xmm0, %xmm1
addsd 0x1056(%rip), %xmm1     # 0x5020
divsd %xmm1, %xmm0
addsd 0x1052(%rip), %xmm0     # 0x5028
mulsd -0x8(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %r15
cmpl $0x18, %esi
jb 0x27e78
movq %rdx, %r14
xorl %eax, %eax
cmpl $0x100, %ebx            # imm = 0x100
setae %al
cmpl $0x10000, %ebx          # imm = 0x10000
pushq $0x2
popq %r12
cmovbl %eax, %r12d
leal 0x18(%r12), %eax
movzbl %al, %esi
movq %r15, %rdi
callq 0x16516
pushq $0x1
popq %rdx
movl %r12d, %ecx
shll %cl, %edx
movq %r15, %rdi
movl %ebx, %esi
movq %r14, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x27e91
movzbl %bl, %esi
movq %r15, %rdi
callq 0x16516
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/common/bio/io.hxx
// Function: std::enable_if<std::is_integral<char16_t>::value && sizeof (char16_t) == 2, bool>::type cxon::bio::imp::put_<char16_t, std::__cxx11::basic_string<unsigned char, std::char_traits<unsigned char>, std::allocator<unsigned char>>>(std::__cxx11::basic_string<unsigned char, std::char_traits<unsigned char>, std::allocator<unsigned char>>&, char16_t, unsigned int)
inline auto put_(O& o, T t, unsigned n)
                -> enable_if_t<std::is_integral<T>::value && sizeof(T) == 2, bool>
            {
                byte bs[sizeof(T)];
                    switch (n) {
                        default:    CXON_ASSERT(0, "unexpected");   // LCOV_EXCL_LINE
                                    return false;                   // LCOV_EXCL_LINE
                        case 2:     bs[n - 2] = byte(t >>  8); CXON_FALLTHROUGH;
                        case 1:     bs[n - 1] = byte(t >>  0);
                    }
                return poke_(o, bs, n);
            }

// Assembly:
pushq %rax
movl %esi, %eax
cmpl $0x1, %edx
je 0x292d2
cmpl $0x2, %edx
jne 0x292e9
movb %ah, 0x6(%rsp)
leal -0x1(%rdx), %ecx
movb %al, 0x6(%rsp,%rcx)
movl %edx, %edx
leaq 0x6(%rsp), %rsi
callq 0x167d8
movb $0x1, %al
jmp 0x292eb
xorl %eax, %eax
popq %rcx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/cbor/compound.hxx
// Function: std::enable_if<std::is_assignable<decltype(*fp), decltype(*fp0)>::value, bool>::type cxon::cbor::imp::read_pointer_<cxon::CBOR<cxon::cbor::format_traits>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*&, unsigned char const*&, unsigned char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>&)
inline auto read_pointer_(T*& t, II& i, II e, Cx& cx)
                -> enable_if_t< std::is_assignable<decltype(*t), decltype(*i)>::value, bool>
            {
                typename X::tag_type tag;
                if (!tag::read<X>(tag, i, e, cx))
                    return false;
                switch (bio::peek(i, e) & X::mjr) {
                    case X::bstr: case X::tstr: case X::arr: {
                                auto c = cxon::cnt::make_pointer_container<X, T>(cx);
                                return cbor::cnt::read_array<X>(c, tag, i, e, cx) && (c.push_back({}), t = c.release());
                    }
                    default:    return read_pointer_t_<X>(t, i, e, cx);
                }
            }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x48(%rsp), %rdi
callq 0x14382
testb %al, %al
je 0xbbba4
movq (%r12), %rax
cmpq %r15, %rax
je 0xbbba8
movzbl (%rax), %eax
andl $-0x20, %eax
cmpl $0x40, %eax
je 0xbbb40
cmpl $0x80, %eax
je 0xbbb40
cmpl $0x60, %eax
jne 0xbbba8
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0xbbbfd
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0xbbe41
testb %al, %al
je 0xbbbbd
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xbbc18
leaq 0x8(%rsp), %rdi
callq 0xbbc40
movq %rax, (%rbx)
testq %rax, %rax
setne %bl
leaq 0x28(%rsp), %rdi
callq 0x6110
jmp 0xbbbbf
xorl %ebx, %ebx
jmp 0xbbbc9
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0xbbc77
movl %eax, %ebx
jmp 0xbbbc9
xorl %ebx, %ebx
leaq 0x8(%rsp), %rdi
callq 0xbbc58
movl %ebx, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x6110
jmp 0xbbbeb
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xbbc58
movq %rbx, %rdi
callq 0x63d0
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/cbor/compound.hxx
// Function: bool cxon::cbor::imp::read_pointer_t_<cxon::CBOR<cxon::cbor::format_traits>, boost::container::basic_string<char, std::char_traits<char>, void>, unsigned char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>>(boost::container::basic_string<char, std::char_traits<char>, void>*&, unsigned char const*&, unsigned char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>&)
inline bool read_pointer_t_(T*& t, II& i, II e, Cx& cx) {
                if (bio::peek(i, e) == X::nil)
                    return bio::get(i, e), t = nullptr, true;
                auto al = alc::make_context_allocator<T>(cx);
                T *const v = al.create();
                    if (!v || !read_value<X>(*v, i, e, cx))
                        return al.release(v), false;
                return t = v, true;
            }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rax
cmpq %rdx, %rax
je 0x2a994
cmpb $-0xa, (%rax)
jne 0x2a994
incq %rax
movq %rax, (%r15)
andq $0x0, (%rbx)
jmp 0x2a9be
leaq 0xf(%rsp), %rdi
callq 0x2b25c
movq %rax, %r13
testq %rax, %rax
je 0x2a9c2
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x25b60
testb %al, %al
je 0x2a9c2
movq %r13, (%rbx)
movb $0x1, %al
jmp 0x2a9d1
leaq 0xf(%rsp), %rdi
movq %r13, %rsi
callq 0x2b27a
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/common/container.hxx
// Function: cxon::cnt::pointer_container<(anonymous namespace)::Struct3, cxon::alc::basic_allocator<(anonymous namespace)::Struct3, 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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x84e52
movq %rax, %r14
shlq $0x4, %r15
leaq (%rax,%r15), %r12
testq %r15, %r15
je 0x84db4
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
addq $0x10, %rax
addq $-0x10, %r15
jmp 0x84d9d
movq 0x8(%rbx), %rdi
movq 0x18(%rbx), %rax
subq %rdi, %rax
sarq $0x4, %rax
xorl %ecx, %ecx
testq %rax, %rax
jle 0x84de1
leaq (%rdi,%rcx), %rdx
leaq (%r14,%rcx), %rsi
movups (%rdx), %xmm0
movups %xmm0, (%rsi)
decq %rax
addq $0x10, %rcx
jmp 0x84dc5
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
sarq $0x4, %rsi
callq 0x84e18
movq 0x18(%rbx), %rax
subq 0x8(%rbx), %rax
movq %r14, %rcx
addq %rax, %rcx
movq %rcx, 0x18(%rbx)
movq %r12, 0x10(%rbx)
movq %r14, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
callq 0xbbdd6
testq %rax, %rax
je 0xbbd9a
shlq $0x5, %rbx
movq %rax, %rcx
testq %rbx, %rbx
je 0xbbd9a
leaq 0x10(%rcx), %rdx
movq %rdx, (%rcx)
andq $0x0, 0x8(%rcx)
movb $0x0, 0x10(%rcx)
addq $0x20, %rcx
addq $-0x20, %rbx
jmp 0xbbd7b
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/common/allocator.hxx
// Function: cxon::alc::basic_allocator<(anonymous namespace)::Struct3, std::allocator<char>>::release((anonymous namespace)::Struct3*, 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 %rdi, %rdi
je 0x84e50
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
shlq $0x4, %r14
xorl %r15d, %r15d
cmpq %r15, %r14
je 0x84e43
leaq (%rbx,%r15), %rdi
callq 0x847fa
addq $0x10, %r15
jmp 0x84e2f
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x6240
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/cbor/lib/boost/dynamic_bitset.hxx
// Function: bool cxon::cbor::imp::write_bitset_<cxon::CBOR<cxon::cbor::format_traits>, std::__cxx11::basic_string<unsigned char, std::char_traits<unsigned char>, std::allocator<unsigned char>>, 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>>&, boost::dynamic_bitset<unsigned char, std::allocator<unsigned char>> const&, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>&)
inline bool write_bitset_(O& o, const boost::dynamic_bitset<B, A>& t, Cx& cx) {
                auto const N = t.size() / 8 + (t.size() % 8 ? 1 : 0);
                if (!cbor::cnt::write_size<X>(o, X::bstr, N + 1, cx))
                    return false;
                if (!bio::poke<X>(o, bio::byte(N * 8 - t.size()), cx))
                    return false;
                bio::byte b = 0;
                for (std::size_t i = t.size(); i != 0; --i) {
                    b |= t[i - 1] << ((i - 1) % 8);
                    if ((i - 1) % 8 == 0) {
                        if (!bio::poke<X>(o, b, cx))
                            return false;
                        b = 0;
                    }
                }
                return true;
            }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rcx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %rax
movq %rax, %r15
shrq $0x3, %r15
andl $0x7, %eax
cmpq $0x1, %rax
sbbq $-0x1, %r15
leaq 0x1(%r15), %rdx
pushq $0x40
popq %rsi
callq 0x16451
movl %eax, %ebp
testb %al, %al
je 0x77c7c
shll $0x3, %r15d
subl 0x18(%rbx), %r15d
movzbl %r15b, %esi
movq %r14, %rdi
callq 0x16516
movq 0x18(%rbx), %r15
decq %r15
xorl %eax, %eax
cmpq $-0x1, %r15
je 0x77c7c
movq %r15, %rcx
shrq $0x3, %rcx
movq (%rbx), %rdx
movzbl (%rdx,%rcx), %edx
movl %r15d, %ecx
andl $0x7, %ecx
btl %ecx, %edx
setb %dl
shlb %cl, %dl
orb %al, %dl
testq %rcx, %rcx
jne 0x77c75
movzbl %dl, %esi
movq %r14, %rdi
callq 0x16516
xorl %edx, %edx
decq %r15
movl %edx, %eax
jmp 0x77c3f
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/cxon.hxx
// Function: cxon::to_bytes_result<unsigned char*> cxon::interface::to_bytes<cxon::CBOR<cxon::cbor::format_traits>, boost::dynamic_bitset<unsigned char, std::allocator<unsigned char>>, unsigned char*>(unsigned char*, unsigned char*, boost::dynamic_bitset<unsigned char, std::allocator<unsigned char>> const&)
inline auto to_bytes(FI b, FI e, const T& t, NaPa&&... p) -> to_bytes_result<FI> {
                auto cx = make_context<X>(std::forward<NaPa>(p)...);
                    auto c = cnt::make_range_container(b, e);
                    bool const r = write_value<X>(c, t, cx); CXON_ASSERT(!r != !cx.ec, "result discrepant");
                return { cx.ec, c.end() };
            }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x20(%rsp), %r13
andl $0x0, (%r13)
callq 0x6130
movq %rax, 0x8(%r13)
leaq 0x8(%rsp), %rbp
movq %r15, (%rbp)
movq %r14, 0x8(%rbp)
movq %r15, 0x10(%rbp)
movq %rbp, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x77cfa
movups (%r13), %xmm0
movups %xmm0, (%r12)
movq 0x10(%rbp), %rax
movq %rax, 0x10(%r12)
movq %r12, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x993f9
cmpl $0xa0, %esi
jne 0x99415
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x99116
testb %al, %al
je 0x99415
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x99116
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/cbor/common/sink.hxx
// Function: bool cxon::cbor::sink_write<cxon::CBOR<cxon::cbor::format_traits>, cxon::cnt::range_container<unsigned char*>, cxon::cbor::sink<std::__cxx11::basic_string<unsigned char, std::char_traits<unsigned char>, std::allocator<unsigned char>>>, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>>(cxon::cnt::range_container<unsigned char*>&, cxon::cbor::sink<std::__cxx11::basic_string<unsigned char, std::char_traits<unsigned char>, std::allocator<unsigned char>>> const&, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>&)
inline bool sink_write(O& o, const S& s, Cx& cx) {
            for (auto e : s.value) 
                if (!bio::poke<X>(o, e, cx))
                    return false;
            return true;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movq (%rsi), %r12
movq 0x8(%rsi), %r15
xorl %ecx, %ecx
movq %rcx, %r13
cmpq %rcx, %r15
je 0x99a10
movzbl (%r12,%r13), %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x77e59
leaq 0x1(%r13), %rcx
testb %al, %al
jne 0x999f0
cmpq %r13, %r15
sete %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/common/bio/io.hxx
// Function: bool cxon::bio::imp::put_<std::__cxx11::basic_string<unsigned char, std::char_traits<unsigned char>, std::allocator<unsigned char>>>(std::__cxx11::basic_string<unsigned char, std::char_traits<unsigned char>, std::allocator<unsigned char>>&, float)
inline bool put_(O& o, float t) {
                union { unsigned long i; float f; } u; u.f = t;
                byte bs[sizeof(float)];
                    bs[0] = byte(u.i >> 24), bs[1] = byte(u.i >> 16),
                    bs[2] = byte(u.i >>  8), bs[3] = byte(u.i >>  0);
                return poke_(o, bs, sizeof(bs));
            }

// Assembly:
pushq %rax
movd %xmm0, %eax
bswapl %eax
leaq 0x4(%rsp), %rsi
movl %eax, (%rsi)
pushq $0x4
popq %rdx
callq 0x167d8
movb $0x1, %al
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1382e
movq %rax, %rbx
movq 0x18(%rax), %r14
addq $0x8, %rbx
movq 0x83ca2(%rip), %r15     # 0x129f78
cmpq %rbx, %r14
je 0xa6341
movq 0x40(%r14), %r12
movq 0x48(%r14), %r13
cmpq %r13, %r12
je 0xa62f7
movq (%r12), %rdi
movq (%rdi), %rax
callq *(%rax)
addq $0x8, %r12
jmp 0xa62e3
movq (%r15), %r12
movq 0x20(%r14), %r13
movq %r13, %rdi
callq 0x137ca
movl 0x1c(%rax), %ebp
movq 0x20(%r14), %rdi
callq 0x137ca
movl 0x18(%rax), %r8d
movq %r12, %rdi
leaq 0x2ec04(%rip), %rsi     # 0xd4f24
movq %r13, %rdx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x6320
movq (%r15), %rdi
callq 0x62b0
movq %r14, %rdi
callq 0x6190
movq %rax, %r14
jmp 0xa62d6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa7700
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/cbor/lib/std/bitset.hxx
// Function: bool cxon::cbor::imp::write_bitset_<cxon::CBOR<cxon::cbor::format_traits>, cxon::cnt::range_container<unsigned char*>, 256ul, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>>(cxon::cnt::range_container<unsigned char*>&, std::bitset<256ul> const&, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>&)
inline bool write_bitset_(O& o, const std::bitset<N>& t, Cx& cx) {
                auto const M = N / 8 + (N % 8 ? 1 : 0);
                if (!cbor::cnt::write_size<X>(o, X::bstr, M + 1, cx))
                    return false;
                if (!bio::poke<X>(o, bio::byte(M * 8 - N), cx))
                    return false;
                bio::byte b = 0;
                for (std::size_t i = N; i != 0; --i) {
                    b |= t[i - 1] << ((i - 1) % 8);
                    if ((i - 1) % 8 == 0) {
                        if (!bio::poke<X>(o, b, cx))
                            return false;
                        b = 0;
                    }
                }
                return true;
            }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x40
popq %rsi
pushq $0x21
popq %rdx
movq %rbx, %rcx
callq 0x77dae
xorl %ebp, %ebp
testb %al, %al
je 0xc043b
movq %r15, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x77e59
testb %al, %al
je 0xc043b
movl $0xff, %r12d
xorl %eax, %eax
cmpq $-0x1, %r12
sete %bpl
je 0xc043b
movq %r12, %rcx
shrq $0x6, %rcx
movq (%r14,%rcx,8), %rcx
btq %r12, %rcx
setb %dl
movl %r12d, %ecx
andl $0x7, %ecx
shlb %cl, %dl
orb %al, %dl
testq %rcx, %rcx
jne 0xc0434
movzbl %dl, %esi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x77e59
testb %al, %al
je 0xc043b
xorl %edx, %edx
decq %r12
movl %edx, %eax
jmp 0xc03f5
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq (%rsi), %rax
cmpq %rdx, %rax
je 0xbd4fb
movb (%rax), %al
andb $-0x20, %al
cmpb $0x40, %al
jne 0xbd4fb
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
pushq $0x2
popq %rdi
movq %rbx, %rcx
callq 0x782d9
testb %al, %al
je 0xbd511
movq (%r14), %rax
cmpq %r12, %rax
je 0xbd4fb
cmpb $0x7, (%rax)
jne 0xbd51f
leaq 0x1(%rax), %rcx
movq %rcx, (%r14)
cmpq %r12, %rcx
je 0xbd4fb
movzbl 0x1(%rax), %ecx
andl $0x1, %ecx
orq %rcx, (%r15)
addq $0x2, %rax
movq %rax, (%r14)
movb $0x1, %al
jmp 0xbd513
pushq $0x1
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1445e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
pushq $0x6
jmp 0xbd4fd
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x7746e
testb %al, %al
je 0xc0da3
pushq $0x2
popq %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x782d9
testb %al, %al
je 0xc0da3
leaq 0x4(%rsp), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0xa5e3c
testb %al, %al
je 0xc0da3
movq %rsp, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0xa5e3c
testb %al, %al
je 0xc0da3
movss 0x4(%rsp), %xmm0
movss %xmm0, (%rbx)
movss (%rsp), %xmm0
movss %xmm0, 0x4(%rbx)
movb $0x1, %al
jmp 0xc0da5
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lib/std/forward_list.hxx
// Function: int& cxon::cnt::traits<std::forward_list<int, std::allocator<int>>>::emplace<>(std::forward_list<int, std::allocator<int>>&)
static auto emplace(std::forward_list<T, R...>& c, A&&... as) -> typename std::forward_list<T, R...>::reference {
#                   if __cplusplus < 201703L
                        return c.emplace_front(std::forward<A>(as)...), c.front();
#                   else
                        return c.emplace_front(std::forward<A>(as)...);
#                   endif
                }

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xc4e7e
movq (%rbx), %rax
addq $0x8, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x28(%rsp), %rdi
callq 0xca000
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0xca000
leaq 0x28(%rsp), %rbx
leaq 0x8(%rsp), %r14
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rdx
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rsi
cmpq %rdx, %rax
je 0xc9750
cmpq %rsi, %rcx
je 0xc9750
movl (%rax), %eax
cmpl (%rcx), %eax
jne 0xc975e
movq %rbx, %rdi
callq 0xc9fe8
movq %r14, %rdi
callq 0xc9fe8
jmp 0xc971a
xorq %rsi, %rcx
xorq %rdx, %rax
orq %rcx, %rax
sete %bl
jmp 0xc9760
xorl %ebx, %ebx
leaq 0x8(%rsp), %rdi
callq 0xca04e
leaq 0x28(%rsp), %rdi
callq 0xca04e
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
jmp 0xc9790
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xca04e
leaq 0x28(%rsp), %rdi
callq 0xca04e
movq %rbx, %rdi
callq 0x63d0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x7746e
testb %al, %al
je 0xcb5c6
pushq $0x2
popq %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x782d9
testb %al, %al
je 0xcb5c6
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x15b92
testb %al, %al
je 0xcb5c6
addq $0x4, %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa5e3c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/cbor/lib/std/valarray.hxx
// Function: cxon::cbor::imp::valarray_container_<int>::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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsp, %rdi
callq 0xcfd3e
movq (%rbx), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rdi
testq %rcx, %rcx
movq %rdi, %rsi
cmoveq %rcx, %rsi
leaq (%rdi,%rcx,4), %rdx
cmoveq %rcx, %rdx
subq %rsi, %rdx
je 0xcfd1a
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xcfd0b
movq 0x8(%rsp), %rdi
callq 0x6390
movq (%rbx), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rdi
movq (%rsp), %rdx
movq %rdx, (%rax)
movq %rcx, (%rsp)
movq 0x8(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq %rdi, 0x8(%rsp)
callq 0x6240
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xf8, %rsp
xorpd %xmm0, %xmm0
movapd %xmm0, 0x40(%rsp)
movapd %xmm0, 0x30(%rsp)
andq $0x0, 0x50(%rsp)
leaq 0x18(%rsp), %r14
leaq 0x78(%rsp), %rdx
movl $0x2710, %esi           # imm = 0x2710
movq %r14, %rdi
callq 0x2928
movq 0x8(%r14), %r12
subq (%r14), %r12
leaq 0x78(%rsp), %rdi
pushq $0x1
popq %rbx
movq %rbx, %rsi
callq 0x2a8e
shrq $0x3, %r12
testl %r12d, %r12d
jle 0x242c
leaq 0x10(%rsp), %rdi
andq $0x0, (%rdi)
movl $0x80, %esi
callq 0x2040
movq %rax, %r15
xorpd %xmm0, %xmm0
movupd %xmm0, 0x28(%rax)
andq $0x0, 0x38(%rax)
movupd %xmm0, 0x18(%rax)
movupd %xmm0, 0x8(%rax)
leaq 0x2978(%rip), %rax      # 0x4d38
movq %rax, (%r15)
movl %r12d, 0x40(%r15)
andl $0x0, 0x44(%r15)
movq $0x1, 0x48(%r15)
leaq 0x30(%rsp), %rax
movq %rax, 0x50(%r15)
movq %r14, 0x58(%r15)
movq %r15, %rdi
addq $0x68, %rdi
leaq 0xf(%rsp), %rsi
callq 0x2ac2
movq 0x10(%rsp), %rax
movq %rax, 0x78(%r15)
leaq 0x68(%rsp), %rdx
andq $0x0, -0x10(%rdx)
movl $0x1, -0x8(%rdx)
movq %rbx, (%rdx)
movq %rbx, 0x8(%rdx)
leaq 0x58(%rsp), %rax
movq %rax, 0x60(%r15)
leaq 0x78(%rsp), %rcx
movq %r15, %rdi
movq %rcx, %rsi
callq 0x2150
leaq 0x78(%rsp), %rdi
callq 0x2a9a
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
xorpd %xmm0, %xmm0
cmpq %rcx, %rax
je 0x2453
addsd (%rax), %xmm0
addq $0x8, %rax
jmp 0x2444
movq 0x2b7e(%rip), %rdi      # 0x4fd8
callq 0x2190
movq %rax, %rdi
callq 0x2090
leaq 0x18(%rsp), %rdi
callq 0x29a6
xorl %eax, %eax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x2493
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x2a9a
jmp 0x2496
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x29a6
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1060
leaq (%rbx,%rax), %rdi
addq $-0x4, %rdi
leaq 0x22f6(%rip), %rsi      # 0x35f3
pushq $0x4
popq %rdx
callq 0x1070
testl %eax, %eax
je 0x1339
leaq 0x25e2(%rip), %rsi      # 0x38f2
movq %rbx, %rdi
callq 0x10e0
movq %rax, 0x4e29(%rip)      # 0x6148
testq %rax, %rax
jne 0x1374
cmpl $0x0, 0x7949(%rip)      # 0x8c74
jne 0x139f
movq 0x4c8c(%rip), %rax      # 0x5fc0
movq (%rax), %rax
jmp 0x136d
cmpl $0x0, 0x7934(%rip)      # 0x8c74
jne 0x1382
leaq 0x1d42(%rip), %rdx      # 0x308b
movq %rsp, %r14
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x1170
leaq 0x258d(%rip), %rsi      # 0x38f2
movq %r14, %rdi
callq 0x1050
movq %rax, 0x4dd4(%rip)      # 0x6148
pushq $0x1
popq %rax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
retq
movq 0x4c47(%rip), %rax      # 0x5fd0
movq (%rax), %rdi
leaq 0x1cc9(%rip), %rsi      # 0x305c
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1140
jmp 0x1342
movq 0x4c2a(%rip), %rax      # 0x5fd0
movq (%rax), %rdi
leaq 0x1cea(%rip), %rsi      # 0x309a
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1140
jmp 0x132d
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4b5e(%rip), %xmm4     # 0x6120
addsd 0x76de(%rip), %xmm4     # 0x8ca8
movsd %xmm4, (%rsp)
movapd %xmm0, %xmm2
movapd %xmm1, %xmm0
mulsd %xmm1, %xmm0
movapd %xmm2, %xmm3
mulsd %xmm2, %xmm3
addsd %xmm0, %xmm3
sqrtsd %xmm3, %xmm0
divsd %xmm4, %xmm0
movsd %xmm0, 0x8(%rsp)
movapd %xmm1, %xmm0
movapd %xmm2, %xmm1
callq 0x1030
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x1190
mulsd (%rsp), %xmm0
subsd 0x4b00(%rip), %xmm0     # 0x6120
mulsd 0x4b00(%rip), %xmm0     # 0x6128
movsd %xmm0, 0x7670(%rip)     # 0x8ca0
movsd 0x8(%rsp), %xmm0
callq 0x1040
mulsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x1190
mulsd (%rsp), %xmm0
mulsd 0x4acb(%rip), %xmm0     # 0x6128
movsd %xmm0, 0x762b(%rip)     # 0x8c90
movsd 0x10(%rsp), %xmm0
callq 0x1040
mulsd (%rsp), %xmm0
mulsd 0x4aab(%rip), %xmm0     # 0x6128
movsd %xmm0, 0x7613(%rip)     # 0x8c98
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movups %xmm0, (%rdi)
andl $0x0, 0x20(%rdi)
movq %rsi, %r12
andq $0x0, 0x28(%rdi)
leaq 0x18(%rdi), %r14
leaq 0x20(%rdi), %rax
movq %rax, 0x30(%rdi)
movq %rax, 0x38(%rdi)
leaq 0x70(%rdi), %rax
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x50(%rdi)
movq %rax, 0x60(%rdi)
andq $0x0, 0x68(%rdi)
xorl %eax, %eax
movb %al, 0x70(%rdi)
andl $0x0, 0x88(%rdi)
leaq 0x48(%rdi), %r15
andq $0x0, 0x90(%rdi)
leaq 0x60(%rdi), %r13
leaq 0x88(%rdi), %rcx
movq %rcx, 0x98(%rdi)
movq %rcx, 0xa0(%rdi)
andq $0x0, 0xa8(%rdi)
movb %al, 0xb0(%rdi)
callq 0x3caa
leaq 0x18(%r12), %rsi
movq %r14, %rdi
callq 0x3f2c
leaq 0x48(%r12), %rsi
movq %r15, %rdi
callq 0x3d74
addq $0x60, %r12
movq %r13, %rdi
movq %r12, %rsi
callq 0x20f0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r12
leaq 0x80(%rbx), %rdi
callq 0x288e
movq %r13, %rdi
callq 0x20b0
movq %r15, %rdi
callq 0x28fe
movq %r14, %rdi
callq 0x2932
movq %rbx, %rdi
callq 0x2838
movq %r12, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/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, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %rdx, %rsi
callq 0x2200
movq %r12, %rdi
movq %r13, %rsi
callq 0x3032
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x20b0
testb %bpl, %bpl
je 0x30d5
addq $0x18, %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x518c
leaq 0x60(%rax), %rsi
movq %rbx, %rdi
callq 0x2200
jmp 0x30e0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x21e0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x2260
nop