LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/jp-myk[P]WAVUtil/src/wav_test.cpp
// Function: main
int main(int argc, char *argv[]){
  if(argc<2){
    std::cout << argv[0] << " FILENAME" << std::endl;
    exit(0);
  }
  const char* wavFName=argv[1];
  std::string outFNameStr=wavFName;
  outFNameStr+="_cp.wav";
  WAV wav;
  int res=0;
  res=wav.Read(wavFName);
  wav.Write(outFNameStr.c_str());
  wav.dumpHeader();
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x78, %rsp
cmpl $0x1, %edi
jle 0x3b6c
movq 0x8(%rsi), %rbx
movq %rsp, %r14
leaq 0x20(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3bd8
leaq 0x841(%rip), %rsi       # 0x4313
movq %r14, %rdi
callq 0x22b0
xorl %eax, %eax
leaq 0x20(%rsp), %rdi
movl %eax, 0x4(%rdi)
movabsq $0x2000100000010, %rcx  # imm = 0x2000100000010
movq %rcx, 0x10(%rdi)
movabsq $0x7d000000ac44, %rcx   # imm = 0x7D000000AC44
movq %rcx, 0x18(%rdi)
movl $0x100002, 0x20(%rdi)   # imm = 0x100002
movl %eax, 0x28(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x40(%rdi)
movq $0x0, 0x50(%rdi)
movq %rbx, %rsi
callq 0x2ab0
movq (%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x2808
leaq 0x20(%rsp), %rdi
callq 0x2e10
leaq 0x20(%rsp), %rdi
callq 0x275e
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3b62
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2190
xorl %eax, %eax
addq $0x78, %rsp
popq %rbx
popq %r14
retq
movq (%rsi), %rsi
movq 0x245a(%rip), %rdi      # 0x5fd0
callq 0x2170
leaq 0x787(%rip), %rsi       # 0x4309
movq %rax, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
xorl %edi, %edi
callq 0x21c0
jmp 0x3bd0
movq %rax, %rbx
jmp 0x3bad
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x275e
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3bc8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2190
movq %rbx, %rdi
callq 0x2280
movq %rax, %rdi
callq 0x37bf
// File: /workspace/github_cpp_makefile_star2_O1/pranavmodx[P]modlang/test/parser_test.cpp
// Function: main
int main()
{
	TestLetStatement();
	TestReturnStatement();
	TestIdentifierExpression();
	TestIntegerLiteralExpression();
}

// Assembly:
pushq %rax
callq 0x7625
callq 0x7a02
callq 0x7d15
callq 0x80d8
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O1/pranavmodx[P]modlang/test/parser_test.cpp
// Function: checkParserErrors(Parser&)
void checkParserErrors(Parser &parser)
{
	std::vector<std::string> errors = parser.Errors();

	if (errors.empty())
		return;

	else
	{
		std::cout << "parser has " << errors.size() << " errors" << std::endl;
		for (std::string error : errors)
			std::cout << "parser error : " << error << std::endl;

		exit(0);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rsi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x13664
movq (%rbx), %rax
cmpq 0x8(%rbx), %rax
jne 0x84ca
movq %rsp, %rdi
callq 0x889e
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x16b07(%rip), %rdi     # 0x1efd8
leaq 0xeb7e(%rip), %rsi      # 0x17056
movl $0xb, %edx
callq 0x4210
movq 0x8(%rsp), %rsi
subq (%rsp), %rsi
sarq $0x5, %rsi
movq 0x16ae2(%rip), %rdi     # 0x1efd8
callq 0x4130
movq %rax, %rbx
leaq 0xeb5d(%rip), %rsi      # 0x17062
movl $0x7, %edx
movq %rax, %rdi
callq 0x4210
movq %rbx, %rdi
callq 0x40e0
movq (%rsp), %r12
movq 0x8(%rsp), %rbp
cmpq %rbp, %r12
jne 0x852f
xorl %edi, %edi
callq 0x4230
leaq 0x28(%rsp), %r13
leaq 0x18(%rsp), %rbx
movq 0x16a98(%rip), %r14     # 0x1efd8
leaq 0xeb23(%rip), %r15      # 0x1706a
movq %r13, 0x18(%rsp)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x8bde
movl $0xf, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x4210
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq %r14, %rdi
callq 0x4210
movq %rax, %rdi
callq 0x40e0
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0x85a1
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x41d0
addq $0x20, %r12
cmpq %rbp, %r12
jne 0x8547
jmp 0x8528
jmp 0x85cd
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0x85d0
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x41d0
jmp 0x85d0
movq %rax, %rbx
movq %rsp, %rdi
callq 0x889e
movq %rbx, %rdi
callq 0x4330
// File: /workspace/github_cpp_makefile_star2_O1/mburhanpurkar[P]fast_xorshift_plus/test_rng.cpp
// Function: main
int main()
{
    // Warm up the CPU - needed for timing
    warm_up_cpu();

    // Timing test
    __m256i out;
    time_64_bits(&out, 1000000);

    cout << "--------------------------------------------------" << endl;
  
    // Test to compare the outputs of vec_xorshift_plus and xorshift_plus
    test_xorshift();

    return 0;
}

// Assembly:
vpxor %xmm0, %xmm0, %xmm0
vpmovsxbq 0x1d71(%rip), %zmm1 # 0x4148
movl $0x3b9aca00, %eax       # imm = 0x3B9ACA00
vpternlogd $0xff, %zmm2, %zmm2, %zmm2
vpbroadcastq 0x1d53(%rip), %zmm3 # 0x4140
vpaddq %zmm2, %zmm1, %zmm4
vpxorq %zmm1, %zmm4, %zmm4
vpaddq %zmm0, %zmm4, %zmm0
vpaddq %zmm3, %zmm1, %zmm1
addq $-0x8, %rax
jne 0x23ed
pushq %rbp
movq %rsp, %rbp
pushq %rbx
andq $-0x20, %rsp
subq $0x40, %rsp
vextracti64x4 $0x1, %zmm0, %ymm1
vpaddq %zmm1, %zmm0, %zmm0
vextracti128 $0x1, %ymm0, %xmm1
vpaddq %xmm1, %xmm0, %xmm0
vpshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
vpaddq %xmm1, %xmm0, %xmm0
vmovq %xmm0, %rdi
movq %rdi, %rax
shrq $0x3f, %rax
addl %edi, %eax
andl $-0x2, %eax
subl %eax, %edi
vzeroupper
callq 0x2170
movq %rsp, %rdi
movl $0xf4240, %esi          # imm = 0xF4240
callq 0x24b5
movq 0x3b69(%rip), %rbx      # 0x5fd0
leaq 0x1d1e(%rip), %rsi      # 0x418c
movl $0x32, %edx
movq %rbx, %rdi
callq 0x2150
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20b0
movl $0x2710, %edi           # imm = 0x2710
callq 0x267f
xorl %eax, %eax
leaq -0x8(%rbp), %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/mburhanpurkar[P]fast_xorshift_plus/test_rng.cpp
// Function: time_64_bits(long long vector[4]*, int)
inline void time_64_bits(__m256i *out, int niter)
{
  fast_rng::vec_xorshift_plus x;
    __m256i tmp;
  
    struct timeval tv0 = rng_helpers::get_time();
  
    for (int iter = 0; iter < niter; iter++)
        tmp = _mm256_xor_si256(tmp, x.gen_rand_bits());

    struct timeval tv1 = rng_helpers::get_time();
    double dt = rng_helpers::time_diff(tv0, tv1);
    double noutputs = double(niter) * 256; // generate 256 random bits per iteration
    double ns_per_output = 1.0e9 * dt / noutputs * 64; // actually, get the time for one bit, then mutiply by 64
    
    _mm256_store_si256(out, tmp);
  
    cout << "64 bit test: time for 64 bits = " << ns_per_output << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
andq $-0x20, %rsp
subq $0xa0, %rsp
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2e68
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x21a0
testl %eax, %eax
js 0x261a
testl %r14d, %r14d
jle 0x2545
vmovdqa 0x20(%rsp), %ymm1
vmovdqa 0x40(%rsp), %ymm0
movl %r14d, %eax
vpsllq $0x17, %ymm1, %ymm2
vpxor %ymm1, %ymm2, %ymm2
vmovdqa %ymm0, %ymm1
vpsrlq $0x11, %ymm2, %ymm0
vpsrlq $0x1a, %ymm1, %ymm3
vpxor %ymm0, %ymm3, %ymm0
vpternlogq $0x96, %ymm1, %ymm2, %ymm0
vpaddq %ymm1, %ymm0, %ymm2
vpxor %ymm4, %ymm2, %ymm4
decl %eax
jne 0x2503
vmovdqa %ymm4, 0x60(%rsp)
vmovdqa %ymm0, 0x40(%rsp)
vmovdqa %ymm1, 0x20(%rsp)
jmp 0x2545
leaq 0x10(%rsp), %rdi
movq (%rdi), %r12
movq 0x8(%rdi), %r15
xorl %esi, %esi
vzeroupper
callq 0x21a0
testl %eax, %eax
js 0x2638
movq 0x10(%rsp), %rax
subq %r12, %rax
movq 0x18(%rsp), %rcx
subq %r15, %rcx
vcvtsi2sd %rax, %xmm5, %xmm0
vcvtsi2sd %rcx, %xmm5, %xmm1
vcvtsi2sd %r14d, %xmm5, %xmm2
vfmadd132sd 0x1bc5(%rip), %xmm0, %xmm1 # xmm1 = (xmm1 * mem) + xmm0
vmulsd 0x1bc5(%rip), %xmm2, %xmm0 # 0x4158
vmulsd 0x1bc5(%rip), %xmm1, %xmm1 # 0x4160
vdivsd %xmm0, %xmm1, %xmm0
vmulsd 0x1bc1(%rip), %xmm0, %xmm0 # 0x4168
vmovsd %xmm0, 0x8(%rsp)
vmovaps 0x60(%rsp), %ymm0
vmovaps %ymm0, (%rbx)
movq 0x3a12(%rip), %rbx      # 0x5fd0
leaq 0x1bfa(%rip), %rsi      # 0x41bf
movl $0x20, %edx
movq %rbx, %rdi
vzeroupper
callq 0x2150
movq %rbx, %rdi
vmovsd 0x8(%rsp), %xmm0
callq 0x2190
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20b0
leaq -0x20(%rbp), %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x2090
movq %rax, %rbx
leaq 0x1be4(%rip), %rsi      # 0x4212
movq %rax, %rdi
callq 0x2070
jmp 0x2654
movl $0x10, %edi
callq 0x2090
movq %rax, %rbx
leaq 0x1bc6(%rip), %rsi      # 0x4212
movq %rax, %rdi
callq 0x2070
movq 0x3995(%rip), %rsi      # 0x5ff0
movq 0x3966(%rip), %rdx      # 0x5fc8
movq %rbx, %rdi
callq 0x21d0
jmp 0x266c
movq %rax, %r14
movq %rbx, %rdi
callq 0x20d0
movq %r14, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O1/uclaopt[P]AsyncQVI/include/async.h
// Function: asyncQVI(int, QVI, Params*)
void asyncQVI(int thread_id, QVI qvi, Params* params) {
	
	while(!params->stop){
		qvi.update(iter);
		iter++;
		
		// evaluate policy every check_step iterations  
		if(iter > params->threshold){
			// let one thread check policy quality
			pthread_barrier_wait(&barrier);
			if(thread_id == 0){
				cout<<iter<<' ';
				qvi.test();
				params->threshold += params->check_step;
				if(iter > params->max_outer_iter)
					params->stop = 1;
			}
			pthread_barrier_wait(&barrier);
		}			
	}
	return;
}

// Assembly:
cmpl $0x0, 0x70(%rsi)
je 0x30ea
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x40(%rsp), %r14
leaq 0x20(%r14), %r15
leaq 0x746e(%rip), %r12      # 0xa578
leaq 0x7(%rsp), %r13
movl 0x60bb(%rip), %esi      # 0x91d0
movq %r14, %rdi
callq 0x3d30
lock
incl 0x60ac(%rip)            # 0x91d0
movl 0x60a6(%rip), %eax      # 0x91d0
cmpl 0x74(%rbx), %eax
jle 0x3198
movq %r12, %rdi
callq 0x2230
testl %ebp, %ebp
jne 0x3190
movl 0x608f(%rip), %esi      # 0x91d0
movq 0x5e90(%rip), %rdi      # 0x8fd8
callq 0x2340
movb $0x20, 0x7(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x2220
movq 0x14e0(%r14), %rsi
movq 0x14e8(%r14), %rdx
movq %r15, %rdi
callq 0x2ebc
movl 0x6c(%rbx), %eax
addl %eax, 0x74(%rbx)
movl 0x604c(%rip), %eax      # 0x91d0
cmpl 0x34(%rbx), %eax
jle 0x3190
movl $0x1, 0x70(%rbx)
movq %r12, %rdi
callq 0x2230
cmpl $0x0, 0x70(%rbx)
je 0x310f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/uclaopt[P]AsyncQVI/include/async.h
// Function: asyncQL(int, Qlearning, Params*)
void asyncQL(int thread_id, Qlearning ql, Params* params) {
	
	while(!params->stop){
		ql.update(iter);
		iter++;
		
		// evaluate policy every check_step iterations
		if(iter > params->threshold){
			// let one thread check policy quality
			pthread_barrier_wait(&barrier);
			if(thread_id == 0){
				cout<<iter<<' ';
				ql.test();
				params->threshold += params->check_step;
				if(iter > params->max_outer_iter)
					params->stop = 1;
			}
			pthread_barrier_wait(&barrier);
		}	
	}
	return;
}

// Assembly:
cmpl $0x0, 0x70(%rsi)
je 0x31b8
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x40(%rsp), %r14
leaq 0x18(%r14), %r15
leaq 0x73a0(%rip), %r12      # 0xa578
leaq 0x7(%rsp), %r13
movl 0x5fed(%rip), %esi      # 0x91d0
movq %r14, %rdi
callq 0x3ef6
lock
incl 0x5fde(%rip)            # 0x91d0
movl 0x5fd8(%rip), %eax      # 0x91d0
cmpl 0x74(%rbx), %eax
jle 0x3266
movq %r12, %rdi
callq 0x2230
testl %ebp, %ebp
jne 0x325e
movl 0x5fc1(%rip), %esi      # 0x91d0
movq 0x5dc2(%rip), %rdi      # 0x8fd8
callq 0x2340
movb $0x20, 0x7(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x2220
movq 0x14e0(%r14), %rsi
movq 0x14e8(%r14), %rdx
movq %r15, %rdi
callq 0x2ebc
movl 0x6c(%rbx), %eax
addl %eax, 0x74(%rbx)
movl 0x5f7e(%rip), %eax      # 0x91d0
cmpl 0x34(%rbx), %eax
jle 0x325e
movl $0x1, 0x70(%rbx)
movq %r12, %rdi
callq 0x2230
cmpl $0x0, 0x70(%rbx)
je 0x31dd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/uclaopt[P]AsyncQVI/include/oracle.h
// Function: Sailing::setValues(Params*)
void setValues(Params* params){
			DIMX = (int)sqrt(params->len_state/DIMWIND);
			DIMY = DIMX;
			GOALX = (int)DIMX/2; // the target place is the center of the grid
			GOALY = GOALX;
			probs = params->probs;
			d = params->d;
			std::random_device rd; 
			local_rng.seed(rd());
		}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1388, %rsp           # imm = 0x1388
movq %rsi, %r14
movl (%rsi), %eax
leal 0x7(%rax), %ecx
testl %eax, %eax
cmovnsl %eax, %ecx
sarl $0x3, %ecx
cvtsi2sd %ecx, %xmm0
movq %rdi, %rbx
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x3c01
sqrtsd %xmm0, %xmm0
jmp 0x3c06
callq 0x2150
cvttsd2si %xmm0, %eax
movl %eax, 0xc(%rbx)
movl %eax, 0x10(%rbx)
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
movl %ecx, 0x14(%rbx)
movl %ecx, 0x18(%rbx)
movsd 0x8(%r14), %xmm0
movsd %xmm0, 0x20(%rbx)
movsd 0x10(%r14), %xmm0
movsd %xmm0, 0x28(%rbx)
movq %rsp, %r14
movq %r14, %rdi
callq 0x4070
movq %r14, %rdi
callq 0x2250
movl %eax, %ecx
movq %rcx, 0x30(%rbx)
movl $0x7, %eax
movq %rcx, %rdx
shrq $0x1e, %rdx
xorl %ecx, %edx
imull $0x6c078965, %edx, %ecx # imm = 0x6C078965
addl %eax, %ecx
addl $-0x6, %ecx
movq %rcx, (%rbx,%rax,8)
incq %rax
cmpq $0x276, %rax            # imm = 0x276
jne 0x3c53
movq $0x270, 0x13b0(%rbx) # imm = 0x270
movq %rsp, %rdi
callq 0x21c0
addq $0x1388, %rsp           # imm = 0x1388
popq %rbx
popq %r14
retq
jmp 0x3ca9
movq %rax, %rbx
movq %rsp, %rdi
callq 0x21c0
movq %rbx, %rdi
callq 0x2360
movq %rax, %rdi
callq 0x53c4
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %r15
movq %rcx, %rbx
movl %edx, %ebp
movq %rdi, %r14
movl 0x10(%rdi), %ecx
movl 0xc(%rdi), %edi
imull %ecx, %edi
movl %esi, %eax
cltd
idivl %edi
movl %eax, 0x8(%r14)
imull %eax, %edi
movl %edx, %eax
cltd
idivl %ecx
movl %eax, (%r14)
imull %ecx, %eax
addl %edi, %eax
subl %eax, %esi
movl %esi, 0x4(%r14)
movq %r14, %rdi
movl %ebp, %esi
callq 0x51a6
movq %r14, %rdi
movl %ebp, %esi
callq 0x5336
movsd %xmm0, (%r15)
movq %r14, %rdi
callq 0x5378
movl 0xc(%r14), %eax
imull 0x8(%r14), %eax
addl (%r14), %eax
imull 0x10(%r14), %eax
addl 0x4(%r14), %eax
movl %eax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/uclaopt[P]AsyncQVI/include/algo.h
// Function: QVI::QVI(std::vector<double, std::allocator<double>>*, std::vector<int, std::allocator<int>>*, Params*)
QVI(std::vector<double>* V_, std::vector<int>* pi_, Params* params_){
			V = V_;
			pi = pi_;
			params = params_;
			init_state = 0;
			init_action = 0;
			s.setValues(params);
		}

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

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq $-0x1, %rax
cmpl $0x7, %esi
ja 0x51d0
movl %esi, %eax
leaq 0x11e4(%rip), %rcx      # 0x63b0
movq (%rcx,%rax,8), %rax
movq %rax, %rcx
shrq $0x20, %rcx
movl (%rbx), %edx
addl %eax, %edx
movl 0xc(%rbx), %eax
leal -0x1(%rax), %ebp
cmpl %edx, %eax
cmovgl %edx, %ebp
xorl %r12d, %r12d
testl %ebp, %ebp
cmovlel %r12d, %ebp
movl 0x10(%rbx), %eax
movl %ebp, (%rbx)
addl 0x4(%rbx), %ecx
leal -0x1(%rax), %edx
cmpl %ecx, %eax
cmovgl %ecx, %edx
testl %edx, %edx
cmovlel %r12d, %edx
movl %edx, 0x4(%rbx)
leaq 0x8(%rsp), %r15
movq %r12, (%r15)
movabsq $0x3fb999999999999a, %r13 # imm = 0x3FB999999999999A
movq %r13, 0x8(%r15)
movq %r12, 0x10(%r15)
movb %r12b, 0x18(%r15)
leaq 0x30(%rbx), %r14
movq %r15, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x58b0
cvttsd2si %xmm0, %eax
addl %ebp, %eax
movl 0x4(%rbx), %ebp
movl 0xc(%rbx), %ecx
leal -0x1(%rcx), %edx
cmpl %eax, %ecx
cmovgl %eax, %edx
testl %edx, %edx
cmovlel %r12d, %edx
movl %edx, (%rbx)
movq %r12, (%r15)
movq %r13, 0x8(%r15)
movq %r12, 0x10(%r15)
movb %r12b, 0x18(%r15)
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rdi, %rdx
callq 0x58b0
cvttsd2si %xmm0, %eax
addl %ebp, %eax
movl 0x10(%rbx), %ecx
leal -0x1(%rcx), %edx
cmpl %eax, %ecx
cmovgl %eax, %edx
testl %edx, %edx
cmovlel %r12d, %edx
movl %edx, 0x4(%rbx)
movq %r14, %rdi
callq 0x578a
movsd 0x20(%rbx), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x5327
movl (%rbx), %ebp
leaq 0x8(%rsp), %r15
movq %r12, (%r15)
movabsq $0x3ff0000000000000, %r13 # imm = 0x3FF0000000000000
movq %r13, 0x8(%r15)
movq %r12, 0x10(%r15)
movb %r12b, 0x18(%r15)
movq %r15, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x58b0
cvttsd2si %xmm0, %eax
addl %ebp, %eax
movl 0x4(%rbx), %ebp
movl 0xc(%rbx), %ecx
leal -0x1(%rcx), %edx
cmpl %eax, %ecx
cmovgl %eax, %edx
testl %edx, %edx
cmovlel %r12d, %edx
movl %edx, (%rbx)
movq %r12, (%r15)
movq %r13, 0x8(%r15)
movq %r12, 0x10(%r15)
movb %r12b, 0x18(%r15)
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rdi, %rdx
callq 0x58b0
cvttsd2si %xmm0, %eax
addl %ebp, %eax
movl 0x10(%rbx), %ecx
leal -0x1(%rcx), %edx
cmpl %eax, %ecx
cmovgl %eax, %edx
testl %edx, %edx
cmovlel %r12d, %edx
movl %edx, 0x4(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpl 0x14(%rdi), %eax
jne 0x534e
movl 0x4(%rdi), %ecx
cmpl 0x18(%rdi), %ecx
jne 0x534e
movsd 0xccb(%rip), %xmm0      # 0x6018
retq
orl 0x4(%rdi), %eax
je 0x5373
subl 0x8(%rdi), %esi
movl %esi, %eax
negl %eax
cmovsl %esi, %eax
movl $0x8, %ecx
subl %eax, %ecx
cmpl %ecx, %eax
cmovll %eax, %ecx
cvtsi2sd %ecx, %xmm0
mulsd 0x28(%rdi), %xmm0
retq
xorps %xmm0, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/uclaopt[P]AsyncQVI/include/oracle.h
// Function: Sailing::windTransition()
void windTransition(){
			double prob = localUniformDouble(0, 1);
			double start = 0;
			for(int nwind = 0; nwind < DIMWIND; nwind++){
				start += wind_transition[wind][nwind];
				if(start > prob){
					wind = nwind;
					break;
				}
			}
		}

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %r15
movq 0x8(%rdx), %r13
cmpq %r13, %r15
jne 0x33ab
testq %r15, %r15
je 0x33e5
movq (%r12), %rsi
movq (%r14), %rdi
movq %r15, %rdx
callq 0x21c0
testl %eax, %eax
je 0x33e5
movq 0x28(%r14), %rdx
cmpq %r13, %rdx
jne 0x33ca
testq %rdx, %rdx
je 0x33fc
movq (%r12), %rsi
movq 0x20(%r14), %rdi
callq 0x21c0
testl %eax, %eax
je 0x33fc
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x4df1(%rip), %rdx      # 0x81c9
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x37e8
jmp 0x3414
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
jmp 0x340f
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
addq %rsi, %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0x3a54
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ncbi[P]amr/./common.hpp
// Function: Common_sp::VectorPtr<(anonymous namespace)::BlastAlignment> const* Common_sp::findPtr<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Common_sp::VectorPtr<(anonymous namespace)::BlastAlignment>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Common_sp::VectorPtr<(anonymous namespace)::BlastAlignment>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Common_sp::VectorPtr<(anonymous namespace)::BlastAlignment>>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
const Value* findPtr (const map <Key, Value> &m,
                        const KeyParent& key)
    { const auto& it = m. find (key);
    	if (it == m. end ())
    		return nullptr;
    	return & it->second; 
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %r12
addq $0x8, %rbx
movq %rbx, %r15
testq %r12, %r12
je 0x24f44
movq %rbx, %r15
leaq 0x20(%r12), %rdi
movq %r14, %rsi
callq 0xb050
testl %eax, %eax
cmovnsq %r12, %r15
shrl $0x1f, %eax
movq 0x10(%r12,%rax,8), %r12
testq %r12, %r12
jne 0x24f24
movq %rbx, %rcx
cmpq %rbx, %r15
je 0x24f61
leaq 0x20(%r15), %rsi
movq %r14, %rdi
callq 0xb050
testl %eax, %eax
cmovsq %rbx, %r15
movq %r15, %rcx
leaq 0x40(%rcx), %rdx
xorl %eax, %eax
cmpq %rbx, %rcx
cmovneq %rdx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x24f7c
movq %rax, %rdi
callq 0x3919b
// File: /workspace/github_cpp_makefile_star2_O1/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), %cl
cmpb $0x1, %cl
jne 0x30c74
cmpq $0x0, 0x10(%rsi)
je 0x30c79
movb 0x38(%rsi), %al
jmp 0x30c7b
movb 0x68(%rdi), %al
jmp 0x30c7b
movb $0x1, %al
movq 0xb8(%rdi), %rdx
movq 0xc8(%rdi), %r8
subq 0xc0(%rdi), %r8
testb %al, %al
movq %r8, %rax
cmovneq %rdx, %rax
testq %rax, %rax
je 0x30cbc
testb %cl, %cl
je 0x30cb3
cmpq $0x0, 0x10(%rsi)
je 0x30cbc
movb $0x1, %al
cmpq $0x4, 0x28(%rsi)
jae 0x30cbc
retq
movb $0x1, %al
cmpq $0x4, 0x50(%rdi)
jb 0x30cb2
testb %cl, %cl
je 0x30ccc
cmpq $0x0, 0x10(%rsi)
je 0x30cd1
movb 0x38(%rsi), %al
jmp 0x30cd3
movb 0x68(%rdi), %al
jmp 0x30cd3
movb $0x1, %al
testb %al, %al
cmovneq %r8, %rdx
testq %rdx, %rdx
je 0x30d01
testb %cl, %cl
je 0x30d04
cmpq $0x0, 0x10(%rsi)
je 0x30d01
movq 0x40(%rsi), %rax
testq %rax, %rax
setne %cl
subq 0x30(%rsi), %rax
cmpq $0x4, %rax
setb %al
andb %cl, %al
retq
xorl %eax, %eax
retq
movq 0x60(%rdi), %rax
subq 0x58(%rdi), %rax
cmpq $0x4, %rax
setb %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x0, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movb $0x0, 0x30(%rdi)
movq 0x218(%rsi), %r14
movq 0x220(%rsi), %r15
cmpq %r15, %r14
je 0x32f2b
movl $0xa8, %r12d
cmpq $0x0, 0x20(%r14)
je 0x32f1f
movq 0x88(%r14), %r13
movq 0x90(%r14), %rbp
cmpq %rbp, %r13
je 0x32f1f
cmpb $0x0, 0x30(%rbx)
jne 0x32f19
movq (%r13), %rsi
addq %r12, %rsi
movq %rbx, %rdi
callq 0x401e8
addq $0x8, %r13
jmp 0x32eff
addq $0xb0, %r14
cmpq %r15, %r14
jne 0x32eea
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 0x4041a
movq %r14, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O1/ncbi[P]amr/amr_report.cpp
// Function: (anonymous namespace)::BlastAlignment::getGeneSymbol[abi:cxx11]() const
string getGeneSymbol () const
    { return susceptible
               ? susceptible->genesymbol
               : alleleMatch () 
                 ? famId 
                 : nvl (getMatchFam () -> genesymbol, na); 
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x3d8(%rsi), %rax
testq %rax, %rax
je 0x32f93
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x3981e
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rsi, %r14
movq %rsi, %rdi
movl $0x1, %esi
callq 0x400f8
testb %al, %al
je 0x32fca
movq %r14, %rdi
callq 0x2e488
testb %al, %al
je 0x32fca
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x2a8(%r14), %rsi
movq 0x2b0(%r14), %rdx
jmp 0x32f79
movq %r14, %rdi
callq 0x2fea4
movq %rax, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x71dd1(%rip), %rsi     # 0xa4db7
leaq 0x71dcc(%rip), %rdx     # 0xa4db9
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x39720
leaq 0x28(%r14), %rax
leaq 0x30(%r14), %rcx
cmpq $0x0, 0x30(%r14)
cmoveq %r15, %rax
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
leaq 0x10(%rsp), %rax
cmovneq %rcx, %rax
movq (%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x3981e
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x32f84
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb550
jmp 0x32f84
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x33066
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb550
movq %rbx, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O1/ncbi[P]amr/./common.hpp
// Function: Common_sp::section(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
inline void section (const string &title,
                     bool useAlsoCout)
  { const Color::Type color = Color::cyan;
    const bool bright = false;
    if (useAlsoCout)
    {
      { const OColor oc1 (cout, color, bright, true);
        const OColor oc2 (cerr, color, bright, true);
        couterr << title /*<< " ..."*/;
      }
      couterr << endl;
    }
    else
    {
      { const OColor oc (cerr, color, bright, true);
        cerr << title /*<< " ..."*/;
      }
      cerr << endl;
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
testl %esi, %esi
je 0x3a4f1
movq 0x91b38(%rip), %rbx     # 0xcbfa0
movq %rsp, %rdi
movq %rbx, %rsi
movl $0x24, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x3abe0
movq 0x91b61(%rip), %rsi     # 0xcbfe8
leaq 0x10(%rsp), %rdi
movl $0x24, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x3abe0
leaq 0x9299d(%rip), %r15     # 0xcce42
movq %r15, %rdi
movq %r14, %rsi
callq 0x3ac86
leaq 0x10(%rsp), %rdi
callq 0x3acc6
movq %rsp, %rdi
callq 0x3acc6
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xb520
movsbl %al, %esi
movq %rbx, %rdi
callq 0xb040
movq %rax, %rdi
callq 0xb3d0
cmpb $0x0, (%r15)
je 0x3a527
jmp 0x3a555
movq 0x91af0(%rip), %rbx     # 0xcbfe8
movq %rsp, %rdi
movq %rbx, %rsi
movl $0x24, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x3abe0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0xb5f0
movq %rsp, %rdi
callq 0x3acc6
movq 0x91aba(%rip), %rbx     # 0xcbfe8
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xb520
movsbl %al, %esi
movq %rbx, %rdi
callq 0xb040
movq %rax, %rdi
callq 0xb3d0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3acc6
jmp 0x3a573
jmp 0x3a570
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3acc6
movq %rbx, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O1/ncbi[P]amr/./common.hpp
// Function: Common_sp::COutErr const& Common_sp::COutErr::operator<<<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
const COutErr& operator<< (const T &val) const
      { cout << val;
        if (! both)
          cerr << val;
        return *this;
      }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
movq 0x91302(%rip), %rdi     # 0xcbfa0
callq 0xb5f0
cmpb $0x0, (%rbx)
jne 0x3acbb
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x91332(%rip), %rdi     # 0xcbfe8
callq 0xb5f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x40144
movq 0xc8(%rdi), %rcx
testq %rcx, %rcx
je 0x40144
movq 0x200(%rdi), %rdx
xorl %eax, %eax
cmpq %rcx, %rdx
jne 0x40143
cmpq 0x38(%rdi), %rdx
jne 0x40143
movl 0x6c(%rdi), %edx
testl %edx, %edx
je 0x40144
andb 0x8(%rdi), %sil
movb $0x1, %al
cmpb $0x1, %sil
jne 0x40143
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_O1/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 0x4015a
andb %cl, %al
retq
movq 0x28(%rdi), %rax
cmpq 0x28(%rsi), %rax
je 0x4016c
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
movb $0x1, %bpl
cmpb $0x0, 0x30(%rdi)
jne 0x40195
movq %rsi, %rbx
cmpb $0x0, 0x30(%rsi)
jne 0x40193
movq %rdi, %r14
movq 0x28(%rbx), %rax
cmpq 0x28(%rdi), %rax
jbe 0x401a4
xorl %ebp, %ebp
andb $0x1, %bpl
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%rbx), %r15
addq $0x8, %rbx
cmpq %rbx, %r15
sete %bpl
je 0x40195
leaq 0x8(%r14), %r12
cmpb $0x0, 0x30(%r14)
jne 0x401d1
leaq 0x20(%r15), %rsi
movq %r14, %rdi
callq 0x40390
cmpq %r12, %rax
je 0x40195
movq %r15, %rdi
callq 0xb610
movq %rax, %r15
cmpq %rbx, %rax
sete %bpl
jne 0x401b9
jmp 0x40195
nop
// File: /workspace/github_cpp_makefile_star2_O1/4shadoww[P]xwinter/xwinter.cpp
// Function: sky::sky(unsigned int, unsigned int)
sky::sky(unsigned int screen_width, unsigned int screen_heigth){
    // Set screen size
    sky::set_screen_size(screen_width, screen_heigth);
    // Seed rng
    this->eng.seed(this->rd());
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %rbx
movaps 0x1aee(%rip), %xmm0     # 0x4010
movups %xmm0, (%rdi)
movaps 0x1af4(%rip), %xmm0     # 0x4020
movups %xmm0, 0x10(%rdi)
movabsq $0x400000002, %rax      # imm = 0x400000002
movq %rax, 0x20(%rdi)
leaq 0x28(%rdi), %r14
movq %r14, %rdi
callq 0x3850
movq $0x1571, 0x13b0(%rbx) # imm = 0x1571
movl $0x1571, %ecx           # imm = 0x1571
movl $0x277, %eax            # imm = 0x277
movq %rcx, %rdx
shrq $0x1e, %rdx
xorl %ecx, %edx
imull $0x6c078965, %edx, %ecx # imm = 0x6C078965
addl %eax, %ecx
addl $0xfffffd8a, %ecx       # imm = 0xFFFFFD8A
movq %rcx, (%rbx,%rax,8)
incq %rax
cmpq $0x4e6, %rax            # imm = 0x4E6
jne 0x255f
movq $0x270, 0x2730(%rbx) # imm = 0x270
xorps %xmm0, %xmm0
movups %xmm0, 0x2738(%rbx)
movq $0x0, 0x2748(%rbx)
movl %r15d, (%rbx)
movl %ebp, 0x4(%rbx)
movq %r14, %rdi
callq 0x2290
movl %eax, %ecx
movq %rcx, 0x13b0(%rbx)
xorl %eax, %eax
movq %rcx, %rdx
shrq $0x1e, %rdx
xorl %ecx, %edx
imull $0x6c078965, %edx, %ecx # imm = 0x6C078965
addl %eax, %ecx
incl %ecx
movq %rcx, 0x13b8(%rbx,%rax,8)
incq %rax
cmpq $0x26f, %rax            # imm = 0x26F
jne 0x25be
movq $0x270, 0x2730(%rbx) # imm = 0x270
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x21b0
movq %rbx, %rdi
callq 0x2360
movq %rax, %rdi
callq 0x38ca
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2654
callq 0x2240
movq 0x2748(%rbx), %rdi
testq %rdi, %rdi
je 0x2665
callq 0x2240
cmpq $0x0, 0x2740(%rbx)
je 0x26b0
cmpl $0x0, 0x8(%rbx)
je 0x2698
xorl %r14d, %r14d
movq 0x2740(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x268d
callq 0x2240
incq %r14
movl 0x8(%rbx), %eax
cmpq %rax, %r14
jb 0x2678
movq 0x2740(%rbx), %rdi
testq %rdi, %rdi
je 0x26b0
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2240
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movss %xmm0, 0xc(%rdi)
movss %xmm1, 0x10(%rdi)
movss %xmm2, 0x14(%rdi)
movss %xmm3, 0x18(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/4shadoww[P]xwinter/xwinter.cpp
// Function: sky::get_random_position(int, int, int, int)
std::pair<int, int> sky::get_random_position(int min_x, int max_x, int min_y, int max_y){
    // Define x range
    std::uniform_int_distribution<> range_x(min_x, max_x);
    // Define y range
    std::uniform_int_distribution<> range_y(min_y, max_y);
    // Create random position in range
    return std::pair<int, int>(range_x(this->eng), range_y(this->eng));
}

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rdx
leaq 0x14dd(%rip), %rsi      # 0x413d
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x38d5
leaq 0x14d1(%rip), %rsi      # 0x4145
movq %rbx, %rdi
callq 0x2390
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x2ca2
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x2ca9
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x42ff(%rip), %rbx      # 0x6fd0
movq %rbx, %rdi
callq 0x2210
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2160
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x2d19
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21f0
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2d34
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x21f0
leaq 0x1415(%rip), %rsi      # 0x4150
movl $0x34d, %edx            # imm = 0x34D
movq %rbx, %rdi
callq 0x2210
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2160
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x2d97
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x2d97
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21f0
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2db2
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x2360