LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/sbingner[P]kerneldec/lzfse/src/lzfse_fse.c
// Function: fse_init_value_decoder_table
void fse_init_value_decoder_table(int nstates, int nsymbols,
                                  const uint16_t *__restrict freq,
                                  const uint8_t *__restrict symbol_vbits,
                                  const int32_t *__restrict symbol_vbase,
                                  fse_value_decoder_entry *__restrict t) {
  assert(nsymbols <= 256);
  assert(fse_check_freq(freq, nsymbols, nstates) == 0);

  int n_clz = __builtin_clz(nstates);
  for (int i = 0; i < nsymbols; i++) {
    int f = (int)freq[i];
    if (f == 0)
      continue; // skip this symbol, no occurrences

    int k =
        __builtin_clz(f) - n_clz; // shift needed to ensure N <= (F<<K) < 2*N
    int j0 = ((2 * nstates) >> k) - f;

    fse_value_decoder_entry ei = {0};
    ei.value_bits = symbol_vbits[i];
    ei.vbase = symbol_vbase[i];

    // Initialize all states S reached by this symbol: OFFSET <= S < OFFSET + F
    for (int j = 0; j < f; j++) {
      fse_value_decoder_entry e = ei;

      if (j < j0) {
        e.total_bits = (uint8_t)k + e.value_bits;
        e.delta = (int16_t)(((f + j) << k) - nstates);
      } else {
        e.total_bits = (uint8_t)(k - 1) + e.value_bits;
        e.delta = (int16_t)((j - j0) << (k - 1));
      }

      memcpy(t, &e, 8);
      t++;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
cmpl $0x101, %esi            # imm = 0x101
jge 0x7970
testl %esi, %esi
je 0x7961
movslq %edi, %rax
movl %esi, %r11d
xorl %ecx, %ecx
xorl %r8d, %r8d
movzwl (%rdx,%rcx,2), %r10d
addq %r10, %r8
incq %rcx
cmpq %rcx, %r11
jne 0x789c
cmpq %rax, %r8
ja 0x798f
testl %esi, %esi
jle 0x7961
bsrl %edi, %eax
xorl $0x1f, %eax
movl %eax, 0x4(%rsp)
leal (%rdi,%rdi), %eax
movl %eax, (%rsp)
xorl %r14d, %r14d
movzwl (%rdx,%r14,2), %r8d
testl %r8d, %r8d
je 0x7955
bsrl %r8d, %esi
xorl $0x1f, %esi
subl 0x4(%rsp), %esi
movl (%rsp), %eax
movl %eax, %r15d
movl %esi, %ecx
sarl %cl, %r15d
movl %r15d, %r12d
subl %r8d, %r12d
movq 0x8(%rsp), %rax
movb (%rax,%r14), %r13b
movq 0x10(%rsp), %rax
movl (%rax,%r14,4), %eax
leal -0x1(%rsi), %r10d
movl %r8d, %r8d
negl %r15d
addq %r8, %r15
xorl %ebp, %ebp
cmpl %r12d, %ebp
jge 0x792a
leal (%r8,%rbp), %ebx
movl %esi, %ecx
shll %cl, %ebx
subl %edi, %ebx
movl %esi, %ecx
jmp 0x7936
leal (%r15,%rbp), %ebx
movl %r10d, %ecx
shll %cl, %ebx
movl %r10d, %ecx
addb %r13b, %cl
movb %cl, (%r9)
movb %r13b, 0x1(%r9)
movw %bx, 0x2(%r9)
movl %eax, 0x4(%r9)
addq $0x8, %r9
incq %rbp
cmpl %ebp, %r8d
jne 0x7917
incq %r14
cmpq %r11, %r14
jne 0x78d0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1fbc(%rip), %rdi      # 0x9933
leaq 0x1fc5(%rip), %rsi      # 0x9943
leaq 0x204d(%rip), %rcx      # 0x99d2
movl $0x72, %edx
callq 0x3070
leaq 0x200f(%rip), %rdi      # 0x99a5
leaq 0x1fa6(%rip), %rsi      # 0x9943
leaq 0x202e(%rip), %rcx      # 0x99d2
movl $0x73, %edx
callq 0x3070
// File: /workspace/github_cpp_makefile_star2_O3/dudulu233[P]EMA-Tool/./log.h
// Function: GET_MSG(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
char *GET_MSG(int level, string s)
{
    static char log_msg[1000];
    time_t t = time(0);
    struct tm *local = localtime(&t);
    char time_buf[128];
    strftime(time_buf, 64, "%Y/%m/%d %H:%M:%S", local);
    strcpy(log_msg, "[");
    strcat(log_msg, time_buf);
    strcat(log_msg, "] [");
    strcat(log_msg, LEVEL[level]);
    strcat(log_msg, "] ");
    strcat(log_msg, s.c_str());
    strcat(log_msg, "\n");
    return log_msg;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rsi, %rbx
movl %edi, %ebp
xorl %edi, %edi
callq 0x2210
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
callq 0x2190
leaq 0x3a50(%rip), %rdx      # 0x6099
leaq 0x10(%rsp), %r15
movl $0x40, %esi
movq %r15, %rdi
movq %rax, %rcx
callq 0x21c0
movw $0x5b, 0x6c09(%rip)     # 0x9270
leaq 0x6c02(%rip), %r14      # 0x9270
movq %r14, %rdi
movq %r15, %rsi
callq 0x23f0
movq %r14, %rdi
callq 0x2110
movl $0x5b205d, (%rax,%r14)  # imm = 0x5B205D
movslq %ebp, %rax
leaq (%rax,%rax,4), %rax
leaq 0x39b9(%rip), %rcx      # 0x6050
leaq (%rcx,%rax,4), %rsi
movq %r14, %rdi
callq 0x23f0
movq %r14, %rdi
callq 0x2110
movw $0x205d, (%rax,%r14)    # imm = 0x205D
movb $0x0, 0x2(%rax,%r14)
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x23f0
movq %r14, %rdi
callq 0x2110
movw $0xa, (%rax,%r14)
movq %r14, %rax
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/dudulu233[P]EMA-Tool/cache_stat.cpp
// Function: StatCache::StatCache(long)
StatCache::StatCache(long st)
{
	total_seq = re_seq = map_size = current_hour = current_day = 0;
	start_time = st;
	for (int i = 0; i < 1024; i++)
	{
		reuse_dis_array[i] = 0l;
	}

	string output_path = "./result";
	string shell_str = "mkdir -p " + output_path;
	int ret = system(shell_str.c_str());
	assert(0 == ret);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x2060(%rdi), %rax
movq %rax, 0x2030(%rdi)
movl $0x1, %eax
movq %rax, 0x2038(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x2040(%rdi)
movl $0x3f800000, %ecx       # imm = 0x3F800000
movl %ecx, 0x2050(%rdi)
movups %xmm0, 0x2058(%rdi)
leaq 0x2098(%rdi), %rdx
movq %rdx, 0x2068(%rdi)
movq %rax, 0x2070(%rdi)
movups %xmm0, 0x2078(%rdi)
movl %ecx, 0x2088(%rdi)
movups %xmm0, 0x2090(%rdi)
movups %xmm0, (%rdi)
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x20(%rdi)
movq %rsi, 0x28(%rdi)
addq $0x30, %rdi
movl $0x2000, %edx           # imm = 0x2000
xorl %esi, %esi
callq 0x2130
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x266a(%rip), %rsi      # 0x63c8
leaq 0x266b(%rip), %rdx      # 0x63d0
movq %rsp, %rdi
callq 0x3c28
leaq 0x265d(%rip), %rsi      # 0x63d1
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x46c5
movq 0x20(%rsp), %rdi
callq 0x21e0
testl %eax, %eax
jne 0x3dba
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3da2
callq 0x2220
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x3db0
callq 0x2220
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x261a(%rip), %rdi      # 0x63db
leaq 0x261c(%rip), %rsi      # 0x63e4
leaq 0x2624(%rip), %rcx      # 0x63f3
movl $0x13, %edx
callq 0x2150
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3df4
callq 0x2220
jmp 0x3df4
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x3e07
callq 0x2220
jmp 0x3e07
movq %rax, %r14
leaq 0x2030(%rbx), %r15
addq $0x2068, %rbx           # imm = 0x2068
movq %rbx, %rdi
callq 0x4746
movq %r15, %rdi
callq 0x47b4
movq %r14, %rdi
callq 0x23e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/dudulu233[P]EMA-Tool/cache_stat.cpp
// Function: StatCache::is_new_day(_IoRecord*)
bool StatCache::is_new_day(IoRecord* ir)
{
	bool result = false;
	long tmp = get_time_day(ir->alloc_time);
	if (tmp - current_day > 0)
	{
		result = true;
		current_day = tmp;
	}
	else if (tmp < current_day)
	{
		ir->alloc_time += 1;
	}
	return result;
}

// Assembly:
movq (%rsi), %rcx
leaq 0x7080(%rcx), %rax
movabsq $0x1845c8a0ce512957, %rdx # imm = 0x1845C8A0CE512957
imulq %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0xd, %rdx
addq %rax, %rdx
movq 0x20(%rdi), %rax
cmpq %rax, %rdx
jle 0x4432
movq %rdx, 0x20(%rdi)
jmp 0x443a
jge 0x443a
incq %rcx
movq %rcx, (%rsi)
cmpq %rax, %rdx
setg %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/dudulu233[P]EMA-Tool/cache_stat.cpp
// Function: StatCache::plot_rar_curve(SeqNum*)
void StatCache::plot_rar_curve(struct SeqNum* sn_tmp)
{
	//y = a*log(t) + b
	//x = log(t)
	//a = (y1-y2)/(x1-x2)
	//b = (x1*y2-x2*y1)/(x1-x2)
	double x1 = log(3600);
	double x2 = log(3600 * 20);
	double x3 = log(3600 * 47);
	double y1 = sn_tmp->re_retio[0];
	double y2 = sn_tmp->re_retio[1];
	double y3 = sn_tmp->re_retio[2];
	sn_tmp->a[0] = (y1 - y2) / (x1 - x2);
	sn_tmp->a[1] = (y3 - y2) / (x3 - x2);
	sn_tmp->b[0] = (x1 * y2 - x2 * y1) / (x1 - x2);
	sn_tmp->b[1] = (x3 * y2 - x2 * y3) / (x3 - x2);

}

// Assembly:
movq (%rsi), %rax
movq 0x10(%rsi), %rcx
movsd (%rcx), %xmm0
movsd 0x8(%rcx), %xmm1
movhpd 0x10(%rcx), %xmm0       # xmm0 = xmm0[0],mem[0]
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
movapd %xmm0, %xmm2
subpd %xmm1, %xmm2
movapd 0x1ef1(%rip), %xmm3     # 0x6380
divpd %xmm3, %xmm2
movupd %xmm2, (%rax)
mulpd 0x1ef1(%rip), %xmm0     # 0x6390
mulpd 0x1ef9(%rip), %xmm1     # 0x63a0
movq 0x8(%rsi), %rax
addpd %xmm0, %xmm1
divpd %xmm3, %xmm1
movupd %xmm1, (%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O3/dudulu233[P]EMA-Tool/cache_stat.cpp
// Function: StatCache::is_new_hour(_IoRecord*)
bool StatCache::is_new_hour(IoRecord* ir)
{
	bool result = false;
	long tmp = get_time_hour(ir->alloc_time);
	if (tmp - current_hour > 0)
	{
		result = true;
		current_hour = tmp;
	}
	else if (tmp < current_hour)
	{
		ir->alloc_time += 1;
	}
	return result;
}

// Assembly:
movq (%rsi), %rcx
movabsq $0x48d159e26af37c05, %rdx # imm = 0x48D159E26AF37C05
movq %rcx, %rax
imulq %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0xa, %rdx
addq %rax, %rdx
movq 0x18(%rdi), %rax
cmpq %rax, %rdx
jle 0x44e8
movq %rdx, 0x18(%rdi)
jmp 0x44f0
jge 0x44f0
incq %rcx
movq %rcx, (%rsi)
cmpq %rax, %rdx
setg %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/dudulu233[P]EMA-Tool/cache_stat.cpp
// Function: StatCache::get_reuse_curve(long, long)
double StatCache::get_reuse_curve(long time_span, long timestamp)
{
	/*
	get reuse distance
	y = a*log(x) + b
	reusedistance = total_block_cnt * (1 - re_access_ratio)
	*/
	double result = 0;
	if (time_span <= 1 || (get_time_day(timestamp) - get_time_day(start_time) < 2))
	{
		result = 0;
	}
	else
	{
		SeqNum* sn_tmp = seq_map[get_time_day(timestamp) - 2];
		if (time_span <= 72000)
		{
			result = sn_tmp->a[0] * log(time_span) + sn_tmp->b[0];
		}
		else
		{
			result = sn_tmp->a[1] * log(time_span) + sn_tmp->b[1];
		}
	}

	return result < 0.99 ? result : 0.99;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
xorpd %xmm0, %xmm0
cmpq $0x2, %rsi
jl 0x45f9
movq %rsi, %rbx
movl $0x7080, %esi           # imm = 0x7080
addq %rsi, %rdx
movabsq $0x1845c8a0ce512957, %rcx # imm = 0x1845C8A0CE512957
movq %rdx, %rax
imulq %rcx
movq %rdx, %rcx
addq 0x28(%rdi), %rsi
movabsq $-0x1845c8a0ce512957, %rdx # imm = 0xE7BA375F31AED6A9
movq %rsi, %rax
imulq %rdx
movq %rcx, %rax
shrq $0x3f, %rax
sarq $0xd, %rcx
addq %rax, %rcx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0xd, %rdx
addq %rax, %rdx
addq %rcx, %rdx
cmpq $0x2, %rdx
jl 0x45f9
addq $0x2068, %rdi           # imm = 0x2068
addq $-0x2, %rcx
leaq 0x10(%rsp), %rsi
movq %rcx, (%rsi)
callq 0x4ab8
movq (%rax), %r14
movq (%r14), %rax
cmpq $0x11940, %rbx          # imm = 0x11940
ja 0x45d2
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %rbx, %xmm0
callq 0x21b0
movq 0x8(%r14), %rax
mulsd 0x8(%rsp), %xmm0
addsd (%rax), %xmm0
jmp 0x45f9
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %rbx, %xmm0
callq 0x21b0
movq 0x8(%r14), %rax
mulsd 0x8(%rsp), %xmm0
addsd 0x8(%rax), %xmm0
minsd 0x1dbf(%rip), %xmm0     # 0x63c0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/dudulu233[P]EMA-Tool/cache_stat.cpp
// Function: StatCache::output_reuse_distance()
void StatCache::output_reuse_distance()
{
	string filename = "./result/reuse_dis.txt";
	FILE* fp = fopen(filename.c_str(), "w");
	assert(NULL != fp);
	for (int i = 0; i < 1024; i++) {
		fprintf(fp, "%ld,", reuse_dis_array[i]);
	}
	fclose(fp);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1e8a(%rip), %rsi      # 0x64b5
leaq 0x1e99(%rip), %rdx      # 0x64cb
movq %rsp, %r14
movq %r14, %rdi
callq 0x3c28
movq (%r14), %rdi
leaq 0x1e1a(%rip), %rsi      # 0x6461
callq 0x22c0
testq %rax, %rax
je 0x46a0
movq %rax, %r14
leaq 0x1e99(%rip), %r15      # 0x64f4
xorl %r13d, %r13d
movq 0x30(%rbx,%r13,8), %rdx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x2350
incq %r13
cmpq $0x400, %r13            # imm = 0x400
jne 0x465e
movq %r14, %rdi
callq 0x2250
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x4692
callq 0x2220
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x1aff(%rip), %rdi      # 0x61a6
leaq 0x1d36(%rip), %rsi      # 0x63e4
leaq 0x1e17(%rip), %rcx      # 0x64cc
movl $0x97, %edx
callq 0x2150
nop
// File: /workspace/github_cpp_makefile_star2_O3/dudulu233[P]EMA-Tool/time_analysis_tool.cpp
// Function: TimeAnalysis::add_time(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void TimeAnalysis::add_time(string key)
{
	if (!TIME_ON)
	{
		return;
	}
	auto it = time_map.find(key);
	if (it == time_map.end())
	{
		struct time_struct* ts = (struct time_struct*)
			malloc(sizeof(struct time_struct));
		ts->cnt = 1;
		ts->latency = end_tv.tv_sec * 1000 + end_tv.tv_usec * 1.0 / 1000 -
			start_tv.tv_sec * 1000 - start_tv.tv_usec * 1.0 / 1000;
		time_map[key] = ts;

	}
	else
	{
		struct time_struct* ts = it->second;
		ts->cnt++;
		ts->latency += end_tv.tv_sec * 1000 + end_tv.tv_usec * 1.0 / 1000 -
			start_tv.tv_sec * 1000 - start_tv.tv_usec * 1.0 / 1000;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rdi), %r15
movq %r15, %rdi
callq 0x5180
testq %rax, %rax
je 0x4edd
movq 0x28(%rax), %rax
incq (%rax)
imulq $0x3e8, 0x10(%rbx), %rcx # imm = 0x3E8
cvtsi2sd %rcx, %xmm0
cvtsi2sdq 0x18(%rbx), %xmm1
movsd 0x165b(%rip), %xmm2     # 0x6500
divsd %xmm2, %xmm1
addsd %xmm0, %xmm1
imulq $0x3e8, (%rbx), %rcx    # imm = 0x3E8
xorps %xmm0, %xmm0
cvtsi2sd %rcx, %xmm0
subsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsi2sdq 0x8(%rbx), %xmm0
divsd %xmm2, %xmm0
subsd %xmm0, %xmm1
addsd 0x8(%rax), %xmm1
movsd %xmm1, 0x8(%rax)
jmp 0x4f4a
movl $0x10, %edi
callq 0x2320
movq %rax, %r12
movq $0x1, (%rax)
imulq $0x3e8, 0x10(%rbx), %rax # imm = 0x3E8
cvtsi2sd %rax, %xmm0
cvtsi2sdq 0x18(%rbx), %xmm1
movsd 0x15f4(%rip), %xmm2     # 0x6500
divsd %xmm2, %xmm1
addsd %xmm0, %xmm1
imulq $0x3e8, (%rbx), %rax    # imm = 0x3E8
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
cvtsi2sdq 0x8(%rbx), %xmm3
subsd %xmm0, %xmm1
divsd %xmm2, %xmm3
subsd %xmm3, %xmm1
movsd %xmm1, 0x8(%r12)
movq %r15, %rdi
movq %r14, %rsi
callq 0x5298
movq %r12, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/dudulu233[P]EMA-Tool/time_analysis_tool.cpp
// Function: TimeAnalysis::get_latency(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
double TimeAnalysis::get_latency(string key)
{
	auto it = time_map.find(key);
	if (it == time_map.end())
	{
		return 0;
	}
	else
	{
		struct time_struct* ts = it->second;
		return ts->latency / ts->cnt;
	}
}

// Assembly:
pushq %rax
addq $0x20, %rdi
callq 0x5180
testq %rax, %rax
je 0x4f93
movq 0x28(%rax), %rax
movsd 0x8(%rax), %xmm0
movsd (%rax), %xmm1
unpcklps 0x1097(%rip), %xmm1     # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x109f(%rip), %xmm1     # 0x6020
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
jmp 0x4f97
xorpd %xmm0, %xmm0
popq %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/dudulu233[P]EMA-Tool/time_analysis_tool.cpp
// Function: TimeAnalysis::print_all_latency()
void TimeAnalysis::print_all_latency()
{
	char shell_str[256];
	strcpy(shell_str, "mkdir -p ./result");
	int ret = system(shell_str);
	assert(0 == ret);

	FILE* fp = fopen("./result/time_analysis.log", "w");
	double total_time = 0;
	for (auto it = time_map.begin();
		it != time_map.end();
		++it)
	{
		struct time_struct* ts = it->second;
		fprintf(fp, "%s : %.6f ms \t\t\t total_time : %.6f ms ( cnt : % llu )\n",
			(it->first).c_str(), ts->latency / ts->cnt,
			ts->latency, ts->cnt);
		total_time += ts->latency;
	}
	fprintf(fp, "---------------------------------------------\n");
	fprintf(fp, "total time-consuming : %.6f minutes\n", total_time / 1000 / 60);
	fclose(fp);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rdi, %r14
movapd 0x155d(%rip), %xmm0     # 0x6510
leaq 0x10(%rsp), %rdi
movapd %xmm0, (%rdi)
movw $0x74, 0x10(%rdi)
callq 0x21e0
testl %eax, %eax
jne 0x50c1
leaq 0x158a(%rip), %rdi      # 0x6560
leaq 0x1484(%rip), %rsi      # 0x6461
callq 0x22c0
movq %rax, %rbx
movq 0x30(%r14), %r15
xorpd %xmm0, %xmm0
testq %r15, %r15
je 0x5065
movsd %xmm0, 0x8(%rsp)
leaq 0x157c(%rip), %r14      # 0x657b
movq 0x8(%r15), %rdx
movq 0x28(%r15), %r12
movsd 0x8(%r12), %xmm1
movq (%r12), %rcx
movq %rcx, %xmm0
punpckldq 0xff1(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0xff9(%rip), %xmm0      # 0x6020
movapd %xmm0, %xmm2
unpckhpd %xmm0, %xmm2            # xmm2 = xmm2[1],xmm0[1]
addsd %xmm0, %xmm2
movapd %xmm1, %xmm0
divsd %xmm2, %xmm0
movq %rbx, %rdi
movq %r14, %rsi
movb $0x2, %al
callq 0x2350
movsd 0x8(%rsp), %xmm0
addsd 0x8(%r12), %xmm0
movsd %xmm0, 0x8(%rsp)
movq (%r15), %r15
testq %r15, %r15
jne 0x4fff
jmp 0x506b
movsd %xmm0, 0x8(%rsp)
leaq 0x1540(%rip), %rdi      # 0x65b2
movl $0x2e, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x2450
movsd 0x8(%rsp), %xmm0
divsd 0x146e(%rip), %xmm0     # 0x6500
divsd 0x146e(%rip), %xmm0     # 0x6508
leaq 0x1540(%rip), %rsi      # 0x65e1
movq %rbx, %rdi
movb $0x1, %al
callq 0x2350
movq %rbx, %rdi
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2250
leaq 0x1313(%rip), %rdi      # 0x63db
leaq 0x1453(%rip), %rsi      # 0x6522
leaq 0x1463(%rip), %rcx      # 0x6539
movl $0x47, %edx
callq 0x2150
// File: /workspace/github_cpp_makefile_star2_O3/gauravtewari[P]netlist/netlist.cpp
// Function: trim(char*)
char *trim(char *token){
		char *last;
		
		/* Remove leading spaces from token */
		while(isspace(*token)) token++;
		if(*token == 0) return token;	/* Check if its all spaces */
			
		/* Remove trailing spaces from token */
		last = token + strlen(token) - 1;				/* Got to last non null character of string */
		while(last > token && isspace(*last)) last--;		/* Check all the characters that are space by going back up */
		*(last+1) = '\0';									/* Null terminate the token */
		return token;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
decq %rbx
movb 0x1(%rbx), %bpl
incq %rbx
movsbl %bpl, %edi
callq 0x2070
testl %eax, %eax
jne 0x356b
testb %bpl, %bpl
je 0x35b1
movq %rbx, %rdi
callq 0x2110
leaq (%rbx,%rax), %rcx
decq %rcx
movq %rcx, %r14
cmpq %rbx, %rcx
jbe 0x35ac
movsbl (%r14), %edi
callq 0x2070
leaq -0x1(%r14), %rcx
testl %eax, %eax
jne 0x3593
movb $0x0, 0x1(%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/gauravtewari[P]netlist/netlist.cpp
// Function: circuit::add_net(net_t, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
u32 circuit::add_net(net_t type, string &tag){
	struct net temp;

	/* Check if the edge already exists */
	if(edge_map.find(tag) == edge_map.end()){
		/* Allocate a new net entry */
		struct net temp;
		edge_map[tag]=num_nets;
		temp.id = num_nets;
		temp.weight = 0;
		temp.type = type;
		temp.gates = list<u32>();
		net_list.push_back(temp);
		net_type[temp.type]++;
		num_nets++;
		return temp.id;
	}
	else
	 return edge_map[tag];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r14
movabsq $-0x7fffffff00000001, %rbp # imm = 0x80000000FFFFFFFF
leaq 0x48(%rsp), %r13
movq %rbp, -0x10(%r13)
movl $0x5, -0x8(%r13)
movq %r13, 0x8(%r13)
movq %r13, (%r13)
movq $0x0, 0x10(%r13)
leaq 0xc0(%rdi), %r12
movq %r12, %rdi
movq %rdx, %rsi
callq 0x41f2
leaq 0xc8(%r14), %rcx
cmpq %rcx, %rax
je 0x3951
movq %r12, %rdi
movq %r15, %rsi
callq 0x3fea
movl (%rax), %ebp
jmp 0x3a1a
movl %ebx, 0xc(%rsp)
leaq 0x20(%rsp), %rbx
movq %rbp, -0x10(%rbx)
movl $0x5, -0x8(%rbx)
movq %rbx, 0x8(%rbx)
movq %rbx, (%rbx)
movq $0x0, 0x10(%rbx)
movl 0x4(%r14), %ebp
movq %r12, %rdi
movq %r15, %rsi
callq 0x3fea
movl %ebp, (%rax)
movl 0x4(%r14), %eax
movl %eax, 0x10(%rsp)
movl $0x0, 0x14(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x18(%rsp)
leaq 0x60(%rsp), %r15
movq %r15, 0x8(%r15)
movq %r15, (%r15)
movq $0x0, 0x10(%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x458e
movq (%r15), %rdi
cmpq %r15, %rdi
je 0x39d9
movq (%rdi), %r12
movl $0x18, %esi
callq 0x2210
movq %r12, %rdi
cmpq %r15, %r12
jne 0x39c4
leaq 0xa8(%r14), %rdi
leaq 0x10(%rsp), %rsi
callq 0x4066
movl 0x18(%rsp), %eax
incl 0x2c(%r14,%rax,4)
incl 0x4(%r14)
movl 0x10(%rsp), %ebp
movq 0x20(%rsp), %rdi
cmpq %rbx, %rdi
je 0x3a1a
movq (%rdi), %r14
movl $0x18, %esi
callq 0x2210
movq %r14, %rdi
cmpq %rbx, %r14
jne 0x3a05
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x3a39
movq (%rdi), %rbx
movl $0x18, %esi
callq 0x2210
movq %rbx, %rdi
cmpq %r13, %rbx
jne 0x3a24
movl %ebp, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3a70
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %rbx, %rdi
je 0x3a73
movq (%rdi), %r15
movl $0x18, %esi
callq 0x2210
movq %r15, %rdi
cmpq %rbx, %r15
jne 0x3a59
jmp 0x3a73
movq %rax, %r14
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x3a92
movq (%rdi), %rbx
movl $0x18, %esi
callq 0x2210
movq %rbx, %rdi
cmpq %r13, %rbx
jne 0x3a7d
movq %r14, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O3/gauravtewari[P]netlist/netlist.cpp
// Function: circuit::add_gate(unsigned int)
u32 circuit::add_gate(u32 type){
	/* we have to add a new gate to the gates adjacency list */
	struct gate temp;
	temp.id = num_gates;
	temp.type = type;
	temp.fan_out = 0;
	temp.fan_in = 0;
	temp.nets = list<u32>();
	gate_list.push_back(temp);
	
	num_gates++;
	gate_type[temp.type]++;
	return temp.id;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
leaq 0x10(%rsp), %rbx
movq %rbx, 0x8(%rbx)
movq %rbx, (%rbx)
xorl %eax, %eax
movq %rax, 0x10(%rbx)
movl (%rdi), %ecx
movl %ecx, -0x10(%rbx)
movl %esi, -0xc(%rbx)
movq %rax, -0x8(%rbx)
leaq 0x28(%rsp), %r15
movq %r15, 0x8(%r15)
movq %r15, (%r15)
movq %rax, 0x10(%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x458e
movq (%r15), %rdi
cmpq %r15, %rdi
je 0x3aff
movq (%rdi), %r12
movl $0x18, %esi
callq 0x2210
movq %r12, %rdi
cmpq %r15, %r12
jne 0x3aea
leaq 0x90(%r14), %rdi
movq %rsp, %rsi
callq 0x40a6
incl (%r14)
movl 0x4(%rsp), %eax
incl 0x8(%r14,%rax,4)
movl (%rsp), %ebp
movq 0x10(%rsp), %rdi
cmpq %rbx, %rdi
je 0x3b3c
movq (%rdi), %r14
movl $0x18, %esi
callq 0x2210
movq %r14, %rdi
cmpq %rbx, %r14
jne 0x3b27
movl %ebp, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %rbx, %rdi
je 0x3b6d
movq (%rdi), %r15
movl $0x18, %esi
callq 0x2210
movq %r15, %rdi
cmpq %rbx, %r15
jne 0x3b58
movq %r14, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O3/gauravtewari[P]netlist/netlist.cpp
// Function: circuit::get_gate_type(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
u32 circuit::get_gate_type(string str){
	u32 size = (u32)gate_t.size();
	if(gate_t.find(str) == gate_t.end())
		gate_t[str]=size;
	return gate_t[str];
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
leaq 0xf0(%rdi), %r14
movq 0x118(%rdi), %r12
movq %r14, %rdi
callq 0x4adc
addq $0xf8, %r15
cmpq %r15, %rax
jne 0x3bb4
movq %r14, %rdi
movq %rbx, %rsi
callq 0x40e0
movl %r12d, (%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x40e0
movl (%rax), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/cgvwzq[P]aes_bf/src/aes-brute-force.cpp
// Function: hexstr_to_bytes(unsigned char*, unsigned long, char*)
size_t hexstr_to_bytes(uint8_t *dst, size_t dst_size, char *hexstr)
{
	unsigned int len = strlen(hexstr);
	if (dst_size > (len/2))
	{
		dst_size = (len/2);
	}
	memset (dst,0,dst_size);
	for (unsigned int i=0; i < dst_size*2; i++)
	{
		unsigned int shift = 4 - 4 * (i & 1);
		unsigned int charIndex = i; //len-1-i;
		char c = hexstr[charIndex];
		uint8_t nibble = hexdigit_value (c);
		dst[i/2] |= nibble << shift;
	}
	return dst_size;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movq %rdx, %rdi
movq %rdx, %r14
movq %rsi, %rbx
callq 0x2070
shrl %eax
movq %r15, %rdi
cmpq %rbx, %rax
cmovbq %rax, %rbx
xorl %esi, %esi
movq %rbx, %rdx
callq 0x20b0
testq %rbx, %rbx
je 0x246b
leal (%rbx,%rbx), %eax
movl $0xff, %esi
xorl %edx, %edx
xorl %edi, %edi
movb (%r14,%rdi), %r8b
movl %edx, %ecx
notb %cl
andb $0x4, %cl
leal -0x30(%r8), %r9d
leal -0x61(%r8), %r10d
leal -0x57(%r8), %r11d
cmpb $0xa, %r9b
movzbl %r9b, %r9d
cmovael %esi, %r9d
cmpb $0x6, %r10b
movzbl %r11b, %r10d
cmovael %r9d, %r10d
leal -0x41(%r8), %r9d
addb $-0x37, %r8b
cmpb $0x6, %r9b
movzbl %r8b, %r8d
cmovael %r10d, %r8d
addb $0x4, %dl
shlb %cl, %r8b
movl %edi, %ecx
shrl %ecx
incq %rdi
orb %r8b, (%r15,%rcx)
cmpq %rdi, %rax
jne 0x2412
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/cgvwzq[P]aes_bf/src/aes-brute-force.cpp
// Function: cleanup_hexstr(char*, unsigned long, char*, unsigned long)
size_t cleanup_hexstr(char *hexstr, size_t hexstr_size, char *str, size_t str_size)
{
	size_t cnt=0;
	int lastIs0=0;
	for (unsigned int j=0; j < str_size; j++)
	{
		char c = str[j];
		if (is_hexdigit (c))
		{
			if (cnt == hexstr_size-1) // need final char for null
			{
				printf ("Too many hex digits. hexstr=%s\n", hexstr);
				hexstr[cnt] = 0;
				return -1;
			}
			hexstr[cnt++] = c;
		}
		else if (lastIs0)
		{
			if ('x' == c)
			{
				cnt--;
			}
			if('X'==c)
			{
				cnt--;
			}
		}
		lastIs0 = '0' == c;
	}
	hexstr[cnt] = 0;
	return cnt;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r9d, %r9d
testq %rcx, %rcx
je 0x256b
movq %rsi, %r14
decq %r14
movl $0x1, %edi
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %r10d, %r10d
xorl %esi, %esi
movsbl (%rdx,%r10), %eax
leal -0x30(%rax), %r10d
leal -0x30(%rax), %r11d
leal -0x57(%rax), %ebp
cmpb $0xa, %r10b
leal -0x61(%rax), %r10d
cmovael %r8d, %r11d
cmpb $0x6, %r10b
leal -0x41(%rax), %r10d
cmovael %r11d, %ebp
movl %eax, %r11d
addl $-0x37, %r11d
cmpb $0x6, %r10b
cmovael %ebp, %r11d
cmpl $-0x1, %r11d
je 0x2536
cmpq %r14, %rsi
je 0x2571
movb %al, (%rbx,%rsi)
incq %rsi
jmp 0x2553
testl %r9d, %r9d
je 0x2553
xorl %r9d, %r9d
cmpb $0x78, %al
sete %r9b
subq %r9, %rsi
xorl %r9d, %r9d
cmpb $0x58, %al
sete %r9b
subq %r9, %rsi
xorl %r9d, %r9d
cmpb $0x30, %al
movl %edi, %r10d
movq %rsi, %rax
sete %r9b
incl %edi
cmpq %rcx, %r10
jb 0x24ec
jmp 0x258c
xorl %esi, %esi
xorl %eax, %eax
jmp 0x258c
leaq 0x2aed(%rip), %rdi      # 0x5065
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2040
movq $-0x1, %rax
movq %r14, %rsi
movb $0x0, (%rbx,%rsi)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/cgvwzq[P]aes_bf/src/aes-brute-force.cpp
// Function: print_128(char const*, unsigned char const*, char const*)
static
void print_128(const char m[], const uint8_t a[16], const char m2[])
{
	print_bytes_sep (m, a, 4, "_", "");
	print_bytes_sep ("", a+4 , 4, "_", "");
	print_bytes_sep ("", a+8 , 4, "_", "");
	print_bytes_sep ("", a+12, 4, m2, "");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x1c8f(%rip), %r15      # 0x544a
movq %rdx, %rbx
movq %rsi, %r14
movq %r15, %rdx
callq 0x3808
leaq 0x1a87(%rip), %r12      # 0x5257
leaq 0x4(%r14), %rsi
movq %r15, %rdx
movq %r12, %rdi
callq 0x3808
leaq 0x8(%r14), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x3808
addq $0xc, %r14
movq %r12, %rdi
movq %rbx, %rdx
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3808
// File: /workspace/github_cpp_makefile_star2_O3/cgvwzq[P]aes_bf/src/aes-brute-force.cpp
// Function: print_bytes_sep(char const*, unsigned char const*, unsigned int, char const*, char const*)
static
void print_bytes_sep(const char *msg,const unsigned char *buf, unsigned int size, const char m2[], const char sep[])
{
    unsigned int i;
    printf ("%s", msg);
    for (i=0; i < size-1; i++)
	{
		printf ("%02X%s", buf[i], sep);
	}
    if (i < size)
	{
		printf ("%02X", buf[i]);
	}
    printf ("%s", m2);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rsi
leaq 0x1c32(%rip), %rdi      # 0x5450
xorl %eax, %eax
movq %rdx, %rbx
callq 0x2040
leaq 0x1c1d(%rip), %r15      # 0x544c
leaq 0x1a21(%rip), %r12      # 0x5257
xorl %r13d, %r13d
movzbl (%r14,%r13), %esi
movq %r15, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x2040
incq %r13
cmpq $0x3, %r13
jne 0x3839
movzbl 0x3(%r14), %esi
leaq 0x1800(%rip), %rdi      # 0x5060
xorl %eax, %eax
callq 0x2040
leaq 0x1be2(%rip), %rdi      # 0x5450
movq %rbx, %rsi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2040
nop
// File: /workspace/github_cpp_makefile_star2_O3/cgvwzq[P]aes_bf/src/aes-brute-force.cpp
// Function: aes_brute_force::mask_to_offsets(unsigned char*, unsigned char*, voffset*)
static
	void mask_to_offsets(uint8_t cipher_mask[16], uint8_t next_block[16], voffset_t *v)
	{
		v->n_offsets = 0;
		for (unsigned int i=0; i < 16; i++)
		{
			v->next[i] = next_block[i];
			if (cipher_mask[i]) 
			{
				v->offsets[v->n_offsets++] = i;
				uint8_t count = 0;
				for (unsigned int j=0x33; j < 0x7f; j++)
				{
					// generate range of valid chars for each byte
					if (j != 0x3b && j != 0x3d && j != 0x22)
					{
						v->valid_chars[i][count++] = j ^ v->next[i];
					}
				}
				v->n_valid_chars = count;
			}
		}
	}

// Assembly:
pushq %r14
pushq %rbx
leaq 0x11(%rdx), %rax
movabsq $0x2800000400000000, %r8 # imm = 0x2800000400000000
xorl %ecx, %ecx
movb $0x0, 0x10(%rdx)
movb (%rsi,%rcx), %r9b
movb %r9b, 0x1012(%rdx,%rcx)
cmpb $0x0, (%rdi,%rcx)
je 0x3903
movzbl 0x10(%rdx), %r9d
movq %rcx, %r11
shlq $0x8, %r11
addq %rax, %r11
leal 0x1(%r9), %r10d
movb %r10b, 0x10(%rdx)
movl $0x33, %r10d
movb %cl, (%rdx,%r9)
xorl %r9d, %r9d
cmpl $0x3d, %r10d
ja 0x38de
movl %r10d, %ebx
btq %rbx, %r8
jb 0x38f3
movb 0x1012(%rdx,%rcx), %bl
movzbl %r9b, %r14d
incb %r9b
xorb %r10b, %bl
movb %bl, (%r14,%r11)
incl %r10d
cmpl $0x7f, %r10d
jne 0x38cf
movb %r9b, 0x1011(%rdx)
incq %rcx
cmpq $0x10, %rcx
jne 0x3899
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/cgvwzq[P]aes_bf/src/aes-brute-force.cpp
// Function: aes_brute_force::aes_brute_force(unsigned char*, unsigned char*, unsigned char*, unsigned char*, unsigned char*, unsigned char*, unsigned char*)
explicit aes_brute_force(uint8_t cipher_mask[16], uint8_t cipher[16], uint8_t key[16], uint8_t iv[16], uint8_t plain_mask[16], uint8_t plain[16], uint8_t next_block[16])
	{
		aes128_block_t b;

		memcpy (&b, cipher, 16);
		memcpy (this->cipher_mask, cipher_mask, 16);
		memcpy (this->key, key, 16);
		memcpy (this->iv, iv, 16);
		memcpy (this->plain_mask, plain_mask, 16);
		memcpy (this->plain, plain, 16);
		memcpy (this->next_block, next_block, 16);

		blocks.push_back (b);
		mask_to_offsets (cipher_mask, next_block, &this->v);
		nbits = this->v.n_offsets * 8;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
vxorps %xmm0, %xmm0, %xmm0
movq $0x0, 0x1050(%rdi)
movq 0x40(%rsp), %rax
movq 0x48(%rsp), %r15
leaq 0x1040(%rdi), %r12
movq %rsi, %r14
movq %rdi, %rbx
vmovups %xmm0, 0x1040(%rdi)
vmovups (%rdx), %xmm0
movq %rsp, %rdx
vmovaps %xmm0, (%rdx)
vmovups (%rsi), %xmm0
vmovups %xmm0, 0x10a8(%rdi)
vmovups (%rcx), %xmm0
vmovups %xmm0, 0x1058(%rdi)
vmovups (%r8), %xmm0
vmovups %xmm0, 0x1068(%rdi)
vmovups (%r9), %xmm0
vmovups %xmm0, 0x1088(%rdi)
vmovups (%rax), %xmm0
vmovups %xmm0, 0x1078(%rdi)
vmovups (%r15), %xmm0
vmovups %xmm0, 0x10b8(%rdi)
movq %r12, %rdi
xorl %esi, %esi
callq 0x3b90
leaq 0x9(%rbx), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x3882
movzbl 0x19(%rbx), %eax
shll $0x3, %eax
movl %eax, 0x102c(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq (%r12), %rdi
movq %rax, %rbx
testq %rdi, %rdi
je 0x39e2
callq 0x2130
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O3/cgvwzq[P]aes_bf/src/aes-brute-force.cpp
// Function: aes_brute_force::compute()
void compute()
	{
		loop_cnt = 0;
		for(auto b=blocks.begin(); b != blocks.end(); ++b) 
		{
			uint64_t cnt;
			search (v, b->bytes, key, iv, plain_mask, plain, cnt, found);
			loop_cnt += cnt;
			if (found)
			{
				memcpy (valid_cipher, b->bytes, 16);
				return;
			}
			if (is_done()) // used for multithread operations
			{ 
				return;
			}
		}
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2078, %rsp           # imm = 0x2078
movq $0x0, (%rdi)
movq 0x1040(%rdi), %r14
cmpq 0x1048(%rdi), %r14
je 0x3af8
leaq 0x9(%rdi), %rax
leaq 0x1058(%rdi), %rdx
leaq 0x1068(%rdi), %rcx
leaq 0x1088(%rdi), %rbp
leaq 0x1078(%rdi), %r15
leaq 0x8(%rdi), %r13
leaq 0x1050(%rsp), %r12
movq %rdi, %rbx
movq %rax, 0x1040(%rsp)
movq %rdx, 0x1038(%rsp)
movq %rcx, 0x1030(%rsp)
movq 0x1040(%rsp), %rsi
movl $0x1022, %edx           # imm = 0x1022
movq %r12, %rdi
callq 0x2100
movl $0x204, %ecx            # imm = 0x204
movq %rsp, %rdi
movq %r12, %rsi
leaq 0x1048(%rsp), %r9
movq %r15, %r8
rep  movsq (%rsi), %es:(%rdi)
movq %r14, %rdi
movq %rbp, %rcx
movzwl 0x2070(%rsp), %eax
movw %ax, 0x1020(%rsp)
movq %r13, 0x1028(%rsp)
movq 0x1038(%rsp), %rsi
movq 0x1030(%rsp), %rdx
callq 0x3cc8
movq 0x1048(%rsp), %rax
addq %rax, (%rbx)
cmpb $0x1, 0x8(%rbx)
je 0x3aeb
cmpb $0x0, 0x365c(%rip)      # 0x7132
jne 0x3af8
addq $0x10, %r14
cmpq 0x1048(%rbx), %r14
jne 0x3a5d
jmp 0x3af8
vmovups (%r14), %xmm0
vmovups %xmm0, 0x1030(%rbx)
addq $0x2078, %rsp           # imm = 0x2078
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/GUI-Graphics[P]cpuraytracing/main.cpp
// Function: main
int main() {
	Film film(256, 128);

	Camera camera(film, 20, 0.1f, 12);
	camera.position = Vector3(12, 2, 3);
	camera.lookAt(Vector3(0, 1, 0));

	Scene scene;
	initScene(scene);

	Renderer renderer(100);
	renderer.render(scene, camera);

	return 0;
}

// Assembly:
pushq %rbx
subq $0x90, %rsp
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movl $0x100, %esi            # imm = 0x100
movl $0x80, %edx
callq 0x327c
leaq 0x48(%rsp), %rdi
movss 0x25c6(%rip), %xmm0     # 0x5014
movss 0x25c2(%rip), %xmm1     # 0x5018
movss 0x25be(%rip), %xmm2     # 0x501c
movq %rbx, %rsi
callq 0x3630
movsd 0x2652(%rip), %xmm0     # 0x50c0
leaq 0x48(%rsp), %rdi
movsd %xmm0, 0x14(%rdi)
movl $0x40400000, 0x1c(%rdi) # imm = 0x40400000
movsd 0x2649(%rip), %xmm0     # 0x50d0
leaq 0x20(%rsp), %rsi
movsd %xmm0, (%rsi)
movl $0x0, 0x8(%rsi)
callq 0x37cc
xorl %eax, %eax
leaq 0x20(%rsp), %rdi
movq %rax, 0x8(%rdi)
leaq 0x51fa(%rip), %rcx      # 0x7ca8
addq $0x10, %rcx
movq %rcx, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq %rax, 0x20(%rdi)
callq 0x23fc
leaq 0xc(%rsp), %rdi
movl $0x64, (%rdi)
leaq 0x20(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x421a
leaq 0x20(%rsp), %rdi
callq 0x2b26
leaq 0x10(%rsp), %rdi
callq 0x3314
xorl %eax, %eax
addq $0x90, %rsp
popq %rbx
retq
jmp 0x2b00
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2b26
jmp 0x2b14
jmp 0x2b11
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3314
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O3/GUI-Graphics[P]cpuraytracing/math.cpp
// Function: gui::Math::randomDisk()
Vector3 Math::randomDisk() {
		Vector3 v;
		do {
			v = Vector3(Math::random(), Math::random(), 0) * 2 - Vector3(1, 1, 0);
		} while(v.length() > 1);
		return v;
	}

// Assembly:
pushq %rbx
subq $0x30, %rsp
leaq 0x651c(%rip), %rbx      # 0x94d8
movq %rbx, %rdi
callq 0x2b9c
movaps %xmm0, (%rsp)
movss 0x7894(%rip), %xmm0     # 0xa864
movaps %xmm0, 0x10(%rsp)
movss 0x7883(%rip), %xmm0     # 0xa860
movaps %xmm0, 0x20(%rsp)
movq %rbx, %rdi
callq 0x2b9c
movaps (%rsp), %xmm2
movss 0x786e(%rip), %xmm1     # 0xa864
movaps 0x10(%rsp), %xmm4
unpcklps %xmm1, %xmm4            # xmm4 = xmm4[0],xmm1[0],xmm4[1],xmm1[1]
movss 0x785a(%rip), %xmm1     # 0xa860
movaps 0x20(%rsp), %xmm3
unpcklps %xmm1, %xmm3            # xmm3 = xmm3[0],xmm1[0],xmm3[1],xmm1[1]
subps %xmm3, %xmm4
unpcklps %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1]
mulps %xmm4, %xmm2
addps %xmm3, %xmm2
addps %xmm2, %xmm2
addps 0x211c(%rip), %xmm2     # 0x5140
movaps %xmm2, %xmm0
mulps %xmm2, %xmm0
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movaps %xmm2, %xmm1
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
xorps %xmm0, %xmm0
sqrtss %xmm1, %xmm0
ucomiss 0x1fc9(%rip), %xmm0     # 0x5010
ja 0x2fbc
xorps %xmm1, %xmm1
movaps %xmm2, %xmm0
addq $0x30, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/GUI-Graphics[P]cpuraytracing/math.cpp
// Function: gui::Math::randomSphere()
Vector3 Math::randomSphere() {
		Vector3 v;
		do {
			v = Vector3(Math::random(), Math::random(), Math::random()) * 2 - Vector3(1);
		} while(v.length() > 1);
		return v;
	}

// Assembly:
pushq %rbx
subq $0x40, %rsp
leaq 0x6472(%rip), %rbx      # 0x94d8
movq %rbx, %rdi
callq 0x2b9c
movaps %xmm0, 0x20(%rsp)
movss 0x77e9(%rip), %xmm0     # 0xa864
movaps %xmm0, 0x10(%rsp)
movss 0x77d8(%rip), %xmm0     # 0xa860
movaps %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x2b9c
movaps %xmm0, 0x30(%rsp)
movss 0x77c3(%rip), %xmm0     # 0xa864
movaps 0x10(%rsp), %xmm1
unpcklps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movaps %xmm1, 0x10(%rsp)
movss 0x77aa(%rip), %xmm0     # 0xa860
movaps (%rsp), %xmm1
unpcklps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movaps %xmm1, (%rsp)
movq %rbx, %rdi
callq 0x2b9c
movaps 0x20(%rsp), %xmm3
movss 0x778e(%rip), %xmm1     # 0xa864
movss 0x7782(%rip), %xmm2     # 0xa860
subss %xmm2, %xmm1
mulss %xmm0, %xmm1
addss %xmm2, %xmm1
addss %xmm1, %xmm1
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm2
subps %xmm0, %xmm2
unpcklps 0x30(%rsp), %xmm3       # xmm3 = xmm3[0],mem[0],xmm3[1],mem[1]
mulps %xmm2, %xmm3
addps %xmm0, %xmm3
addps %xmm3, %xmm3
addps 0x2031(%rip), %xmm3     # 0x5140
addss 0x2039(%rip), %xmm1     # 0x5150
movaps %xmm3, %xmm0
mulps %xmm3, %xmm0
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movaps %xmm3, %xmm2
mulss %xmm3, %xmm2
addss %xmm0, %xmm2
movaps %xmm1, %xmm0
mulss %xmm1, %xmm0
addss %xmm2, %xmm0
sqrtss %xmm0, %xmm0
ucomiss 0x1ece(%rip), %xmm0     # 0x5010
ja 0x3066
movaps %xmm3, %xmm0
addq $0x40, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/GUI-Graphics[P]cpuraytracing/film.cpp
// Function: gui::Film::Film(int, int)
Film::Film(int width, int height) : width(width), height(height) {
		pixels = new Vector3*[height];
		for(int i = 0; i < height; ++i) {
			pixels[i] = new Vector3[width];
			for (int j = 0; j < width; ++j) {
				pixels[i][j] = Vector3(0);
			}
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %ebx
movq %rdi, %r14
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
movl %edx, %r13d
leaq (,%r13,8), %rdi
testl %edx, %edx
movq $-0x1, %r12
cmovsq %r12, %rdi
callq 0x2030
movq %rax, 0x8(%r14)
testl %ebp, %ebp
jle 0x3304
movslq %ebx, %rax
movl $0xc, %ecx
mulq %rcx
movq %rax, %r15
cmovoq %r12, %r15
movl %ebx, %eax
shlq $0x2, %rax
leaq (%rax,%rax,2), %r12
xorl %ebp, %ebp
movq %r15, %rdi
callq 0x2030
movq 0x8(%r14), %rcx
movq %rax, (%rcx,%rbp,8)
testl %ebx, %ebx
jle 0x32fc
movq 0x8(%r14), %rax
movq (%rax,%rbp,8), %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x20c0
incq %rbp
cmpq %rbp, %r13
jne 0x32d6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/GUI-Graphics[P]cpuraytracing/film.cpp
// Function: gui::Film::gammaCorrection()
void Film::gammaCorrection() {
		for(int i = 0; i < height; ++i) {
			for(int j = 0; j < width; ++j) {
				Vector3& c = pixels[i][j];
				c.x = sqrtf(c.x);
				c.y = sqrtf(c.y);
				c.z = sqrtf(c.z);
			}
		}
	}

// Assembly:
movl 0x4(%rdi), %ecx
testl %ecx, %ecx
jle 0x3423
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %eax
xorl %r14d, %r14d
xorps %xmm1, %xmm1
testl %eax, %eax
jle 0x340b
movl $0x8, %r15d
xorl %r12d, %r12d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %r13
movss -0x8(%r13,%r15), %xmm0
ucomiss %xmm1, %xmm0
jb 0x33a8
sqrtss %xmm0, %xmm0
jmp 0x33b0
callq 0x2250
xorps %xmm1, %xmm1
movss %xmm0, -0x8(%r13,%r15)
movss -0x4(%r13,%r15), %xmm0
ucomiss %xmm1, %xmm0
jb 0x33c9
sqrtss %xmm0, %xmm0
jmp 0x33d1
callq 0x2250
xorps %xmm1, %xmm1
movss %xmm0, -0x4(%r13,%r15)
movss (%r13,%r15), %xmm0
ucomiss %xmm1, %xmm0
jb 0x33ea
sqrtss %xmm0, %xmm0
jmp 0x33f2
callq 0x2250
xorps %xmm1, %xmm1
movss %xmm0, (%r13,%r15)
incq %r12
movslq (%rbx), %rax
addq $0xc, %r15
cmpq %rax, %r12
jl 0x338e
movl 0x4(%rbx), %ecx
incq %r14
movslq %ecx, %rdx
cmpq %rdx, %r14
jl 0x337d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/GUI-Graphics[P]cpuraytracing/film.cpp
// Function: gui::Film::writePPM() const
void Film::writePPM() const {
		std::ofstream file;
		file.open("image.ppm");
		file << "P3\n" << width << ' ' << height << '\n' << "255\n";
		for(int i = 0; i < height; ++i) {
			for(int j = 0; j < width; ++j) {
				file << (int) (pixels[i][j].x * 255) << ' '
					 << (int) (pixels[i][j].y * 255) << ' '
					 << (int) (pixels[i][j].z * 255) << ' ';
			}
			file << '\n';
		}
		file.close();
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2200
leaq 0x1d44(%rip), %rsi      # 0x5190
movq %r14, %rdi
movl $0x10, %edx
callq 0x2050
leaq 0x1d3a(%rip), %rsi      # 0x519a
leaq 0x8(%rsp), %rdi
movl $0x3, %edx
callq 0x2160
movl (%rbx), %esi
leaq 0x8(%rsp), %rdi
callq 0x2210
leaq 0x7(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2160
movl 0x4(%rbx), %esi
movq %rax, %rdi
callq 0x2210
leaq 0x7(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2160
leaq 0x1ce7(%rip), %rsi      # 0x519e
movl $0x4, %edx
movq %rax, %rdi
callq 0x2160
cmpl $0x0, 0x4(%rbx)
jle 0x35c8
xorl %r12d, %r12d
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %r15
cmpl $0x0, (%rbx)
jle 0x35a3
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x8(%rbx), %rax
movq (%rax,%r12,8), %rax
movss (%rax,%r13), %xmm0
mulss 0x1c8d(%rip), %xmm0     # 0x518c
cvttss2si %xmm0, %esi
movq %r14, %rdi
callq 0x2210
movb $0x20, 0x7(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2160
movq 0x8(%rbx), %rcx
movq (%rcx,%r12,8), %rcx
movss 0x4(%rcx,%r13), %xmm0
mulss 0x1c55(%rip), %xmm0     # 0x518c
cvttss2si %xmm0, %esi
movq %rax, %rdi
callq 0x2210
movb $0x20, 0x7(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2160
movq 0x8(%rbx), %rcx
movq (%rcx,%r12,8), %rcx
movss 0x8(%rcx,%r13), %xmm0
mulss 0x1c1d(%rip), %xmm0     # 0x518c
cvttss2si %xmm0, %esi
movq %rax, %rdi
callq 0x2210
movb $0x20, 0x7(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2160
incq %rbp
movslq (%rbx), %rax
addq $0xc, %r13
cmpq %rax, %rbp
jl 0x34e9
movb $0xa, 0x7(%rsp)
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2160
incq %r12
movslq 0x4(%rbx), %rax
cmpq %rax, %r12
jl 0x34db
leaq 0x8(%rsp), %rdi
callq 0x21a0
movq 0x4a07(%rip), %rax      # 0x7fe0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x10(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x8(%rsp,%rcx)
callq 0x2100
leaq 0x100(%rsp), %rdi
callq 0x2070
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x361a
jmp 0x361a
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x21c0
movq %rbx, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O3/GUI-Graphics[P]cpuraytracing/camera.cpp
// Function: gui::Camera::getRay(float, float) const
Ray Camera::getRay(float px, float py) const {
		Vector3 offset = Math::randomDisk() * apeture;
		offset = x * offset.x + y * offset.y;
		float u = (px - film.width * 0.5f) / resolution;
		float v = (film.height * 0.5f - py) / resolution;
		return Ray(position + offset, x * u + y * v - z - offset / focal);
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movss %xmm1, 0xc(%rsp)
movaps %xmm0, 0x10(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2fb0
movss 0xc(%r14), %xmm1
movaps %xmm1, %xmm3
mulss %xmm0, %xmm3
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
mulss %xmm1, %xmm0
movss 0x28(%r14), %xmm6
movaps %xmm3, %xmm2
mulss %xmm6, %xmm2
movss 0x34(%r14), %xmm1
movaps %xmm0, %xmm5
mulss %xmm1, %xmm5
movq (%r14), %rax
cvtsi2ssl (%rax), %xmm4
addss %xmm2, %xmm5
movss 0x1ac1(%rip), %xmm7     # 0x51c4
mulss %xmm7, %xmm4
movaps 0x10(%rsp), %xmm8
subss %xmm4, %xmm8
movss 0x8(%r14), %xmm4
xorps %xmm2, %xmm2
cvtsi2ssl 0x4(%rax), %xmm2
divss %xmm4, %xmm8
mulss %xmm7, %xmm2
subss 0xc(%rsp), %xmm2
divss %xmm4, %xmm2
movss 0x1c(%r14), %xmm4
addss %xmm5, %xmm4
mulss %xmm8, %xmm6
mulss %xmm2, %xmm1
addss %xmm6, %xmm1
subss 0x40(%r14), %xmm1
movss 0x18b8(%rip), %xmm6     # 0x5010
divss 0x10(%r14), %xmm6
mulss %xmm6, %xmm5
subss %xmm5, %xmm1
movsd 0x20(%r14), %xmm5
shufps $0x0, %xmm3, %xmm3      # xmm3 = xmm3[0,0,0,0]
mulps %xmm5, %xmm3
movsd 0x2c(%r14), %xmm7
shufps $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
mulps %xmm7, %xmm0
addps %xmm3, %xmm0
movsd 0x14(%r14), %xmm3
addps %xmm0, %xmm3
unpcklps %xmm8, %xmm8            # xmm8 = xmm8[0,0,1,1]
mulps %xmm5, %xmm8
unpcklps %xmm2, %xmm2            # xmm2 = xmm2[0,0,1,1]
mulps %xmm7, %xmm2
addps %xmm8, %xmm2
movsd 0x38(%r14), %xmm5
subps %xmm5, %xmm2
unpcklps %xmm6, %xmm6            # xmm6 = xmm6[0,0,1,1]
mulps %xmm0, %xmm6
subps %xmm6, %xmm2
movlps %xmm3, (%rbx)
movss %xmm4, 0x8(%rbx)
movlps %xmm2, 0xc(%rbx)
movss %xmm1, 0x14(%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/GUI-Graphics[P]cpuraytracing/scene.cpp
// Function: gui::Scene::intersect(gui::Ray const&, float, float, gui::Intersection&) const
bool Scene::intersect(
		const Ray& ray,
		float tMin,
		float tMax,
		Intersection& intersection) const {
			
		bool intersected = false;
		for(auto e : shapes) {
			if(e->intersect(ray, tMin, tMax, intersection)) {
				if(intersection.t < tMax) {
					tMax = intersection.t;
					intersected = true;
				}
			}
		}
		return intersected;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movss %xmm0, 0xc(%rsp)
movq 0x10(%rdi), %r15
movq 0x18(%rdi), %r12
cmpq %r12, %r15
je 0x3b22
movq %rdx, %rbx
movq %rsi, %r14
xorl %ebp, %ebp
movq (%r15), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movss 0xc(%rsp), %xmm0
movss %xmm1, 0x8(%rsp)
movq %rbx, %rdx
callq *0x10(%rax)
testb %al, %al
je 0x3b11
movss (%rbx), %xmm0
movss 0x8(%rsp), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x3b17
movb $0x1, %bpl
movaps %xmm0, %xmm1
jmp 0x3b17
movss 0x8(%rsp), %xmm1
addq $0x8, %r15
cmpq %r12, %r15
jne 0x3adb
jmp 0x3b24
xorl %ebp, %ebp
andb $0x1, %bpl
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/GUI-Graphics[P]cpuraytracing/diffuse.cpp
// Function: gui::Diffuse::scatter(gui::Ray const&, gui::Intersection const&, gui::Vector3&, gui::Ray&) const
bool Diffuse::scatter(
		const Ray& in,
		const Intersection& intersection,
		Vector3& attenuation,
		Ray& scattered) const {

		attenuation = albedo;
		scattered.origin = intersection.position + intersection.normal * 0.001f;
		scattered.direction = intersection.normal + Math::randomSphere();
		return true;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rdx, %r14
movl 0x10(%rdi), %eax
movl %eax, 0x8(%rcx)
movq 0x8(%rdi), %rax
movq %rax, (%rcx)
movss 0x18(%rdx), %xmm0
mulss 0x1688(%rip), %xmm0     # 0x51fc
movsd 0x4(%rdx), %xmm1
movsd 0x10(%rdx), %xmm2
mulps 0x167b(%rip), %xmm2     # 0x5200
addps %xmm1, %xmm2
addss 0xc(%rdx), %xmm0
movlps %xmm2, (%r8)
movss %xmm0, 0x8(%r8)
callq 0x305a
movsd 0x10(%r14), %xmm2
addss 0x18(%r14), %xmm1
addps %xmm0, %xmm2
movlps %xmm2, 0xc(%rbx)
movss %xmm1, 0x14(%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq