LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: gpertea[P]gclib/./khashl.hh
// Function: klib::KHashSet<klib::KHashMapCachedBucket<char const*, int, unsigned int>, klib::KHashCachedHash<klib::KHashMapCachedBucket<char const*, int, unsigned int>, unsigned int>, klib::KHashCachedEq<klib::KHashMapCachedBucket<char const*, int, unsigned int>, cstr_eq>, unsigned int>::get(klib::KHashMapCachedBucket<char const*, int, unsigned int> const&) const
khint_t get(const T &key) const {
		khint_t i, last, mask, nb;
		if (keys == 0) return 0;
		nb = n_buckets();
		mask = nb - khint_t(1);
		i = last = __kh_h2b(Hash()(key), bits);
		while (__kh_used(used, i) && !Eq()(keys[i], key)) {
			i = (i + khint_t(1)) & mask;
			if (i == last) return nb;
		}
		return !__kh_used(used, i)? nb : i;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, 0x10(%rax)
jne 0x1229b
movl $0x0, -0x4(%rbp)
jmp 0x12360
movq -0x38(%rbp), %rdi
callq 0x11da0
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x29(%rbp), %rdi
callq 0x12110
movl %eax, %edi
movq -0x38(%rbp), %rax
movl (%rax), %esi
callq 0x120f0
movl %eax, -0x20(%rbp)
movl %eax, -0x1c(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x1c(%rbp), %esi
callq 0x12130
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x39(%rbp)
je 0x12310
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rsi
movl -0x1c(%rbp), %eax
shlq $0x4, %rax
addq %rax, %rsi
movq -0x18(%rbp), %rdx
leaq -0x2a(%rbp), %rdi
callq 0x12160
xorb $-0x1, %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x12319
jmp 0x12337
movl -0x1c(%rbp), %eax
addl $0x1, %eax
andl -0x24(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jne 0x12335
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x12360
jmp 0x122d0
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x1c(%rbp), %esi
callq 0x12130
cmpl $0x0, %eax
jne 0x12354
movl -0x28(%rbp), %eax
movl %eax, -0x40(%rbp)
jmp 0x1235a
movl -0x1c(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: gpertea[P]gclib/./GVec.hh
// Function: GPVec<HStrData>::Clear()
void GPVec<OBJ>::Clear() {
 if (FREEDATA) {
   for (int i=0; i<fCount; i++) {
     (*fFreeProc)(fList[i]);
     }
   }
 //GFREE(fList);
 delete[] fList;
 fList=nullptr;
 fCount=0;
 fCapacity=0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x18(%rax)
je 0x13c11
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x10(%rcx), %eax
jge 0x13c0f
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rax
movq 0x8(%rcx), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
callq *%rax
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x13be2
jmp 0x13c11
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x13c2c
movq -0x20(%rbp), %rdi
callq 0x2320
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movl $0x0, 0x10(%rax)
movl $0x0, 0x14(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: struthj[P]Python-to-C-transpiler/parser-push.cpp
// Function: yypstate_new()
yypstate *
yypstate_new (void)
{
  yypstate *yyps;
  yyps = YY_CAST (yypstate *, YYMALLOC (sizeof *yyps));
  if (!yyps)
    return YY_NULLPTR;
  yystacksize = YYINITDEPTH;
  yyss = yyssa;
  yyvs = yyvsa;
  yyls = yylsa;
  yypstate_clear (yyps);
  return yyps;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x13d8, %edi           # imm = 0x13D8
callq 0x2220
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3fd7
movq $0x0, -0x8(%rbp)
jmp 0x4033
movq -0x10(%rbp), %rax
movq $0xc8, 0x10(%rax)
movq -0x10(%rbp), %rcx
addq $0x18, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xe0(%rax)
movq -0x10(%rbp), %rcx
addq $0xf0, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x730(%rax)
movq -0x10(%rbp), %rcx
addq $0x740, %rcx            # imm = 0x740
movq -0x10(%rbp), %rax
movq %rcx, 0x13c0(%rax)
movq -0x10(%rbp), %rdi
callq 0x4040
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: struthj[P]Python-to-C-transpiler/parser-push.cpp
// Function: yypstate_clear(yypstate*)
static void
yypstate_clear (yypstate *yyps)
{
  yynerrs = 0;
  yystate = 0;
  yyerrstatus = 0;

  yyssp = yyss;
  yyvsp = yyvs;
  yylsp = yyls;

  /* Initialize the state stack, in case yypcontext_expected_tokens is
     called before the first call to yyparse. */
  *yyssp = 0;
  yyps->yynew = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0xe0(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xe8(%rax)
movq -0x8(%rbp), %rax
movq 0x730(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x738(%rax)
movq -0x8(%rbp), %rax
movq 0x13c0(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x13c8(%rax)
movq -0x8(%rbp), %rax
movq 0xe8(%rax), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x13d0(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: struthj[P]Python-to-C-transpiler/parser-push.cpp
// Function: yypstate_delete(yypstate*)
void
yypstate_delete (yypstate *yyps)
{
  if (yyps)
    {
#ifndef yyoverflow
      /* If the stack was reallocated but the parse did not complete, then the
         stack still needs to be freed.  */
      if (yyss != yyssa)
        YYSTACK_FREE (yyss);
#endif
      YYFREE (yyps);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4114
movq -0x8(%rbp), %rax
movq 0xe0(%rax), %rax
movq -0x8(%rbp), %rcx
addq $0x18, %rcx
cmpq %rcx, %rax
je 0x410b
movq -0x8(%rbp), %rax
movq 0xe0(%rax), %rdi
callq 0x21f0
movq -0x8(%rbp), %rdi
callq 0x21f0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: struthj[P]Python-to-C-transpiler/scanner-push.cpp
// Function: yy_get_previous_state()
static yy_state_type yy_get_previous_state (void)
{
	yy_state_type yy_current_state;
	char *yy_cp;
    
	yy_current_state = (yy_start);
	yy_current_state += YY_AT_BOL();

	(yy_state_ptr) = (yy_state_buf);
	*(yy_state_ptr)++ = yy_current_state;

	for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
		{
		YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
			{
			yy_current_state = (int) yy_def[yy_current_state];
			if ( yy_current_state >= 172 )
				yy_c = yy_meta[yy_c];
			}
		yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
		*(yy_state_ptr)++ = yy_current_state;
		}

	return yy_current_state;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x9576(%rip), %eax      # 0x122e0
movl %eax, -0x4(%rbp)
movq 0x9574(%rip), %rax      # 0x122e8
movq 0x9575(%rip), %rcx      # 0x122f0
movq (%rax,%rcx,8), %rax
movl 0x28(%rax), %eax
addl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movq 0x9549(%rip), %rax      # 0x122d8
movq %rax, 0x9572(%rip)      # 0x12308
movl -0x4(%rbp), %ecx
movq 0x9568(%rip), %rax      # 0x12308
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, 0x955a(%rip)      # 0x12308
movl %ecx, (%rax)
movq 0x9499(%rip), %rax      # 0x12250
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq 0x9532(%rip), %rax      # 0x122f8
jae 0x8ea7
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x8dee
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x384b(%rip), %rax      # 0xc630
movzbl (%rax,%rcx), %eax
movl %eax, -0x18(%rbp)
jmp 0x8df8
movl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x8df8
movl -0x18(%rbp), %eax
movb %al, -0x11(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x3b77(%rip), %rax      # 0xc980
movswl (%rax,%rcx,2), %eax
movzbl -0x11(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x3913(%rip), %rax      # 0xc730
movswl (%rax,%rcx,2), %eax
cmpl -0x4(%rbp), %eax
je 0x8e56
movslq -0x4(%rbp), %rcx
leaq 0x3cbf(%rip), %rax      # 0xcaf0
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
cmpl $0xac, -0x4(%rbp)
jl 0x8e54
movzbl -0x11(%rbp), %eax
movl %eax, %ecx
leaq 0x3e12(%rip), %rax      # 0xcc60
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
jmp 0x8dfe
movslq -0x4(%rbp), %rcx
leaq 0x3b1f(%rip), %rax      # 0xc980
movswl (%rax,%rcx,2), %eax
movzbl -0x11(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x3e1b(%rip), %rax      # 0xcc90
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %ecx
movq 0x9482(%rip), %rax      # 0x12308
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, 0x9474(%rip)      # 0x12308
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x8dbb
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: struthj[P]Python-to-C-transpiler/scanner-push.cpp
// Function: yy_try_NUL_trans(int)
static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
{
	int yy_is_jam;
    
	YY_CHAR yy_c = 1;
	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
		{
		yy_current_state = (int) yy_def[yy_current_state];
		if ( yy_current_state >= 172 )
			yy_c = yy_meta[yy_c];
		}
	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
	yy_is_jam = (yy_current_state == 171);
	if ( ! yy_is_jam )
		*(yy_state_ptr)++ = yy_current_state;

		return yy_is_jam ? 0 : yy_current_state;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movb $0x1, -0x9(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x3aba(%rip), %rax      # 0xc980
movswl (%rax,%rcx,2), %eax
movzbl -0x9(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x3856(%rip), %rax      # 0xc730
movswl (%rax,%rcx,2), %eax
cmpl -0x4(%rbp), %eax
je 0x8f13
movslq -0x4(%rbp), %rcx
leaq 0x3c02(%rip), %rax      # 0xcaf0
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
cmpl $0xac, -0x4(%rbp)
jl 0x8f11
movzbl -0x9(%rbp), %eax
movl %eax, %ecx
leaq 0x3d55(%rip), %rax      # 0xcc60
movb (%rax,%rcx), %al
movb %al, -0x9(%rbp)
jmp 0x8ebb
movslq -0x4(%rbp), %rcx
leaq 0x3a62(%rip), %rax      # 0xc980
movswl (%rax,%rcx,2), %eax
movzbl -0x9(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x3d5e(%rip), %rax      # 0xcc90
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
cmpl $0xab, -0x4(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x8f6b
movl -0x4(%rbp), %ecx
movq 0x93ad(%rip), %rax      # 0x12308
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, 0x939f(%rip)      # 0x12308
movl %ecx, (%rax)
cmpl $0x0, -0x8(%rbp)
je 0x8f78
xorl %eax, %eax
movl %eax, -0x10(%rbp)
jmp 0x8f7e
movl -0x4(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: xukmin[P]rase/calculate-routing-metrics.cc
// Function: RoutingMetrics::AddData(double, int, int, double)
void AddData(double range, int builder, int calculator, double metric) {
    assert(data_.find(range) != data_.end());
    std::pair<double, int>& p = data_[range][builder][calculator];
    p.first += metric;
    p.second++;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x70, %rdi
leaq -0x10(%rbp), %rsi
callq 0x9570
movq -0x40(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x70, %rdi
callq 0x69a0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x9540
testb $0x1, %al
jne 0x4fb9
jmp 0x4fbb
jmp 0x4fda
leaq 0x19233(%rip), %rdi     # 0x1e1f5
leaq 0x1924d(%rip), %rsi     # 0x1e216
movl $0x67, %edx
leaq 0x1925e(%rip), %rcx     # 0x1e233
callq 0x3140
movq -0x40(%rbp), %rdi
addq $0x70, %rdi
leaq -0x10(%rbp), %rsi
callq 0x6720
movq %rax, %rdi
movslq -0x14(%rbp), %rsi
callq 0x6890
movq %rax, %rdi
movslq -0x18(%rbp), %rsi
callq 0x95a0
movq %rax, -0x38(%rbp)
movsd -0x20(%rbp), %xmm0
movq -0x38(%rbp), %rax
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movq -0x38(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: xukmin[P]rase/calculate-routing-metrics.cc
// Function: RoutingMetrics::GetData(double, int, int) const
double GetData(double range, int builder, int calculator) const {
    const std::pair<double, int>& p = data_[range][builder][calculator];
    if (p.second > 0) {
      return p.first / p.second;
    } else {
      return 0.0;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movl %edx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x70, %rdi
leaq -0x18(%rbp), %rsi
callq 0x6720
movq %rax, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x6890
movq %rax, %rdi
movslq -0x20(%rbp), %rsi
callq 0x95a0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jle 0x509a
movq -0x28(%rbp), %rax
movsd (%rax), %xmm0
movq -0x28(%rbp), %rax
cvtsi2sdl 0x8(%rax), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x50a2
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: CMU-SAFARI[P]optimal-seed-solver/optimalSolverLN.cc
// Function: OptimalSolverLN::OptimalSolverLN()
OptimalSolverLN::OptimalSolverLN() {
	matrix = NULL;
	base = NULL;
	defaultMatrix = NULL;
	defaultBase = NULL;
	readLength = 0;
	seedNum = 0;
	matrixSize = 0;
	baseSize = 0;
	L0Loaded = false;
	minLength = 1;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x8, %rdi
movl $0xa, %esi
movl $0x1e, %edx
callq 0xf890
movq 0x8(%rsp), %rdi
addq $0x380, %rdi            # imm = 0x380
callq 0xa340
movq 0x8(%rsp), %rdi
addq $0x398, %rdi            # imm = 0x398
callq 0xa340
movq 0x8(%rsp), %rdi
addq $0x3c8, %rdi            # imm = 0x3C8
callq 0xa350
movq 0x8(%rsp), %rdi
addq $0x3e8, %rdi            # imm = 0x3E8
callq 0xa360
movq 0x8(%rsp), %rax
movq $0x0, 0x370(%rax)
movq $0x0, 0x378(%rax)
movq $0x0, 0x3b0(%rax)
movq $0x0, 0x3b8(%rax)
movl $0x0, 0x360(%rax)
movl $0x0, 0x364(%rax)
movl $0x0, 0x3c0(%rax)
movl $0x0, 0x3c4(%rax)
movb $0x0, (%rax)
movl $0x1, 0x368(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]optimal-seed-solver/optimalSolverLN.cc
// Function: OptimalSolverLN::~OptimalSolverLN()
OptimalSolverLN::~OptimalSolverLN() {
	if  (matrix != NULL) {
		delete [] matrix;
		matrix = NULL;
	}
	if  (base != NULL) {
		delete [] base;
		base = NULL;
	}
	if  (defaultMatrix != NULL) {
		delete [] defaultMatrix;
		defaultMatrix = NULL;
	}
	if  (defaultBase != NULL) {
		delete [] defaultBase;
		defaultBase = NULL;
	}

	if (level.size() != 0)
		level.clear();
	if (level0.size() != 0)
		level0.clear();
	if (seeds.size() != 0)
		seeds.clear();
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x370(%rax)
je 0x60ce
movq 0x28(%rsp), %rax
movq 0x370(%rax), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0x60be
movq 0x20(%rsp), %rdi
callq 0x3420
movq 0x28(%rsp), %rax
movq $0x0, 0x370(%rax)
movq 0x28(%rsp), %rax
cmpq $0x0, 0x378(%rax)
je 0x610e
movq 0x28(%rsp), %rax
movq 0x378(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x60fe
movq 0x18(%rsp), %rdi
callq 0x3420
movq 0x28(%rsp), %rax
movq $0x0, 0x378(%rax)
movq 0x28(%rsp), %rax
cmpq $0x0, 0x3b0(%rax)
je 0x614e
movq 0x28(%rsp), %rax
movq 0x3b0(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x613e
movq 0x10(%rsp), %rdi
callq 0x3420
movq 0x28(%rsp), %rax
movq $0x0, 0x3b0(%rax)
movq 0x28(%rsp), %rax
cmpq $0x0, 0x3b8(%rax)
je 0x618e
movq 0x28(%rsp), %rax
movq 0x3b8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x617e
movq 0x8(%rsp), %rdi
callq 0x3420
movq 0x28(%rsp), %rax
movq $0x0, 0x3b8(%rax)
movq 0x28(%rsp), %rdi
addq $0x380, %rdi            # imm = 0x380
callq 0xa370
cmpq $0x0, %rax
je 0x61b6
movq 0x28(%rsp), %rdi
addq $0x380, %rdi            # imm = 0x380
callq 0xa390
movq 0x28(%rsp), %rdi
addq $0x398, %rdi            # imm = 0x398
callq 0xa370
cmpq $0x0, %rax
je 0x61de
movq 0x28(%rsp), %rdi
addq $0x398, %rdi            # imm = 0x398
callq 0xa390
movq 0x28(%rsp), %rdi
addq $0x3c8, %rdi            # imm = 0x3C8
callq 0xa3b0
cmpq $0x0, %rax
je 0x6206
movq 0x28(%rsp), %rdi
addq $0x3c8, %rdi            # imm = 0x3C8
callq 0xa3d0
movq 0x28(%rsp), %rdi
addq $0x3e8, %rdi            # imm = 0x3E8
callq 0xa3f0
movq 0x28(%rsp), %rdi
addq $0x3c8, %rdi            # imm = 0x3C8
callq 0xa450
movq 0x28(%rsp), %rdi
addq $0x398, %rdi            # imm = 0x398
callq 0xa4b0
movq 0x28(%rsp), %rdi
addq $0x380, %rdi            # imm = 0x380
callq 0xa4b0
movq 0x28(%rsp), %rdi
addq $0x8, %rdi
callq 0xfa40
addq $0x38, %rsp
retq
nopl (%rax)
// File: CMU-SAFARI[P]optimal-seed-solver/optimalSolverLN.cc
// Function: OptimalSolverLN::feedL0()
void OptimalSolverLN::feedL0() {
	reset();
	tree.setHashLength(10);
	int lvPosCount = readLength + 1 - minLength;

	for (int i = 0; i < lvPosCount; i++) {
		for (int j = 0; j < lvPosCount - i; j++) {
			cin >> level0[i][j].start;
			cin >> level0[i][j].end;
			cin >> level0[i][j].frequency;
			cin >> level0[i][j].isleaf;
#ifdef DEBUG
			cout << "level0[" << i << "][" << j << "]:" << level0[i][j].start << "-" 
				<<level0[i][j].end << ":" << level0[i][j].frequency << " ";
			cout.flush();
		}
		cout << endl;
#else
		}
#endif

	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x6c60
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
movl $0xa, %esi
callq 0xa780
movq 0x8(%rsp), %rcx
movl 0x360(%rcx), %eax
addl $0x1, %eax
subl 0x368(%rcx), %eax
movl %eax, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x6e27
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl 0x1c(%rsp), %ecx
subl 0x18(%rsp), %ecx
cmpl %ecx, %eax
jge 0x6e15
movq 0x8(%rsp), %rdi
addq $0x398, %rdi            # imm = 0x398
movslq 0x18(%rsp), %rsi
callq 0xa600
movq (%rax), %rsi
movslq 0x14(%rsp), %rax
imulq $0x28, %rax, %rax
addq %rax, %rsi
movq 0x1d277(%rip), %rdi     # 0x23fd8
callq 0x3070
movq 0x8(%rsp), %rdi
addq $0x398, %rdi            # imm = 0x398
movslq 0x18(%rsp), %rsi
callq 0xa600
movq (%rax), %rsi
movslq 0x14(%rsp), %rax
imulq $0x28, %rax, %rax
addq %rax, %rsi
addq $0x4, %rsi
movq 0x1d242(%rip), %rdi     # 0x23fd8
callq 0x3070
movq 0x8(%rsp), %rdi
addq $0x398, %rdi            # imm = 0x398
movslq 0x18(%rsp), %rsi
callq 0xa600
movq (%rax), %rsi
movslq 0x14(%rsp), %rax
imulq $0x28, %rax, %rax
addq %rax, %rsi
addq $0xc, %rsi
movq 0x1d20d(%rip), %rdi     # 0x23fd8
callq 0x3070
movq 0x8(%rsp), %rdi
addq $0x398, %rdi            # imm = 0x398
movslq 0x18(%rsp), %rsi
callq 0xa600
movq (%rax), %rsi
movslq 0x14(%rsp), %rax
imulq $0x28, %rax, %rax
addq %rax, %rsi
addq $0x8, %rsi
movq 0x1d1d8(%rip), %rdi     # 0x23fd8
callq 0x3280
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x6d21
jmp 0x6e17
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x6d0b
movq 0x8(%rsp), %rax
movb $0x1, (%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]optimal-seed-solver/optimalSolverLN.cc
// Function: OptimalSolverLN::calculateLastDiv()
unsigned int OptimalSolverLN::calculateLastDiv() {
	// The last level

	if (seedNum > 1) {
		int lvPosCount = readLength - seedNum * minLength;
		finalDiv = solveFirstOptimal(lvPosCount, lvPosCount, seedNum - 1);
	}
	else {
		finalDiv = readLength;
	}

#ifdef DEBUG
	cout << "opt_div: " << finalDiv << endl;
#endif

	return finalDiv;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpl $0x1, 0x364(%rax)
jle 0x998c
movq (%rsp), %rdi
movl 0x360(%rdi), %eax
movl 0x364(%rdi), %ecx
imull 0x368(%rdi), %ecx
subl %ecx, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %esi
movl 0xc(%rsp), %edx
movl 0x364(%rdi), %ecx
subl $0x1, %ecx
callq 0x9540
movl %eax, %ecx
movq (%rsp), %rax
movl %ecx, 0x3e0(%rax)
jmp 0x999c
movq (%rsp), %rax
movl 0x360(%rax), %ecx
movl %ecx, 0x3e0(%rax)
movq (%rsp), %rax
movl 0x3e0(%rax), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: CMU-SAFARI[P]optimal-seed-solver/optimalSolverLN.cc
// Function: OptimalSolverLN::calcualteFreq()
unsigned int OptimalSolverLN::calcualteFreq() {
	int bestFreq;

	if (seedNum > 1) {
		int lvPosCount = readLength - seedNum * minLength;
		bestFreq = level[seedNum - 2][finalDiv].frequency + level0[lvPosCount - finalDiv][finalDiv + (seedNum - 1) * minLength].frequency;
	} else
		bestFreq = level0[readLength - minLength][0].frequency;
	
#ifdef DEBUG
	cout << "bestFreq: " << bestFreq << endl;
#endif

	return bestFreq;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpl $0x1, 0x364(%rax)
jle 0x9a7b
movq 0x10(%rsp), %rax
movl 0x360(%rax), %ecx
movl 0x364(%rax), %edx
imull 0x368(%rax), %edx
subl %edx, %ecx
movl %ecx, 0x18(%rsp)
movq %rax, %rdi
addq $0x380, %rdi            # imm = 0x380
movl 0x364(%rax), %eax
subl $0x2, %eax
movslq %eax, %rsi
callq 0xa600
movq 0x10(%rsp), %rcx
movq (%rax), %rax
movl 0x3e0(%rcx), %edx
imulq $0x28, %rdx, %rdx
addq %rdx, %rax
movl 0xc(%rax), %eax
movl %eax, 0xc(%rsp)
movq %rcx, %rdi
addq $0x398, %rdi            # imm = 0x398
movl 0x18(%rsp), %eax
subl 0x3e0(%rcx), %eax
movl %eax, %eax
movl %eax, %esi
callq 0xa600
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl 0xc(%rsp), %eax
movq (%rcx), %rcx
movl 0x3e0(%rdi), %edx
movl 0x364(%rdi), %esi
subl $0x1, %esi
imull 0x368(%rdi), %esi
addl %esi, %edx
movl %edx, %edx
imulq $0x28, %rdx, %rdx
addq %rdx, %rcx
addl 0xc(%rcx), %eax
movl %eax, 0x1c(%rsp)
jmp 0x9aa8
movq 0x10(%rsp), %rcx
movq %rcx, %rdi
addq $0x398, %rdi            # imm = 0x398
movl 0x360(%rcx), %eax
subl 0x368(%rcx), %eax
movslq %eax, %rsi
callq 0xa600
movq (%rax), %rax
movl 0xc(%rax), %eax
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]optimal-seed-solver/optimalSolverLN.cc
// Function: OptimalSolverLN::solveDNA(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
unsigned int OptimalSolverLN::solveDNA(string& DNA) {
	fillMatrix(DNA);
	calculateLastDiv();
	processedReads++;
	return calcualteFreq();
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x8(%rsp), %rsi
callq 0x8130
movq (%rsp), %rdi
callq 0x9930
movq (%rsp), %rdi
movl 0x400(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x400(%rdi)
callq 0x99b0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: CMU-SAFARI[P]optimal-seed-solver/optimalSolverLN.cc
// Function: OptimalSolverLN::printSeeds(std::ostream&)
void OptimalSolverLN::printSeeds(ostream& stream) {
	for (int i = 0; i < seedNum; i++) {
		stream << "Seed[" << i << "]: start: " << seeds[i].start;
		stream << " end: " << seeds[i].end;
		stream << " frequency: " << seeds[i].frequency;
		stream << endl;
	}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x24(%rsp)
movq 0x18(%rsp), %rcx
movl 0x24(%rsp), %eax
cmpl 0x364(%rcx), %eax
jge 0xa039
movq 0x28(%rsp), %rdi
leaq 0x1138a(%rip), %rsi     # 0x1b2eb
callq 0x32e0
movq %rax, %rdi
movl 0x24(%rsp), %esi
callq 0x35b0
movq %rax, %rdi
leaq 0x11375(%rip), %rsi     # 0x1b2f1
callq 0x32e0
movq 0x18(%rsp), %rdi
movq %rax, (%rsp)
addq $0x3c8, %rdi            # imm = 0x3C8
movslq 0x24(%rsp), %rsi
callq 0xa7c0
movq (%rsp), %rdi
movl (%rax), %esi
callq 0x3460
movq 0x28(%rsp), %rdi
leaq 0x1134a(%rip), %rsi     # 0x1b2fc
callq 0x32e0
movq 0x18(%rsp), %rdi
movq %rax, 0x8(%rsp)
addq $0x3c8, %rdi            # imm = 0x3C8
movslq 0x24(%rsp), %rsi
callq 0xa7c0
movq 0x8(%rsp), %rdi
movl 0x4(%rax), %esi
callq 0x3460
movq 0x28(%rsp), %rdi
leaq 0x1173e(%rip), %rsi     # 0x1b729
callq 0x32e0
movq 0x18(%rsp), %rdi
movq %rax, 0x10(%rsp)
addq $0x3c8, %rdi            # imm = 0x3C8
movslq 0x24(%rsp), %rsi
callq 0xa7c0
movq 0x10(%rsp), %rdi
movl 0xc(%rax), %esi
callq 0x3460
movq 0x28(%rsp), %rdi
movq 0x19f94(%rip), %rsi     # 0x23fb8
callq 0x3330
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x9f40
addq $0x38, %rsp
retq
nop
// File: CMU-SAFARI[P]optimal-seed-solver/optimalSolverLN.cc
// Function: OptimalSolverLN::printStats(std::ostream&)
void OptimalSolverLN::printStats(ostream& stream) {
	unsigned long long sumOfTravel = 0;
	stream << "divTravel distribution: ";
	for (int i = 0; i < readLength; i++) {
		stream << divTravel[i] << " ";
		sumOfTravel += divTravel[i] * i;
	}
	stream << endl;

	unsigned long long prefixesPerRead = (readLength + 1 - seedNum * minLength) * (seedNum - 2) + 1;
	unsigned long long totalPrefixes = processedReads * prefixesPerRead;
	stream << "divTravel per prefix: " << (double) sumOfTravel / totalPrefixes << endl;
	stream << endl;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x38(%rsp), %rdi
leaq 0x11146(%rip), %rsi     # 0x1b303
callq 0x32e0
movl $0x0, 0x2c(%rsp)
movq 0x10(%rsp), %rcx
movl 0x2c(%rsp), %eax
cmpl 0x360(%rcx), %eax
jge 0xa253
movq 0x10(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x3e8, %rdi            # imm = 0x3E8
movslq 0x2c(%rsp), %rsi
callq 0xa7a0
movq 0x8(%rsp), %rdi
movq (%rax), %rsi
callq 0x32c0
movq %rax, %rdi
leaq 0x114de(%rip), %rsi     # 0x1b6f0
callq 0x32e0
movq 0x10(%rsp), %rdi
addq $0x3e8, %rdi            # imm = 0x3E8
movslq 0x2c(%rsp), %rsi
callq 0xa7a0
movq (%rax), %rax
movslq 0x2c(%rsp), %rcx
imulq %rcx, %rax
addq 0x30(%rsp), %rax
movq %rax, 0x30(%rsp)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0xa1ca
movq 0x38(%rsp), %rdi
movq 0x19d59(%rip), %rsi     # 0x23fb8
callq 0x3330
movq 0x10(%rsp), %rax
movl 0x360(%rax), %esi
movl 0x364(%rax), %edx
movl 0x368(%rax), %ecx
movl %edx, %edi
imull %ecx, %edi
movl %esi, %ecx
negl %edi
movl %edi, %esi
leal 0x1(%rcx,%rsi), %ecx
addl $-0x2, %edx
imull %edx, %ecx
incl %ecx
movslq %ecx, %rcx
movq %rcx, 0x20(%rsp)
movl 0x400(%rax), %eax
movq 0x20(%rsp), %rcx
imulq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
leaq 0x11062(%rip), %rsi     # 0x1b31c
callq 0x32e0
movq %rax, %rdi
movaps 0x10e07(%rip), %xmm3    # 0x1b0d0
movq 0x30(%rsp), %xmm0
punpckldq %xmm3, %xmm0    # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
movapd 0x10e05(%rip), %xmm2    # 0x1b0e0
subpd %xmm2, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movq 0x18(%rsp), %xmm1
punpckldq %xmm3, %xmm1    # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
callq 0x3620
movq %rax, %rdi
movq 0x19ca2(%rip), %rsi     # 0x23fb8
callq 0x3330
movq 0x38(%rsp), %rdi
movq 0x19c91(%rip), %rsi     # 0x23fb8
callq 0x3330
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: patxitron[P]BattleyeRconToolLinux/a3s.cpp
// Function: patxi::a3s::login(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void a3s::login(std::string const& password)
{
	if(!listening_) {
		send_request(password.data(), password.size(), LOGIN);
		listening_ = true;
		receive();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x1(%rax)
jne 0x92d6
movq -0x10(%rbp), %rdi
callq 0x8610
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8300
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdi
movq %rax, %rdx
movl $0x1, %ecx
callq 0x92e0
movq -0x18(%rbp), %rdi
movb $0x1, 0x1(%rdi)
callq 0x9480
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: patxitron[P]BattleyeRconToolLinux/a3s.cpp
// Function: patxi::a3s::send_request(char const*, unsigned long, patxi::a3s::request_type)
void a3s::send_request(char const* data, std::size_t length, request_type rtp)
{
	request_t req;
	char* request = reinterpret_cast<char*>(&req);
	if(rtp == LOGIN) {
		memcpy(req.payload, data, length);
		length += sizeof(reqheader_t);
	} else if(rtp == BROADCAST_RESPONSE) {
		req.hdr.begin_msg = 0x02;
		memcpy(req.payload, data, length);
		length += sizeof(reqheader_t);
	} else {
		req.hdr.begin_msg = 0x01;
		req.payload[0] = *reinterpret_cast<char*>(&sequence_);
		sequence_ += 1;
		memcpy(req.payload + 1, data, length);
		length += sizeof(reqheader_t) + 1;
	}
	boost::crc_32_type crc;
	crc.process_bytes(request + 6, length - 6);
	req.hdr.checksum = crc.checksum();
	socket_.async_send_to(
		boost::asio::buffer(request, length),
		endpoint_,
		[](boost::system::error_code ec, std::size_t /*bytes_sent*/)
		{
			if(ec) {
				cerr << "Error sending request" << ec << endl;
			}
		}
	);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x158(%rbp)
leaq -0x124(%rbp), %rdi
callq 0xdd10
leaq -0x124(%rbp), %rax
movq %rax, -0x130(%rbp)
cmpl $0x1, -0x1c(%rbp)
jne 0x934b
leaq -0x124(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x83b0
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
jmp 0x93c9
cmpl $0x2, -0x1c(%rbp)
jne 0x937e
movb $0x2, -0x11d(%rbp)
leaq -0x124(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x83b0
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
jmp 0x93c7
movq -0x158(%rbp), %rax
movb $0x1, -0x11d(%rbp)
movb 0x2(%rax), %cl
movb %cl, -0x11c(%rbp)
movzbl 0x2(%rax), %ecx
addl $0x1, %ecx
movb %cl, 0x2(%rax)
leaq -0x124(%rbp), %rdi
addq $0x8, %rdi
addq $0x1, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x83b0
movq -0x18(%rbp), %rax
addq $0x9, %rax
movq %rax, -0x18(%rbp)
jmp 0x93c9
leaq -0x134(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xdd30
movq -0x130(%rbp), %rsi
addq $0x6, %rsi
movq -0x18(%rbp), %rdx
subq $0x6, %rdx
leaq -0x134(%rbp), %rdi
callq 0xdd60
leaq -0x134(%rbp), %rdi
callq 0xdda0
movl %eax, %ecx
movq -0x158(%rbp), %rax
movl %ecx, -0x122(%rbp)
addq $0x48, %rax
movq %rax, -0x160(%rbp)
movq -0x130(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xdde0
movq -0x160(%rbp), %rdi
movq %rax, %rcx
movq %rdx, %rax
movq -0x158(%rbp), %rdx
movq %rcx, -0x148(%rbp)
movq %rax, -0x140(%rbp)
addq $0x140, %rdx            # imm = 0x140
leaq -0x148(%rbp), %rsi
leaq -0x149(%rbp), %rcx
callq 0x9640
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: patxitron[P]BattleyeRconToolLinux/a3s.cpp
// Function: patxi::a3s::consoleInput()
void a3s::consoleInput()
{
	boost::asio::async_read_until(
		 input_
		,console_data_
		,'\n'
		,[this](boost::system::error_code const& ec, std::size_t length)
		{
			if(!ec && length > 0) {
				send_request(boost::asio::buffer_cast<char const*>(console_data_.data()), length - 1);
				console_data_.consume(length);
			}
			consoleInput();
		}
	);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rdi
addq $0x98, %rdi
movq %rax, %rsi
addq $0xe0, %rsi
movq %rax, -0x10(%rbp)
movl $0xa, %edx
leaq -0x10(%rbp), %rcx
callq 0x95f0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: patxitron[P]BattleyeRconToolLinux/./a3s.h
// Function: patxi::a3s::reqheader_t::reqheader_t()
reqheader_t()
			:begin_header{'B','E'}
			,checksum{0}
			,end_header{0xff}
			,begin_msg{0} {}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb $0x42, (%rax)
movb $0x45, 0x1(%rax)
movl $0x0, 0x2(%rax)
movb $-0x1, 0x6(%rax)
movb $0x0, 0x7(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Aries-orz[P]Ari-RayTracing/src/Demo.cpp
// Function: main
int main(int argc, char* argv[]) {
    Scene scene;
    generateWorld(scene);
    
    //Make a 2x2 sampling
    int samps = (argc==2 ? atoi(argv[1])/4 : 1);
    //Initialize the camera
    Ray camera(Vec3d(50, 52, 295.6), Vec3d(0, -0.042612, -1).norm());
    
    //Start the ray tracing
    engine::raytracing(&scene, samps, camera, w, h, "result.ppm");
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x8c00
movq -0xf0(%rbp), %rdi
callq 0x22f0
jmp 0x33f7
cmpl $0x2, -0x8(%rbp)
jne 0x341a
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2160
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, -0xf4(%rbp)
jmp 0x3427
movl $0x1, %eax
movl %eax, -0xf4(%rbp)
jmp 0x3427
movl -0xf4(%rbp), %eax
movl %eax, -0x40(%rbp)
leaq -0x88(%rbp), %rdi
movsd 0x7cc1(%rip), %xmm0     # 0xb100
movsd 0x7cc1(%rip), %xmm1     # 0xb108
movsd 0x7cc1(%rip), %xmm2     # 0xb110
callq 0x3540
jmp 0x3456
leaq -0xb8(%rbp), %rdi
xorps %xmm0, %xmm0
movsd 0x7cb0(%rip), %xmm1     # 0xb118
movsd 0x7bb8(%rip), %xmm2     # 0xb028
callq 0x3540
jmp 0x3477
leaq -0xb8(%rbp), %rdi
callq 0xa170
movq %rax, -0x100(%rbp)
jmp 0x348c
movq -0x100(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
callq 0x9ea0
jmp 0x34a1
leaq -0x70(%rbp), %rdi
leaq -0x88(%rbp), %rsi
leaq -0xa0(%rbp), %rdx
callq 0x8bc0
jmp 0x34ba
movl -0x40(%rbp), %eax
movl %eax, -0x104(%rbp)
leaq -0xe8(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x3690
jmp 0x34d5
movl -0x104(%rbp), %esi
leaq 0x7c52(%rip), %r9       # 0xb134
leaq -0x30(%rbp), %rdi
leaq -0xe8(%rbp), %rdx
movl $0x400, %ecx            # imm = 0x400
movl $0x300, %r8d            # imm = 0x300
callq 0x4410
jmp 0x34ff
leaq -0x30(%rbp), %rdi
callq 0x8c30
movl -0x4(%rbp), %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x8c30
movq -0x38(%rbp), %rdi
callq 0x21b0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Aries-orz[P]Ari-RayTracing/src/ObjParser.h
// Function: rt::ObjParser::TriArray::operator[](int)
int& operator[] (const int i) {
            switch (i) {
                case 0: return a;
                case 1: return b;
                case 2: return c;
                default: {
                    printf("RTError: The TriArray index is out of range!");
                    return a;
                }
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
testl %eax, %eax
je 0x35d7
jmp 0x35c3
movl -0x18(%rbp), %eax
subl $0x1, %eax
je 0x35e1
jmp 0x35cd
movl -0x18(%rbp), %eax
subl $0x2, %eax
je 0x35ef
jmp 0x35fd
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3613
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x8(%rbp)
jmp 0x3613
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0x3613
leaq 0x7b3b(%rip), %rdi      # 0xb13f
movb $0x0, %al
callq 0x2040
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Aries-orz[P]Ari-RayTracing/src/ObjParser.cpp
// Function: rt::ObjParser::destroy()
void ObjParser::destroy() {
    if (verticeList)
        delete [] verticeList;
    if (faceList)
        delete [] faceList;
        
    numOfVertices = -1;
    numOfFaces = -1;
    verticeList = NULL;
    faceList = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x4d28
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x4d26
movq -0x18(%rbp), %rdi
callq 0x2130
jmp 0x4d28
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x4d50
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x4d4e
movq -0x20(%rbp), %rdi
callq 0x2130
jmp 0x4d50
movq -0x10(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movl $0xffffffff, 0x4(%rax)  # imm = 0xFFFFFFFF
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Aries-orz[P]Ari-RayTracing/src/ObjParser.cpp
// Function: rt::ObjParser::readFromObj(char const*)
bool ObjParser::readFromObj(const char* filename) {
    FILE* fp = fopen(filename, "r");
    if (fp == NULL) {
        printf("RTError: The file %s doesn't exist.\n", filename);
        return false;
    } else {
        if (parse(fp)) {
            printf("Read from %s successfully.\n", filename);
            printf("Vertex Number = %d\n", numOfVertices);
            printf("Face Number = %d\n", numOfFaces);
            fclose(fp);
            return true;
        } else {
            printf("RTError: Cannot parse %s.\n", filename);
            fclose(fp);
            return false;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x6480(%rip), %rsi      # 0xb223
callq 0x2120
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x4dcb
movq -0x18(%rbp), %rsi
leaq 0x6467(%rip), %rdi      # 0xb225
movb $0x0, %al
callq 0x2040
movb $0x0, -0x1(%rbp)
jmp 0x4e47
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4e60
testb $0x1, %al
jne 0x4dde
jmp 0x4e28
movq -0x18(%rbp), %rsi
leaq 0x6461(%rip), %rdi      # 0xb24a
movb $0x0, %al
callq 0x2040
movq -0x28(%rbp), %rax
movl (%rax), %esi
leaq 0x6469(%rip), %rdi      # 0xb266
movb $0x0, %al
callq 0x2040
movq -0x28(%rbp), %rax
movl 0x4(%rax), %esi
leaq 0x6468(%rip), %rdi      # 0xb27a
movb $0x0, %al
callq 0x2040
movq -0x20(%rbp), %rdi
callq 0x20f0
movb $0x1, -0x1(%rbp)
jmp 0x4e47
movq -0x18(%rbp), %rsi
leaq 0x6459(%rip), %rdi      # 0xb28c
movb $0x0, %al
callq 0x2040
movq -0x20(%rbp), %rdi
callq 0x20f0
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Aries-orz[P]Ari-RayTracing/src/RTBox.cpp
// Function: rt::RTBox::getNormal(rt::Ray const&, double) const
Vec3d RTBox::getNormal(const Ray& r, const double t) const {
    switch (face) {
        case 0: return Vec3d(-1,0,0);
        case 1: return Vec3d(0,-1,0);
        case 2: return Vec3d(0,0,-1);
        case 3: return Vec3d(1,0,0);
        case 4: return Vec3d(0,1,0);
        case 5: return Vec3d(0,0,1);
    }
    return Vec3d();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x70(%rax), %eax
movq %rax, -0x28(%rbp)
subq $0x5, %rax
ja 0x7bf6
movq -0x28(%rbp), %rax
leaq 0x3814(%rip), %rcx      # 0xb368
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x38(%rbp), %rdi
movsd 0x34bf(%rip), %xmm0     # 0xb028
xorps %xmm2, %xmm2
movaps %xmm2, %xmm1
callq 0x3540
jmp 0x7c08
movq -0x38(%rbp), %rdi
xorps %xmm2, %xmm2
movsd 0x34a0(%rip), %xmm1     # 0xb028
movaps %xmm2, %xmm0
callq 0x3540
jmp 0x7c08
movq -0x38(%rbp), %rdi
xorps %xmm1, %xmm1
movsd 0x3487(%rip), %xmm2     # 0xb028
movaps %xmm1, %xmm0
callq 0x3540
jmp 0x7c08
movq -0x38(%rbp), %rdi
movsd 0x3451(%rip), %xmm0     # 0xb008
xorps %xmm2, %xmm2
movaps %xmm2, %xmm1
callq 0x3540
jmp 0x7c08
movq -0x38(%rbp), %rdi
xorps %xmm2, %xmm2
movsd 0x3435(%rip), %xmm1     # 0xb008
movaps %xmm2, %xmm0
callq 0x3540
jmp 0x7c08
movq -0x38(%rbp), %rdi
xorps %xmm1, %xmm1
movsd 0x341c(%rip), %xmm2     # 0xb008
movaps %xmm1, %xmm0
callq 0x3540
jmp 0x7c08
movq -0x38(%rbp), %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x3540
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Aries-orz[P]Ari-RayTracing/src/RTComplexObj.cpp
// Function: rt::RTComplexObj::hit(rt::Ray const&)
double RTComplexObj::hit(const Ray& r) {
    if (!bbox->hit(r)) return 0;
    double tmin = 0;
    for (int i=0; i<size; ++i) {
        double t = indices[i].hit(r);
        if (!t) continue;
        if (t < tmin || !tmin) {
            tmin = t;
            index = i;
        }
    }
    return tmin;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x48(%rax), %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x7e5e
jp 0x7e5e
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x7efe
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x38(%rbp), %rcx
movl -0x24(%rbp), %eax
cmpl 0x54(%rcx), %eax
jge 0x7ef4
movq -0x38(%rbp), %rax
movq 0x40(%rax), %rdi
movslq -0x24(%rbp), %rax
imulq $0x88, %rax, %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x7eb0
jp 0x7eb0
jmp 0x7ee6
movsd -0x30(%rbp), %xmm1
movsd -0x20(%rbp), %xmm0
ucomisd %xmm1, %xmm0
ja 0x7ed0
movsd -0x20(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x7ee4
jp 0x7ee4
movq -0x38(%rbp), %rax
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x24(%rbp), %ecx
movl %ecx, 0x50(%rax)
jmp 0x7ee6
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x7e6d
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: Aries-orz[P]Ari-RayTracing/src/RTPlane.cpp
// Function: rt::RTPlane::hit(rt::Ray const&)
double RTPlane::hit(const Ray& r) {
    double t = (point - r.o).dot(normal) / (r.d).dot(normal);
    if (t > 1e-4)
        return t;
    else
        return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x48(%rbp)
addq $0x40, %rsi
movq -0x18(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x9f40
movq -0x48(%rbp), %rsi
addq $0x58, %rsi
leaq -0x38(%rbp), %rdi
callq 0xa1f0
movq -0x48(%rbp), %rsi
movsd %xmm0, -0x40(%rbp)
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
addq $0x58, %rsi
callq 0xa1f0
movaps %xmm0, %xmm1
movsd -0x40(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movsd 0x31be(%rip), %xmm1     # 0xb350
ucomisd %xmm1, %xmm0
jbe 0x81a4
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x81ac
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Aries-orz[P]Ari-RayTracing/src/RTSphere.cpp
// Function: rt::RTSphere::hit(rt::Ray const&)
double RTSphere::hit(const Ray& r) {
	Vec3d dis = pos - r.o;
	double t;
	double eps = 1e-4;
	double b = dis.dot(r.d);
	double det = b*b - dis.dot(dis) + rad*rad;
	if (det < 0) return 0;
	else det = sqrt(det);

    return (t=b-det)>eps ? t : ((t=b+det)>eps ? t : 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x58(%rbp)
addq $0x40, %rsi
movq -0x18(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x9f40
movsd 0x2f9c(%rip), %xmm0     # 0xb350
movsd %xmm0, -0x40(%rbp)
movq -0x18(%rbp), %rsi
addq $0x18, %rsi
leaq -0x30(%rbp), %rdi
callq 0xa1f0
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
leaq -0x30(%rbp), %rsi
movq %rsi, %rdi
callq 0xa1f0
movsd -0x68(%rbp), %xmm1
movsd -0x60(%rbp), %xmm2
movq -0x58(%rbp), %rax
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd 0x58(%rax), %xmm0
movsd 0x58(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x50(%rbp), %xmm0
jbe 0x8447
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x84b8
movsd -0x50(%rbp), %xmm0
callq 0x20d0
movsd %xmm0, -0x50(%rbp)
movsd -0x48(%rbp), %xmm0
subsd -0x50(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
ucomisd -0x40(%rbp), %xmm0
jbe 0x8478
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x70(%rbp)
jmp 0x84ae
movsd -0x48(%rbp), %xmm0
addsd -0x50(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
ucomisd -0x40(%rbp), %xmm0
jbe 0x849a
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x78(%rbp)
jmp 0x84a4
xorps %xmm0, %xmm0
movsd %xmm0, -0x78(%rbp)
jmp 0x84a4
movsd -0x78(%rbp), %xmm0
movsd %xmm0, -0x70(%rbp)
movsd -0x70(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Aries-orz[P]Ari-RayTracing/src/RTTriangle.cpp
// Function: rt::RTTriangle::hit(rt::Ray const&)
double RTTriangle::hit(const Ray& r) {
	Vec3d e1 = p1 - p0;
	Vec3d e2 = p2 - p0;
	Vec3d p = (r.d)^(e2);
	double det = e1.dot(p);
	Vec3d tt;
	if (det > 0) tt = r.o - p0;
	else {
		tt = p0 - r.o;
		det = -det;
	}
	if (det < 0.0001f) return 0;
	double u = tt.dot(p);
	if (u < 0.0f || u > det) return 0;
	Vec3d q = tt^e1;
	double v = r.d.dot(q);
	if (v < 0.0f || u+v > det) return 0;
	if (e2.dot(q) <= 0) return 0;
	double t = e2.dot(q);
	double invDet = 1.0f / det;
	t *= invDet;
	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdx
movq %rdx, -0xf0(%rbp)
movq %rdx, %rsi
addq $0x58, %rsi
addq $0x40, %rdx
leaq -0x30(%rbp), %rdi
callq 0x9f40
movq -0xf0(%rbp), %rdx
movq %rdx, %rsi
addq $0x70, %rsi
addq $0x40, %rdx
leaq -0x48(%rbp), %rdi
callq 0x9f40
movq -0x18(%rbp), %rsi
addq $0x18, %rsi
leaq -0x60(%rbp), %rdi
leaq -0x48(%rbp), %rdx
callq 0xa050
leaq -0x30(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xa1f0
movsd %xmm0, -0x68(%rbp)
leaq -0x80(%rbp), %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x3540
movsd -0x68(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x8831
movq -0xf0(%rbp), %rdx
movq -0x18(%rbp), %rsi
addq $0x40, %rdx
leaq -0x98(%rbp), %rdi
callq 0x9f40
leaq -0x80(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0xa130
jmp 0x887d
movq -0xf0(%rbp), %rsi
addq $0x40, %rsi
movq -0x18(%rbp), %rdx
leaq -0xb0(%rbp), %rdi
callq 0x9f40
leaq -0x80(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0xa130
movsd -0x68(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x68(%rbp)
movsd 0x2b4b(%rip), %xmm0     # 0xb3d0
ucomisd -0x68(%rbp), %xmm0
jbe 0x8899
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x89ad
leaq -0x80(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xa1f0
movsd %xmm0, -0xb8(%rbp)
xorps %xmm0, %xmm0
ucomisd -0xb8(%rbp), %xmm0
ja 0x88ca
movsd -0xb8(%rbp), %xmm0
ucomisd -0x68(%rbp), %xmm0
jbe 0x88d7
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x89ad
leaq -0xd0(%rbp), %rdi
leaq -0x80(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0xa050
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
leaq -0xd0(%rbp), %rsi
callq 0xa1f0
movsd %xmm0, -0xd8(%rbp)
xorps %xmm0, %xmm0
ucomisd -0xd8(%rbp), %xmm0
ja 0x892b
movsd -0xb8(%rbp), %xmm0
addsd -0xd8(%rbp), %xmm0
ucomisd -0x68(%rbp), %xmm0
jbe 0x8935
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x89ad
leaq -0x48(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0xa1f0
movaps %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jb 0x895b
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x89ad
leaq -0x48(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0xa1f0
movsd %xmm0, -0xe0(%rbp)
movsd 0x268d(%rip), %xmm0     # 0xb008
divsd -0x68(%rbp), %xmm0
movsd %xmm0, -0xe8(%rbp)
movsd -0xe8(%rbp), %xmm0
mulsd -0xe0(%rbp), %xmm0
movsd %xmm0, -0xe0(%rbp)
movsd -0xe0(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0xf0, %rsp
popq %rbp
retq
nopl (%rax,%rax)