LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/uclaopt[P]AsyncQVI/include/algo.h
// Function: QVI::update(int)
void update(int iter){
			
			// select (state, action) uniformly random
			if(params->style == 0){
				init_state = uniformInt(0, params->len_state-1);
				init_action = uniformInt(0, params->len_action-1);
			}
			// select (state, action) globally cyclic
			else{
				init_state = (iter/params->len_action) % params->len_state;
				init_action = iter % params->len_action;
			}
			
			S = 0.;
			for (int i = 0; i < params->max_inner_iter; i++){
				// call sample oracle
				s.SO(init_state, init_action, next_state, r);
				S += r + params->gamma * V->at(next_state);
			}
			// averaged reward
			S = S / params->max_inner_iter;
			double newQ = S - (1-params->gamma)*params->epsilon/4.;
			
			// update shared memory
			pthread_mutex_lock(&writelock);
			if (newQ > V->at(init_state)){
				V->at(init_state) = newQ;
				pi->at(init_state) = init_action;
			}
			pthread_mutex_unlock(&writelock);
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x14e8(%rdi), %rdi
cmpl $0x0, 0x2c(%rdi)
je 0x3719
movl %esi, %eax
cltd
idivl 0x4(%rdi)
movl %edx, %ecx
cltd
idivl (%rdi)
movl %edx, (%rbx)
jmp 0x373b
movl (%rdi), %esi
decl %esi
xorl %edi, %edi
callq 0x2aec
movl %eax, (%rbx)
movq 0x14e8(%rbx), %rax
movl 0x4(%rax), %esi
decl %esi
xorl %edi, %edi
callq 0x2aec
movl %eax, %ecx
movl %ecx, 0x4(%rbx)
andq $0x0, 0x18(%rbx)
leaq 0x20(%rbx), %r14
leaq 0x8(%rbx), %r15
leaq 0x10(%rbx), %r12
xorl %ebp, %ebp
xorpd %xmm1, %xmm1
movq 0x14e8(%rbx), %rax
movl 0x38(%rax), %ecx
cmpl %ecx, %ebp
jge 0x37bf
movl (%rbx), %esi
movl 0x4(%rbx), %edx
movq %r14, %rdi
movq %r15, %rcx
movq %r12, %r8
callq 0x36a0
movsd 0x10(%rbx), %xmm0
movsd %xmm0, (%rsp)
movq 0x14e8(%rbx), %rax
movsd 0x18(%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x14d8(%rbx), %rdi
movslq 0x8(%rbx), %rsi
callq 0x48d4
movsd 0x8(%rsp), %xmm1
mulsd (%rax), %xmm1
addsd (%rsp), %xmm1
addsd 0x18(%rbx), %xmm1
movsd %xmm1, 0x18(%rbx)
incl %ebp
jmp 0x3755
cvtsi2sd %ecx, %xmm0
divsd %xmm0, %xmm1
movsd %xmm1, 0x18(%rbx)
movsd 0x2844(%rip), %xmm0     # 0x6018
subsd 0x18(%rax), %xmm0
mulsd 0x60(%rax), %xmm0
mulsd 0x283a(%rip), %xmm0     # 0x6020
addsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
leaq 0x6d82(%rip), %rdi      # 0xa578
callq 0x2240
movq 0x14d8(%rbx), %rdi
movslq (%rbx), %rsi
callq 0x48d4
movsd (%rsp), %xmm0
ucomisd (%rax), %xmm0
jbe 0x3841
movq 0x14d8(%rbx), %rdi
movslq (%rbx), %rsi
callq 0x48d4
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movl 0x4(%rbx), %ebp
movq 0x14e0(%rbx), %rdi
movslq (%rbx), %rsi
callq 0x48f6
movl %ebp, (%rax)
leaq 0x6d30(%rip), %rdi      # 0xa578
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O2/uclaopt[P]AsyncQVI/include/algo.h
// Function: Qlearning::update(int)
void update(int iter){
			
			// select (state, action) uniformly random
			if(params->style == 0){
				init_state = uniformInt(0, params->len_state-1); 
				init_action = uniformInt(0, params->len_action-1);
			}
			// select (state, action) globally cyclic 
			else if(params->style == 1){
				init_state = (iter/params->len_action) % params->len_state;
				init_action = iter % params->len_action;
			}
			// select (state, action) following a Markovian trajectory with some exploration
			else{
				init_state = next_state;
				init_action = (*pi)[next_state];
				if(uniformDouble(0.,1.) < params->explore)
					init_action = uniformInt(0, params->len_action-1);
			}
			
			// call sample oracle
			s.SO(init_state, init_action, next_state, r);
			
			// update global variables with mutex
			pthread_mutex_lock(&writelock);
			
			// learning rate of Q-learning
			//params->alpha = 1./pow(iter,0.51);
			(*Q)[init_state][init_action] = (1-params->alpha) * (*Q)[init_state][init_action]
											+ params->alpha * (r + params->gamma*(*V)[next_state]);
			if((*Q)[init_state][init_action] > (*V)[init_state]){
				(*V)[init_state] = (*Q)[init_state][init_action];
				(*pi)[init_state] = init_action;
			}
			pthread_mutex_unlock(&writelock);			
		}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x14e8(%rdi), %rcx
movl 0x2c(%rcx), %eax
cmpl $0x1, %eax
je 0x38a1
testl %eax, %eax
jne 0x38b5
movl (%rcx), %esi
decl %esi
xorl %edi, %edi
callq 0x2aec
movl %eax, (%rbx)
movq 0x14e8(%rbx), %rax
jmp 0x38ee
movl %esi, %eax
cltd
idivl 0x4(%rcx)
movl %edx, %r9d
cltd
idivl (%rcx)
movl %edx, (%rbx)
movl %r9d, 0x4(%rbx)
jmp 0x3906
movslq 0x8(%rbx), %rax
movl %eax, (%rbx)
movq 0x14e0(%rbx), %rcx
movq (%rcx), %rcx
movl (%rcx,%rax,4), %eax
movl %eax, 0x4(%rbx)
movsd 0x2745(%rip), %xmm1     # 0x6018
xorpd %xmm0, %xmm0
callq 0x2b06
movq 0x14e8(%rbx), %rax
movsd 0x48(%rax), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x3902
movl 0x4(%rax), %esi
decl %esi
xorl %edi, %edi
callq 0x2aec
movl %eax, %r9d
movl %eax, 0x4(%rbx)
jmp 0x3906
movl 0x4(%rbx), %r9d
leaq 0x18(%rbx), %rdi
movl (%rbx), %esi
leaq 0x8(%rbx), %rcx
leaq 0x10(%rbx), %r8
movl %r9d, %edx
callq 0x36a0
leaq 0x6c55(%rip), %rdi      # 0xa578
callq 0x2240
movq 0x14e8(%rbx), %rax
movsd 0x18(%rax), %xmm1
movsd 0x50(%rax), %xmm2
movsd 0x26d7(%rip), %xmm0     # 0x6018
subsd %xmm2, %xmm0
movslq (%rbx), %rax
movq 0x14d0(%rbx), %rcx
movq 0x14d8(%rbx), %rdx
movq (%rcx), %rsi
imulq $0x18, %rax, %rdi
movslq 0x4(%rbx), %rcx
movq (%rsi,%rdi), %rsi
movslq 0x8(%rbx), %rdi
movq (%rdx), %rdx
mulsd (%rdx,%rdi,8), %xmm1
addsd 0x10(%rbx), %xmm1
mulsd %xmm2, %xmm1
mulsd (%rsi,%rcx,8), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rsi,%rcx,8)
ucomisd (%rdx,%rax,8), %xmm0
jbe 0x39a1
movsd %xmm0, (%rdx,%rax,8)
movq 0x14e0(%rbx), %rdx
movq (%rdx), %rdx
movl %ecx, (%rdx,%rax,4)
leaq 0x6bd0(%rip), %rdi      # 0xa578
popq %rbx
jmp 0x2100
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x20(%rdi), %r13
movq %r13, %rdi
callq 0x4964
movq %r15, 0x14d8(%r12)
movq %r14, 0x14e0(%r12)
movq %rbx, 0x14e8(%r12)
andq $0x0, (%r12)
movq %r13, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x3608
// File: /workspace/github_cpp_makefile_star2_O2/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, %r15
movq %rdi, %r12
andq $0x0, (%rdi)
movq %rsi, %r13
andl $0x0, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x18(%rdi), %rbp
movq %rbp, %rdi
callq 0x4964
movq %r13, 0x14d0(%r12)
movq %r15, 0x14d8(%r12)
movq %r14, 0x14e0(%r12)
movq %rbx, 0x14e8(%r12)
movq %rbp, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3608
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdi, %r12
andq $0x0, (%rdi)
movq %rdx, %r13
andl $0x0, 0x8(%rdi)
movq %rsi, %rbp
leaq 0x20(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq %r14, %rdi
callq 0x4964
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 0x3608
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdi, %r15
movq 0x50(%rsp), %r12
andq $0x0, (%rdi)
movq %rcx, %r13
andl $0x0, 0x8(%rdi)
movq %rdx, %rbp
movq %rsi, %rbx
leaq 0x28(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
andq $0x0, 0x20(%rdi)
movq %r14, %rdi
callq 0x4964
movq %rbx, 0x14e0(%r15)
movq %rbp, 0x14e8(%r15)
movq %r13, 0x14f0(%r15)
movq 0x8(%rsp), %rax
movq %rax, 0x14f8(%r15)
movq 0x10(%rsp), %rax
movq %rax, 0x1500(%r15)
movq %r12, 0x1508(%r15)
movq %r14, %rdi
movq %r12, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3608
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x486c
movq %rax, %xmm0
movq (%rbx), %xmm1
paddd %xmm0, %xmm1
movq 0xc(%rbx), %xmm0
pcmpeqd %xmm2, %xmm2
paddd %xmm0, %xmm2
pcmpgtd %xmm1, %xmm0
pand %xmm0, %xmm1
pandn %xmm2, %xmm0
por %xmm1, %xmm0
pxor %xmm1, %xmm1
movdqa %xmm0, %xmm2
pcmpgtd %xmm1, %xmm2
pand %xmm0, %xmm2
movdqa %xmm2, (%rsp)
movq %xmm2, (%rbx)
movsd 0x1993(%rip), %xmm1     # 0x6060
pxor %xmm0, %xmm0
movq %rbx, %rdi
callq 0x4884
cvttsd2si %xmm0, %eax
movdqa (%rsp), %xmm0
movd %xmm0, %ecx
addl %eax, %ecx
movl 0x4(%rbx), %r14d
movl 0xc(%rbx), %eax
leal -0x1(%rax), %edx
cmpl %ecx, %eax
cmovgl %ecx, %edx
xorl %ebp, %ebp
testl %edx, %edx
cmovlel %ebp, %edx
movl %edx, (%rbx)
pxor %xmm0, %xmm0
movq %rbx, %rdi
movsd 0x1951(%rip), %xmm1     # 0x6060
callq 0x4884
cvttsd2si %xmm0, %eax
addl %r14d, %eax
movl 0x10(%rbx), %ecx
leal -0x1(%rcx), %edx
cmpl %eax, %ecx
cmovgl %eax, %edx
testl %edx, %edx
cmovlel %ebp, %edx
movl %edx, 0x4(%rbx)
movsd 0x18e2(%rip), %xmm1     # 0x6018
xorpd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x48b0
movsd 0x20(%rbx), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x47af
movl (%rbx), %r14d
movsd 0x18c0(%rip), %xmm1     # 0x6018
xorpd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x4884
cvttsd2si %xmm0, %eax
addl %r14d, %eax
movl 0x4(%rbx), %r14d
movl 0xc(%rbx), %ecx
leal -0x1(%rcx), %edx
cmpl %eax, %ecx
cmovgl %eax, %edx
testl %edx, %edx
cmovlel %ebp, %edx
movl %edx, (%rbx)
xorpd %xmm0, %xmm0
movq %rbx, %rdi
movsd 0x1888(%rip), %xmm1     # 0x6018
callq 0x4884
cvttsd2si %xmm0, %eax
addl %r14d, %eax
movl 0x10(%rbx), %ecx
leal -0x1(%rcx), %edx
cmpl %eax, %ecx
cmovgl %eax, %edx
testl %edx, %edx
cmovlel %ebp, %edx
movl %edx, 0x4(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x47d0
cmpl 0x18(%rdi), %ecx
jne 0x47d0
movsd 0x1849(%rip), %xmm0     # 0x6018
retq
orl %eax, %ecx
je 0x47f2
subl 0x8(%rdi), %esi
movl %esi, %eax
negl %eax
cmovsl %esi, %eax
pushq $0x8
popq %rcx
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_O2/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
subq $0x10, %rsp
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x1808(%rip), %xmm1     # 0x6018
callq 0x48b0
movslq 0x8(%rbx), %rax
shlq $0x5, %rax
leaq (%rax,%rbx), %rcx
addq $0x13b8, %rcx           # imm = 0x13B8
xorl %eax, %eax
cmpq $0x8, %rax
je 0x4853
cvtss2sd (%rcx,%rax,4), %xmm1
movsd 0x8(%rsp), %xmm2
addsd %xmm1, %xmm2
ucomisd %xmm0, %xmm2
ja 0x4850
movsd %xmm2, 0x8(%rsp)
incq %rax
jmp 0x482a
movl %eax, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movq %rdi, (%rsp)
movups %xmm0, (%rdi)
movq (%rsi), %r12
leaq 0x8(%rsp), %r13
leaq 0x2d4f(%rip), %rbp      # 0x51ad
cmpq 0x8(%r15), %r12
je 0x24a0
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x2e54
movq %r13, %rdi
movq %rbp, %rsi
callq 0x2e4a
movl %eax, %ebx
movq %r13, %rdi
callq 0x20f0
testb %bl, %bl
je 0x2497
movq (%rsp), %rdi
movq %r12, %rsi
callq 0x2ebc
addq $0xc0, %r12
jmp 0x245e
movq (%rsp), %rbx
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
leaq -0x96(%rip), %rdx       # 0x241c
callq 0x372c
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x24cd
jmp 0x24cd
movq %rax, %r14
jmp 0x24df
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x20f0
movq (%rsp), %rdi
callq 0x2eec
movq %r14, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x311b
leaq 0x20(%r14), %rsi
testb %al, %al
je 0x2e7e
movq %rbx, %rdi
jmp 0x2e93
movq %rsi, %rdi
movq %r15, %rsi
callq 0x311b
testb %al, %al
je 0x2e9a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2220
jmp 0x2eae
leaq 0x230c(%rip), %rsi      # 0x51ad
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x3144
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/amr_report.cpp
// Function: (anonymous namespace)::HmmAlignment::good() const
bool good () const
    { QC_ASSERT (fam);
      QC_ASSERT (! fam->hmm. empty ());
    	return    score1 >= fam->tc1
             && score2 >= fam->tc2; 
    }

// Assembly:
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rdi, %rbx
callq 0xb060
andl $0x0, (%rax)
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x1aa6b
cmpq $0x0, 0x78(%rax)
je 0x1ab3f
movsd 0x20(%rbx), %xmm0
ucomisd 0x90(%rax), %xmm0
jae 0x1aa52
xorl %eax, %eax
jmp 0x1aa62
movsd 0x28(%rbx), %xmm0
ucomisd 0x98(%rax), %xmm0
setae %al
addq $0x110, %rsp            # imm = 0x110
popq %rbx
retq
callq 0xb680
testl %eax, %eax
jne 0x1ac13
leaq 0x4eea8(%rip), %rsi     # 0x69927
leaq 0x70(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x27230
leaq 0x50(%rsp), %rdi
movl $0xef, %esi
callq 0x279bd
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x27956
leaq 0x4ee84(%rip), %rdx     # 0x6993f
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x273ec
leaq 0x4fc47(%rip), %rsi     # 0x6a71e
leaq 0x10(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x27230
leaq 0x4f323(%rip), %rdx     # 0x69e10
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x273ec
leaq 0xd0(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x27956
leaq 0x4e638(%rip), %rdx     # 0x69155
leaq 0xf0(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
callq 0x273ec
leaq 0xf0(%rsp), %rdi
callq 0x2f08c
callq 0xb680
testl %eax, %eax
jne 0x1ac13
leaq 0x4edd4(%rip), %rsi     # 0x69927
leaq 0x70(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x27230
leaq 0x50(%rsp), %rdi
movl $0xf0, %esi
callq 0x279bd
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x27956
leaq 0x4edb0(%rip), %rdx     # 0x6993f
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x273ec
leaq 0x4fb73(%rip), %rsi     # 0x6a71e
leaq 0x10(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x27230
leaq 0x4f24f(%rip), %rdx     # 0x69e10
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x273ec
leaq 0xd0(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x27956
leaq 0x4fb64(%rip), %rdx     # 0x6a755
leaq 0xf0(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
callq 0x273ec
leaq 0xf0(%rsp), %rdi
callq 0x2f08c
pushq $0x1
popq %rdi
callq 0xb690
jmp 0x1ac1f
jmp 0x1ac31
movq %rax, %rbx
leaq 0xf0(%rsp), %rdi
callq 0xbb38
jmp 0x1ac34
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0xbb38
jmp 0x1ac48
jmp 0x1ac45
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xbb38
jmp 0x1ac59
jmp 0x1ac56
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xbb38
jmp 0x1ac6a
jmp 0x1ac67
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0xbb38
jmp 0x1ac7e
jmp 0x1ac7b
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0xbb38
jmp 0x1ac92
jmp 0x1ac8f
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xbb38
jmp 0x1aca3
jmp 0x1aca0
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xbb38
jmp 0x1acb4
jmp 0x1acb1
movq %rax, %rbx
movq %rbx, %rdi
callq 0xb9f0
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/amr_report.cpp
// Function: (anonymous namespace)::BlastAlignment::setTargetAlign()
void setTargetAlign ()
    { targetAlign = targetEnd - targetStart;
      targetAlign_aa = targetAlign;
      if (! targetProt)
      {
        QC_ASSERT (targetAlign % 3 == 0);
        targetAlign_aa = targetAlign / 3;
      }
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq 0x58(%rdi), %r14
subq 0x50(%rdi), %r14
movq %r14, 0x238(%rdi)
movq %r14, 0x240(%rdi)
cmpb $0x0, 0x8(%rdi)
jne 0x1ade8
movq %rdi, %rbx
callq 0xb060
andl $0x0, (%rax)
pushq $0x3
popq %rcx
movq %r14, %rax
xorl %edx, %edx
divq %rcx
testq %rdx, %rdx
jne 0x1adf3
movq %rax, 0x240(%rbx)
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
retq
callq 0xb680
testl %eax, %eax
jne 0x1aec7
leaq 0x4eb20(%rip), %rsi     # 0x69927
leaq 0x68(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x27230
leaq 0x48(%rsp), %rdi
movl $0x4fe, %esi            # imm = 0x4FE
callq 0x279bd
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x27956
leaq 0x4eafc(%rip), %rdx     # 0x6993f
leaq 0xa8(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x273ec
leaq 0x4f982(%rip), %rsi     # 0x6a7e1
leaq 0x8(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0x27230
leaq 0x4ef9b(%rip), %rdx     # 0x69e10
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x273ec
leaq 0xc8(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x27956
leaq 0x4f979(%rip), %rdx     # 0x6a81e
leaq 0xe8(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
callq 0x273ec
leaq 0xe8(%rsp), %rdi
callq 0x2f08c
pushq $0x1
popq %rdi
callq 0xb690
movq %rax, %rbx
leaq 0xe8(%rsp), %rdi
callq 0xbb38
jmp 0x1aee4
movq %rax, %rbx
leaq 0xc8(%rsp), %rdi
callq 0xbb38
jmp 0x1aef6
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xbb38
jmp 0x1af05
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xbb38
jmp 0x1af14
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0xbb38
jmp 0x1af26
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0xbb38
jmp 0x1af38
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xbb38
jmp 0x1af47
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0xbb38
movq %rbx, %rdi
callq 0xb9f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %rsi
movq %rax, %rdi
callq 0xb4f0
pushq $0x9
popq %rbp
movq %rax, %rdi
movl %ebp, %esi
callq 0xb640
movsd 0x28(%rbx), %xmm0
movq %rax, %rdi
callq 0xb8d0
movq %rax, %rdi
movl %ebp, %esi
callq 0xb640
leaq 0x30(%rbx), %rsi
movq %rax, %rdi
callq 0xb4f0
movq %rax, %rdi
movl %ebp, %esi
callq 0xb640
leaq 0x50(%rbx), %rsi
movq %rax, %rdi
callq 0xb4f0
movq %rax, %rdi
movl %ebp, %esi
callq 0xb640
addq $0x70, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0xb4f0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xb2d0
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/amr_report.cpp
// Function: (anonymous namespace)::BlastAlignment::getFam() const
const Fam* getFam () const
    { ASSERT (inFam ());
      const Fam* fam = famId2fam [famId];
      if (! fam)
        fam = famId2fam [gene];
      if (! fam)
      	throw runtime_error ("Cannot find hierarchy for: " + famId + " / " + gene);
      return fam;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdi, %rbx
callq 0xb060
andl $0x0, (%rax)
movq %rbx, %rdi
callq 0x202bc
testb %al, %al
je 0x2034c
leaq 0x2a8(%rbx), %r15
leaq 0x7779c(%rip), %rdi     # 0x97aa8
movq %r15, %rsi
callq 0x1fb4e
movq (%rax), %rax
testq %rax, %rax
jne 0x2033e
addq $0x2c8, %rbx            # imm = 0x2C8
leaq 0x7777e(%rip), %rdi     # 0x97aa8
movq %rbx, %rsi
callq 0x1fb4e
movq (%rax), %rax
testq %rax, %rax
je 0x20428
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0xb680
testl %eax, %eax
jne 0x20420
leaq 0x495c7(%rip), %rsi     # 0x69927
leaq 0xc8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x27230
leaq 0xa8(%rsp), %rdi
movl $0x4b9, %esi            # imm = 0x4B9
callq 0x279bd
leaq 0xe8(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
leaq 0xa8(%rsp), %rdx
callq 0x27956
leaq 0x49597(%rip), %rdx     # 0x6993f
leaq 0x8(%rsp), %rdi
leaq 0xe8(%rsp), %rsi
callq 0x273ec
leaq 0x49e78(%rip), %rsi     # 0x6a239
leaq 0x68(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0x27230
leaq 0x49a39(%rip), %rdx     # 0x69e10
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x273ec
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x88(%rsp), %rdx
callq 0x27956
leaq 0x4ac5b(%rip), %rdx     # 0x6b062
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x273ec
leaq 0x48(%rsp), %rdi
callq 0x2f08c
pushq $0x1
popq %rdi
callq 0xb690
pushq $0x10
popq %rdi
callq 0xb2e0
movq %rax, %r14
leaq 0x49e40(%rip), %rsi     # 0x6a27a
leaq 0x8(%rsp), %rdi
movq %r15, %rdx
callq 0x2740b
leaq 0x49e48(%rip), %rdx     # 0x6a296
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x273ec
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
movq %rbx, %rdx
callq 0x281bb
movb $0x1, %bpl
leaq 0x48(%rsp), %rsi
movq %r14, %rdi
callq 0xb8f0
xorl %ebp, %ebp
movq 0x76b68(%rip), %rsi     # 0x96ff0
movq 0x76ad9(%rip), %rdx     # 0x96f68
movq %r14, %rdi
callq 0xb990
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xbb38
jmp 0x204a9
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xbb38
jmp 0x204b8
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0xbb38
jmp 0x204ca
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0xbb38
jmp 0x204d9
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xbb38
jmp 0x204e8
movq %rax, %rbx
leaq 0xe8(%rsp), %rdi
callq 0xbb38
jmp 0x2051b
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xbb38
jmp 0x2050c
movq %rax, %rbx
movb $0x1, %bpl
leaq 0x28(%rsp), %rdi
callq 0xbb38
jmp 0x20530
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0xbb38
jmp 0x20544
movq %rax, %rbx
movb $0x1, %bpl
leaq 0x8(%rsp), %rdi
callq 0xbb38
testb %bpl, %bpl
jne 0x20556
jmp 0x20563
movq %rax, %rbx
leaq 0xc8(%rsp), %rdi
callq 0xbb38
jmp 0x20563
movq %rax, %rbx
movq %r14, %rdi
callq 0xb440
jmp 0x20563
movq %rax, %rbx
movq %rbx, %rdi
callq 0xb9f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/amr_report.cpp
// Function: (anonymous namespace)::Batch::setStopCodon((anonymous namespace)::BlastAlignment&)
void setStopCodon (BlastAlignment &blastAlP)
    { 
      ASSERT (blastAlP. targetProt);
      for (const Locus& cds : blastAlP. cdss)
        if (const VectorPtr<BlastAlignment>* blastAlsX = findPtr (target2blastAls, cds. contig))
          for (const BlastAlignment* blastAlX : *blastAlsX)
            if (   ! blastAlX->targetProt 
                && blastAlX->stopCodon
                && blastAlP. better (*blastAlX)
               )
              blastAlP. stopCodon = true;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rsi, %rbx
movq %rdi, %r14
callq 0xb060
andl $0x0, (%rax)
cmpb $0x0, 0x8(%rbx)
je 0x21a19
movq 0x3b8(%rbx), %r15
movq 0x3c0(%rbx), %r12
addq $0xf0, %r14
cmpq %r12, %r15
je 0x21a07
leaq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x1ad30
testq %rax, %rax
je 0x219fe
movq (%rax), %r13
movq 0x8(%rax), %rbp
cmpq %rbp, %r13
je 0x219fe
movq (%r13), %rsi
cmpb $0x0, 0x8(%rsi)
jne 0x219f8
cmpb $0x1, 0x249(%rsi)
jne 0x219f8
movq %rbx, %rdi
callq 0x225e2
testb %al, %al
je 0x219f8
movb $0x1, 0x249(%rbx)
addq $0x8, %r13
jmp 0x219cd
addq $0x90, %r15
jmp 0x219b0
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xb680
testl %eax, %eax
jne 0x21aed
leaq 0x47efa(%rip), %rsi     # 0x69927
leaq 0x68(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x27230
leaq 0x48(%rsp), %rdi
movl $0x671, %esi            # imm = 0x671
callq 0x279bd
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x27956
leaq 0x47ed6(%rip), %rdx     # 0x6993f
leaq 0xa8(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x273ec
leaq 0x491eb(%rip), %rsi     # 0x6ac70
leaq 0x8(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0x27230
leaq 0x48375(%rip), %rdx     # 0x69e10
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x273ec
leaq 0xc8(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x27956
leaq 0x491e7(%rip), %rdx     # 0x6acb2
leaq 0xe8(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
callq 0x273ec
leaq 0xe8(%rsp), %rdi
callq 0x2f08c
pushq $0x1
popq %rdi
callq 0xb690
movq %rax, %rbx
leaq 0xe8(%rsp), %rdi
callq 0xbb38
jmp 0x21b0a
movq %rax, %rbx
leaq 0xc8(%rsp), %rdi
callq 0xbb38
jmp 0x21b1c
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xbb38
jmp 0x21b2b
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xbb38
jmp 0x21b3a
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0xbb38
jmp 0x21b4c
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0xbb38
jmp 0x21b5e
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xbb38
jmp 0x21b6d
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0xbb38
movq %rbx, %rdi
callq 0xb9f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rdi, %rbx
callq 0xb060
andl $0x0, (%rax)
movq %rbx, %rdi
callq 0x202bc
testb %al, %al
je 0x21c36
cmpb $0x1, 0x24a(%rbx)
jne 0x21c26
movq %rbx, %rdi
addq $0x110, %rsp            # imm = 0x110
popq %rbx
jmp 0x202da
movq 0x350(%rbx), %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbx
retq
callq 0xb680
testl %eax, %eax
jne 0x21d0a
leaq 0x47cdd(%rip), %rsi     # 0x69927
leaq 0x70(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x27230
leaq 0x50(%rsp), %rdi
movl $0x4c3, %esi            # imm = 0x4C3
callq 0x279bd
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x27956
leaq 0x47cb9(%rip), %rdx     # 0x6993f
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x273ec
leaq 0x492be(%rip), %rsi     # 0x6af60
leaq 0x10(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x27230
leaq 0x48158(%rip), %rdx     # 0x69e10
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x273ec
leaq 0xd0(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x27956
leaq 0x4937a(%rip), %rdx     # 0x6b062
leaq 0xf0(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
callq 0x273ec
leaq 0xf0(%rsp), %rdi
callq 0x2f08c
pushq $0x1
popq %rdi
callq 0xb690
movq %rax, %rbx
leaq 0xf0(%rsp), %rdi
callq 0xbb38
jmp 0x21d27
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0xbb38
jmp 0x21d39
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xbb38
jmp 0x21d48
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xbb38
jmp 0x21d57
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0xbb38
jmp 0x21d69
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0xbb38
jmp 0x21d7b
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xbb38
jmp 0x21d8a
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xbb38
movq %rbx, %rdi
callq 0xb9f0
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x3b8(%rdi), %rcx
movq 0x3c0(%rdi), %r15
movq %rcx, %r14
cmpq %r15, %rcx
je 0x224ea
movq %rbx, %rdi
movq %r14, %rsi
callq 0x22524
leaq 0x90(%r14), %rcx
testb %al, %al
je 0x224cc
cmpq %r15, %r14
setne %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/amr_report.cpp
// Function: (anonymous namespace)::BlastAlignment::truncated(GFF_sp::Locus const&) const
bool getTargetStrand (const Locus &cds) const
    { return targetProt
               ? cds. empty ()
                 ? true
                 : cds. strand
               : targetStrand;
    }

// Assembly:
movb 0x8(%rdi), %al
cmpb $0x1, %al
jne 0x22538
cmpq $0x0, 0x10(%rsi)
je 0x2253e
movb 0x38(%rsi), %r8b
jmp 0x22541
movb 0x68(%rdi), %r8b
jmp 0x22541
movb $0x1, %r8b
movq 0xb8(%rdi), %rcx
movq 0xc8(%rdi), %rdx
subq 0xc0(%rdi), %rdx
testb $0x1, %r8b
movq %rdx, %r8
cmovneq %rcx, %r8
testq %r8, %r8
je 0x2257d
testb %al, %al
je 0x225b9
movq 0x10(%rsi), %rdi
testq %rdi, %rdi
je 0x22585
movb $0x1, %al
cmpq $0x4, 0x28(%rsi)
jae 0x22585
retq
testb %al, %al
je 0x225c2
movq 0x10(%rsi), %rdi
testb $0x1, 0x38(%rsi)
cmovneq %rdx, %rcx
testq %rdi, %rdi
cmoveq %rdx, %rcx
sete %al
testq %rcx, %rcx
sete %cl
orb %al, %cl
jne 0x225df
movq 0x40(%rsi), %rax
testq %rax, %rax
setne %cl
subq 0x30(%rsi), %rax
cmpq $0x4, %rax
setb %al
andb %cl, %al
retq
movb $0x1, %al
cmpq $0x4, 0x50(%rdi)
jb 0x2257c
cmpb $0x0, 0x68(%rdi)
cmovneq %rdx, %rcx
testq %rcx, %rcx
je 0x225df
movq 0x60(%rdi), %rax
subq 0x58(%rdi), %rax
cmpq $0x4, %rax
setb %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/amr_report.cpp
// Function: (anonymous namespace)::BlastAlignment::fusion2geneSymbols[abi:cxx11]() const
string fusion2geneSymbols () const
    { ASSERT (! isMutationProt ());
      if (fusions. empty ())
        return getGeneSymbol ();
      string s;
      for (const BlastAlignment* fusion : fusions)
        add (s, "/" /*fusion_infix*/, fusion->getGeneSymbol ());  // PD-5155 ??
      return s;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rsi, %r15
movq %rdi, %r14
callq 0xb060
andl $0x0, (%rax)
movq %r15, %rdi
callq 0x202a8
testb %al, %al
jne 0x22f5e
movq 0x280(%r15), %rbx
movq 0x288(%r15), %r12
cmpq %r12, %rbx
je 0x22f3e
leaq 0x10(%r14), %rax
movq %rax, (%r14)
andq $0x0, 0x8(%r14)
movb $0x0, 0x10(%r14)
leaq 0x28(%rsp), %r15
leaq 0x8(%rsp), %r13
cmpq %r12, %rbx
je 0x22f49
movq (%rbx), %rbp
movq %r15, %rdi
leaq 0x49764(%rip), %rsi     # 0x6c669
leaq 0x48(%rsp), %rdx
callq 0x27230
movq %r13, %rdi
movq %rbp, %rsi
callq 0x239c6
movq %r14, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x2c6f9
movq %r13, %rdi
callq 0xbb38
movq %r15, %rdi
callq 0xbb38
addq $0x8, %rbx
jmp 0x22ef3
movq %r14, %rdi
movq %r15, %rsi
callq 0x239c6
movq %r14, %rax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xb680
testl %eax, %eax
jne 0x23032
leaq 0x469b5(%rip), %rsi     # 0x69927
leaq 0xc8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x27230
leaq 0xa8(%rsp), %rdi
movl $0x343, %esi            # imm = 0x343
callq 0x279bd
leaq 0xe8(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
leaq 0xa8(%rsp), %rdx
callq 0x27956
leaq 0x46985(%rip), %rdx     # 0x6993f
leaq 0x48(%rsp), %rdi
leaq 0xe8(%rsp), %rsi
callq 0x273ec
leaq 0x47d87(%rip), %rsi     # 0x6ad5a
leaq 0x68(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0x27230
leaq 0x46e27(%rip), %rdx     # 0x69e10
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x273ec
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0x88(%rsp), %rdx
callq 0x27956
leaq 0x47d8a(%rip), %rdx     # 0x6ada3
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x273ec
leaq 0x28(%rsp), %rdi
callq 0x2f08c
pushq $0x1
popq %rdi
callq 0xb690
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xbb38
jmp 0x2304c
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xbb38
jmp 0x2305b
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0xbb38
jmp 0x2306d
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0xbb38
jmp 0x2307c
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xbb38
jmp 0x2308b
movq %rax, %rbx
leaq 0xe8(%rsp), %rdi
callq 0xbb38
jmp 0x2309d
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0xbb38
jmp 0x230af
movq %rax, %rbx
leaq 0xc8(%rsp), %rdi
jmp 0x230e2
movq %rax, %rbx
jmp 0x230e7
movq %rax, %rbx
jmp 0x230df
movq %rax, %rbx
jmp 0x230d5
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xbb38
leaq 0x28(%rsp), %rdi
callq 0xbb38
movq %r14, %rdi
callq 0xbb38
movq %rbx, %rdi
callq 0xb9f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
andl $0x0, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
movb $0x0, 0x30(%rdi)
movq 0x218(%rsi), %r14
movq 0x220(%rsi), %r15
movl $0xa8, %r12d
cmpq %r15, %r14
je 0x239a1
cmpq $0x0, 0x20(%r14)
je 0x23998
movq 0x88(%r14), %r13
movq 0x90(%r14), %rbp
cmpq %rbp, %r13
je 0x23998
movq (%r13), %rsi
addq %r12, %rsi
movq %rbx, %rdi
callq 0x2c73c
addq $0x8, %r13
jmp 0x2397e
addq $0xb0, %r14
jmp 0x23964
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2c9c6
movq %r14, %rdi
callq 0xb9f0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x3d8(%rsi), %rsi
testq %rsi, %rsi
je 0x239ea
addq $0x8, %rsi
movq %rbx, %rdi
jmp 0x23a03
movq %r14, %rdi
callq 0x23906
testb %al, %al
je 0x23a15
addq $0x2a8, %r14            # imm = 0x2A8
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb760
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0x21bee
movq %rax, %r14
leaq 0x47390(%rip), %rsi     # 0x6adb7
leaq 0x10(%rsp), %r15
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
callq 0x27230
addq $0x28, %r14
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2c724
leaq 0x10(%rsp), %rdi
callq 0xbb38
jmp 0x23a08
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xbb38
movq %rbx, %rdi
callq 0xb9f0
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/amr_report.cpp
// Function: (anonymous namespace)::BlastAlignment::fusion2reportable() const
uchar fusion2reportable () const
    { ASSERT (! isMutationProt ());
      if (susceptible)
        return 2;
      if (fusions. empty ())
        return getReportable ();
      uchar reportable_max = 0;
      for (const BlastAlignment* fusion : fusions)
        maximize (reportable_max, fusion->getReportable ());
      return reportable_max;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdi, %r14
callq 0xb060
andl $0x0, (%rax)
movq %r14, %rdi
callq 0x202a8
testb %al, %al
jne 0x26c1b
movb $0x2, %bl
cmpq $0x0, 0x3d8(%r14)
je 0x26bd2
movl %ebx, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x280(%r14), %r15
movq 0x288(%r14), %r12
cmpq %r12, %r15
je 0x26c05
xorl %ebx, %ebx
cmpq %r12, %r15
je 0x26bc1
movq (%r15), %rdi
callq 0x26f0e
movzbl %bl, %ecx
movzbl %al, %ebx
cmpb %bl, %cl
cmoval %ecx, %ebx
addq $0x8, %r15
jmp 0x26be7
movq %r14, %rdi
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x26f0e
callq 0xb680
testl %eax, %eax
jne 0x26cef
leaq 0x42cf8(%rip), %rsi     # 0x69927
leaq 0x68(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x27230
leaq 0x48(%rsp), %rdi
movl $0x32f, %esi            # imm = 0x32F
callq 0x279bd
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x27956
leaq 0x42cd4(%rip), %rdx     # 0x6993f
leaq 0xa8(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x273ec
leaq 0x4493c(%rip), %rsi     # 0x6b5c3
leaq 0x8(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0x27230
leaq 0x43173(%rip), %rdx     # 0x69e10
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x273ec
leaq 0xc8(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x27956
leaq 0x440d6(%rip), %rdx     # 0x6ada3
leaq 0xe8(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
callq 0x273ec
leaq 0xe8(%rsp), %rdi
callq 0x2f08c
pushq $0x1
popq %rdi
callq 0xb690
movq %rax, %rbx
leaq 0xe8(%rsp), %rdi
callq 0xbb38
jmp 0x26d0c
movq %rax, %rbx
leaq 0xc8(%rsp), %rdi
callq 0xbb38
jmp 0x26d1e
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xbb38
jmp 0x26d2d
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xbb38
jmp 0x26d3c
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0xbb38
jmp 0x26d4e
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0xbb38
jmp 0x26d60
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xbb38
jmp 0x26d6f
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0xbb38
movq %rbx, %rdi
callq 0xb9f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2c66e
movq 0xc8(%rdi), %rcx
testq %rcx, %rcx
je 0x2c66e
movq 0x200(%rdi), %rdx
xorl %eax, %eax
cmpq %rcx, %rdx
jne 0x2c66d
cmpq 0x38(%rdi), %rdx
jne 0x2c66d
movl 0x6c(%rdi), %edx
testl %edx, %edx
je 0x2c66e
andb 0x8(%rdi), %sil
movb $0x1, %al
cmpb $0x1, %sil
jne 0x2c66d
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_O2/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 0x2c684
andb %cl, %al
retq
movq 0x28(%rdi), %rax
cmpq 0x28(%rsi), %rax
je 0x2c696
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movb $0x1, %bpl
cmpb $0x0, 0x30(%rdi)
jne 0x2c6be
movq %rsi, %rbx
cmpb $0x0, 0x30(%rsi)
jne 0x2c6bc
movq %rdi, %r14
movq 0x28(%rbx), %rax
cmpq 0x28(%rdi), %rax
jbe 0x2c6cb
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%rbx), %r15
addq $0x8, %rbx
cmpq %rbx, %r15
sete %bpl
je 0x2c6be
leaq 0x20(%r15), %rsi
movq %r14, %rdi
callq 0x2c932
testb %al, %al
je 0x2c6be
movq %r15, %rdi
callq 0xb620
movq %rax, %r15
jmp 0x2c6d3
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movl %edx, %ebp
movq %rdi, %r15
andq $0x0, (%rdi)
movl %esi, %r12d
movl $0x1f4, 0x8(%rdi)       # imm = 0x1F4
movaps 0x1b22(%rip), %xmm0     # 0x4010
movups %xmm0, 0xc(%rdi)
movabsq $0x200000003, %rax      # imm = 0x200000003
movq %rax, 0x1c(%rdi)
movl $0x4, 0x24(%rdi)
leaq 0x28(%rdi), %rbx
movq %rbx, %rdi
callq 0x33a6
leaq 0x13b0(%r15), %r14
movq %r14, %rdi
callq 0x33fc
andq $0x0, 0x2748(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x2738(%r15)
movl %r12d, (%r15)
movl %ebp, 0x4(%r15)
movq %rbx, %rdi
callq 0x2240
movl %eax, %esi
movq %r14, %rdi
callq 0x3406
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x343e
movq %r14, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/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 0x259e
callq 0x21e0
movq 0x2748(%rbx), %rdi
testq %rdi, %rdi
je 0x25af
callq 0x21e0
cmpq $0x0, 0x2740(%rbx)
je 0x25ef
xorl %r14d, %r14d
movl 0x8(%rbx), %eax
movq 0x2740(%rbx), %rdi
cmpq %rax, %r14
jae 0x25de
movq (%rdi,%r14,8), %rdi
testq %rdi, %rdi
je 0x25d9
callq 0x21e0
incq %r14
jmp 0x25bc
testq %rdi, %rdi
je 0x25ef
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21e0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/4shadoww[P]xwinter/xwinter.cpp
// Function: sky::create_sky()
void sky::create_sky(){
    // Check is there an old sky
    sky::free_memory();

    // Reverse memory
    this->snowflakes = new XRectangle[this->particle_count];
    this->snowflakespeeds = new flakespeed[this->particle_count];
    this->positions = new float*[this->particle_count];

    for(unsigned int i = 0; i < this->particle_count; i++){
        this->positions[i] = new float[2];
    }

    // Temp variables
    std::pair<int, int> temp_pair;
    int temp_int;

    // Create randomised flakes
    for(unsigned int i = 0; i < this->particle_count; i++){
        // Get random position
        temp_pair = sky::get_random_position(0, this->screen_width, 0, this->screen_heigth);
        // Set position on screen
        this->snowflakes[i].x = temp_pair.first;
        this->snowflakes[i].y = temp_pair.second;
        // Set position to float number table
        this->positions[i][0] = temp_pair.first;
        this->positions[i][1] = temp_pair.second;
        // Set random size
        temp_int = sky::get_random_size(this->min_size, this->max_size);
        this->snowflakes[i].height = temp_int;
        this->snowflakes[i].width = temp_int;
        // Set random speed
        temp_pair = this->get_random_speed(this->min_speed_x, this->max_speed_x, this->min_speed_y, this->max_speed_y);
        this->snowflakespeeds[i].speed_x = temp_pair.first;
        this->snowflakespeeds[i].speed_y = temp_pair.second;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2586
movl 0x8(%rbx), %r12d
leaq (,%r12,8), %r14
movq %r14, %rdi
callq 0x2030
movq %rax, 0x2738(%rbx)
movq %r14, %rdi
callq 0x2030
movq %rax, %r15
testq %r12, %r12
je 0x273e
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x20f0
movq %r15, 0x2748(%rbx)
movq %r14, %rdi
callq 0x2030
movq %rax, 0x2740(%rbx)
xorl %r15d, %r15d
pushq $0x8
popq %r14
cmpq %r15, %r12
je 0x2778
movq %r14, %rdi
callq 0x2030
movq 0x2740(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
jmp 0x275b
xorl %r14d, %r14d
movl %r12d, %eax
cmpq %rax, %r14
jae 0x2824
movl (%rbx), %edx
movl 0x4(%rbx), %r8d
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x2654
movq 0x2738(%rbx), %rcx
movw %ax, (%rcx,%r14,8)
cvtsi2ss %eax, %xmm0
shrq $0x20, %rax
movw %ax, 0x2(%rcx,%r14,8)
movq 0x2740(%rbx), %rcx
movq (%rcx,%r14,8), %rcx
cvtsi2ss %eax, %xmm1
movss %xmm0, (%rcx)
movss %xmm1, 0x4(%rcx)
movl 0x20(%rbx), %esi
movl 0x24(%rbx), %edx
movq %rbx, %rdi
callq 0x26dc
movq 0x2738(%rbx), %rcx
movw %ax, 0x6(%rcx,%r14,8)
movw %ax, 0x4(%rcx,%r14,8)
movss 0xc(%rbx), %xmm0
movss 0x10(%rbx), %xmm1
movss 0x14(%rbx), %xmm2
movss 0x18(%rbx), %xmm3
callq 0x26a0
movq 0x2748(%rbx), %rax
cvttps2dq %xmm0, %xmm0
cvtdq2ps %xmm0, %xmm0
movlps %xmm0, (%rax,%r14,8)
incq %r14
movl 0x8(%rbx), %r12d
jmp 0x277b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq