LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/uclaopt[P]AsyncQVI/include/algo.h
// Function: QVI::QVI(std::vector<double, std::allocator<double>>*, std::vector<int, std::allocator<int>>*, Params*)
QVI(std::vector<double>* V_, std::vector<int>* pi_, Params* params_){
			V = V_;
			pi = pi_;
			params = params_;
			init_state = 0;
			init_action = 0;
			s.setValues(params);
		}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq $0x1571, 0x50(%rdi)     # imm = 0x1571
movl $0x1571, %ecx           # imm = 0x1571
movl $0xb, %eax
movq %rcx, %rdx
shrq $0x1e, %rdx
xorl %ecx, %edx
imull $0x6c078965, %edx, %ecx # imm = 0x6C078965
addl %eax, %ecx
addl $-0xa, %ecx
movq %rcx, (%r14,%rax,8)
incq %rax
cmpq $0x27a, %rax            # imm = 0x27A
jne 0x4391
leaq 0x20(%r14), %r13
movq $0x270, 0x13d0(%r14) # imm = 0x270
leaq 0x13d8(%r14), %rdi
leaq 0x1f5f(%rip), %rsi      # 0x6330
movl $0x100, %edx            # imm = 0x100
callq 0x2170
movq %r12, 0x14d8(%r14)
movq %r15, 0x14e0(%r14)
movq %rbx, 0x14e8(%r14)
movq $0x0, (%r14)
movq %r13, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x3b9e
nop
// File: /workspace/github_cpp_makefile_star2_O3/uclaopt[P]AsyncQVI/include/algo.h
// Function: Qlearning::Qlearning(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>*, std::vector<double, std::allocator<double>>*, std::vector<int, std::allocator<int>>*, Params*)
Qlearning(std::vector<std::vector<double>>* Q_, 
				  std::vector<double>* V_, 
				  std::vector<int>* pi_, 
				  Params* params_){
			Q = Q_;
			V = V_;
			pi = pi_;
			params = params_;
			s.setValues(params);			
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
xorl %eax, %eax
movq %rax, (%rdi)
movl $0x0, 0x8(%rdi)
movq %rax, 0x10(%rdi)
movq $0x1571, 0x48(%rdi)     # imm = 0x1571
movl $0x1571, %ecx           # imm = 0x1571
movl $0xa, %eax
movq %rcx, %rdx
shrq $0x1e, %rdx
xorl %ecx, %edx
imull $0x6c078965, %edx, %ecx # imm = 0x6C078965
addl %eax, %ecx
addl $-0x9, %ecx
movq %rcx, (%r15,%rax,8)
incq %rax
cmpq $0x279, %rax            # imm = 0x279
jne 0x4654
leaq 0x18(%r15), %rbp
movq $0x270, 0x13c8(%r15) # imm = 0x270
leaq 0x13d0(%r15), %rdi
leaq 0x1c9c(%rip), %rsi      # 0x6330
movl $0x100, %edx            # imm = 0x100
callq 0x2170
movq %r13, 0x14d0(%r15)
movq %r12, 0x14d8(%r15)
movq %r14, 0x14e0(%r15)
movq %rbx, 0x14e8(%r15)
movq %rbp, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3b9e
nop
// File: /workspace/github_cpp_makefile_star2_O3/uclaopt[P]AsyncQVI/include/algo.h
// Function: VRVI::VRVI(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>*, std::vector<double, std::allocator<double>>*, std::vector<double, std::allocator<double>>*, std::vector<int, std::allocator<int>>*, Params*)
VRVI(std::vector<std::vector<double>>* x_, 
						 std::vector<double>* v_outer_,
						 std::vector<double>* v_inner_,
						 std::vector<int>* pi_,
						 Params* params_){
				x = x_;
				v_outer = v_outer_;
				v_inner = v_inner_;
				pi = pi_;
				params = params_;
				s.setValues(params);			
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, (%rsp)
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r12
movq $0x0, (%rdi)
movl $0x0, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq $0x1571, 0x50(%rdi)     # imm = 0x1571
movl $0x1571, %ecx           # imm = 0x1571
movl $0xb, %eax
movq %rcx, %rdx
shrq $0x1e, %rdx
xorl %ecx, %edx
imull $0x6c078965, %edx, %ecx # imm = 0x6C078965
addl %eax, %ecx
addl $-0xa, %ecx
movq %rcx, (%r12,%rax,8)
incq %rax
cmpq $0x27a, %rax            # imm = 0x27A
jne 0x4817
leaq 0x20(%r12), %r14
movq $0x270, 0x13d0(%r12) # imm = 0x270
leaq 0x13d8(%r12), %rdi
leaq 0x1ad6(%rip), %rsi      # 0x6330
movl $0x100, %edx            # imm = 0x100
callq 0x2170
movq %rbp, 0x14d8(%r12)
movq %r13, 0x14e0(%r12)
movq %r15, 0x14e8(%r12)
movq (%rsp), %rax
movq %rax, 0x14f0(%r12)
movq %rbx, 0x14f8(%r12)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3b9e
nop
// File: /workspace/github_cpp_makefile_star2_O3/uclaopt[P]AsyncQVI/include/algo.h
// Function: VRQVI::VRQVI(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>*, std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>*, std::vector<double, std::allocator<double>>*, std::vector<double, std::allocator<double>>*, std::vector<int, std::allocator<int>>*, Params*)
VRQVI(std::vector<std::vector<double>>* Q_, 
			 std::vector<std::vector<double>>* w_, 
						 std::vector<double>* v_outer_,
						 std::vector<double>* v_inner_,
						 std::vector<int>* pi_,
						 Params* params_){
				Q = Q_;
				w = w_;
				v_outer = v_outer_;
				v_inner = v_inner_;
				pi = pi_;
				params = params_;
				s.setValues(params);			
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movq %r8, 0x8(%rsp)
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %rbx
movq %rdi, %r12
movq 0x50(%rsp), %r15
xorl %eax, %eax
movq %rax, (%rdi)
movl $0x0, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq %rax, 0x20(%rdi)
movq $0x1571, 0x58(%rdi)     # imm = 0x1571
movl $0x1571, %ecx           # imm = 0x1571
movl $0xc, %eax
movq %rcx, %rdx
shrq $0x1e, %rdx
xorl %ecx, %edx
imull $0x6c078965, %edx, %ecx # imm = 0x6C078965
addl %eax, %ecx
addl $-0xb, %ecx
movq %rcx, (%r12,%rax,8)
incq %rax
cmpq $0x27b, %rax            # imm = 0x27B
jne 0x4bec
leaq 0x28(%r12), %r14
movq $0x270, 0x13d8(%r12) # imm = 0x270
leaq 0x13e0(%r12), %rdi
leaq 0x1701(%rip), %rsi      # 0x6330
movl $0x100, %edx            # imm = 0x100
callq 0x2170
movq %rbx, 0x14e0(%r12)
movq %rbp, 0x14e8(%r12)
movq %r13, 0x14f0(%r12)
movq 0x8(%rsp), %rax
movq %rax, 0x14f8(%r12)
movq 0x10(%rsp), %rax
movq %rax, 0x1500(%r12)
movq %r15, 0x1508(%r12)
movq %r14, %rdi
movq %r15, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3b9e
// File: /workspace/github_cpp_makefile_star2_O3/uclaopt[P]AsyncQVI/include/oracle.h
// Function: Sailing::apply(int)
void apply(int a){
			std::pair<int, int> dir = direction(a);
			x = max(0, min(x + dir.first, DIMX-1));
			y = max(0, min(y + dir.second, DIMY-1));
			
			// some noise in positioning
			// simulate wind
			x = max(0, min(x + (int)localNormalDouble(0.,0.1), DIMX-1));
			y = max(0, min(y + (int)localNormalDouble(0.,0.1), DIMY-1));

			// simulate vortex
			if(localUniformDouble(0,1) < probs){
				x = max(0, min(x + (int)localNormalDouble(0.,1.), DIMX-1));
				y = max(0, min(y + (int)localNormalDouble(0.,1.), DIMY-1));
			}
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
pcmpeqd %xmm0, %xmm0
pcmpeqd %xmm1, %xmm1
cmpl $0x7, %esi
ja 0x5250
movl %esi, %eax
leaq 0x11e5(%rip), %rcx      # 0x6430
movq (%rcx,%rax,8), %xmm1
movq (%rbx), %xmm2
paddd %xmm1, %xmm2
movq 0xc(%rbx), %xmm1
paddd %xmm1, %xmm0
pcmpgtd %xmm2, %xmm1
pand %xmm1, %xmm2
pandn %xmm0, %xmm1
por %xmm2, %xmm1
pxor %xmm0, %xmm0
movdqa %xmm1, %xmm2
pcmpgtd %xmm0, %xmm2
pand %xmm1, %xmm2
movdqa %xmm2, 0x10(%rsp)
movq %xmm2, (%rbx)
movhpd 0xdcd(%rip), %xmm0      # xmm0 = xmm0[0],mem[0]
movapd %xmm0, (%rsp)
leaq 0x20(%rsp), %r15
movapd %xmm0, (%r15)
xorl %r12d, %r12d
movq %r12, 0x10(%r15)
movb %r12b, 0x18(%r15)
leaq 0x30(%rbx), %r14
movq %r15, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x5982
cvttsd2si %xmm0, %eax
movdqa 0x10(%rsp), %xmm0
movd %xmm0, %ecx
addl %eax, %ecx
movl 0xc(%rbx), %eax
leal -0x1(%rax), %edx
cmpl %ecx, %eax
cmovgl %ecx, %edx
movl 0x4(%rbx), %ebp
testl %edx, %edx
cmovlel %r12d, %edx
movl %edx, (%rbx)
movapd (%rsp), %xmm0
movapd %xmm0, (%r15)
movq %r12, 0x10(%r15)
movb %r12b, 0x18(%r15)
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
movq %rdi, %rdx
callq 0x5982
cvttsd2si %xmm0, %eax
addl %ebp, %eax
movl 0x10(%rbx), %ecx
leal -0x1(%rcx), %edx
cmpl %eax, %ecx
cmovgl %eax, %edx
testl %edx, %edx
cmovlel %r12d, %edx
movl %edx, 0x4(%rbx)
movq %r14, %rdi
callq 0x585c
movsd 0x20(%rbx), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x53c3
movl (%rbx), %ebp
xorpd %xmm0, %xmm0
movhpd 0xcd2(%rip), %xmm0      # xmm0 = xmm0[0],mem[0]
movapd %xmm0, (%rsp)
leaq 0x20(%rsp), %r15
movapd %xmm0, (%r15)
movq %r12, 0x10(%r15)
movb %r12b, 0x18(%r15)
movq %r15, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x5982
cvttsd2si %xmm0, %eax
addl %ebp, %eax
movl 0xc(%rbx), %ecx
leal -0x1(%rcx), %edx
cmpl %eax, %ecx
cmovgl %eax, %edx
movl 0x4(%rbx), %ebp
testl %edx, %edx
cmovlel %r12d, %edx
movl %edx, (%rbx)
movapd (%rsp), %xmm0
movapd %xmm0, (%r15)
movq %r12, 0x10(%r15)
movb %r12b, 0x18(%r15)
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
movq %rdi, %rdx
callq 0x5982
cvttsd2si %xmm0, %eax
addl %ebp, %eax
movl 0x10(%rbx), %ecx
leal -0x1(%rcx), %edx
cmpl %eax, %ecx
cmovgl %eax, %edx
testl %edx, %edx
cmovlel %r12d, %edx
movl %edx, 0x4(%rbx)
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/uclaopt[P]AsyncQVI/include/oracle.h
// Function: Sailing::reward(int)
double reward(int a){
			if( x == GOALX && y == GOALY){
				return 1.;
			}
			else if(x==0 & y==0)
				return 0.;
			else{	
				int angle = abs(a - wind);
				angle = angle < 8 - angle ? angle : 8 - angle;
				return angle * d;
			}
		}

// Assembly:
movl (%rdi), %eax
movl 0x4(%rdi), %ecx
cmpl 0x14(%rdi), %eax
jne 0x53e8
cmpl 0x18(%rdi), %ecx
jne 0x53e8
movsd 0xc31(%rip), %xmm0      # 0x6018
retq
orl %eax, %ecx
je 0x540c
subl 0x8(%rdi), %esi
movl %esi, %eax
negl %eax
cmovsl %esi, %eax
movl $0x8, %ecx
subl %eax, %ecx
cmpl %ecx, %eax
cmovll %eax, %ecx
cvtsi2sd %ecx, %xmm0
mulsd 0x28(%rdi), %xmm0
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/uclaopt[P]AsyncQVI/include/oracle.h
// Function: Sailing::windTransition()
void windTransition(){
			double prob = localUniformDouble(0, 1);
			double start = 0;
			for(int nwind = 0; nwind < DIMWIND; nwind++){
				start += wind_transition[wind][nwind];
				if(start > prob){
					wind = nwind;
					break;
				}
			}
		}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x30, %rdi
callq 0x585c
movslq 0x8(%rbx), %rax
shlq $0x5, %rax
leaq (%rax,%rbx), %rcx
addq $0x13b8, %rcx           # imm = 0x13B8
xorpd %xmm1, %xmm1
xorl %eax, %eax
movapd %xmm1, %xmm2
xorps %xmm1, %xmm1
cvtss2sd (%rcx,%rax,4), %xmm1
addsd %xmm2, %xmm1
ucomisd %xmm0, %xmm1
ja 0x5457
incq %rax
cmpq $0x8, %rax
jne 0x5436
jmp 0x545a
movl %eax, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/codeniko[P]mossel_tov/mossel_tov.cpp
// Function: Match::hasStudent[abi:cxx11](Student const&)
string hasStudent(const Student &s) {
		if (student1 == s.student)
			return student2;
		else if (student2 == s.student)
			return student1;
		else
			return "";
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %r15
movq 0x8(%rdx), %r12
cmpq %r12, %r15
jne 0x33b3
testq %r15, %r15
je 0x33ed
movq (%r13), %rsi
movq (%r14), %rdi
movq %r15, %rdx
callq 0x21c0
testl %eax, %eax
je 0x33ed
cmpq %r12, 0x28(%r14)
jne 0x33d2
testq %r12, %r12
je 0x3404
movq (%r13), %rsi
movq 0x20(%r14), %rdi
movq %r12, %rdx
callq 0x21c0
testl %eax, %eax
je 0x3404
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x4de9(%rip), %rdx      # 0x81c9
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x3800
jmp 0x341c
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
jmp 0x3417
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
addq %rsi, %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0x3a80
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/amr_report.cpp
// Function: (anonymous namespace)::BlastAlignment::getGeneSymbol[abi:cxx11]() const
string getGeneSymbol () const
    { return susceptible
               ? susceptible->genesymbol
               : alleleMatch () 
                 ? famId 
                 : nvl (getMatchFam () -> genesymbol, na); 
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x3d8(%rsi), %rax
testq %rax, %rax
je 0x32265
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3890e
movq %rsi, %r14
movq %rsi, %rdi
movl $0x1, %esi
callq 0x3f216
testb %al, %al
je 0x3229c
movq %r14, %rdi
callq 0x2d7c8
testb %al, %al
je 0x3229c
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x2a8(%r14), %rsi
movq 0x2b0(%r14), %rdx
jmp 0x3224f
movq %r14, %rdi
callq 0x2f1ba
movq %rax, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x71aff(%rip), %rsi     # 0xa3db7
leaq 0x71afa(%rip), %rdx     # 0xa3db9
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x3880a
leaq 0x28(%r14), %rax
leaq 0x30(%r14), %rcx
cmpq $0x0, 0x30(%r14)
cmoveq %r15, %rax
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
leaq 0x10(%rsp), %rax
cmovneq %rcx, %rax
movq (%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x3890e
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x32315
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa550
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x3233b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa550
movq %rbx, %rdi
callq 0xa9c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/./common.hpp
// Function: Common_sp::section(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
inline void section (const string &title,
                     bool useAlsoCout)
  { const Color::Type color = Color::cyan;
    const bool bright = false;
    if (useAlsoCout)
    {
      { const OColor oc1 (cout, color, bright, true);
        const OColor oc2 (cerr, color, bright, true);
        couterr << title /*<< " ..."*/;
      }
      couterr << endl;
    }
    else
    {
      { const OColor oc (cerr, color, bright, true);
        cerr << title /*<< " ..."*/;
      }
      cerr << endl;
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
testl %esi, %esi
je 0x395fb
movq 0x91a2e(%rip), %rbx     # 0xcafa0
movq %rsp, %rdi
movq %rbx, %rsi
movl $0x24, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x39d06
movq 0x91a57(%rip), %rsi     # 0xcafe8
leaq 0x10(%rsp), %rdi
movl $0x24, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x39d06
leaq 0x92893(%rip), %r15     # 0xcbe42
movq %r15, %rdi
movq %r14, %rsi
callq 0x39dac
leaq 0x10(%rsp), %rdi
callq 0x39dec
movq %rsp, %rdi
callq 0x39dec
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xa520
movsbl %al, %esi
movq %rbx, %rdi
callq 0xa040
movq %rax, %rdi
callq 0xa3d0
cmpb $0x0, (%r15)
je 0x39631
jmp 0x3965f
movq 0x919e6(%rip), %rbx     # 0xcafe8
movq %rsp, %rdi
movq %rbx, %rsi
movl $0x24, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x39d06
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0xa5f0
movq %rsp, %rdi
callq 0x39dec
movq 0x919b0(%rip), %rbx     # 0xcafe8
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xa520
movsbl %al, %esi
movq %rbx, %rdi
callq 0xa040
movq %rax, %rdi
callq 0xa3d0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x39dec
jmp 0x3967d
jmp 0x3967a
movq %rax, %rbx
movq %rsp, %rdi
callq 0x39dec
movq %rbx, %rdi
callq 0xa9c0
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/./common.hpp
// Function: Common_sp::COutErr const& Common_sp::COutErr::operator<<<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
const COutErr& operator<< (const T &val) const
      { cout << val;
        if (! both)
          cerr << val;
        return *this;
      }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
movq 0x911dc(%rip), %rdi     # 0xcafa0
callq 0xa5f0
cmpb $0x0, (%rbx)
jne 0x39de1
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x9120c(%rip), %rdi     # 0xcafe8
callq 0xa5f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/./alignment.hpp
// Function: Alignment_sp::Alignment::refProtExactlyMatched(bool) const
bool refProtExactlyMatched (bool targetComplete) const
    { return    refProt
             && refLen   
             && nident == refLen 
             && nident == targetSeq. size ()
             && targetStopCodon != efalse
             && (! targetProt || ! targetComplete || refLen + (targetStopCodon == etrue ? 1 : 0) == targetLen); 
	  }

// Assembly:
cmpb $0x1, 0x70(%rdi)
jne 0x3f262
movq 0xc8(%rdi), %rcx
testq %rcx, %rcx
je 0x3f262
movq 0x200(%rdi), %rdx
xorl %eax, %eax
cmpq %rcx, %rdx
jne 0x3f261
cmpq 0x38(%rdi), %rdx
jne 0x3f261
movl 0x6c(%rdi), %edx
testl %edx, %edx
je 0x3f262
andb 0x8(%rdi), %sil
movb $0x1, %al
cmpb $0x1, %sil
jne 0x3f261
xorl %eax, %eax
cmpl $0x1, %edx
sete %al
addq %rax, %rcx
cmpq 0x60(%rdi), %rcx
sete %al
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/./common.hpp
// Function: Common_sp::Set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::operator==(Common_sp::Set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&) const
bool operator== (const Set<T> &other) const
      { return universal
                 ? other. universal ? true : false
                 : other. universal
                   ? false
                   :    P::size () == other. size ()
                     && containsAll (other);
      }

// Assembly:
movb 0x30(%rdi), %al
movb 0x30(%rsi), %cl
movl %eax, %edx
orb %cl, %dl
testb $0x1, %dl
je 0x3f278
andb %cl, %al
retq
movq 0x28(%rdi), %rax
cmpq 0x28(%rsi), %rax
je 0x3f28a
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/./common.hpp
// Function: bool Common_sp::Set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::containsAll<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(Common_sp::Set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&) const
bool containsAll (const Set<U> &other) const
        { if (universal)
      	    return true;
      	  if (other. universal)
      		  return false;
      	  if (other. size () > P::size ())
      	    return false;
          for (const U& u : other)
            if (! contains (u))
              return false;
          return true;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movb $0x1, %bl
cmpb $0x0, 0x30(%rdi)
jne 0x3f2b3
movq %rsi, %r14
cmpb $0x0, 0x30(%rsi)
jne 0x3f2b1
movq %rdi, %r15
movq 0x28(%r14), %rax
cmpq 0x28(%rdi), %rax
jbe 0x3f2bf
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x18(%r14), %r12
addq $0x8, %r14
cmpq %r14, %r12
je 0x3f2b3
leaq 0x8(%r15), %r13
cmpb $0x0, 0x30(%r15)
jne 0x3f2e9
leaq 0x20(%r12), %rsi
movq %r15, %rdi
callq 0x3f4a4
cmpq %r13, %rax
je 0x3f2b1
movq %r12, %rdi
callq 0xa610
movq %rax, %r12
cmpq %r14, %rax
jne 0x3f2d0
jmp 0x3f2b3
nop
// File: /workspace/github_cpp_makefile_star2_O3/4shadoww[P]xwinter/xwinter.cpp
// Function: sky::sky(unsigned int, unsigned int)
sky::sky(unsigned int screen_width, unsigned int screen_heigth){
    // Set screen size
    sky::set_screen_size(screen_width, screen_heigth);
    // Seed rng
    this->eng.seed(this->rd());
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %rbx
movq $0x0, (%rdi)
movl $0x1f4, 0x8(%rdi)       # imm = 0x1F4
movaps 0x1ae0(%rip), %xmm0     # 0x4010
movups %xmm0, 0xc(%rdi)
movabsq $0x200000003, %rax      # imm = 0x200000003
movq %rax, 0x1c(%rdi)
movl $0x4, 0x24(%rdi)
leaq 0x28(%rdi), %r14
movq %r14, %rdi
callq 0x3848
movq $0x1571, 0x13b0(%rbx) # imm = 0x1571
movl $0x1571, %ecx           # imm = 0x1571
movl $0x277, %eax            # imm = 0x277
movq %rcx, %rdx
shrq $0x1e, %rdx
xorl %ecx, %edx
imull $0x6c078965, %edx, %ecx # imm = 0x6C078965
addl %eax, %ecx
addl $0xfffffd8a, %ecx       # imm = 0xFFFFFD8A
movq %rcx, (%rbx,%rax,8)
incq %rax
cmpq $0x4e6, %rax            # imm = 0x4E6
jne 0x256a
movq $0x270, 0x2730(%rbx) # imm = 0x270
xorps %xmm0, %xmm0
movups %xmm0, 0x2738(%rbx)
movq $0x0, 0x2748(%rbx)
movl %r15d, (%rbx)
movl %ebp, 0x4(%rbx)
movq %r14, %rdi
callq 0x2290
movl %eax, %ecx
movq %rcx, 0x13b0(%rbx)
xorl %eax, %eax
movq %rcx, %rdx
shrq $0x1e, %rdx
xorl %ecx, %edx
imull $0x6c078965, %edx, %ecx # imm = 0x6C078965
addl %eax, %ecx
incl %ecx
movq %rcx, 0x13b8(%rbx,%rax,8)
incq %rax
cmpq $0x26f, %rax            # imm = 0x26F
jne 0x25c9
movq $0x270, 0x2730(%rbx) # imm = 0x270
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x21b0
movq %rbx, %rdi
callq 0x2360
movq %rax, %rdi
callq 0x38c2
// File: /workspace/github_cpp_makefile_star2_O3/4shadoww[P]xwinter/xwinter.cpp
// Function: sky::free_memory()
void sky::free_memory(){
    if(this->snowflakes) delete[] this->snowflakes;
    if(this->snowflakespeeds) delete[] this->snowflakespeeds;
    if(this->positions){
        for(unsigned int i = 0; i < this->particle_count; i++){
            delete[] this->positions[i];
        }
        delete[] this->positions;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x2738(%rdi), %rdi
testq %rdi, %rdi
je 0x265e
callq 0x2240
movq 0x2748(%rbx), %rdi
testq %rdi, %rdi
je 0x266f
callq 0x2240
movq 0x2740(%rbx), %rdi
testq %rdi, %rdi
je 0x26bf
movl 0x8(%rbx), %eax
testl %eax, %eax
je 0x26b3
xorl %r14d, %r14d
movq 0x2740(%rbx), %rcx
movq (%rcx,%r14,8), %rdi
testq %rdi, %rdi
je 0x269d
callq 0x2240
movl 0x8(%rbx), %eax
incq %r14
movl %eax, %ecx
cmpq %rcx, %r14
jb 0x2685
movq 0x2740(%rbx), %rdi
testq %rdi, %rdi
je 0x26bf
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2240
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/4shadoww[P]xwinter/xwinter.cpp
// Function: sky::get_random_position(int, int, int, int)
std::pair<int, int> sky::get_random_position(int min_x, int max_x, int min_y, int max_y){
    // Define x range
    std::uniform_int_distribution<> range_x(min_x, max_x);
    // Define y range
    std::uniform_int_distribution<> range_y(min_y, max_y);
    // Create random position in range
    return std::pair<int, int>(range_x(this->eng), range_y(this->eng));
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %rax
movl %esi, (%rax)
movl %edx, 0x4(%rax)
movq %rsp, %rbx
movl %ecx, (%rbx)
movl %r8d, 0x4(%rbx)
leaq 0x13b0(%rdi), %r14
movq %rax, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x3a76
movl %eax, %ebp
movq %rbx, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3a76
shlq $0x20, %rax
movl %ebp, %ecx
orq %rcx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/4shadoww[P]xwinter/xwinter.cpp
// Function: sky::get_random_size(int, int)
int sky::get_random_size(int min, int max){
    // Define range
    std::uniform_int_distribution<> range(min, max);
    // Create random number
    return range(this->eng);
}

// Assembly:
pushq %rax
movq %rsp, %rax
movl %esi, (%rax)
movl %edx, 0x4(%rax)
leaq 0x13b0(%rdi), %rsi
movq %rax, %rdi
movq %rax, %rdx
callq 0x3a76
popq %rcx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/4shadoww[P]xwinter/xwinter.cpp
// Function: print_usage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void print_usage(std::string path){
    std::cout << "usage: " + path + " [options]" << std::endl;
    std::cout << R"(Options:
  -h, --help                                  Print this message
  -v, --version                               Print version info
  -c, --count <int>                           Set particle count
  -sx, --speed-x <float>                      Set speed on X-axis
  -sy, --speed-y <float>                      Set speed on Y-axis
  -cl, --color {white|blue|red|green}         Set particle color
  -rx, --random-x <float>                     Set randomness on speed on X-axis
  -ry, --random-y <float>                     Set randomness on speed on Y-axis
  -ys, --y-spawn <int>                        Set particle spawn intensity on X-axis
  -s, --size <int>                            Set particle size
  -rs, --random-size <int>                    Set randomness to size
  -fps, --frame-rate <int>                    Set target framerate)" << std::endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rdx
leaq 0x151c(%rip), %rsi      # 0x416d
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x38cd
leaq 0x1510(%rip), %rsi      # 0x4175
movq %rbx, %rdi
callq 0x2390
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x2c93
movq %rsi, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x2c9d
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq %r15, %rsi
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x4314(%rip), %rbx      # 0x6fd0
movq %rbx, %rdi
callq 0x2210
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2160
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x2d04
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21f0
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2d1f
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x21f0
leaq 0x145a(%rip), %rsi      # 0x4180
movl $0x34d, %edx            # imm = 0x34D
movq %rbx, %rdi
callq 0x2210
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2160
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x2d82
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x2d82
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21f0
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2d9d
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O3/nurseiit[P]cpp-server/./include/asio/detail/executor_function.hpp
// Function: asio::detail::executor_function<asio::detail::binder2<asio::detail::write_op<asio::basic_stream_socket<asio::ip::tcp, asio::executor>, asio::const_buffers_1, asio::const_buffer const*, asio::detail::transfer_all_t, Session::read_next_line(std::shared_ptr<Session>)::'lambda'(std::error_code const&, unsigned long)::operator()(std::error_code const&, unsigned long) const::'lambda'(std::error_code const&, unsigned long)>, std::error_code, unsigned long>, std::allocator<void>>::do_complete(asio::detail::executor_function_base*, bool)
static void do_complete(executor_function_base* base, bool call)
  {
    // Take ownership of the function object.
    executor_function* o(static_cast<executor_function*>(base));
    Alloc allocator(o->allocator_);
    ptr p = { detail::addressof(allocator), o, o };

    // Make a copy of the function so that the memory can be deallocated before
    // the upcall is made. Even if we're not about to make an upcall, a
    // sub-object of the function may be the true owner of the memory
    // associated with the function. Consequently, a local copy of the function
    // is required to ensure that any owning sub-object remains valid until
    // after we have deallocated the memory here.
    Function function(ASIO_MOVE_CAST(Function)(o->function_));
    p.reset();

    // Make the upcall if required.
    if (call)
    {
      function();
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movl %esi, %ebx
leaq 0x7(%rsp), %rcx
leaq 0x68(%rsp), %rax
movq %rcx, (%rax)
movq %rdi, 0x8(%rax)
movq %rdi, 0x10(%rax)
movq 0x8(%rdi), %rcx
movq %rcx, 0x8(%rsp)
movups 0x10(%rdi), %xmm0
movups %xmm0, 0x10(%rsp)
movq 0x20(%rdi), %rcx
movq %rcx, 0x20(%rsp)
movl 0x28(%rdi), %ecx
movl %ecx, 0x28(%rsp)
movups 0x30(%rdi), %xmm0
xorl %ecx, %ecx
movq %rcx, 0x38(%rdi)
movups %xmm0, 0x30(%rsp)
movq %rcx, 0x30(%rdi)
movq 0x40(%rdi), %rdx
movq %rdx, 0x40(%rsp)
movq 0x48(%rdi), %r14
movq %rcx, 0x48(%rdi)
movq %r14, 0x48(%rsp)
movq %rcx, 0x40(%rdi)
movups 0x50(%rdi), %xmm0
movups %xmm0, 0x50(%rsp)
movq 0x60(%rdi), %r15
movq %r15, 0x60(%rsp)
movq %rax, %rdi
callq 0xf30e
testb %bl, %bl
je 0xf2b1
leaq 0x50(%rsp), %rsi
leaq 0x8(%rsp), %rdi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0xe978
movq 0x48(%rsp), %r14
testq %r14, %r14
je 0xf2be
movq %r14, %rdi
callq 0x7000
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0xf2cd
callq 0x7000
leaq 0x68(%rsp), %rdi
callq 0xf30e
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xf305
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xeec8
leaq 0x68(%rsp), %rdi
callq 0xf30e
movq %rbx, %rdi
callq 0x55d0
movq %rax, %rdi
callq 0x6e5b
nop
// File: /workspace/github_cpp_makefile_star2_O3/nurseiit[P]cpp-server/./include/asio/impl/read_until.hpp
// Function: void asio::detail::initiate_async_read_until_delim_v1<asio::basic_stream_socket<asio::ip::tcp, asio::executor>>::operator()<Session::read_first_line(std::shared_ptr<Session>)::'lambda'(std::error_code const&, unsigned long), asio::basic_streambuf_ref<std::allocator<char>>>(Session::read_first_line(std::shared_ptr<Session>)::'lambda'(std::error_code const&, unsigned long)&&, asio::basic_streambuf_ref<std::allocator<char>>&&, char) const
void operator()(ASIO_MOVE_ARG(ReadHandler) handler,
        ASIO_MOVE_ARG(DynamicBuffer_v1) buffers,
        char delim) const
    {
      // If you get an error on the following line it means that your handler
      // does not meet the documented type requirements for a ReadHandler.
      ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;

      non_const_lvalue<ReadHandler> handler2(handler);
      read_until_delim_op_v1<AsyncReadStream,
        typename decay<DynamicBuffer_v1>::type,
          typename decay<ReadHandler>::type>(
            stream_, ASIO_MOVE_CAST(DynamicBuffer_v1)(buffers),
            delim, handler2.value)(asio::error_code(), 0, 1);
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq (%rdi), %rax
leaq 0x18(%rsp), %rbx
movq %rax, (%rbx)
movq (%rdx), %rax
movq %rax, 0x8(%rbx)
movb %cl, 0x10(%rbx)
xorl %eax, %eax
movl %eax, 0x14(%rbx)
movq %rax, 0x18(%rbx)
movups (%rsi), %xmm0
movq %rax, 0x8(%rsi)
movups %xmm0, 0x20(%rbx)
movq %rax, (%rsi)
leaq 0x8(%rsp), %r14
movl %eax, (%r14)
callq 0x5220
movq %rax, 0x8(%r14)
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movl $0x1, %ecx
callq 0xb182
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0xb15f
callq 0x7000
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0xb179
callq 0x7000
movq %rbx, %rdi
callq 0x55d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/nurseiit[P]cpp-server/./include/asio/impl/executor.hpp
// Function: void asio::executor::dispatch<asio::detail::binder2<asio::detail::write_op<asio::basic_stream_socket<asio::ip::tcp, asio::executor>, asio::const_buffers_1, asio::const_buffer const*, asio::detail::transfer_all_t, Session::read_next_line(std::shared_ptr<Session>)::'lambda'(std::error_code const&, unsigned long)::operator()(std::error_code const&, unsigned long) const::'lambda'(std::error_code const&, unsigned long)>, std::error_code, unsigned long>, std::allocator<void>>(asio::detail::binder2<asio::detail::write_op<asio::basic_stream_socket<asio::ip::tcp, asio::executor>, asio::const_buffers_1, asio::const_buffer const*, asio::detail::transfer_all_t, Session::read_next_line(std::shared_ptr<Session>)::'lambda'(std::error_code const&, unsigned long)::operator()(std::error_code const&, unsigned long) const::'lambda'(std::error_code const&, unsigned long)>, std::error_code, unsigned long>&&, std::allocator<void> const&) const
void executor::dispatch(ASIO_MOVE_ARG(Function) f,
    const Allocator& a) const
{
  impl_base* i = get_impl();
  if (i->fast_dispatch_)
    system_executor().dispatch(ASIO_MOVE_CAST(Function)(f), a);
  else
    i->dispatch(function(ASIO_MOVE_CAST(Function)(f), a));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdx, %rbx
movq %rsi, %r15
callq 0xc024
cmpb $0x1, 0x8(%rax)
jne 0xefd3
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xf0b2
jmp 0xf075
movq %rax, %r14
movq (%r15), %rax
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movups 0x8(%r15), %xmm0
movups %xmm0, 0x8(%rsi)
movq 0x18(%r15), %rax
movq %rax, 0x18(%rsi)
movl 0x20(%r15), %eax
movl %eax, 0x20(%rsi)
movups 0x28(%r15), %xmm0
xorl %eax, %eax
movq %rax, 0x30(%r15)
movups %xmm0, 0x28(%rsi)
movq %rax, 0x28(%r15)
movups 0x38(%r15), %xmm0
movq %rax, 0x40(%r15)
movups %xmm0, 0x38(%rsi)
movq %rax, 0x38(%r15)
movups 0x48(%r15), %xmm0
movups %xmm0, 0x48(%rsi)
movq 0x58(%r15), %rax
movq %rax, 0x58(%rsi)
leaq 0x8(%rsp), %rdi
movq %rbx, %rdx
callq 0xf14e
movq (%r14), %rax
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq *0x28(%rax)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xf057
xorl %esi, %esi
callq *(%rdi)
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0xf066
callq 0x7000
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0xf075
callq 0x7000
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xf094
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xf09f
xorl %esi, %esi
callq *(%rdi)
jmp 0xf09f
movq %rax, %rdi
callq 0x6e5b
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xeec8
movq %rbx, %rdi
callq 0x55d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/nurseiit[P]cpp-server/./include/asio/executor.hpp
// Function: asio::executor::get_impl() const
impl_base* get_impl() const
  {
    if (!impl_)
    {
      bad_executor ex;
      asio::detail::throw_exception(ex);
    }
    return impl_;
  }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq (%rdi), %rax
testq %rax, %rax
je 0xc037
addq $0x10, %rsp
popq %rbx
retq
leaq 0xcc42(%rip), %rbx      # 0x18c80
movq %rbx, 0x8(%rsp)
movl $0x8, %edi
callq 0x51d0
movq %rbx, (%rax)
leaq 0xcc41(%rip), %rsi      # 0x18c98
movq 0xcf82(%rip), %rdx      # 0x18fe0
movq %rax, %rdi
callq 0x55b0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x56b8
movq %rbx, %rdi
callq 0x55d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/nurseiit[P]cpp-server/./include/asio/impl/executor.hpp
// Function: asio::executor::function::function<asio::detail::binder2<asio::detail::write_op<asio::basic_stream_socket<asio::ip::tcp, asio::executor>, asio::const_buffers_1, asio::const_buffer const*, asio::detail::transfer_all_t, Session::read_next_line(std::shared_ptr<Session>)::'lambda'(std::error_code const&, unsigned long)::operator()(std::error_code const&, unsigned long) const::'lambda'(std::error_code const&, unsigned long)>, std::error_code, unsigned long>, std::allocator<void>>(asio::detail::binder2<asio::detail::write_op<asio::basic_stream_socket<asio::ip::tcp, asio::executor>, asio::const_buffers_1, asio::const_buffer const*, asio::detail::transfer_all_t, Session::read_next_line(std::shared_ptr<Session>)::'lambda'(std::error_code const&, unsigned long)::operator()(std::error_code const&, unsigned long) const::'lambda'(std::error_code const&, unsigned long)>, std::error_code, unsigned long>, std::allocator<void> const&)
explicit function(F f, const Alloc& a)
  {
    // Allocate and construct an operation to wrap the function.
    typedef detail::executor_function<F, Alloc> func_type;
    typename func_type::ptr p = {
      detail::addressof(a), func_type::ptr::allocate(a), 0 };
    func_ = new (p.v) func_type(ASIO_MOVE_CAST(F)(f), a);
    p.v = 0;
  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, (%rsp)
movq %fs:-0x8, %rax
testq %rax, %rax
je 0xf173
movq 0x8(%rax), %rdi
jmp 0xf175
xorl %edi, %edi
movl $0x70, %esi
callq 0xc1c4
xorl %ecx, %ecx
movq %rsp, %rdi
movq %rcx, 0x10(%rdi)
leaq 0x79(%rip), %rdx        # 0xf208
movq %rdx, (%rax)
movq (%r14), %rdx
movq %rdx, 0x8(%rax)
movq 0x18(%r14), %rdx
movq %rdx, 0x20(%rax)
movups 0x8(%r14), %xmm0
movups %xmm0, 0x10(%rax)
movl 0x20(%r14), %edx
movl %edx, 0x28(%rax)
movq %rcx, 0x38(%rax)
movups 0x28(%r14), %xmm0
movq %rcx, 0x30(%r14)
movups %xmm0, 0x30(%rax)
movq %rcx, 0x28(%r14)
movq %rcx, 0x48(%rax)
movups 0x38(%r14), %xmm0
movq %rcx, 0x40(%r14)
movups %xmm0, 0x40(%rax)
movq %rcx, 0x38(%r14)
movups 0x48(%r14), %xmm0
movups %xmm0, 0x50(%rax)
movq 0x58(%r14), %rdx
movq %rdx, 0x60(%rax)
movq %rax, (%rbx)
movq %rcx, 0x8(%rdi)
callq 0xf30e
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x6e5b
// File: /workspace/github_cpp_makefile_star2_O3/nurseiit[P]cpp-server/./include/asio/detail/reactive_socket_recv_op.hpp
// Function: asio::detail::reactive_socket_recv_op_base<asio::mutable_buffers_1>::do_perform(asio::detail::reactor_op*)
static status do_perform(reactor_op* base)
  {
    reactive_socket_recv_op_base* o(
        static_cast<reactive_socket_recv_op_base*>(base));

    buffer_sequence_adapter<asio::mutable_buffer,
        MutableBufferSequence> bufs(o->buffers_);

    status result = socket_ops::non_blocking_recv(o->socket_,
        bufs.buffers(), bufs.count(), o->flags_,
        (o->state_ & socket_ops::stream_oriented) != 0,
        o->ec_, o->bytes_transferred_) ? done : not_done;

    if (result == done)
      if ((o->state_ & socket_ops::stream_oriented) != 0)
        if (o->bytes_transferred_ == 0)
          result = done_and_exhausted;

    ASIO_HANDLER_REACTOR_OPERATION((*o, "non_blocking_recv",
          o->ec_, o->bytes_transferred_));

    return result;
  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x40(%rdi), %rax
movq 0x48(%rdi), %rcx
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq %rcx, 0x8(%rsi)
movq %rcx, 0x10(%rsi)
movl 0x38(%rdi), %edi
movl 0x50(%rbx), %ecx
movb 0x3c(%rbx), %al
andb $0x10, %al
shrb $0x4, %al
leaq 0x18(%rbx), %r9
leaq 0x28(%rbx), %r14
movq %r14, (%rsp)
movzbl %al, %r8d
movl $0x1, %edx
callq 0xc428
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
je 0xc420
movl $0x1, %eax
testb $0x10, 0x3c(%rbx)
je 0xc420
cmpq $0x0, (%r14)
movzbl %cl, %ecx
movl $0x2, %eax
cmovnel %ecx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/nurseiit[P]cpp-server/server.cpp
// Function: Headers::read_request_line(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void read_request_line(std::string line) {
    std::stringstream request_stream(line);
    request_stream >> method;
    request_stream >> url;
    request_stream >> version;

    std::cout << "🙈 Requested: " << url << std::endl;
  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
movl $0x18, %edx
callq 0x5560
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5440
leaq 0x20(%rbx), %rsi
movq %rsp, %rdi
callq 0x5440
leaq 0x40(%rbx), %rsi
movq %rsp, %rdi
callq 0x5440
movq 0xc6f7(%rip), %rdi      # 0x18fa8
leaq 0x4e88(%rip), %rsi      # 0x11740
movl $0x10, %edx
callq 0x53b0
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
movq 0xc6d7(%rip), %rdi      # 0x18fa8
callq 0x53b0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x5350
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5040
movq %rax, %rdi
callq 0x5280
movq 0xc661(%rip), %rsi      # 0x18f68
movq %rsp, %rdi
callq 0x52d0
leaq 0x80(%rsp), %rdi
callq 0x5150
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0xc637(%rip), %rsi      # 0x18f68
movq %rsp, %rdi
callq 0x52d0
leaq 0x80(%rsp), %rdi
callq 0x5150
movq %rbx, %rdi
callq 0x55d0
// File: /workspace/github_cpp_makefile_star2_O3/nurseiit[P]cpp-server/server.cpp
// Function: Headers::read_header(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void read_header(std::string line) {
    std::stringstream header_stream(line);
    std::string header_name;
    std::getline(header_stream, header_name, ':');

    std::string header_value;
    std::getline(header_stream, header_value);
    headers_map[header_name] = header_value;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rdi, %rbx
leaq 0x40(%rsp), %r14
movq %r14, %rdi
movl $0x18, %edx
callq 0x5560
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
movl $0x3a, %edx
callq 0x5630
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movq 0x40(%rsp), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x5350
movsbl %al, %edx
leaq 0x40(%rsp), %rdi
movq %rsp, %rsi
callq 0x5630
addq $0x60, %rbx
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0xe1fa
movq %rsp, %rsi
movq %rax, %rdi
callq 0x5200
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xda40
callq 0x5340
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0xda4f
callq 0x5340
movq 0xb512(%rip), %rsi      # 0x18f68
leaq 0x40(%rsp), %rdi
callq 0x52d0
leaq 0xc0(%rsp), %rdi
callq 0x5150
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0xda92
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xda92
callq 0x5340
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0xdaa1
callq 0x5340
movq 0xb4c0(%rip), %rsi      # 0x18f68
leaq 0x40(%rsp), %rdi
callq 0x52d0
leaq 0xc0(%rsp), %rdi
callq 0x5150
movq %rbx, %rdi
callq 0x55d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/nurseiit[P]cpp-server/server.cpp
// Function: Headers::content_length()
int content_length() {
    if (headers_map.count("content-length")) {
      std::stringstream content_length_stream(headers_map["content-length"]);
      int content_length;
      content_length_stream >> content_length;
      return content_length;
    }
    return 0;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdi, %r14
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x3c67(%rip), %rsi      # 0x11751
leaq 0x3c6e(%rip), %rdx      # 0x1175f
leaq 0x20(%rsp), %rdi
callq 0x6dc6
leaq 0x60(%r14), %rbx
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0xe662
movq %rax, %r15
addq $0x68, %r14
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0xdb22
callq 0x5340
cmpq %r14, %r15
je 0xdba1
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3c1a(%rip), %rsi      # 0x11751
leaq 0x3c21(%rip), %rdx      # 0x1175f
movq %rsp, %rdi
callq 0x6dc6
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xe5e6
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
movl $0x18, %edx
callq 0x5560
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0xdb71
callq 0x5340
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x5240
movl (%rsp), %ebx
movq 0xb3e0(%rip), %rsi      # 0x18f68
leaq 0x20(%rsp), %rdi
callq 0x52d0
leaq 0xa0(%rsp), %rdi
callq 0x5150
jmp 0xdba3
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0xb3aa(%rip), %rsi      # 0x18f68
leaq 0x20(%rsp), %rdi
callq 0x52d0
leaq 0xa0(%rsp), %rdi
callq 0x5150
jmp 0xdbfe
jmp 0xdbe8
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
jne 0xdbf9
jmp 0xdbfe
movq %rax, %rbx
jmp 0xdbfe
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0xdbfe
callq 0x5340
movq %rbx, %rdi
callq 0x55d0
// File: /workspace/github_cpp_makefile_star2_O3/nurseiit[P]cpp-server/server.cpp
// Function: Session::read_body(std::shared_ptr<Session>)
static void read_body(std::shared_ptr<Session> ptr) {
    int nbuffer = 6969;
    std::shared_ptr<std::vector<char>> bufptr =
        std::make_shared<std::vector<char>>(nbuffer);
    asio::async_read(ptr->socket, asio::buffer(*bufptr, nbuffer),
                     [ptr](const asio::error_code &e, std::size_t s) {});
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
leaq 0x34(%rsp), %r14
movl $0x1b39, (%r14)         # imm = 0x1B39
xorl %r13d, %r13d
leaq 0x28(%rsp), %rdi
movq %r13, -0x8(%rdi)
leaq 0x20(%rsp), %r15
leaq 0x38(%rsp), %r12
movq %r15, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0xf580
movq (%rbx), %rcx
leaq 0xf0(%rcx), %rax
movq (%r15), %rdx
movslq (%r14), %rsi
movq (%rdx), %rdi
movq 0x8(%rdx), %rdx
subq %rdi, %rdx
cmoveq %r13, %rdi
cmpq %rsi, %rdx
cmovaeq %rsi, %rdx
movq %rdi, (%r12)
movq %rdx, 0x8(%r12)
movq %rcx, 0x10(%rsp)
movq 0x8(%rbx), %rcx
movq %rcx, 0x18(%rsp)
testq %rcx, %rcx
je 0xe188
movq 0xae26(%rip), %rdx      # 0x18fa0
cmpb $0x0, (%rdx)
je 0xe184
incl 0x8(%rcx)
jmp 0xe188
lock
incl 0x8(%rcx)
leaq 0x48(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x10(%rsp), %rsi
leaq 0x38(%rsp), %rdx
leaq 0xf(%rsp), %rcx
callq 0xf6ee
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xe1b3
callq 0x7000
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0xe1c2
callq 0x7000
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xe1e2
callq 0x7000
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0xe1f1
callq 0x7000
movq %rbx, %rdi
callq 0x55d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/nurseiit[P]cpp-server/./include/asio/impl/write.hpp
// Function: void asio::detail::initiate_async_write_buffer_sequence<asio::basic_stream_socket<asio::ip::tcp, asio::executor>>::operator()<Session::read_next_line(std::shared_ptr<Session>)::'lambda'(std::error_code const&, unsigned long)::operator()(std::error_code const&, unsigned long) const::'lambda'(std::error_code const&, unsigned long), asio::const_buffers_1, asio::detail::transfer_all_t>(Session::read_next_line(std::shared_ptr<Session>)::'lambda'(std::error_code const&, unsigned long)::operator()(std::error_code const&, unsigned long) const::'lambda'(std::error_code const&, unsigned long)&&, asio::const_buffers_1 const&, asio::detail::transfer_all_t&&) const
void operator()(ASIO_MOVE_ARG(WriteHandler) handler,
        const ConstBufferSequence& buffers,
        ASIO_MOVE_ARG(CompletionCondition) completion_cond) const
    {
      // If you get an error on the following line it means that your handler
      // does not meet the documented type requirements for a WriteHandler.
      ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;

      non_const_lvalue<WriteHandler> handler2(handler);
      non_const_lvalue<CompletionCondition> completion_cond2(completion_cond);
      start_write_buffer_sequence_op(stream_, buffers,
          asio::buffer_sequence_begin(buffers),
          completion_cond2.value, handler2.value);
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq (%rdi), %rax
leaq 0x10(%rsp), %rbx
movq %rax, (%rbx)
movups (%rdx), %xmm0
movups %xmm0, 0x8(%rbx)
xorl %eax, %eax
movq %rax, 0x18(%rbx)
movl %eax, 0x20(%rbx)
movups (%rsi), %xmm0
movq %rax, 0x8(%rsi)
movups %xmm0, 0x28(%rbx)
movq %rax, (%rsi)
movups 0x10(%rsi), %xmm0
movq %rax, 0x18(%rsi)
movups %xmm0, 0x38(%rbx)
movq %rax, 0x10(%rsi)
movq %rsp, %r14
movl %eax, (%r14)
callq 0x5220
movq %rax, 0x8(%r14)
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movl $0x1, %ecx
callq 0xe978
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0xe94c
callq 0x7000
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0xe95b
callq 0x7000
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xea50
movq %rbx, %rdi
callq 0x55d0