LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: uclaopt[P]AsyncQVI/include/oracle.h
// Function: Sailing::SO(int, int, int&, double&)
void SO(int i, int a, int& j, double& r){
			indexToState(i);
			apply(a);
			r = reward(a);
			windTransition();
			j = stateToIndex();
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl -0xc(%rbp), %esi
callq 0x7050
movq -0x28(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x70b0
movq -0x28(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x72f0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
callq 0x73b0
movq -0x28(%rbp), %rdi
callq 0x7450
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x20, %rdi
callq 0x7950
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x14d8(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x14e0(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x14e8(%rax)
movl $0x0, (%rax)
movl $0x0, 0x4(%rax)
movq %rax, %rdi
addq $0x20, %rdi
movq 0x14e8(%rax), %rsi
callq 0x4cc0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl $0x0, (%rdi)
movl $0x0, 0x4(%rdi)
movl $0x0, 0x8(%rdi)
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rdi)
addq $0x18, %rdi
callq 0x7950
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x14d0(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x14d8(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x14e0(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x14e8(%rax)
movq %rax, %rdi
addq $0x18, %rdi
movq 0x14e8(%rax), %rsi
callq 0x4cc0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl $0x0, (%rdi)
movl $0x0, 0x4(%rdi)
movl $0x0, 0x8(%rdi)
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rdi)
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rdi)
addq $0x20, %rdi
callq 0x7950
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x14d8(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x14e0(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x14e8(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x14f0(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x14f8(%rax)
movq %rax, %rdi
addq $0x20, %rdi
movq 0x14f8(%rax), %rsi
callq 0x4cc0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl $0x0, (%rdi)
movl $0x0, 0x4(%rdi)
movl $0x0, 0x8(%rdi)
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rdi)
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rdi)
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rdi)
addq $0x28, %rdi
callq 0x7950
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x14e0(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x14e8(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x14f0(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x14f8(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x1500(%rax)
movq 0x10(%rbp), %rcx
movq %rcx, 0x1508(%rax)
movq %rax, %rdi
addq $0x28, %rdi
movq 0x1508(%rax), %rsi
callq 0x4cc0
addq $0x40, %rsp
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl (%rcx), %eax
cmpl 0x14(%rcx), %eax
jne 0x7325
movq -0x20(%rbp), %rcx
movl 0x4(%rcx), %eax
cmpl 0x18(%rcx), %eax
jne 0x7325
movsd 0x5cfa(%rip), %xmm0     # 0xd018
movsd %xmm0, -0x8(%rbp)
jmp 0x73a1
movq -0x20(%rbp), %rcx
cmpl $0x0, (%rcx)
sete %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, 0x4(%rcx)
sete %cl
andb $0x1, %cl
movzbl %cl, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x7352
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x73a1
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
subl 0x8(%rcx), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl $0x8, %ecx
subl -0x18(%rbp), %ecx
cmpl %ecx, %eax
jge 0x737d
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x7388
movl $0x8, %eax
subl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, -0x18(%rbp)
cvtsi2sdl -0x18(%rbp), %xmm0
mulsd 0x28(%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd 0x5c49(%rip), %xmm1     # 0xd018
callq 0x76d0
movsd %xmm0, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x8, -0x1c(%rbp)
jge 0x7442
movq -0x28(%rbp), %rcx
movq %rcx, %rax
addq $0x13b8, %rax           # imm = 0x13B8
movslq 0x8(%rcx), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movslq -0x1c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
ucomisd -0x10(%rbp), %xmm0
jbe 0x7435
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, 0x8(%rax)
jmp 0x7442
jmp 0x7437
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x73e8
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: uclaopt[P]AsyncQVI/include/oracle.h
// Function: Sailing::direction(int)
std::pair<int, int> direction(int a){
			switch( a ) {
				case 0: return std::make_pair(0, 1);
				case 1: return std::make_pair(1, 1);
				case 2: return std::make_pair(1, 0);
				case 3: return std::make_pair(1, -1);
				case 4: return std::make_pair(0, -1);
				case 5: return std::make_pair(-1, -1);
				case 6: return std::make_pair(-1, 0);
				case 7: return std::make_pair(-1, 1);
				default: return std::make_pair(-1, -1);
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq %rax, -0x68(%rbp)
subq $0x7, %rax
ja 0x75cb
movq -0x68(%rbp), %rax
leaq 0x5c15(%rip), %rcx      # 0xd0c0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x7720
movq %rax, -0x8(%rbp)
jmp 0x75ea
movl $0x1, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x7720
movq %rax, -0x8(%rbp)
jmp 0x75ea
movl $0x1, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x7720
movq %rax, -0x8(%rbp)
jmp 0x75ea
movl $0x1, -0x30(%rbp)
movl $0xffffffff, -0x34(%rbp) # imm = 0xFFFFFFFF
leaq -0x30(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0x7720
movq %rax, -0x8(%rbp)
jmp 0x75ea
movl $0x0, -0x38(%rbp)
movl $0xffffffff, -0x3c(%rbp) # imm = 0xFFFFFFFF
leaq -0x38(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0x7720
movq %rax, -0x8(%rbp)
jmp 0x75ea
movl $0xffffffff, -0x40(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x44(%rbp) # imm = 0xFFFFFFFF
leaq -0x40(%rbp), %rdi
leaq -0x44(%rbp), %rsi
callq 0x7720
movq %rax, -0x8(%rbp)
jmp 0x75ea
movl $0xffffffff, -0x48(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x4c(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x4c(%rbp), %rsi
callq 0x7720
movq %rax, -0x8(%rbp)
jmp 0x75ea
movl $0xffffffff, -0x50(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x54(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x54(%rbp), %rsi
callq 0x7720
movq %rax, -0x8(%rbp)
jmp 0x75ea
movl $0xffffffff, -0x58(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x5c(%rbp) # imm = 0xFFFFFFFF
leaq -0x58(%rbp), %rdi
leaq -0x5c(%rbp), %rsi
callq 0x7720
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: codeniko[P]mossel_tov/mossel_tov.cpp
// Function: getStudentMatches(std::vector<Match, std::allocator<Match>>, Student const&)
vector<Match> getStudentMatches(vector<Match> matches, const Student &studentObj) {
	vector<Match> studentMatches;
	for (vector<Match>::iterator match_it = matches.begin(); match_it != matches.end(); match_it++) {
		if (match_it->hasStudent(studentObj) != "") //student exists, add match to collection
			studentMatches.push_back(*match_it);
	}

	sort(studentMatches.begin(), studentMatches.end(), sort_numIdentical);
	return studentMatches;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x80(%rbp)
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x3670
movq -0x80(%rbp), %rdi
callq 0x3690
movq %rax, -0x28(%rbp)
movq -0x80(%rbp), %rdi
callq 0x3700
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x36c0
testb $0x1, %al
jne 0x25c5
jmp 0x2667
leaq -0x28(%rbp), %rdi
callq 0x3760
movq %rax, %rsi
movq -0x18(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x3780
jmp 0x25e0
leaq 0x8bd6(%rip), %rsi      # 0xb1bd
leaq -0x50(%rbp), %rdi
callq 0x3730
movb %al, -0x91(%rbp)
jmp 0x25f8
leaq -0x50(%rbp), %rdi
callq 0x2150
movb -0x91(%rbp), %al
testb $0x1, %al
jne 0x260d
jmp 0x2651
leaq -0x28(%rbp), %rdi
callq 0x38c0
movq -0x90(%rbp), %rdi
movq %rax, %rsi
callq 0x3850
jmp 0x2627
jmp 0x2651
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x26c3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x2150
jmp 0x26c3
jmp 0x2653
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x38e0
movq %rax, -0x68(%rbp)
jmp 0x25a2
movq -0x90(%rbp), %rdi
callq 0x3690
movq -0x90(%rbp), %rdi
movq %rax, -0x70(%rbp)
callq 0x3700
movq %rax, -0x78(%rbp)
movq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rsi
leaq -0x166(%rip), %rdx      # 0x2530
callq 0x3920
jmp 0x269d
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x26b3
movq -0x90(%rbp), %rdi
callq 0x3970
movq -0x88(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0x3970
movq -0x58(%rbp), %rdi
callq 0x23a0
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x18(%rbp), %rsi
callq 0x43c0
testb $0x1, %al
jne 0x37b6
jmp 0x37c9
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rsi
addq $0x20, %rsi
callq 0x20e0
jmp 0x3834
movq -0x38(%rbp), %rdi
addq $0x20, %rdi
movq -0x18(%rbp), %rsi
callq 0x43c0
testb $0x1, %al
jne 0x37e0
jmp 0x37ef
movq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rdi
callq 0x20e0
jmp 0x3834
leaq -0x19(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x23b0
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0x79b2(%rip), %rsi      # 0xb1bd
callq 0x4450
jmp 0x3812
leaq -0x19(%rbp), %rdi
callq 0x2260
jmp 0x3834
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x2260
jmp 0x383e
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x23a0
nopw (%rax,%rax)
// File: ncbi[P]amr/amr_report.cpp
// Function: (anonymous namespace)::Susceptible::saveText(std::ostream&) const
void saveText (ostream &os) const final
    { os         << genesymbol 
         << '\t' << cutoff 
         << '\t' << classS
         << '\t' << subclass
         << '\t' << name
         << endl;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rsi
movq %rsi, (%rsp)
movq 0x8(%rsp), %rdi
addq $0x8, %rsi
callq 0xc630
movq %rax, %rdi
movl $0x9, %esi
callq 0xc820
movq %rax, %rdi
movq (%rsp), %rax
movsd 0x28(%rax), %xmm0
callq 0xcd80
movq %rax, %rdi
movl $0x9, %esi
callq 0xc820
movq (%rsp), %rsi
movq %rax, %rdi
addq $0x30, %rsi
callq 0xc630
movq %rax, %rdi
movl $0x9, %esi
callq 0xc820
movq (%rsp), %rsi
movq %rax, %rdi
addq $0x50, %rsi
callq 0xc630
movq %rax, %rdi
movl $0x9, %esi
callq 0xc820
movq (%rsp), %rsi
movq %rax, %rdi
addq $0x70, %rsi
callq 0xc630
movq %rax, %rdi
movq 0x10b28c(%rip), %rsi    # 0x140f50
callq 0xc710
addq $0x18, %rsp
retq
nop
// File: ncbi[P]amr/./common.hpp
// Function: Common_sp::Iter<Common_sp::VectorPtr<(anonymous namespace)::BlastAlignment>>::next()
bool next () 
      { it = itNext;
        if (it == t. end ())
          return false;
        itNext = it;
        itNext++;
        return true;
      }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x10(%rax)
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, 0x10(%rsp)
movq (%rax), %rdi
callq 0x29760
movq 0x10(%rsp), %rdi
movq %rax, 0x20(%rsp)
leaq 0x20(%rsp), %rsi
callq 0x436a0
testb $0x1, %al
jne 0x3deb9
jmp 0x3dec0
movb $0x0, 0x37(%rsp)
jmp 0x3dee2
movq 0x8(%rsp), %rdi
movq 0x10(%rdi), %rax
movq %rax, 0x8(%rdi)
addq $0x8, %rdi
xorl %esi, %esi
callq 0x446b0
movq %rax, 0x18(%rsp)
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax)
// File: ncbi[P]amr/amr_report.cpp
// Function: (anonymous namespace)::BlastAlignment::getMatchFam() const
const Fam* getMatchFam () const
    { ASSERT (inFam ());
      if (fromHmm)
        return getFam ();
      return brFam;
    }

// Assembly:
subq $0x148, %rsp            # imm = 0x148
movq %rdi, 0x138(%rsp)
movq 0x138(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0xc090
movq 0x10(%rsp), %rdi
movl $0x0, (%rax)
callq 0x37dc0
testb $0x1, %al
jne 0x4025a
callq 0xc870
cmpl $0x0, %eax
jne 0x40250
leaq 0x97(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xcca0
movq 0x8(%rsp), %rdx
leaq 0xbd8e2(%rip), %rsi     # 0xfd907
leaq 0x98(%rsp), %rdi
callq 0x50b50
jmp 0x40034
leaq 0x60(%rsp), %rdi
movl $0x4c3, %esi            # imm = 0x4C3
callq 0x52760
jmp 0x40045
leaq 0xb8(%rsp), %rdi
leaq 0x98(%rsp), %rsi
leaq 0x60(%rsp), %rdx
callq 0x52670
jmp 0x40061
leaq 0xbd8b7(%rip), %rdx     # 0xfd91f
leaq 0xd8(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x50db0
jmp 0x4007f
leaq 0x1f(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xcca0
movq (%rsp), %rdx
leaq 0xbeef3(%rip), %rsi     # 0xfef8b
leaq 0x20(%rsp), %rdi
callq 0x50b50
jmp 0x400a4
leaq 0xbdd73(%rip), %rdx     # 0xfde1e
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x50db0
jmp 0x400bc
leaq 0xf8(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0x52670
jmp 0x400d8
leaq 0xbefae(%rip), %rdx     # 0xff08d
leaq 0x118(%rsp), %rdi
leaq 0xf8(%rsp), %rsi
callq 0x50db0
jmp 0x400f6
leaq 0x118(%rsp), %rdi
callq 0x69f20
jmp 0x40105
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x40241
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x40234
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x4022a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x4021d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x40206
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x401fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x401f2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x401e5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x118(%rsp), %rdi
callq 0xce58
leaq 0xf8(%rsp), %rdi
callq 0xce58
leaq 0x40(%rsp), %rdi
callq 0xce58
leaq 0x20(%rsp), %rdi
callq 0xce58
leaq 0x1f(%rsp), %rdi
callq 0xc750
leaq 0xd8(%rsp), %rdi
callq 0xce58
leaq 0xb8(%rsp), %rdi
callq 0xce58
leaq 0x60(%rsp), %rdi
callq 0xce58
leaq 0x98(%rsp), %rdi
callq 0xce58
leaq 0x97(%rsp), %rdi
callq 0xc750
jmp 0x402a0
movl $0x1, %edi
callq 0xc880
movq 0x10(%rsp), %rax
testb $0x1, 0x24a(%rax)
je 0x4027c
movq 0x10(%rsp), %rdi
callq 0x37e00
movq %rax, 0x140(%rsp)
jmp 0x40290
movq 0x10(%rsp), %rax
movq 0x350(%rax), %rax
movq %rax, 0x140(%rsp)
movq 0x140(%rsp), %rax
addq $0x148, %rsp            # imm = 0x148
retq
movq 0x88(%rsp), %rdi
callq 0xcc90
nopl (%rax)
// File: ncbi[P]amr/amr_report.cpp
// Function: (anonymous namespace)::Fam::getHmmFam() const
const Fam* getHmmFam () const
    // Return: most specific HMM
    { const Fam* f = this;
      while (f && f->hmm. empty ())
        f = f->parent;
      return f;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x8(%rsp)
movb %al, 0x7(%rsp)
je 0x402e3
movq 0x8(%rsp), %rdi
addq $0x70, %rdi
callq 0xcbb0
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x402ed
jmp 0x402fc
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x402c3
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ncbi[P]amr/amr_report.cpp
// Function: (anonymous namespace)::BlastAlignment::truncatedCds() const
bool truncatedCds () const
    { for (const Locus& cds : cdss)
        if (truncated (cds))
          return true;
      return false;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
addq $0x3b8, %rax            # imm = 0x3B8
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x53090
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x530c0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x530f0
testb $0x1, %al
jne 0x44da0
jmp 0x44dd8
leaq 0x18(%rsp), %rdi
callq 0x53130
movq (%rsp), %rdi
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rsi
callq 0x44e50
testb $0x1, %al
jne 0x44dc3
jmp 0x44dca
movb $0x1, 0x37(%rsp)
jmp 0x44ddd
jmp 0x44dcc
leaq 0x18(%rsp), %rdi
callq 0x53140
jmp 0x44d8b
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: ncbi[P]amr/amr_report.cpp
// Function: (anonymous namespace)::BlastAlignment::getTargetStrand(GFF_sp::Locus const&) const
bool getTargetStrand (const Locus &cds) const
    { return targetProt
               ? cds. empty ()
                 ? true
                 : cds. strand
               : targetStrand;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
testb $0x1, 0x8(%rax)
je 0x4509c
movq 0x18(%rsp), %rdi
callq 0x62230
testb $0x1, %al
jne 0x4507e
jmp 0x45086
movb $0x1, %al
movb %al, 0xf(%rsp)
jmp 0x45092
movq 0x18(%rsp), %rax
movb 0x38(%rax), %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
movb %al, 0xe(%rsp)
jmp 0x450a8
movq 0x10(%rsp), %rax
movb 0x68(%rax), %al
movb %al, 0xe(%rsp)
movb 0xe(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ncbi[P]amr/amr_report.cpp
// Function: (anonymous namespace)::BlastAlignment::getMutationSymbols[abi:cxx11]() const
Set<string> getMutationSymbols () const
    { Set<string> mutationSymbols;
      for (const SeqChange& seqChange : seqChanges)
        if (! seqChange. empty ())
          for (const AmrMutation* mutation : seqChange. mutations)
            mutationSymbols << mutation->geneMutation;
      return mutationSymbols;
    }

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x18(%rsp)
movb $0x0, 0x77(%rsp)
callq 0x626f0
movq 0x18(%rsp), %rax
addq $0x218, %rax            # imm = 0x218
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rdi
callq 0x5cf70
movq %rax, 0x60(%rsp)
movq 0x68(%rsp), %rdi
callq 0x5cfa0
movq %rax, 0x58(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x61200
testb $0x1, %al
jne 0x47ceb
jmp 0x47db4
leaq 0x60(%rsp), %rdi
callq 0x61240
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0x61620
testb $0x1, %al
jne 0x47da3
movq 0x50(%rsp), %rax
addq $0x88, %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0x616d0
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
callq 0x61700
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x62720
testb $0x1, %al
jne 0x47d4f
jmp 0x47da1
leaq 0x40(%rsp), %rdi
callq 0x62760
movq 0x8(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rsi
addq $0xa8, %rsi
callq 0x62770
jmp 0x47d79
jmp 0x47d7b
leaq 0x40(%rsp), %rdi
callq 0x627b0
jmp 0x47d3a
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x62630
jmp 0x47dd7
jmp 0x47da3
jmp 0x47da5
leaq 0x60(%rsp), %rdi
callq 0x61320
jmp 0x47cd3
movb $0x1, 0x77(%rsp)
testb $0x1, 0x77(%rsp)
jne 0x47dca
movq 0x8(%rsp), %rdi
callq 0x62630
movq 0x10(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0xcc90
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x3d8(%rax), %rax
movb $0x0, 0x46(%rsp)
movb $0x0, 0x33(%rsp)
cmpq $0x0, %rax
je 0x47e7b
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x3d8(%rax), %rsi
addq $0x8, %rsi
callq 0xc300
jmp 0x47f01
movq 0x28(%rsp), %rdi
callq 0x47c20
testb $0x1, %al
jne 0x47e8b
jmp 0x47ea3
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rsi
addq $0x2a8, %rsi            # imm = 0x2A8
callq 0xc300
jmp 0x47eff
movq 0x28(%rsp), %rdi
callq 0x3ffc0
addq $0x28, %rax
movq %rax, 0x8(%rsp)
leaq 0x47(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xcca0
movq 0x10(%rsp), %rdx
movb $0x1, 0x46(%rsp)
leaq 0xb6f0c(%rip), %rsi     # 0xfede2
leaq 0x48(%rsp), %rdi
callq 0x50b50
jmp 0x47ee2
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rdi
movb $0x1, 0x33(%rsp)
leaq 0x48(%rsp), %rdx
callq 0x62690
jmp 0x47efd
jmp 0x47eff
jmp 0x47f01
testb $0x1, 0x33(%rsp)
jne 0x47f0a
jmp 0x47f14
leaq 0x48(%rsp), %rdi
callq 0xce58
testb $0x1, 0x46(%rsp)
jne 0x47f1d
jmp 0x47f27
leaq 0x47(%rsp), %rdi
callq 0xc750
movq 0x20(%rsp), %rax
addq $0x78, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x47f64
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
testb $0x1, 0x33(%rsp)
jne 0x47f58
jmp 0x47f62
leaq 0x48(%rsp), %rdi
callq 0xce58
jmp 0x47f64
testb $0x1, 0x46(%rsp)
jne 0x47f6d
jmp 0x47f77
leaq 0x47(%rsp), %rdi
callq 0xc750
jmp 0x47f79
movq 0x38(%rsp), %rdi
callq 0xcc90
nopw %cs:(%rax,%rax)
// File: ncbi[P]amr/amr_report.cpp
// Function: (anonymous namespace)::Fam::descendantOf((anonymous namespace)::Fam const*) const
bool descendantOf (const Fam* ancestor) const
	  { if (! ancestor)
	  	  return true;
	  	if (this == ancestor)
	  		return true;
	  	if (parent)
	  		return parent->descendantOf (ancestor);
	  	return false;
	  }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x499c7
movb $0x1, 0x27(%rsp)
jmp 0x49a04
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
jne 0x499da
movb $0x1, 0x27(%rsp)
jmp 0x49a04
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0x499ff
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x499a0
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x49a04
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nop
// File: ncbi[P]amr/amr_report.cpp
// Function: (anonymous namespace)::BlastAlignment::fusion2hmmAl() const
const HmmAlignment* fusion2hmmAl () const
    { if (fusions. empty ())
        return hmmAl;
      for (const BlastAlignment* fusion : fusions)
        if (fusion->hmmAl)
          return fusion->hmmAl;
      return nullptr;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x280, %rdi            # imm = 0x280
callq 0x1d4f0
testb $0x1, %al
jne 0x4fc14
jmp 0x4fc29
movq (%rsp), %rax
movq 0x3e0(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x4fcb6
movq (%rsp), %rax
addq $0x280, %rax            # imm = 0x280
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x28570
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x285a0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x285d0
testb $0x1, %al
jne 0x4fc6b
jmp 0x4fcad
leaq 0x18(%rsp), %rdi
callq 0x28610
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x3e0(%rax)
je 0x4fc9f
movq 0x8(%rsp), %rax
movq 0x3e0(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x4fcb6
jmp 0x4fca1
leaq 0x18(%rsp), %rdi
callq 0x28620
jmp 0x4fc56
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
// File: ncbi[P]amr/amr_report.cpp
// Function: (anonymous namespace)::BlastAlignment::fusion2famIds[abi:cxx11]() const
string fusion2famIds () const
    { if (isMutationProt () || fusions. empty ())
        return famId;
      string s;
      for (const BlastAlignment* fusion : fusions)
        add (s, fusion_infix, fusion->famId);
      return s;
    }

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x88(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x37da0
testb $0x1, %al
jne 0x4fd11
movq 0x20(%rsp), %rdi
addq $0x280, %rdi            # imm = 0x280
callq 0x1d4f0
testb $0x1, %al
jne 0x4fd11
jmp 0x4fd2c
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
addq $0x2a8, %rsi            # imm = 0x2A8
callq 0xc300
jmp 0x4fe59
movq 0x10(%rsp), %rdi
movb $0x0, 0x87(%rsp)
callq 0xc9b0
movq 0x20(%rsp), %rax
addq $0x280, %rax            # imm = 0x280
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rdi
callq 0x28570
movq %rax, 0x70(%rsp)
movq 0x78(%rsp), %rdi
callq 0x285a0
movq %rax, 0x68(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x285d0
testb $0x1, %al
jne 0x4fd84
jmp 0x4fe3b
leaq 0x70(%rsp), %rdi
callq 0x28610
movq (%rax), %rax
movq %rax, 0x60(%rsp)
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xcca0
movq 0x8(%rsp), %rdx
leaq 0xaf894(%rip), %rsi     # 0xff645
leaq 0x40(%rsp), %rdi
callq 0x50b50
jmp 0x4fdbd
movq 0x10(%rsp), %rdi
movq 0x60(%rsp), %rdx
addq $0x2a8, %rdx            # imm = 0x2A8
leaq 0x40(%rsp), %rsi
callq 0x62640
jmp 0x4fdda
leaq 0x40(%rsp), %rdi
callq 0xce58
leaq 0x3f(%rsp), %rdi
callq 0xc750
leaq 0x70(%rsp), %rdi
callq 0x28620
jmp 0x4fd6c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x4fe25
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xce58
leaq 0x3f(%rsp), %rdi
callq 0xc750
movq 0x10(%rsp), %rdi
callq 0xce58
jmp 0x4fe66
movb $0x1, 0x87(%rsp)
testb $0x1, 0x87(%rsp)
jne 0x4fe57
movq 0x10(%rsp), %rdi
callq 0xce58
jmp 0x4fe59
movq 0x18(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0xcc90
// File: ncbi[P]amr/./alignment.hpp
// Function: Alignment_sp::Alignment::hasMutation() const
bool hasMutation () const
    { for (const SeqChange& seqChange : seqChanges)
        if (seqChange. hasMutation ())
          return true;
      return false;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
addq $0x218, %rax            # imm = 0x218
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x5cf70
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x5cfa0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x61200
testb $0x1, %al
jne 0x6235c
jmp 0x62390
leaq 0x18(%rsp), %rdi
callq 0x61240
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x615b0
testb $0x1, %al
jne 0x6237b
jmp 0x62382
movb $0x1, 0x37(%rsp)
jmp 0x62395
jmp 0x62384
leaq 0x18(%rsp), %rdi
callq 0x61320
jmp 0x62347
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
// File: 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:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, 0x10(%rsp)
xorl %eax, %eax
testb $0x1, 0x70(%rcx)
movb %al, 0x1e(%rsp)
je 0x62495
movq 0x10(%rsp), %rcx
xorl %eax, %eax
cmpq $0x0, 0xc8(%rcx)
movb %al, 0x1e(%rsp)
je 0x62495
movq 0x10(%rsp), %rdx
movq 0x200(%rdx), %rcx
xorl %eax, %eax
cmpq 0xc8(%rdx), %rcx
movb %al, 0x1e(%rsp)
jne 0x62495
movq 0x10(%rsp), %rdi
movq 0x200(%rdi), %rax
movq %rax, 0x8(%rsp)
addq $0x30, %rdi
callq 0xc500
movq 0x8(%rsp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, 0x1e(%rsp)
jne 0x62495
movq 0x10(%rsp), %rcx
xorl %eax, %eax
cmpl $0x0, 0x6c(%rcx)
movb %al, 0x1e(%rsp)
je 0x62495
movq 0x10(%rsp), %rcx
movb $0x1, %al
testb $0x1, 0x8(%rcx)
movb %al, 0x7(%rsp)
je 0x6248d
movb $0x1, %al
testb $0x1, 0x1f(%rsp)
movb %al, 0x7(%rsp)
je 0x6248d
movq 0x10(%rsp), %rcx
movq 0xc8(%rcx), %rax
movl 0x6c(%rcx), %edi
xorl %edx, %edx
movl $0x1, %esi
cmpl $0x1, %edi
cmovel %esi, %edx
movslq %edx, %rdx
addq %rdx, %rax
cmpq 0x60(%rcx), %rax
sete %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
movb %al, 0x1e(%rsp)
movb 0x1e(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
testb $0x1, 0x30(%rax)
je 0x624d0
movq 0x18(%rsp), %rax
movb 0x30(%rax), %al
andb $0x1, %al
negb %al
movb %al, 0xf(%rsp)
jmp 0x62530
movq 0x18(%rsp), %rax
testb $0x1, 0x30(%rax)
je 0x624e3
xorl %eax, %eax
movb %al, 0xe(%rsp)
jmp 0x62528
movq 0x10(%rsp), %rdi
callq 0x63190
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x63190
movq (%rsp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, 0xd(%rsp)
jne 0x62520
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x62540
movb %al, 0xd(%rsp)
movb 0xd(%rsp), %al
movb %al, 0xe(%rsp)
movb 0xe(%rsp), %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x30(%rax)
je 0x62568
movb $0x1, 0x47(%rsp)
jmp 0x62621
movq 0x30(%rsp), %rax
testb $0x1, 0x30(%rax)
je 0x6257d
movb $0x0, 0x47(%rsp)
jmp 0x62621
movq 0x30(%rsp), %rdi
callq 0x63190
movq 0x8(%rsp), %rdi
movq %rax, (%rsp)
callq 0x63190
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jbe 0x625a8
movb $0x0, 0x47(%rsp)
jmp 0x62621
movq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x631b0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x631e0
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x63210
testb $0x1, %al
jne 0x625e5
jmp 0x6261c
leaq 0x20(%rsp), %rdi
callq 0x63230
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rsi
callq 0x63250
testb $0x1, %al
jne 0x6260e
movb $0x0, 0x47(%rsp)
jmp 0x62621
jmp 0x62610
leaq 0x20(%rsp), %rdi
callq 0x632c0
jmp 0x625d0
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl $0x0, (%rdi)
movl $0x0, 0x4(%rdi)
movl $0x1f4, 0x8(%rdi)       # imm = 0x1F4
movl $0x41a00000, 0xc(%rdi)  # imm = 0x41A00000
movl $0x42200000, 0x10(%rdi) # imm = 0x42200000
movl $0x41a00000, 0x14(%rdi) # imm = 0x41A00000
movl $0x42200000, 0x18(%rdi) # imm = 0x42200000
movl $0x3, 0x1c(%rdi)
movl $0x2, 0x20(%rdi)
movl $0x4, 0x24(%rdi)
addq $0x28, %rdi
movq %rdi, -0x30(%rbp)
callq 0x5260
movq -0x28(%rbp), %rdi
addq $0x13b0, %rdi           # imm = 0x13B0
callq 0x5300
jmp 0x36be
movq -0x28(%rbp), %rdi
movq $0x0, 0x2738(%rdi)
movq $0x0, 0x2740(%rdi)
movq $0x0, 0x2748(%rdi)
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x3750
jmp 0x36f0
movq -0x28(%rbp), %rdi
movq %rdi, %rax
addq $0x13b0, %rax           # imm = 0x13B0
movq %rax, -0x40(%rbp)
addq $0x28, %rdi
callq 0x53e0
movl %eax, -0x34(%rbp)
jmp 0x370f
movq -0x40(%rbp), %rdi
movl -0x34(%rbp), %eax
movl %eax, %eax
movl %eax, %esi
callq 0x5320
jmp 0x3721
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x5400
movq -0x18(%rbp), %rdi
callq 0x3400
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x2738(%rax)
je 0x37ee
movq -0x18(%rbp), %rax
movq 0x2738(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x37ec
movq -0x20(%rbp), %rdi
callq 0x32b0
jmp 0x37ee
movq -0x18(%rbp), %rax
cmpq $0x0, 0x2748(%rax)
je 0x381c
movq -0x18(%rbp), %rax
movq 0x2748(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x381a
movq -0x28(%rbp), %rdi
callq 0x32b0
jmp 0x381c
movq -0x18(%rbp), %rax
cmpq $0x0, 0x2740(%rax)
je 0x388f
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x8(%rcx), %eax
jae 0x386f
movq -0x18(%rbp), %rax
movq 0x2740(%rax), %rax
movl -0xc(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x3862
movq -0x30(%rbp), %rdi
callq 0x32b0
jmp 0x3864
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3831
movq -0x18(%rbp), %rax
movq 0x2740(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x388d
movq -0x38(%rbp), %rdi
callq 0x32b0
jmp 0x388f
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 4shadoww[P]xwinter/xwinter.cpp
// Function: sky::set_speed(float, float, float, float)
void sky::set_speed(float min_x, float max_x, float min_y, float max_y){
    this->min_speed_x = min_x;
    this->max_speed_x = max_x;
    this->min_speed_y = min_y;
    this->max_speed_y = max_y;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movss %xmm1, -0x10(%rbp)
movss %xmm2, -0x14(%rbp)
movss %xmm3, -0x18(%rbp)
movq -0x8(%rbp), %rax
movss -0xc(%rbp), %xmm0
movss %xmm0, 0xc(%rax)
movss -0x10(%rbp), %xmm0
movss %xmm0, 0x10(%rax)
movss -0x14(%rbp), %xmm0
movss %xmm0, 0x14(%rax)
movss -0x18(%rbp), %xmm0
movss %xmm0, 0x18(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
leaq -0x28(%rbp), %rdi
callq 0x5440
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
leaq -0x30(%rbp), %rdi
callq 0x5440
movq -0x40(%rbp), %rsi
addq $0x13b0, %rsi           # imm = 0x13B0
leaq -0x28(%rbp), %rdi
callq 0x5470
movq -0x40(%rbp), %rsi
movl %eax, -0x34(%rbp)
addq $0x13b0, %rsi           # imm = 0x13B0
leaq -0x30(%rbp), %rdi
callq 0x5470
movl %eax, -0x38(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x34(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x54a0
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 4shadoww[P]xwinter/xwinter.cpp
// Function: print_copyright()
void print_copyright(){
    std::cout << "xwinter " << version << std::endl;
    std::cout << R"(Copyright (C) 2019 Noa-Emil Nissinen
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.)" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x5f25(%rip), %rdi      # 0x9fd0
leaq 0x2f62(%rip), %rsi      # 0x7014
callq 0x3210
movq %rax, %rdi
leaq 0x61a7(%rip), %rsi      # 0xa268
callq 0x31e0
movq %rax, %rdi
movq 0x5ee8(%rip), %rsi      # 0x9fb8
callq 0x3220
movq 0x5ef4(%rip), %rdi      # 0x9fd0
leaq 0x2f3a(%rip), %rsi      # 0x701d
callq 0x3210
movq %rax, %rdi
movq 0x5ec6(%rip), %rsi      # 0x9fb8
callq 0x3220
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, %rdx
movq %rdx, -0x8(%rbp)
leaq 0x2fb3(%rip), %rsi      # 0x7109
leaq -0x48(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x55f0
movq -0x60(%rbp), %rsi
leaq 0x2fa3(%rip), %rdx      # 0x7111
leaq -0x28(%rbp), %rdi
callq 0x55a0
jmp 0x4179
movq 0x5e50(%rip), %rdi      # 0x9fd0
leaq -0x28(%rbp), %rsi
callq 0x31e0
movq %rax, -0x68(%rbp)
jmp 0x418f
movq -0x68(%rbp), %rdi
movq 0x5e1e(%rip), %rsi      # 0x9fb8
callq 0x3220
jmp 0x41a1
leaq -0x28(%rbp), %rdi
callq 0x3488
leaq -0x48(%rbp), %rdi
callq 0x3488
movq 0x5e16(%rip), %rdi      # 0x9fd0
leaq 0x2f5b(%rip), %rsi      # 0x711c
callq 0x3210
movq %rax, %rdi
movq 0x5de8(%rip), %rsi      # 0x9fb8
callq 0x3220
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x41fe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3488
leaq -0x48(%rbp), %rdi
callq 0x3488
movq -0x50(%rbp), %rdi
callq 0x3400
// File: nurseiit[P]cpp-server/server.cpp
// Function: accept_and_run(asio::basic_socket_acceptor<asio::ip::tcp, asio::executor>&, asio::io_context&)
void accept_and_run(tcp::acceptor &acceptor, asio::io_service &io_service) {
  std::shared_ptr<Session> sesh = std::make_shared<Session>(io_service);
  acceptor.async_accept(
      sesh->socket,
      [sesh, &acceptor, &io_service](const asio::error_code &accept_error) {
        accept_and_run(acceptor, io_service);
        if (!accept_error) {
          Session::start(sesh);
        }
      });
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x8090
movq -0x70(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
callq 0x8100
movq -0x70(%rbp), %rsi
addq $0xf0, %rax
movq %rax, -0x60(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x8120
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
movl %eax, %ecx
callq 0x6c90
jmp 0x6c44
leaq -0x40(%rbp), %rdi
callq 0x6ce0
leaq -0x20(%rbp), %rdi
callq 0x8150
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x6ce0
leaq -0x20(%rbp), %rdi
callq 0x8150
movq -0x48(%rbp), %rdi
callq 0x6700
nopw %cs:(%rax,%rax)
// File: nurseiit[P]cpp-server/server.cpp
// Function: main
int main(int argc, const char *argv[]) {
  if (argc != 2) {
    std::cout << "Usage: " << argv[0] << " <port>\n";
    std::cout << "Examples:\n";
    std::cout << "  " << argv[0] << " 8080\n";
    return EXIT_FAILURE;
  }

  int PORT = std::atoi(argv[1]);

  asio::io_service io_service;
  tcp::acceptor acceptor(io_service, tcp::endpoint(tcp::v4(), PORT));

  acceptor.listen();
  accept_and_run(acceptor, io_service);

  io_service.run();
  return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
je 0x6da4
movq 0x2e29e(%rip), %rdi     # 0x34fc8
leaq 0x1c30b(%rip), %rsi     # 0x2303c
callq 0x6400
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x6400
movq %rax, %rdi
leaq 0x1c2f5(%rip), %rsi     # 0x23044
callq 0x6400
movq 0x2e26d(%rip), %rdi     # 0x34fc8
leaq 0x1c2eb(%rip), %rsi     # 0x2304d
callq 0x6400
movq 0x2e25a(%rip), %rdi     # 0x34fc8
leaq 0x1c2e3(%rip), %rsi     # 0x23058
callq 0x6400
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x6400
movq %rax, %rdi
leaq 0x1c2c8(%rip), %rsi     # 0x2305b
callq 0x6400
movl $0x1, -0x4(%rbp)
jmp 0x6e80
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6650
movl %eax, -0x14(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x8170
callq 0x8220
movl %eax, -0x78(%rbp)
movzwl -0x14(%rbp), %edx
leaq -0x74(%rbp), %rdi
movq %rdi, -0x90(%rbp)
leaq -0x78(%rbp), %rsi
callq 0x8240
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdx
xorl %eax, %eax
movl %eax, %r8d
leaq -0x58(%rbp), %rdi
movl $0x1, %ecx
callq 0x8280
jmp 0x6e07
leaq -0x58(%rbp), %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0x8520
jmp 0x6e17
leaq -0x58(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6bd0
jmp 0x6e26
leaq -0x28(%rbp), %rdi
callq 0x8590
jmp 0x6e31
movl $0x0, -0x4(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x85e0
leaq -0x28(%rbp), %rdi
callq 0x8610
jmp 0x6e80
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x6e75
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x85e0
leaq -0x28(%rbp), %rdi
callq 0x8610
jmp 0x6e8c
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x6700
nopw %cs:(%rax,%rax)