LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/pranavmodx[P]modlang/src/evaluator.cpp
// Function: Evaluator::evalMaxHeapLiteral(MaxHeapLiteral*, Environment*)
Object *Evaluator::evalMaxHeapLiteral(MaxHeapLiteral *maxHeapLiteral, Environment *env)
{
	MaxHeap *maxHeap = new MaxHeap(maxHeapLiteral->type);

	for (auto elem : maxHeapLiteral->elements)
	{
		Object *obj = Eval(elem, env);

		if (obj->type() == ERROR_OBJ)
		{
			delete maxHeap;
			return obj;
		}

		maxHeap->elements.push(obj);
	}

	return maxHeap;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, 0x20(%rsp)
movq %rsi, %r13
movq %rdi, %r15
movl $0x48, %edi
callq 0x51b0
movq %rax, %rbx
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x48(%r13), %rsi
movq 0x50(%r13), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0xbde8
leaq 0x124fe(%rip), %rax     # 0x34d38
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rbp
movq %rbp, 0x8(%rbx)
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
addq %rsi, %rdx
movq %rdi, 0x18(%rsp)
callq 0xbde8
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movq $0x0, 0x38(%rbx)
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x22886
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x51c0
movq 0x68(%r13), %r12
movq 0x70(%r13), %r13
cmpq %r13, %r12
je 0x22990
movq %rbx, %rax
addq $0x28, %rax
movq %rax, 0x10(%rsp)
movq (%r12), %rsi
movq %r15, %rdi
movq 0x20(%rsp), %rdx
callq 0x1ef50
movq %rax, (%rsp)
movq (%rax), %rcx
leaq 0x48(%rsp), %rdi
movq %rax, %rsi
callq *(%rcx)
movq 0x50(%rsp), %rdx
cmpq 0x15a67(%rip), %rdx     # 0x38338
jne 0x228f1
testq %rdx, %rdx
je 0x228f6
movq 0x15a51(%rip), %rsi     # 0x38330
movq 0x48(%rsp), %rdi
callq 0x51d0
testl %eax, %eax
sete %r14b
jmp 0x228f9
xorl %r14d, %r14d
jmp 0x228f9
movb $0x1, %r14b
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x22915
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x51c0
testb %r14b, %r14b
je 0x2296a
leaq 0x12417(%rip), %rax     # 0x34d38
movq %rax, (%rbx)
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x22939
movq 0x38(%rbx), %rsi
subq %rdi, %rsi
callq 0x51c0
movq 0x18(%rsp), %rax
movq (%rax), %rdi
cmpq %rbp, %rdi
je 0x22952
movq (%rbp), %rsi
incq %rsi
callq 0x51c0
movl $0x48, %esi
movq %rbx, %rdi
callq 0x51c0
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x22977
movq 0x10(%rsp), %rdi
movq %rsp, %rsi
callq 0x243da
testb %r14b, %r14b
jne 0x2298b
addq $0x8, %r12
cmpq %r13, %r12
jne 0x228a3
jmp 0x22990
movq 0x8(%rsp), %rbx
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x229c1
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x51c0
jmp 0x229c1
movq %rax, %r14
movl $0x48, %esi
movq %rbx, %rdi
callq 0x51c0
movq %r14, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O1/pranavmodx[P]modlang/src/evaluator.cpp
// Function: Evaluator::evalMinHeapLiteral(MinHeapLiteral*, Environment*)
Object *Evaluator::evalMinHeapLiteral(MinHeapLiteral *minHeapLiteral, Environment *env)
{
	MinHeap *minHeap = new MinHeap(minHeapLiteral->type);

	for (auto elem : minHeapLiteral->elements)
	{
		Object *obj = Eval(elem, env);

		if (obj->type() == ERROR_OBJ)
		{
			delete minHeap;
			return obj;
		}

		minHeap->elements.push(obj);
	}

	return minHeap;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, 0x20(%rsp)
movq %rsi, %r13
movq %rdi, %r15
movl $0x48, %edi
callq 0x51b0
movq %rax, %rbx
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x48(%r13), %rsi
movq 0x50(%r13), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0xbde8
leaq 0x1234e(%rip), %rax     # 0x34d70
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rbp
movq %rbp, 0x8(%rbx)
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
addq %rsi, %rdx
movq %rdi, 0x18(%rsp)
callq 0xbde8
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movq $0x0, 0x38(%rbx)
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x22a6e
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x51c0
movq 0x68(%r13), %r12
movq 0x70(%r13), %r13
cmpq %r13, %r12
je 0x22b78
movq %rbx, %rax
addq $0x28, %rax
movq %rax, 0x10(%rsp)
movq (%r12), %rsi
movq %r15, %rdi
movq 0x20(%rsp), %rdx
callq 0x1ef50
movq %rax, (%rsp)
movq (%rax), %rcx
leaq 0x48(%rsp), %rdi
movq %rax, %rsi
callq *(%rcx)
movq 0x50(%rsp), %rdx
cmpq 0x1587f(%rip), %rdx     # 0x38338
jne 0x22ad9
testq %rdx, %rdx
je 0x22ade
movq 0x15869(%rip), %rsi     # 0x38330
movq 0x48(%rsp), %rdi
callq 0x51d0
testl %eax, %eax
sete %r14b
jmp 0x22ae1
xorl %r14d, %r14d
jmp 0x22ae1
movb $0x1, %r14b
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x22afd
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x51c0
testb %r14b, %r14b
je 0x22b52
leaq 0x12267(%rip), %rax     # 0x34d70
movq %rax, (%rbx)
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x22b21
movq 0x38(%rbx), %rsi
subq %rdi, %rsi
callq 0x51c0
movq 0x18(%rsp), %rax
movq (%rax), %rdi
cmpq %rbp, %rdi
je 0x22b3a
movq (%rbp), %rsi
incq %rsi
callq 0x51c0
movl $0x48, %esi
movq %rbx, %rdi
callq 0x51c0
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x22b5f
movq 0x10(%rsp), %rdi
movq %rsp, %rsi
callq 0x2447c
testb %r14b, %r14b
jne 0x22b73
addq $0x8, %r12
cmpq %r13, %r12
jne 0x22a8b
jmp 0x22b78
movq 0x8(%rsp), %rbx
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x22ba9
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x51c0
jmp 0x22ba9
movq %rax, %r14
movl $0x48, %esi
movq %rbx, %rdi
callq 0x51c0
movq %r14, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O1/pranavmodx[P]modlang/src/evaluator.cpp
// Function: Evaluator::evalBangPrefixExpression(Object*)
Object *Evaluator::evalBangPrefixExpression(Object *right)
{
	if (right == __TRUE)
		return __FALSE;

	else if (right == __FALSE)
		return __TRUE;
	else if (right == __NULL)
		return __TRUE;

	else if (right->type() == INTEGER_OBJ)
	{
		if (((Integer *)right)->value == 0)
			return __TRUE;
		else
			return __FALSE;
	}

	return __FALSE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
leaq 0x14927(%rip), %r15     # 0x374f8
movq (%r15), %rax
leaq 0x14925(%rip), %r12     # 0x37500
movq (%r12), %rcx
cmpq %rsi, %rax
je 0x22c30
movq %rsi, %rbx
cmpq %rsi, %rcx
je 0x22c66
leaq 0x148fd(%rip), %rcx     # 0x374f0
cmpq %rbx, (%rcx)
je 0x22c66
movq (%rbx), %rax
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq *(%rax)
movq 0x8(%r14), %rdx
cmpq 0x15547(%rip), %rdx     # 0x38158
jne 0x22c35
testq %rdx, %rdx
je 0x22c39
movq 0x15531(%rip), %rsi     # 0x38150
movq (%rsp), %rdi
callq 0x51d0
testl %eax, %eax
sete %bpl
jmp 0x22c3c
movq %rcx, %rax
jmp 0x22c66
xorl %ebp, %ebp
jmp 0x22c3c
movb $0x1, %bpl
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x22c57
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x51c0
testb %bpl, %bpl
je 0x22c62
cmpl $0x0, 0x8(%rbx)
je 0x22c73
movq (%r12), %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%r15), %rax
jmp 0x22c66
// File: /workspace/github_cpp_makefile_star2_O1/pranavmodx[P]modlang/src/evaluator.cpp
// Function: Evaluator::extendFunctionEnv(Function*, std::vector<Object*, std::allocator<Object*>>&, Environment*)
Environment *Evaluator::extendFunctionEnv(Function *fn, std::vector<Object *> &args, Environment *outer)
{
	Environment *env = outer->NewEnclosed();

	for (int i = 0; i < args.size(); i++)
		env->Set(fn->parameters[i]->value, args[i]);

	return env;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rcx, %rdi
callq 0x192e6
movq %rax, %r15
movq 0x8(%rbx), %rax
cmpq (%rbx), %rax
je 0x23aac
leaq 0x18(%rsp), %r13
xorl %ebp, %ebp
leaq 0x8(%rsp), %r12
movq 0x8(%r14), %rax
movq (%rax,%rbp,8), %rax
movq %r13, 0x8(%rsp)
movq 0x48(%rax), %rsi
movq 0x50(%rax), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0xbde8
movq (%rbx), %rax
movq (%rax,%rbp,8), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x1945a
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x23a99
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x51c0
incq %rbp
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x3, %rax
cmpq %rbp, %rax
ja 0x23a50
movq %r15, %rax
addq $0x28, %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 0x23ad8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x51c0
movq %rbx, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O1/pranavmodx[P]modlang/src/evaluator.cpp
// Function: Evaluator::evalArrayIndexExpression(Array*, Integer*)
Object *Evaluator::evalArrayIndexExpression(Array *array, Integer *index)
{
	int i = index->value;
	auto arr = array->elements;

	if (arr.size() <= i)
		return new Error("error: index " + index->inspect() + " out of range");

	return arr[i];
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r14
movslq 0x8(%rdx), %r15
addq $0x8, %rsi
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
callq 0x24822
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r15, %rcx
jbe 0x23df7
movq (%rax,%r15,8), %rbx
jmp 0x23f3c
movl $0x28, %edi
callq 0x51b0
movq %rax, %rbx
movq (%r14), %rax
leaq 0x58(%rsp), %rdi
movq %r14, %rsi
callq *0x8(%rax)
leaq 0x5db8(%rip), %rcx      # 0x29bd1
leaq 0x58(%rsp), %rdi
movl $0xd, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x51f0
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x23e54
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
jmp 0x23e5b
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
leaq 0x20(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x571d(%rip), %rsi      # 0x2959b
callq 0x5360
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x23eaa
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x23eb2
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x10bc7(%rip), %rax     # 0x34a98
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
movq %rbx, %rax
addq $0x18, %rax
movq %rax, 0x8(%rbx)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
callq 0xbde8
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x23f0a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x51c0
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x23f21
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x51c0
leaq 0x68(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x23f3c
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x51c0
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x23f53
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x51c0
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x23f80
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x51c0
jmp 0x23f80
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x23f9c
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x51c0
jmp 0x23f9c
movq %rax, %r14
leaq 0x68(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x23fbc
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x51c0
jmp 0x23fbc
movq %rax, %r14
movl $0x28, %esi
movq %rbx, %rdi
callq 0x51c0
jmp 0x23fce
movq %rax, %r14
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x23fe5
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x51c0
movq %r14, %rdi
callq 0x5330
nop
// File: /workspace/github_cpp_makefile_star2_O1/pranavmodx[P]modlang/src/../header/./object.hpp
// Function: Array::inspect[abi:cxx11]()
std::string inspect()
	{
		std::string res = "[";

		for (auto elem : elements)
			res += elem->inspect() + ", ";

		if (elements.size() != 0)
		{
			res.pop_back();
			res.pop_back();
		}

		res.push_back(']');

		return res;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x8(%rsp)
movq %rax, (%rdi)
leaq 0x3913(%rip), %rsi      # 0x29188
leaq 0x390d(%rip), %rdx      # 0x29189
callq 0xbe78
movq 0x8(%r14), %r13
movq %r14, 0x30(%rsp)
movq 0x10(%r14), %rbp
cmpq %rbp, %r13
je 0x25954
leaq 0x20(%rsp), %r14
leaq 0x38(%rsp), %r15
leaq 0x3909(%rip), %r12      # 0x291b1
movq (%r13), %rsi
movq (%rsi), %rax
movq %r15, %rdi
callq *0x8(%rax)
movq %r15, %rdi
movq %r12, %rsi
callq 0x5360
movq %r14, 0x10(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x258e3
movq %rdx, 0x10(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x20(%rsp)
jmp 0x258ea
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rdx, 0x18(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0x50b0
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x2592b
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x51c0
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x25947
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x51c0
addq $0x8, %r13
cmpq %rbp, %r13
jne 0x258a8
movq 0x30(%rsp), %rcx
movq 0x10(%rcx), %rax
cmpq 0x8(%rcx), %rax
je 0x25973
movq %rbx, %rdi
callq 0x5220
movq %rbx, %rdi
callq 0x5220
movq %rbx, %rdi
movl $0x5d, %esi
callq 0x5180
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x25994
movq %rax, %r15
jmp 0x259d4
movq %rax, %r15
jmp 0x259b8
movq %rax, %r15
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x259b8
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x51c0
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x259d4
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x51c0
movq (%rbx), %rdi
cmpq 0x8(%rsp), %rdi
je 0x259ee
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x51c0
movq %r15, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O1/pranavmodx[P]modlang/src/../header/./object.hpp
// Function: HashSet::inspect[abi:cxx11]()
std::string inspect()
	{
		std::string res = "hashset<> {";

		for (auto pair : pairs)
			res += pair.second->inspect() + ", ";

		if (pairs.size() != 0)
		{
			res.pop_back();
			res.pop_back();
		}

		res.push_back('}');

		return res;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
leaq 0x3353(%rip), %rsi      # 0x291b8
leaq 0x3357(%rip), %rdx      # 0x291c3
callq 0xbe78
movq %r14, 0x28(%rsp)
movq 0x18(%r14), %rbp
testq %rbp, %rbp
je 0x25f93
leaq 0x18(%rsp), %r14
leaq 0x50(%rsp), %r15
leaq 0x30(%rsp), %r12
leaq 0x3318(%rip), %r13      # 0x291b1
leaq 0x8(%rbp), %rsi
movq %r15, %rdi
callq 0x24fd8
movq 0x90(%rsp), %rsi
movq (%rsi), %rax
movq %r12, %rdi
callq *0x8(%rax)
movq %r12, %rdi
movq %r13, %rsi
callq 0x5360
movq %r14, 0x8(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x25ee4
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x25eeb
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x50b0
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x25f2c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x51c0
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x25f48
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x51c0
movq 0x70(%rsp), %rdi
leaq 0x80(%rsp), %rax
cmpq %rax, %rdi
je 0x25f6a
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x51c0
movq 0x50(%rsp), %rdi
leaq 0x60(%rsp), %rax
cmpq %rax, %rdi
je 0x25f86
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x51c0
movq (%rbp), %rbp
testq %rbp, %rbp
jne 0x25e99
movq 0x28(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x25faf
movq %rbx, %rdi
callq 0x5220
movq %rbx, %rdi
callq 0x5220
movq %rbx, %rdi
movl $0x7d, %esi
callq 0x5180
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x25fd3
movq %rax, %r15
jmp 0x26022
movq %rax, %r15
jmp 0x26018
movq %rax, %r15
jmp 0x25ffc
movq %rax, %r15
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x25ffc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x51c0
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x26018
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x51c0
leaq 0x50(%rsp), %rdi
callq 0x2470a
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x2603a
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x51c0
movq %r15, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O1/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 0x260e1
cmpq 0x40(%rsi), %rax
jne 0x2608f
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 0x3b84(%rip), %rcx      # 0x29c2c
movl $0xe, %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 0x26103
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x2610a
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x3b28(%rip), %rsi      # 0x29c17
leaq 0x3b35(%rip), %rdx      # 0x29c2b
movq %rbx, %rdi
callq 0xbe78
jmp 0x261a3
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 0x3ae8(%rip), %rsi      # 0x29c15
callq 0x5360
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x26154
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x2615a
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 0x26188
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x51c0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x261a3
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 0x261cd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x51c0
jmp 0x261cd
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x261e8
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x51c0
movq %rbx, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2645d
movq (%rax), %rsi
movq (%rsi), %rax
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq *0x8(%rax)
leaq 0x382e(%rip), %rcx      # 0x29c52
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 0x2647f
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x26486
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x37d0(%rip), %rsi      # 0x29c3b
leaq 0x37df(%rip), %rdx      # 0x29c51
movq %rbx, %rdi
callq 0xbe78
jmp 0x2651f
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 0x376c(%rip), %rsi      # 0x29c15
callq 0x5360
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x264d0
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x264d6
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 0x26504
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x51c0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2651f
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 0x26549
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x51c0
jmp 0x26549
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x26564
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x51c0
movq %rbx, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O1/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 0x10f56(%rip), %rdx     # 0x38158
jne 0x27221
testq %rdx, %rdx
je 0x27225
movq 0x10f40(%rip), %rsi     # 0x38150
movq (%rsp), %rdi
callq 0x51d0
testl %eax, %eax
sete %bpl
jmp 0x27228
xorl %ebp, %ebp
jmp 0x27228
movb $0x1, %bpl
leaq 0x10(%rsp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x27244
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x51c0
testb %bpl, %bpl
je 0x27255
movl 0x8(%r14), %eax
cmpl 0x8(%rbx), %eax
setl %al
jmp 0x272c7
movq (%r14), %rax
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq *(%rax)
movq 0x8(%r15), %rdx
cmpq 0x10f2a(%rip), %rdx     # 0x38198
jne 0x2728d
testq %rdx, %rdx
je 0x27291
movq 0x10f14(%rip), %rsi     # 0x38190
movq (%rsp), %rdi
callq 0x51d0
testl %eax, %eax
sete %bpl
jmp 0x27294
xorl %ebp, %ebp
jmp 0x27294
movb $0x1, %bpl
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x272aa
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x51c0
movb $0x1, %al
testb %bpl, %bpl
je 0x272c7
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 0xbc77
// File: /workspace/github_cpp_makefile_star2_O1/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 0x10e54(%rip), %rdx     # 0x38158
jne 0x27324
testq %rdx, %rdx
je 0x27328
movq 0x10e3e(%rip), %rsi     # 0x38150
movq 0x8(%rsp), %rdi
callq 0x51d0
testl %eax, %eax
sete %bpl
jmp 0x2732b
xorl %ebp, %ebp
jmp 0x2732b
movb $0x1, %bpl
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x27346
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x51c0
addq $0x8, %r14
testb %bpl, %bpl
je 0x27357
movl (%r14), %eax
cmpl 0x8(%rbx), %eax
jmp 0x27368
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 0xbc77
// File: /workspace/github_cpp_makefile_star2_O1/oknenavin[P]cxon/test/../src/cxon/lang/cbor/common/container.hxx
// Function: bool cxon::cbor::cnt::imp::read_array_b_<cxon::CBOR<cxon::cbor::format_traits>, cxon::cnt::range_container<signed char*>, unsigned char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>>(cxon::cnt::range_container<signed char*>&, unsigned char, unsigned char const*&, unsigned char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>&)
inline bool read_array_b_(T& t, bio::byte m, II& i, II e, Cx& cx) {
                switch (m & X::mnr) {
                    case 0x1C: case 0x1D: case 0x1E:    return cx/cbor::read_error::size_invalid;
                    case 0x1F:                          return read_array_b_var_<X>(t, i, e, cx);
                    default:                            return read_array_b_fix_<X>(t, i, e, cx);
                }
            }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
andl $0x1f, %esi
leal -0x1c(%rsi), %eax
cmpl $0x3, %eax
jae 0x99d63
callq 0x31a3a
movl $0x6, (%rbx)
movq %rax, 0x8(%rbx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
cmpl $0x1f, %esi
jne 0x99d90
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x99ff4
movq 0x8(%r12), %rbp
movq 0x10(%r12), %r13
movq (%r15), %rax
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x31ea6
testb %al, %al
je 0x99dca
subq %r13, %rbp
movq 0x10(%rsp), %rcx
movb $0x1, %al
cmpq %rbp, %rcx
ja 0x99dd9
jmp 0x99df2
callq 0x31a3a
movl $0x6, (%rbx)
movq %rax, 0x8(%rbx)
movq 0x8(%rsp), %rax
movq %rax, (%r15)
callq 0x31a3a
movl $0x6, (%rbx)
movq %rax, 0x8(%rbx)
xorl %eax, %eax
testb %al, %al
je 0x99d52
movq 0x8(%r12), %rdi
movq 0x10(%r12), %rax
movq (%r15), %rdx
subq %rdx, %r14
cmpq %rcx, %r14
movq %rcx, %rsi
cmovbq %r14, %rsi
subq %rax, %rdi
cmpq %rdi, %rsi
jg 0x99e4f
testq %rsi, %rsi
jle 0x99e3c
leaq 0x1(%rsi), %rdi
xorl %r8d, %r8d
movb (%rdx,%r8), %r9b
movb %r9b, (%rax,%r8)
decq %rdi
incq %r8
cmpq $0x1, %rdi
jg 0x99e28
addq %rsi, 0x10(%r12)
addq %rsi, (%r15)
movb $0x1, %al
cmpq %rcx, %r14
jae 0x99d54
callq 0x31a3a
movl $0x1, (%rbx)
jmp 0x99d4e
// File: /workspace/github_cpp_makefile_star2_O1/oknenavin[P]cxon/test/../src/cxon/lang/cbor/common/container.hxx
// Function: bool cxon::cbor::cnt::imp::read_array_b_var_<cxon::CBOR<cxon::cbor::format_traits>, cxon::cnt::range_container<signed char*>, unsigned char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>>(cxon::cnt::range_container<signed char*>&, unsigned char const*&, unsigned char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>&)
inline bool read_array_b_var_(T& t, II& i, II e, Cx& cx) {
                bio::byte const m = bio::get(i, e) & X::mjr;
                    for (auto b = bio::peek(i, e, 0); b != X::brk; b = bio::peek(i, e, 0)) {
                        if (m != (b & X::mjr))
                            return cx/cbor::read_error::array_invalid;
                        if (!read_array_b_fix_<X>(t, i, e, cx))
                            return false;
                    }
                return bio::get(i, e, 0), true;
            }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rsi, %rbx
movq %rdi, %r12
movq (%rsi), %rax
cmpq %rdx, %rax
je 0x9a022
leaq 0x1(%rax), %rcx
movq %rcx, (%rbx)
movb (%rax), %al
movb %al, 0x6(%rsp)
jmp 0x9a027
movb $-0x1, 0x6(%rsp)
movq (%rbx), %rax
cmpq %rdx, %rax
je 0x9a033
movb (%rax), %al
jmp 0x9a035
xorl %eax, %eax
cmpb $-0x1, %al
sete %cl
je 0x9a148
movq %rdx, 0x8(%rsp)
movb %cl, 0x7(%rsp)
xorb 0x6(%rsp), %al
cmpb $0x1f, %al
ja 0x9a12b
movq 0x8(%r12), %r13
movq 0x10(%r12), %r15
movq (%rbx), %rbp
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rcx
callq 0x31ea6
testb %al, %al
je 0x9a087
subq %r15, %r13
movq 0x10(%rsp), %rax
movb $0x1, %cl
cmpq %r13, %rax
ja 0x9a097
jmp 0x9a0ac
callq 0x31a3a
movl $0x6, (%r14)
movq %rax, 0x8(%r14)
movq %rbp, (%rbx)
callq 0x31a3a
movl $0x6, (%r14)
movq %rax, 0x8(%r14)
xorl %ecx, %ecx
testb %cl, %cl
je 0x9a13c
movq 0x8(%r12), %r8
movq (%rbx), %r11
movq 0x8(%rsp), %rdx
movq %rdx, %rcx
subq %r11, %rcx
cmpq %rax, %rcx
movq %rax, %rsi
cmovbq %rcx, %rsi
movq 0x10(%r12), %rdi
subq %rdi, %r8
movl $0x1, %ebp
cmpq %r8, %rsi
jg 0x9a130
testq %rsi, %rsi
jle 0x9a103
leaq 0x1(%rsi), %r8
xorl %r9d, %r9d
movb (%r11,%r9), %r10b
movb %r10b, (%rdi,%r9)
decq %r8
incq %r9
cmpq $0x1, %r8
jg 0x9a0ef
addq %rsi, 0x10(%r12)
addq %rsi, (%rbx)
cmpq %rax, %rcx
jb 0x9a130
movq (%rbx), %rax
cmpq %rdx, %rax
je 0x9a11c
movb (%rax), %al
jmp 0x9a11e
xorl %eax, %eax
cmpb $-0x1, %al
sete %cl
jne 0x9a045
jmp 0x9a148
movl $0x7, %ebp
callq 0x31a3a
movl %ebp, (%r14)
movq %rax, 0x8(%r14)
testb $0x1, 0x7(%rsp)
movq 0x8(%rsp), %rdx
je 0x9a15a
movq (%rbx), %rcx
movb $0x1, %al
cmpq %rdx, %rcx
je 0x9a15c
incq %rcx
movq %rcx, (%rbx)
jmp 0x9a15c
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x401f9
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 0x32ffa
movl $0x1, %eax
movl %r15d, %ecx
shll %cl, %eax
cmpl $0x1, %eax
je 0x401e1
cmpl $0x2, %eax
je 0x401da
cmpl $0x4, %eax
jne 0x40212
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 0x33212
jmp 0x40204
movzbl %bl, %esi
movq %r12, %rdi
callq 0x32ffa
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x33176
movl $0x1, (%r14)
movq %rax, 0x8(%r14)
xorl %eax, %eax
jmp 0x40206
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8c494
movq %rax, %r14
movq %r15, %r12
shlq $0x4, %r12
addq %rax, %r12
testq %r15, %r15
je 0x8c3f2
movq %r14, %rax
movl $0x0, (%rax)
movq $0x0, 0x8(%rax)
addq $0x10, %rax
cmpq %r12, %rax
jne 0x8c3db
movq 0x8(%rbx), %rdi
movq 0x18(%rbx), %rax
subq %rdi, %rax
sarq $0x4, %rax
testq %rax, %rax
jle 0x8c421
incq %rax
xorl %ecx, %ecx
movups (%rdi,%rcx), %xmm0
movups %xmm0, (%r14,%rcx)
decq %rax
addq $0x10, %rcx
cmpq $0x1, %rax
jg 0x8c40b
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
sarq $0x4, %rsi
callq 0x8c458
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_O1/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 0xcb774
testq %rax, %rax
je 0xcb729
testq %rbx, %rbx
je 0xcb729
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 0xcb710
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xcb772
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
testq %rdx, %rdx
je 0xcb765
shlq $0x5, %r14
addq %rbx, %r14
movq %rbx, %r15
movq (%r15), %rdi
addq $0x10, %r15
cmpq %r15, %rdi
je 0xcb75c
callq 0x5200
addq $0x10, %r15
cmpq %r14, %r15
jne 0xcb74b
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x5200
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9ff4f
cmpl $0xa0, %esi
jne 0x9ff6b
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x9fbba
testb %al, %al
je 0x9ff6b
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x9fbba
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x30f96
movq %rax, %rbx
movq 0x18(%rax), %r14
addq $0x8, %rbx
cmpq %rbx, %r14
je 0xaf2a4
movq 0x67d35(%rip), %r15     # 0x116f70
movq 0x40(%r14), %r12
movq 0x48(%r14), %r13
cmpq %r13, %r12
je 0xaf257
movq (%r12), %rdi
movq (%rdi), %rax
callq *(%rax)
addq $0x8, %r12
jmp 0xaf243
movq (%r15), %r12
movq 0x20(%r14), %r13
movq %r13, %rdi
callq 0x30f20
movl 0x1c(%rax), %ebp
movq 0x20(%r14), %rdi
callq 0x30f20
movl 0x18(%rax), %r8d
movq %r12, %rdi
leaq 0x2dc90(%rip), %rsi     # 0xdcf10
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 0xaf23b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb051c
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq (%rsi), %r13
cmpq %rdx, %r13
je 0xcbef7
movb (%r13), %al
andb $-0x20, %al
cmpb $0x40, %al
jne 0xcbef7
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movq %rsp, %rdi
movq %rbx, %rcx
callq 0x31ea6
movl %eax, %ebp
testb %al, %al
jne 0xcbebc
callq 0x31a3a
movl $0x6, (%rbx)
movq %rax, 0x8(%rbx)
cmpq $0x2, (%rsp)
sete %al
testb %al, %bpl
je 0xcbf04
movq (%r14), %rax
cmpq %r12, %rax
je 0xcbef7
cmpb $0x7, (%rax)
jne 0xcbf07
leaq 0x1(%rax), %rcx
movq %rcx, (%r14)
cmpq %r12, %rcx
je 0xcbef7
movzbl 0x1(%rax), %ecx
andl $0x1, %ecx
orq %rcx, (%r15)
addq $0x2, %rax
movq %rax, (%r14)
movb $0x1, %al
jmp 0xcbf18
callq 0x31a3a
movl $0x1, (%rbx)
jmp 0xcbf12
movq %r13, (%r14)
callq 0x31a3a
movl $0x6, (%rbx)
movq %rax, 0x8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq (%rsi), %rax
cmpq %rdx, %rax
je 0xcdb66
movb (%rax), %cl
jmp 0xcdb68
movb $-0x1, %cl
movl %ecx, %edx
andb $-0x20, %dl
cmpb $-0x40, %dl
jne 0xcdb8f
andb $0x1f, %cl
cmpb $0x18, %cl
jae 0xcdc36
movl $0x1, %edx
cmpq %r15, %rax
je 0xcdb8f
addq %rdx, %rax
movq %rax, (%r12)
movq (%r12), %r13
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x31ea6
movl %eax, %ebp
testb %al, %al
jne 0xcdbbb
callq 0x31a3a
movl $0x6, (%rbx)
movq %rax, 0x8(%rbx)
cmpq $0x2, 0x8(%rsp)
sete %al
testb %al, %bpl
je 0xcdc12
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0xaef6a
testb %al, %al
je 0xcdc25
leaq 0x14(%rsp), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0xaef6a
testb %al, %al
je 0xcdc25
movss 0x8(%rsp), %xmm0
movss %xmm0, (%r14)
movss 0x14(%rsp), %xmm0
movss %xmm0, 0x4(%r14)
movb $0x1, %al
jmp 0xcdc27
movq %r13, (%r12)
callq 0x31a3a
movl $0x6, (%rbx)
movq %rax, 0x8(%rbx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movzbl %cl, %edx
addl $-0x18, %edx
cmpl $0x4, %edx
jae 0xcdc69
addb $-0x18, %cl
movl $0x1, %edx
shll %cl, %edx
incl %edx
movq %r15, %rcx
subq %rax, %rcx
cmpq %rdx, %rcx
jae 0xcdb88
callq 0x31a3a
movl $0x1, (%rbx)
jmp 0xcdc21
callq 0x31a3a
movl $0x8, (%rbx)
jmp 0xcdc21
// File: /workspace/github_cpp_makefile_star2_O1/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 0xd4e9c
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0xd4e9c
leaq 0x28(%rsp), %rbx
leaq 0x8(%rsp), %r14
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rcx
cmpq %rcx, %rax
je 0xd4612
movq 0x8(%rsp), %rdx
cmpq 0x10(%rsp), %rdx
je 0xd4609
movl (%rax), %eax
cmpl (%rdx), %eax
jne 0xd460e
movq %rbx, %rdi
callq 0xd4e64
movq %r14, %rdi
callq 0xd4e64
jmp 0xd45d6
cmpq %rcx, %rax
je 0xd4612
xorl %ebx, %ebx
jmp 0xd461f
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
sete %bl
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xd462e
callq 0x5200
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0xd463d
callq 0x5200
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
jmp 0xd465e
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xd465e
callq 0x5200
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0xd466d
callq 0x5200
movq %rbx, %rdi
callq 0x5370
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq (%rsi), %rax
cmpq %rdx, %rax
je 0xd5cd1
movb (%rax), %cl
jmp 0xd5cd3
movb $-0x1, %cl
movl %ecx, %edx
andb $-0x20, %dl
cmpb $-0x40, %dl
jne 0xd5cf9
andb $0x1f, %cl
cmpb $0x18, %cl
jae 0xd5d7e
movl $0x1, %edx
cmpq %r14, %rax
je 0xd5cf9
addq %rdx, %rax
movq %rax, (%r15)
movq (%r15), %r13
movq %rsp, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x31ea6
movl %eax, %ebp
testb %al, %al
jne 0xd5d22
callq 0x31a3a
movl $0x6, (%rbx)
movq %rax, 0x8(%rbx)
cmpq $0x2, (%rsp)
sete %al
testb %al, %bpl
je 0xd5d5b
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x32944
testb %al, %al
je 0xd5d6d
addq $0x4, %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xaef6a
jmp 0xd5d6f
movq %r13, (%r15)
callq 0x31a3a
movl $0x6, (%rbx)
movq %rax, 0x8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movzbl %cl, %edx
addl $-0x18, %edx
cmpl $0x4, %edx
jae 0xd5db1
addb $-0x18, %cl
movl $0x1, %edx
shll %cl, %edx
incl %edx
movq %r14, %rcx
subq %rax, %rcx
cmpq %rdx, %rcx
jae 0xd5cf3
callq 0x31a3a
movl $0x1, (%rbx)
jmp 0xd5d69
callq 0x31a3a
movl $0x8, (%rbx)
jmp 0xd5d69
// File: /workspace/github_cpp_makefile_star2_O1/oknenavin[P]cxon/test/../src/cxon/lang/cbor/common/container.hxx
// Function: std::enable_if<!std::is_assignable<decltype(*std::begin(fp)), decltype(*fp0)>::value, bool>::type cxon::cbor::cnt::imp::read_array_<cxon::CBOR<cxon::cbor::format_traits>, std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, int>>>, unsigned char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>>(std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, int>>>&, unsigned char const*&, unsigned char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>&)
inline auto read_array_(T& t, II& i, II e, Cx& cx)
                -> enable_if_t<!std::is_assignable<decltype(*std::begin(t)), decltype(*i)>::value, bool>
            {
                auto const m = bio::peek(i, e);
                switch (m & X::mjr) {
                    case X::arr: case X::map:   return imp::read_array_w_<X>(t, m, i, e, cx);
                    default:                    return cx/cbor::read_error::array_invalid;
                }
            }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
movq (%rsi), %r13
cmpq %rdx, %r13
je 0xd6432
movb (%r13), %al
jmp 0xd6434
movb $-0x1, %al
movl %eax, %ecx
andb $-0x40, %cl
movzbl %cl, %ecx
orl $0x20, %ecx
cmpl $0xa0, %ecx
jne 0xd6461
andb $0x1f, %al
movzbl %al, %eax
leal -0x1c(%rax), %ecx
cmpl $0x3, %ecx
jae 0xd6481
callq 0x31a3a
movl $0x6, (%rbx)
jmp 0xd646c
callq 0x31a3a
movl $0x7, (%rbx)
movq %rax, 0x8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x1f, %eax
jne 0xd64c7
cmpq %r15, %r13
je 0xd6492
leaq 0x1(%r13), %rax
movq %rax, (%r14)
movabsq $0x7fffffffffffffe, %rbp # imm = 0x7FFFFFFFFFFFFFE
cmpq %rbp, 0x18(%r12)
ja 0xd64e6
movq (%r14), %rax
cmpq %r15, %rax
je 0xd64b0
cmpb $-0x1, (%rax)
je 0xd64e6
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0xd6606
testb %al, %al
jne 0xd649c
jmp 0xd6470
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd6509
movq (%r14), %rax
cmpq %r15, %rax
je 0xd64fa
leaq 0x1(%rax), %rcx
movq %rcx, (%r14)
cmpb $-0x1, (%rax)
je 0xd6502
movq %r13, (%r14)
jmp 0xd6454
movb $0x1, %al
jmp 0xd6472