LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/qmmlib[P]QmmLibrary/linear.cpp
// Function: l2r_l2_svc_fun::l2r_l2_svc_fun(problem const*, double*)
l2r_l2_svc_fun::l2r_l2_svc_fun(const problem *prob, double *C)
{
	int l=prob->l;

	this->prob = prob;

	z = new double[l];
	D = new double[l];
	I = new int[l];
	this->C = C;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x17d21(%rip), %rax     # 0x1db10
movq %rax, (%rdi)
movslq (%rsi), %rax
movq %rsi, 0x30(%rdi)
leaq (,%rax,8), %r15
testq %rax, %rax
movq $-0x1, %rcx
cmovsq %rcx, %r15
leaq (,%rax,4), %r12
cmovsq %rcx, %r12
movq %r15, %rdi
callq 0x3030
movq %rax, 0x10(%r14)
movq %r15, %rdi
callq 0x3030
movq %rax, 0x18(%r14)
movq %r12, %rdi
callq 0x3030
movq %rax, 0x20(%r14)
movq %rbx, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/qmmlib[P]QmmLibrary/linear.cpp
// Function: l2r_l2_svc_fun::fun(double*)
double l2r_l2_svc_fun::fun(double *w)
{
	int i;
	double f=0;
	double *y=prob->y;
	int l=prob->l;
	int w_size=get_nr_variable();

	Xv(w, z);

	for(i=0;i<w_size;i++)
		f += w[i]*w[i];
	f /= 2.0;
	for(i=0;i<l;i++)
	{
		z[i] = y[i]*z[i];
		double d = 1-z[i];
		if (d > 0)
			f += C[i]*d*d;
	}

	return(f);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x30(%rdi), %rcx
movq 0x8(%rcx), %r15
movl (%rcx), %r12d
callq *0x18(%rax)
movl %eax, %ebp
movq 0x10(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5f24
testl %ebp, %ebp
jle 0x5ec4
movl %ebp, %eax
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
movsd (%r14,%rcx,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x5ea4
mulsd 0x1323e(%rip), %xmm0    # 0x19100
jmp 0x5ec8
xorpd %xmm0, %xmm0
testl %r12d, %r12d
jle 0x5f1a
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
xorl %edx, %edx
movsd 0x133b9(%rip), %xmm1    # 0x19298
xorpd %xmm2, %xmm2
movsd (%r15,%rdx,8), %xmm4
mulsd (%rcx,%rdx,8), %xmm4
movsd %xmm4, (%rcx,%rdx,8)
movapd %xmm1, %xmm3
subsd %xmm4, %xmm3
ucomisd %xmm2, %xmm3
jbe 0x5f12
movsd (%rax,%rdx,8), %xmm4
mulsd %xmm3, %xmm4
mulsd %xmm3, %xmm4
addsd %xmm4, %xmm0
incq %rdx
cmpq %rdx, %r12
jne 0x5ee3
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/qmmlib[P]QmmLibrary/linear.cpp
// Function: l2r_l2_svc_fun::grad(double*, double*)
void l2r_l2_svc_fun::grad(double *w, double *g)
{
	int i;
	double *y=prob->y;
	int l=prob->l;
	int w_size=get_nr_variable();

	sizeI = 0;
	for (i=0;i<l;i++)
		if (z[i] < 1)
		{
			z[sizeI] = C[i]*y[i]*(z[i]-1);
			I[sizeI] = i;
			sizeI++;
		}
	subXTv(z, g);

	for(i=0;i<w_size;i++)
		g[i] = w[i] + 2*g[i];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rax
movq 0x30(%rdi), %rcx
movq 0x8(%rcx), %r12
movslq (%rcx), %r13
callq *0x18(%rax)
movl %eax, %ebp
movl $0x0, 0x28(%r15)
movq 0x10(%r15), %rsi
testq %r13, %r13
jle 0x6011
movq 0x8(%r15), %rax
movq 0x20(%r15), %rcx
xorl %edx, %edx
movsd 0x132cc(%rip), %xmm0    # 0x19298
movsd 0x132cc(%rip), %xmm1    # 0x192a0
xorl %edi, %edi
movsd (%rsi,%rdi,8), %xmm2
ucomisd %xmm2, %xmm0
jbe 0x6009
movsd (%rax,%rdi,8), %xmm3
mulsd (%r12,%rdi,8), %xmm3
addsd %xmm1, %xmm2
mulsd %xmm3, %xmm2
movslq %edx, %rdx
movsd %xmm2, (%rsi,%rdx,8)
movl %edi, (%rcx,%rdx,4)
movl 0x28(%r15), %edx
incl %edx
movl %edx, 0x28(%r15)
incq %rdi
cmpq %rdi, %r13
jne 0x5fd6
movq %r15, %rdi
movq %rbx, %rdx
callq 0x6050
testl %ebp, %ebp
jle 0x6040
movl %ebp, %eax
xorl %ecx, %ecx
movsd (%rbx,%rcx,8), %xmm0
addsd %xmm0, %xmm0
addsd (%r14,%rcx,8), %xmm0
movsd %xmm0, (%rbx,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x6024
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/qmmlib[P]QmmLibrary/linear.cpp
// Function: l2r_l2_svc_fun::subXTv(double*, double*)
void l2r_l2_svc_fun::subXTv(double *v, double *XTv)
{
	int i;
	int w_size=get_nr_variable();
	feature_node **x=prob->x;

	for(i=0;i<w_size;i++)
		XTv[i]=0;
	for(i=0;i<sizeI;i++)
	{
		feature_node *s=x[I[i]];
		while(s->index!=-1)
		{
			XTv[s->index-1]+=v[i]*s->value;
			s++;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x30(%r15), %rcx
movq 0x10(%rcx), %r12
testl %eax, %eax
jle 0x6083
movl %eax, %edx
shlq $0x3, %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3110
movslq 0x28(%r15), %rax
testq %rax, %rax
jle 0x60d2
movq 0x20(%r15), %rcx
xorl %edx, %edx
movslq (%rcx,%rdx,4), %rsi
movq (%r12,%rsi,8), %rsi
movl (%rsi), %edi
cmpl $-0x1, %edi
je 0x60ca
addq $0x10, %rsi
movsd (%r14,%rdx,8), %xmm0
movslq %edi, %rdi
mulsd -0x8(%rsi), %xmm0
addsd -0x8(%rbx,%rdi,8), %xmm0
movsd %xmm0, -0x8(%rbx,%rdi,8)
movl (%rsi), %edi
addq $0x10, %rsi
cmpl $-0x1, %edi
jne 0x60a5
incq %rdx
cmpq %rax, %rdx
jne 0x6092
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/qmmlib[P]QmmLibrary/linear.cpp
// Function: l2r_l2_svc_fun::Hv(double*, double*)
void l2r_l2_svc_fun::Hv(double *s, double *Hs)
{
	int i;
	int w_size=get_nr_variable();
	double *wa = new double[sizeI];

	subXv(s, wa);
	for(i=0;i<sizeI;i++)
		wa[i] = C[I[i]]*wa[i];

	subXTv(wa, Hs);
	for(i=0;i<w_size;i++)
		Hs[i] = s[i] + 2*Hs[i];
	delete[] wa;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ebp
movslq 0x28(%r12), %r13
leaq (,%r13,8), %rax
testq %r13, %r13
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x3030
movq %rax, %r15
movq %r12, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x61aa
testq %r13, %r13
jle 0x6161
movq 0x8(%r12), %rax
movq 0x20(%r12), %rcx
xorl %edx, %edx
movslq (%rcx,%rdx,4), %rsi
movsd (%rax,%rsi,8), %xmm0
mulsd (%r15,%rdx,8), %xmm0
movsd %xmm0, (%r15,%rdx,8)
incq %rdx
cmpq %rdx, %r13
jne 0x6144
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x6050
testl %ebp, %ebp
jle 0x6193
movl %ebp, %eax
xorl %ecx, %ecx
movsd (%rbx,%rcx,8), %xmm0
addsd %xmm0, %xmm0
addsd (%r14,%rcx,8), %xmm0
movsd %xmm0, (%rbx,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x6177
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x32d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/qmmlib[P]QmmLibrary/linear.cpp
// Function: l2r_l2_svc_fun::subXv(double*, double*)
void l2r_l2_svc_fun::subXv(double *v, double *Xv)
{
	int i;
	feature_node **x=prob->x;

	for(i=0;i<sizeI;i++)
	{
		feature_node *s=x[I[i]];
		Xv[i]=0;
		while(s->index!=-1)
		{
			Xv[i]+=v[s->index-1]*s->value;
			s++;
		}
	}
}

// Assembly:
movslq 0x28(%rdi), %rax
testq %rax, %rax
jle 0x6212
movq 0x30(%rdi), %rcx
movq 0x10(%rcx), %rcx
movq 0x20(%rdi), %rdi
xorl %r8d, %r8d
movslq (%rdi,%r8,4), %r9
movq (%rcx,%r9,8), %r9
movq $0x0, (%rdx,%r8,8)
movl (%r9), %r10d
cmpl $-0x1, %r10d
je 0x620a
addq $0x10, %r9
xorpd %xmm0, %xmm0
movslq %r10d, %r10
movsd -0x8(%rsi,%r10,8), %xmm1
mulsd -0x8(%r9), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%rdx,%r8,8)
movl (%r9), %r10d
addq $0x10, %r9
cmpl $-0x1, %r10d
jne 0x61e3
incq %r8
cmpq %rax, %r8
jne 0x61c2
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/qmmlib[P]QmmLibrary/linear.cpp
// Function: l2r_l2_svr_fun::fun(double*)
double l2r_l2_svr_fun::fun(double *w)
{
	int i;
	double f=0;
	double *y=prob->y;
	int l=prob->l;
	int w_size=get_nr_variable();
	double d;
	
	Xv(w, z);

	for(i=0;i<w_size;i++)
		f += w[i]*w[i];
	f /= 2;	
	for(i=0;i<l;i++)
	{
		d = z[i] - y[i];
		if(d < -p)
			f += C[i]*(d+p)*(d+p);
		else if(d > p)
			f += C[i]*(d-p)*(d-p);
	}

	return(f);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x30(%rdi), %rcx
movq 0x8(%rcx), %r15
movl (%rcx), %r12d
callq *0x18(%rax)
movl %eax, %ebp
movq 0x10(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5f24
testl %ebp, %ebp
jle 0x629e
movl %ebp, %eax
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
movsd (%r14,%rcx,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x627e
mulsd 0x12e64(%rip), %xmm0    # 0x19100
jmp 0x62a2
xorpd %xmm0, %xmm0
testl %r12d, %r12d
jle 0x62fc
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
movsd 0x38(%rbx), %xmm1
movapd 0x12e74(%rip), %xmm2    # 0x19130
xorpd %xmm1, %xmm2
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm3
subsd (%r15,%rdx,8), %xmm3
ucomisd %xmm3, %xmm2
jbe 0x62d9
addsd %xmm1, %xmm3
jmp 0x62e3
ucomisd %xmm1, %xmm3
jbe 0x62f4
subsd %xmm1, %xmm3
movsd (%rax,%rdx,8), %xmm4
mulsd %xmm3, %xmm4
mulsd %xmm3, %xmm4
addsd %xmm4, %xmm0
incq %rdx
cmpq %rdx, %r12
jne 0x62c2
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/qmmlib[P]QmmLibrary/linear.cpp
// Function: l2r_l2_svr_fun::grad(double*, double*)
void l2r_l2_svr_fun::grad(double *w, double *g)
{
	int i;
	double *y=prob->y;
	int l=prob->l;
	int w_size=get_nr_variable();
	double d;

	sizeI = 0;
	for(i=0;i<l;i++)
	{
		d = z[i] - y[i];
		
		// generate index set I
		if(d < -p)
		{
			z[sizeI] = C[i]*(d+p);
			I[sizeI] = i;
			sizeI++;
		}
		else if(d > p)
		{
			z[sizeI] = C[i]*(d-p);
			I[sizeI] = i;
			sizeI++;
		}
	
	}
	subXTv(z, g);

	for(i=0;i<w_size;i++)
		g[i] = w[i] + 2*g[i];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rax
movq 0x30(%rdi), %rcx
movq 0x8(%rcx), %r12
movslq (%rcx), %r13
callq *0x18(%rax)
movl %eax, %ebp
movl $0x0, 0x28(%r15)
movq 0x10(%r15), %rsi
testq %r13, %r13
jle 0x63a3
movq 0x8(%r15), %rax
movq 0x20(%r15), %rcx
xorl %edx, %edx
movapd 0x12de0(%rip), %xmm0    # 0x19130
xorl %edi, %edi
movsd (%rsi,%rdi,8), %xmm1
subsd (%r12,%rdi,8), %xmm1
movsd 0x38(%r15), %xmm2
movapd %xmm2, %xmm3
xorpd %xmm0, %xmm3
ucomisd %xmm1, %xmm3
jbe 0x6377
addsd %xmm2, %xmm1
jmp 0x6381
ucomisd %xmm2, %xmm1
jbe 0x639b
subsd %xmm2, %xmm1
mulsd (%rax,%rdi,8), %xmm1
movslq %edx, %rdx
movsd %xmm1, (%rsi,%rdx,8)
movl %edi, (%rcx,%rdx,4)
movl 0x28(%r15), %edx
incl %edx
movl %edx, 0x28(%r15)
incq %rdi
cmpq %rdi, %r13
jne 0x6352
movq %r15, %rdi
movq %rbx, %rdx
callq 0x6050
testl %ebp, %ebp
jle 0x63d2
movl %ebp, %eax
xorl %ecx, %ecx
movsd (%rbx,%rcx,8), %xmm0
addsd %xmm0, %xmm0
addsd (%r14,%rcx,8), %xmm0
movsd %xmm0, (%rbx,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x63b6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/qmmlib[P]QmmLibrary/linear.cpp
// Function: free_and_destroy_model
void free_and_destroy_model(struct model **model_ptr_ptr)
{
	struct model *model_ptr = *model_ptr_ptr;
	if(model_ptr != NULL)
	{
		free_model_content(model_ptr);
		free(model_ptr);
	}
}

// Assembly:
pushq %rbx
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x14529
movq %rbx, %rdi
callq 0x1502a
movq %rbx, %rdi
popq %rbx
jmp 0x3290
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/qmmlib[P]QmmLibrary/linear.cpp
// Function: predict_values
double predict_values(const struct model *model_, const struct feature_node *x, double *dec_values)
{
	int idx;
	int n;
	if(model_->bias>=0)
		n=model_->nr_feature+1;
	else
		n=model_->nr_feature;
	double *w=model_->w;
	int nr_class=model_->nr_class;
	int i;
	int nr_w;
	if(nr_class==2 && model_->param.solver_type != MCSVM_CS)
		nr_w = 1;
	else
		nr_w = nr_class;

	const feature_node *lx=x;
	for(i=0;i<nr_w;i++)
		dec_values[i] = 0;
	for(; (idx=lx->index)!=-1; lx++)
	{
		// the dimension of testing data may exceed that of training
		if(idx<=n)
			for(i=0;i<nr_w;i++)
				dec_values[i] += w[(idx-1)*nr_w+i]*lx->value;
	}

	if(nr_class==2)
	{
		if(model_->param.solver_type == L2R_L2LOSS_SVR ||
		   model_->param.solver_type == L2R_L1LOSS_SVR_DUAL ||
		   model_->param.solver_type == L2R_L2LOSS_SVR_DUAL)
			return dec_values[0];
		else
			return (dec_values[0]>0)?model_->label[0]:model_->label[1];
	}
	else
	{
		int dec_max_idx = 0;
		for(i=1;i<nr_class;i++)
		{
			if(dec_values[i] > dec_values[dec_max_idx])
				dec_max_idx = i;
		}
		return model_->label[dec_max_idx];
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movsd 0xc8(%rdi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movl 0xb0(%rdi), %r12d
movl 0xb4(%rdi), %ebp
sbbl $-0x1, %ebp
movq 0xb8(%rdi), %r13
cmpq $0x2, %r12
jne 0x14575
xorl %ebx, %ebx
cmpl $0x4, (%rdi)
sete %bl
incl %ebx
jmp 0x14580
movl %r12d, %ebx
movl %r12d, %eax
testl %r12d, %r12d
jle 0x1459a
movl %ebx, %edx
shlq $0x3, %rdx
movq %rdi, (%rsp)
movq %r14, %rdi
xorl %esi, %esi
callq 0x3110
movq (%rsp), %rdi
movl %ebx, %eax
movl (%r15), %edx
cmpl $-0x1, %edx
je 0x145ed
movl %eax, %ecx
cmpl %ebp, %edx
jg 0x145e0
testl %eax, %eax
jle 0x145e0
decl %edx
imull %eax, %edx
movslq %edx, %rdx
leaq (,%rdx,8), %rdx
addq %r13, %rdx
xorl %esi, %esi
movsd (%rdx,%rsi,8), %xmm0
mulsd 0x8(%r15), %xmm0
addsd (%r14,%rsi,8), %xmm0
movsd %xmm0, (%r14,%rsi,8)
incq %rsi
cmpq %rsi, %rcx
jne 0x145c1
movl 0x10(%r15), %edx
addq $0x10, %r15
cmpl $-0x1, %edx
jne 0x145a4
cmpl $0x2, %r12d
jne 0x14614
movl (%rdi), %eax
addl $-0xb, %eax
movsd (%r14), %xmm0
cmpl $0x3, %eax
jb 0x14655
xorpd %xmm1, %xmm1
xorl %eax, %eax
ucomisd %xmm1, %xmm0
setbe %al
shll $0x2, %eax
jmp 0x14647
xorl %eax, %eax
cmpl $0x2, %r12d
jl 0x14643
movl $0x1, %ecx
movsd (%r14,%rcx,8), %xmm0
movslq %eax, %rdx
ucomisd (%r14,%rdx,8), %xmm0
movl %ecx, %edx
ja 0x14636
movl %eax, %edx
incq %rcx
movl %edx, %eax
cmpq %rcx, %r12
jne 0x14621
movslq %edx, %rax
shlq $0x2, %rax
addq 0xc0(%rdi), %rax
xorps %xmm0, %xmm0
cvtsi2sdl (%rax), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/qmmlib[P]QmmLibrary/linear.cpp
// Function: free_model_content
void free_model_content(struct model *model_ptr)
{
	if(model_ptr->w != NULL)
		free(model_ptr->w);
	if(model_ptr->label != NULL)
		free(model_ptr->label);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0xb8(%rdi), %rdi
testq %rdi, %rdi
je 0x1503f
callq 0x3290
movq 0xc0(%rbx), %rdi
testq %rdi, %rdi
je 0x15051
popq %rbx
jmp 0x3290
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/qmmlib[P]QmmLibrary/linear.cpp
// Function: destroy_param
void destroy_param(parameter* param)
{
	if(param->weight_label != NULL)
		free(param->weight_label);
	if(param->weight != NULL)
		free(param->weight);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x98(%rdi), %rdi
testq %rdi, %rdi
je 0x15068
callq 0x3290
movq 0xa0(%rbx), %rdi
testq %rdi, %rdi
je 0x1507a
popq %rbx
jmp 0x3290
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/qmmlib[P]QmmLibrary/transform_line.cpp
// Function: split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, char)
unsigned int split(const std::string &txt, std::vector<std::string> &strs, char ch)
{
    size_t pos = txt.find( ch );
    size_t initialPos = 0;
    strs.clear();

    // Decompose statement
    while( pos != std::string::npos ) {
        strs.push_back( txt.substr( initialPos, pos - initialPos + 1 ) );
        initialPos = pos + 1;

        pos = txt.find( ch, initialPos );
    }

    // Add the last one
    strs.push_back( txt.substr( initialPos, std::min( pos, txt.size() ) - initialPos + 1 ) );

    return strs.size();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movq %rsi, %r13
movq %rdi, %r14
xorl %r12d, %r12d
movl %edx, %esi
xorl %edx, %edx
callq 0x32e0
movq %rax, %r15
movq (%r13), %rsi
movq %r13, (%rsp)
movq %r13, %rdi
callq 0x171fe
cmpq $-0x1, %r15
je 0x16b45
xorl %eax, %eax
leaq 0x8(%rsp), %r13
movsbl %bl, %ebp
xorl %r12d, %r12d
movq %r15, %rbx
leaq (%r15,%rax), %rcx
incq %rcx
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x3230
movq (%rsp), %rdi
movq %r13, %rsi
callq 0x172e6
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x16b20
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3220
leaq 0x1(%rbx), %r12
movq %r14, %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0x32e0
movq %rax, %r15
movq %rbx, %rax
notq %rax
cmpq $-0x1, %r15
jne 0x16ae0
negq %rbx
jmp 0x16b4a
movl $0x1, %ebx
addq 0x8(%r14), %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x3230
movq (%rsp), %rdi
movq %r15, %rsi
callq 0x172e6
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x16b8b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3220
movq (%rsp), %rcx
movq 0x8(%rcx), %rax
subq (%rcx), %rax
shrq $0x5, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
jmp 0x16bc4
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x16bd6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3220
movq %rbx, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O3/qmmlib[P]QmmLibrary/transform_line.cpp
// Function: split
void split(char* _str, double* read_line, int * y)
{
    int i = 0;
	while(1)
	{
		if(_str[i]==0)
			break;
		else if(_str[i]==':' || _str[i]=='\r' || _str[i]=='\n' || _str[i]=='\t')
			_str[i] = ' ';
		i++;
	}
	
	std::vector<std::string> v;
	std::string str(_str);
	split(str, v, ' ' ); 
	
	bool labeled = false;
	int last_index = 0;
	for(int i=0; i<v.size(); i++)
	{
		string s = v[i];
		if(s.find_first_not_of(' ') != std::string::npos)
		{
			if(!labeled)
			{
				*y = atoi(s.c_str());
				labeled = true;
				continue;
			}
			if(last_index==0)
				last_index = (int) atof(s.c_str());
			else
			{
				read_line[last_index] = atof(s.c_str());
				last_index = 0;
			}
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdi, %rsi
movabsq $0x400000000002600, %rax # imm = 0x400000000002600
movq %rdi, %rcx
movzbl (%rcx), %edx
cmpq $0x3a, %rdx
ja 0x16c18
btq %rdx, %rax
jae 0x16c1d
movb $0x20, (%rcx)
incq %rcx
jmp 0x16c06
testq %rdx, %rdx
jne 0x16c18
xorpd %xmm0, %xmm0
movapd %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rdx
callq 0x170cc
leaq 0x58(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl $0x20, %edx
callq 0x16a98
movq 0x10(%rsp), %rax
cmpq %rax, 0x18(%rsp)
je 0x16d3f
xorl %r13d, %r13d
movl $0x8, %ebp
leaq 0x48(%rsp), %r14
leaq 0x38(%rsp), %r15
movl $0x0, 0xc(%rsp)
xorl %ebx, %ebx
movq %r14, 0x38(%rsp)
movq -0x8(%rax,%rbp), %rsi
movq (%rax,%rbp), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x17168
movq %r15, %rdi
movl $0x20, %esi
xorl %edx, %edx
callq 0x31e0
cmpq $-0x1, %rax
je 0x16cd6
testb $0x1, %bl
je 0x16cdd
movq 0x38(%rsp), %r12
movq %r12, %rdi
callq 0x32b0
movl 0xc(%rsp), %eax
testl %eax, %eax
jne 0x16cf3
cvttsd2si %xmm0, %eax
movl %eax, 0xc(%rsp)
jmp 0x16d07
movq 0x38(%rsp), %r12
jmp 0x16d09
movq 0x38(%rsp), %r12
movq %r12, %rdi
callq 0x3360
movq 0x30(%rsp), %rcx
movl %eax, (%rcx)
jmp 0x16d07
cltq
movq 0x28(%rsp), %rcx
movsd %xmm0, (%rcx,%rax,8)
movl $0x0, 0xc(%rsp)
movb $0x1, %bl
cmpq %r14, %r12
je 0x16d1e
movq 0x48(%rsp), %rsi
incq %rsi
movq %r12, %rdi
callq 0x3220
incq %r13
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
addq $0x20, %rbp
cmpq %r13, %rcx
ja 0x16c84
leaq 0x68(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x16d5a
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x3220
leaq 0x10(%rsp), %rdi
callq 0x1710a
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x16d7a
movq %rax, %rbx
jmp 0x16d98
movq %rax, %rbx
leaq 0x68(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x16d98
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x3220
leaq 0x10(%rsp), %rdi
callq 0x1710a
movq %rbx, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O3/CHEN-Zhihan[P]Compiler/compiler.cpp
// Function: defineFunctions()
void defineFunctions() {
    for (const auto& FID : functionLabel) {
        auto func = functionTable[FID.first];
        int tempVariablesSize = addressTable[FID.first].first;
        printf("L%03d:\n", FID.second);
        if (tempVariablesSize != 0) {
            printf("\tpush\t%d\n", tempVariablesSize);
            printf("\tpush\tsp\n");   
            printf("\tadd\n");
            printf("\tpop\tsp\n");
        }
        auto v = vector<int>{FID.first};
        func->exStmt(v, FID.first, 998, 998);
        printf("\tpush\t0\n");
        printf("\tret\n");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x12394(%rip), %r15     # 0x1c420
testq %r15, %r15
je 0xa175
leaq -0x48(%rbp), %r12
leaq 0x8(%r15), %r13
leaq 0x122c4(%rip), %rdi     # 0x1c368
movq %r13, %rsi
callq 0xaf30
movq (%rax), %rbx
leaq 0x123ca(%rip), %rdi     # 0x1c480
movq %r13, %rsi
callq 0xb1ce
movl (%rax), %r14d
movl 0xc(%r15), %esi
leaq 0xa54e(%rip), %rdi      # 0x1461a
xorl %eax, %eax
callq 0x4050
testl %r14d, %r14d
je 0xa10d
leaq 0xa543(%rip), %rdi      # 0x14622
movl %r14d, %esi
xorl %eax, %eax
callq 0x4050
leaq 0xa57f(%rip), %rdi      # 0x1466f
callq 0x4330
leaq 0xa57c(%rip), %rdi      # 0x14678
callq 0x4330
leaq 0xa575(%rip), %rdi      # 0x1467d
callq 0x4330
movl (%r13), %eax
movl %eax, -0x30(%rbp)
movl $0x1, %edx
movq %r12, %rdi
leaq -0x30(%rbp), %rsi
leaq -0x29(%rbp), %rcx
callq 0xa93e
movl (%r13), %edx
movq %rbx, %rdi
movq %r12, %rsi
movl $0x3e6, %ecx            # imm = 0x3E6
movl $0x3e6, %r8d            # imm = 0x3E6
callq 0xe424
leaq 0xa518(%rip), %rdi      # 0x14662
callq 0x4330
leaq 0xa514(%rip), %rdi      # 0x1466a
callq 0x4330
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0xa169
callq 0x41e0
movq (%r15), %r15
testq %r15, %r15
jne 0xa099
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0xa195
callq 0x41e0
movq %rbx, %rdi
callq 0x43b0
// File: /workspace/github_cpp_makefile_star2_O3/CHEN-Zhihan[P]Compiler/Node.cpp
// Function: findSpace(int, int)
int findSpace(int functionID, int targetSize) {
    for (const auto & i : reusableAddress[functionID]) {
        if (i.second == targetSize) {
            #if DEBUG
                cerr << "found a space at " << i.first << " of size " << targetSize << endl;
            #endif
            reusableAddress[functionID].erase(i);
            return i.first;
        } else if (i.second > targetSize) {
            #if DEBUG
                cerr << "found a space at " << i.first << " of size " << i.second << " " << i.second - targetSize << " left" << endl;
            #endif
            reusableAddress[functionID].erase(i);
            reusableAddress[functionID].insert({i.first + targetSize, i.second - targetSize});
            return i.first;
        }
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %r14d
leaq -0x2c(%rbp), %rsi
movl %edi, (%rsi)
leaq 0x101fb(%rip), %rdi     # 0x1c448
callq 0xbf44
movq %rax, %r12
movq 0x18(%rax), %rbx
addq $0x8, %r12
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
cmpq %r12, %rbx
je 0xc31a
cmpl %r14d, 0x24(%rbx)
je 0xc289
jg 0xc2b8
movq %rbx, %rdi
callq 0x4270
movq %rax, %rbx
cmpq %r12, %rax
jne 0xc26c
jmp 0xc31a
addq $0x20, %rbx
leaq 0x101b4(%rip), %rdi     # 0x1c448
leaq -0x2c(%rbp), %rsi
callq 0xbf44
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1105a
movq %r14, %rdi
movq %rax, %rsi
callq 0x1112e
jmp 0xc317
leaq 0x20(%rbx), %r15
leaq 0x10185(%rip), %rdi     # 0x1c448
leaq -0x2c(%rbp), %r13
movq %r13, %rsi
callq 0xbf44
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x1105a
movq %r12, %rdi
movq %rax, %rsi
callq 0x1112e
leaq 0x10159(%rip), %rdi     # 0x1c448
movq %r13, %rsi
callq 0xbf44
movl 0x20(%rbx), %ecx
addl %r14d, %ecx
movl 0x24(%rbx), %edx
subl %r14d, %edx
leaq -0x34(%rbp), %rsi
movl %ecx, (%rsi)
movl %edx, 0x4(%rsi)
movq %rax, %rdi
callq 0x111b0
movq %r15, %rbx
movl (%rbx), %r15d
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/CHEN-Zhihan[P]Compiler/Node.cpp
// Function: releaseSpace(int, int)
void releaseSpace(int functionID, int scopeID) {
    for (const auto & i : addressTable[functionID].second[scopeID]) {
        auto dimension = sizeMap[{scopeID, i.first}];
        auto size = accumulate(dimension.begin(), dimension.end(), 1, multiplies<int>());
        auto p = pair<int, int>{i.second, size};
        reusableAddress[functionID].insert(p);
        #if DEBUG
            cerr << "Returning space at " << i.second << " of size " << size << endl; 
        #endif
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq -0x38(%rbp), %rax
movl %edi, (%rax)
leaq -0x34(%rbp), %rbx
movl %esi, (%rbx)
leaq 0x10130(%rip), %rdi     # 0x1c480
movq %rax, %rsi
callq 0xb1ce
leaq 0x8(%rax), %rdi
movq %rbx, %rsi
callq 0x11302
movq 0x10(%rax), %rbx
testq %rbx, %rbx
je 0xc3fa
leaq -0x30(%rbp), %r14
leaq -0x50(%rbp), %r15
leaq 0x100c8(%rip), %r12     # 0x1c448
leaq -0x38(%rbp), %r13
movl -0x34(%rbp), %eax
movl %eax, -0x30(%rbp)
movl 0x8(%rbx), %eax
movl %eax, -0x2c(%rbp)
leaq 0x10131(%rip), %rdi     # 0x1c4c8
movq %r14, %rsi
callq 0x10704
movq %r15, %rdi
movq %rax, %rsi
callq 0x10790
movq -0x50(%rbp), %rcx
movq -0x48(%rbp), %rdx
movl $0x1, %eax
cmpq %rdx, %rcx
je 0xc3c5
imull (%rcx), %eax
addq $0x4, %rcx
jmp 0xc3b7
movl 0xc(%rbx), %ecx
movl %ecx, -0x30(%rbp)
movl %eax, -0x2c(%rbp)
movq %r12, %rdi
movq %r13, %rsi
callq 0xbf44
movq %rax, %rdi
movq %r14, %rsi
callq 0x1188c
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0xc3f2
callq 0x41e0
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0xc384
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0xc41a
callq 0x41e0
movq %rbx, %rdi
callq 0x43b0
// File: /workspace/github_cpp_makefile_star2_O3/CHEN-Zhihan[P]Compiler/Node.cpp
// Function: incdec(std::shared_ptr<VarNode>, int, int, std::vector<int, std::allocator<int>>&, int, bool)
void incdec(shared_ptr<VarNode> v, int blbl, int clbl, vector<int>& sList, int function, bool inc) {
    v->ex(sList, function, blbl, clbl);
    printf("\tpush\t1\n");
    if (inc) {
        printf("\tadd\n");
    } else {
        printf("\tsub\n");
    }
    v->pop(sList, function);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r9d, %r15d
movl %r8d, %ebx
movq %rcx, %r14
movl %edx, %r8d
movl %esi, %ecx
movq %rdi, %r12
movq (%rdi), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movl %ebx, %edx
callq *(%rax)
leaq 0x84ba(%rip), %rdi      # 0x14b1f
callq 0x4330
leaq 0x8007(%rip), %rax      # 0x14678
leaq 0x84af(%rip), %rdi      # 0x14b27
testl %r15d, %r15d
cmovneq %rax, %rdi
callq 0x4330
movq (%r12), %rdi
movq %r14, %rsi
movl %ebx, %edx
xorl %ecx, %ecx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xf3f6
// File: /workspace/github_cpp_makefile_star2_O3/CHEN-Zhihan[P]Compiler/Node.cpp
// Function: ExprNode::ExprNode(int, std::vector<std::shared_ptr<Node>, std::allocator<std::shared_ptr<Node>>> const&)
ExprNode::ExprNode(int oper, const vector<shared_ptr<Node> > &op):oper(oper) {
    this->op = array<shared_ptr<Node>, 2>();
    this->op[0] = op[0];
    if (op.size() == 2) {
        this->op[1] = op[1];
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0xf406(%rip), %rax      # 0x1bac8
movq %rax, (%rdi)
movl %esi, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movaps %xmm0, -0x30(%rbp)
movaps %xmm0, -0x40(%rbp)
xorl %r15d, %r15d
movups -0x40(%rbp,%r15), %xmm0
xorps %xmm1, %xmm1
movups %xmm1, -0x40(%rbp,%r15)
movq 0x20(%rbx,%r15), %rdi
movups %xmm0, 0x18(%rbx,%r15)
testq %rdi, %rdi
je 0xc702
callq 0x864c
addq $0x10, %r15
cmpq $0x20, %r15
jne 0xc6de
movl $0x20, %r15d
movq -0x48(%rbp,%r15), %rdi
testq %rdi, %rdi
je 0xc721
callq 0x864c
addq $-0x10, %r15
jne 0xc712
movq (%r14), %rsi
movq (%rsi), %rax
movq %rax, 0x18(%rbx)
leaq 0x20(%rbx), %rdi
addq $0x8, %rsi
callq 0x10f94
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
cmpq $0x20, %rax
jne 0xc766
movq 0x10(%rsi), %rax
movq %rax, 0x28(%rbx)
addq $0x30, %rbx
addq $0x18, %rsi
movq %rbx, %rdi
callq 0x10f94
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/CHEN-Zhihan[P]Compiler/Node.cpp
// Function: ExprNode::checkArray(std::vector<int, std::allocator<int>>&, int, std::shared_ptr<Node> const&) const
void ExprNode::checkArray(vector<int>& sList, int functionID, const shared_ptr<Node>& t) const {
    auto e = dynamic_pointer_cast<VarNode>(t);
    if (e == nullptr) {
        return;
    }
    if (!e->matched) {
        if (e != nullptr and e->getDimensions() != sizeMap[{e->getDefinitionScope(sList, functionID), e->getID()}].size()) {
            cerr << "Invalid operation on array " << reverseLookup[e->getID()] << endl;
            exit(-1);
        }
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rcx), %rdi
testq %rdi, %rdi
je 0xcdc0
movq %rcx, %rbx
movl %edx, %r15d
movq %rsi, %r12
leaq 0xec16(%rip), %rsi      # 0x1b948
leaq 0xefa7(%rip), %rdx      # 0x1bce0
xorl %ecx, %ecx
callq 0x4250
testq %rax, %rax
je 0xcdc0
movq %rax, %r14
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
je 0xcd66
movq 0xf260(%rip), %rax      # 0x1bfb8
cmpb $0x0, (%rax)
je 0xcd62
incl 0x8(%rbx)
jmp 0xcd66
lock
incl 0x8(%rbx)
cmpb $0x0, 0xd(%r14)
jne 0xcdb3
movq 0x18(%r14), %r13
subq 0x10(%r14), %r13
movq %r14, %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0xce4e
movl 0x8(%r14), %ecx
leaq -0x30(%rbp), %rsi
movl %eax, (%rsi)
movl %ecx, 0x4(%rsi)
leaq 0xf731(%rip), %rdi      # 0x1c4c8
callq 0x10704
shrq $0x4, %r13
movslq %r13d, %rcx
movq 0x8(%rax), %rdx
subq (%rax), %rdx
sarq $0x2, %rdx
cmpq %rcx, %rdx
jne 0xcdcf
testq %rbx, %rbx
je 0xcdc0
movq %rbx, %rdi
callq 0x864c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xf212(%rip), %rdi      # 0x1bfe8
leaq 0x7a2e(%rip), %rsi      # 0x1480b
movl $0x1b, %edx
callq 0x4260
movslq 0x8(%r14), %rax
leaq 0xf53e(%rip), %rcx      # 0x1c330
movq (%rcx), %rcx
shlq $0x5, %rax
movq (%rcx,%rax), %rsi
movq 0x8(%rcx,%rax), %rdx
movq 0xf1df(%rip), %rdi      # 0x1bfe8
callq 0x4260
movq %rax, %rdi
callq 0x4120
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x42a0
jmp 0xce24
jmp 0xce24
movq %rax, %r14
testq %rbx, %rbx
je 0xce34
movq %rbx, %rdi
callq 0x864c
movq %r14, %rdi
callq 0x43b0
// File: /workspace/github_cpp_makefile_star2_O3/CHEN-Zhihan[P]Compiler/Node.cpp
// Function: VarNode::getDefinitionScope(std::vector<int, std::allocator<int>> const&, int) const
int VarNode::getDefinitionScope(const vector<int>& sList, int functionID) const {
    if (global) {
        return GLOBAL;
    }
    for (auto j = sList.size() - 1; j != -1; --j) {
        if (variableTable[sList[j]].count(i) != 0) {
            return sList[j];
        }
        if (sList[j] == functionID) {
            return NOT_FOUND;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpb $0x0, 0xc(%rdi)
je 0xce6b
leaq 0xf65b(%rip), %rsi      # 0x1c4c4
jmp 0xcec1
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rsi
movq 0x8(%r14), %r13
subq %rsi, %r13
addq $0x8, %r15
addq $-0x4, %r13
leaq 0xf514(%rip), %r12      # 0x1c3a0
addq %r13, %rsi
movq %r12, %rdi
callq 0xb9ba
movq %rax, %rdi
movq %r15, %rsi
callq 0x11a64
movq (%r14), %rsi
testq %rax, %rax
jne 0xcebe
leaq -0x4(%r13), %rax
cmpl %ebx, (%rsi,%r13)
movq %rax, %r13
jne 0xce8c
movl $0x7d0, %eax            # imm = 0x7D0
jmp 0xcec3
addq %r13, %rsi
movl (%rsi), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/CHEN-Zhihan[P]Compiler/Node.cpp
// Function: VarNode::getDimension() const
vector<int> VarNode::getDimension() const {
    if (subscriptions.size() == 0) {
        return {};
    }
    auto result = vector<int>(subscriptions.size());
    transform(subscriptions.begin(), subscriptions.end(), result.begin(), [this] (shared_ptr<ExprNode> node) -> int {
        if (node != nullptr) {
            node->evaluate();
            if (!node->isKnown()) {
                cerr << "Invalid size of array " << reverseLookup[i] << endl;
                exit(-1);
            }
            return node->getValue();
        }
        return 0;
    });
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq 0x18(%rsi), %rsi
subq 0x10(%rbx), %rsi
je 0xee91
sarq $0x4, %rsi
leaq -0x29(%rbp), %rdx
movq %rdi, -0x38(%rbp)
callq 0x10960
movq 0x10(%rbx), %r13
movq %rbx, -0x40(%rbp)
movq 0x18(%rbx), %rbx
cmpq %rbx, %r13
je 0xee8b
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
xorl %r15d, %r15d
movq (%r13,%r15,4), %r12
movq 0x8(%r13,%r15,4), %r14
testq %r14, %r14
je 0xee40
movq 0xd188(%rip), %rax      # 0x1bfb8
cmpb $0x0, (%rax)
je 0xee3b
incl 0x8(%r14)
jmp 0xee40
lock
incl 0x8(%r14)
testq %r12, %r12
je 0xee5c
movq %r12, %rdi
callq 0xd472
cmpb $0x0, 0x14(%r12)
je 0xeeb1
movl 0x10(%r12), %eax
jmp 0xee5e
xorl %eax, %eax
movq -0x48(%rbp), %rcx
movl %eax, (%rcx,%r15)
testq %r14, %r14
je 0xee73
movq %r14, %rdi
callq 0x864c
leaq (,%r15,4), %rax
addq %r13, %rax
addq $0x4, %r15
addq $0x10, %rax
cmpq %rbx, %rax
jne 0xee1a
movq -0x38(%rbp), %rax
jmp 0xeea2
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq %rdi, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xd130(%rip), %rdi      # 0x1bfe8
leaq 0x5c44(%rip), %rsi      # 0x14b03
movl $0x16, %edx
callq 0x4260
movq -0x40(%rbp), %rax
movslq 0x8(%rax), %rax
leaq 0xd458(%rip), %rcx      # 0x1c330
movq (%rcx), %rcx
shlq $0x5, %rax
movq (%rcx,%rax), %rsi
movq 0x8(%rcx,%rax), %rdx
movq 0xd0f9(%rip), %rdi      # 0x1bfe8
callq 0x4260
movq %rax, %rdi
callq 0x4120
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x42a0
jmp 0xef08
movq %rax, %r15
testq %r14, %r14
je 0xef18
movq %r14, %rdi
callq 0x864c
movq -0x38(%rbp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0xef29
callq 0x41e0
movq %r15, %rdi
callq 0x43b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/CHEN-Zhihan[P]Compiler/Node.cpp
// Function: CallNode::ex(std::vector<int, std::allocator<int>>&, int, int, int) const
void CallNode::ex(vector<int>& sList, int function, int blbl, int clbl) const {
    if (i < 3) {
        cout << "\t" << reverseLookup[i] << "\n";
    } else if (i < 9) {
        arguments.back()->ex(sList, function, blbl, clbl);
        cout << "\t" << reverseLookup[i] << "\n";
    } else {
        for (const auto& i: arguments) {
            i->ex(sList, function, blbl, clbl);
        }
        printf("\tcall\tL%03d, %d\n", functionLabel[i], (int)arguments.size());
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x8(%rdi), %r14
movl 0x8(%rdi), %eax
cmpl $0x2, %eax
jg 0xefcf
movq 0xd024(%rip), %rbx      # 0x1bfc0
leaq 0x5866(%rip), %rsi      # 0x14809
movl $0x1, %edx
movq %rbx, %rdi
callq 0x4260
movslq (%r14), %rax
leaq 0xd376(%rip), %rcx      # 0x1c330
movq (%rcx), %rcx
shlq $0x5, %rax
movq (%rcx,%rax), %rsi
movq 0x8(%rcx,%rax), %rdx
movq %rbx, %rdi
jmp 0xf029
movl %r8d, %r12d
movl %ecx, %r13d
movq %rdi, %r15
cmpl $0x8, %eax
ja 0xf050
movq 0x18(%r15), %rax
movq -0x10(%rax), %rdi
movq (%rdi), %rax
movl %r13d, %ecx
movl %r12d, %r8d
callq *(%rax)
movq 0xcfc9(%rip), %r14      # 0x1bfc0
leaq 0x580b(%rip), %rsi      # 0x14809
movl $0x1, %edx
movq %r14, %rdi
callq 0x4260
movslq 0x8(%r15), %rax
leaq 0xd31a(%rip), %rcx      # 0x1c330
movq (%rcx), %rcx
shlq $0x5, %rax
movq (%rcx,%rax), %rsi
movq 0x8(%rcx,%rax), %rdx
movq %r14, %rdi
callq 0x4260
leaq 0x51e0(%rip), %rsi      # 0x14215
movl $0x1, %edx
movq %rax, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4260
movq %r14, -0x30(%rbp)
movq 0x10(%r15), %rbx
movq %r15, -0x38(%rbp)
movq 0x18(%r15), %rax
cmpq %rax, %rbx
je 0xf090
movq %rax, -0x40(%rbp)
movq (%rbx), %rdi
movq (%rdi), %rax
movl %r13d, %ecx
movl %r12d, %r8d
movl %edx, %r14d
movq %rsi, %r15
callq *(%rax)
movq -0x40(%rbp), %rax
movq %r15, %rsi
movl %r14d, %edx
addq $0x10, %rbx
cmpq %rax, %rbx
jne 0xf069
leaq 0xd379(%rip), %rdi      # 0x1c410
movq -0x30(%rbp), %rsi
callq 0x1237e
movl (%rax), %esi
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rdx
subq 0x10(%rax), %rdx
shrq $0x4, %rdx
leaq 0x58ac(%rip), %rdi      # 0x14965
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4050
// File: /workspace/github_cpp_makefile_star2_O3/CHEN-Zhihan[P]Compiler/Node.cpp
// Function: VarNode::ex(std::vector<int, std::allocator<int>>&, int, int, int) const
void VarNode::ex(vector<int>& sList, int functionID, int blbl, int clbl) const {
    int definitionScope = getDefinitionScope(sList, functionID);
    if (sizeMap[{definitionScope, i}].size() != 0 and subscriptions.size() == 0) { // pass by reference
        int address = addressTable[functionID].second[definitionScope][i];
        if (address < 0) { // is parameter
            printf("\tpush\tfp[%d]\n", address);
        } else {
            if (global) {
                printf("\tpush\t%d\n", addressTable[GLOBAL].second[GLOBAL][i]);
            } else if (functionID == GLOBAL) {
                auto address = addressTable[GLOBAL].second[getDefinitionScope(sList, functionID)][i];
                printf("\tpush\t%d\n", address);
            } else {
                printf("\tpush\t%d\n", addressTable[functionID].second[definitionScope][i]);
                printf("\tpush\tfp\n");
                printf("\tadd\n");
            }
        }
    } else {
        push(sList, functionID);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl %edx, -0x24(%rbp)
callq 0xce4e
movl %eax, -0x28(%rbp)
leaq -0x30(%rbp), %rsi
movl %eax, (%rsi)
movl 0x8(%r15), %eax
movl %eax, 0x4(%rsi)
leaq 0xc776(%rip), %rdi      # 0x1c4c8
callq 0x10704
movq 0x8(%rax), %rcx
cmpq (%rax), %rcx
je 0xfd6a
movq 0x18(%r15), %rax
cmpq 0x10(%r15), %rax
je 0xfd81
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
movl $0x1, %ecx
callq 0xf3f6
jmp 0xfe40
leaq 0x8(%r15), %rbx
leaq 0xc6f4(%rip), %rdi      # 0x1c480
leaq -0x24(%rbp), %rsi
callq 0xb1ce
leaq 0x8(%rax), %rdi
leaq -0x28(%rbp), %rsi
callq 0x11302
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1237e
movl (%rax), %esi
testl %esi, %esi
js 0xfdde
cmpb $0x1, 0xc(%r15)
jne 0xfde7
leaq 0xc6bf(%rip), %rdi      # 0x1c480
leaq 0xc6fc(%rip), %r14      # 0x1c4c4
movq %r14, %rsi
callq 0xb1ce
leaq 0x8(%rax), %rdi
movq %r14, %rsi
callq 0x11302
jmp 0xfe25
leaq 0x4c14(%rip), %rdi      # 0x149f9
jmp 0xfe39
movl -0x24(%rbp), %eax
cmpl 0xc6d4(%rip), %eax      # 0x1c4c4
jne 0xfe4d
leaq 0xc687(%rip), %rdi      # 0x1c480
leaq 0xc6c4(%rip), %rsi      # 0x1c4c4
callq 0xb1ce
leaq 0x8(%rax), %r12
movl -0x24(%rbp), %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0xce4e
leaq -0x30(%rbp), %rsi
movl %eax, (%rsi)
movq %r12, %rdi
callq 0x124a0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1237e
movl (%rax), %esi
leaq 0x47e9(%rip), %rdi      # 0x14622
xorl %eax, %eax
callq 0x4050
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc62c(%rip), %rdi      # 0x1c480
leaq -0x24(%rbp), %rsi
callq 0xb1ce
leaq 0x8(%rax), %rdi
leaq -0x28(%rbp), %rsi
callq 0x11302
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1237e
movl (%rax), %esi
leaq 0x47a4(%rip), %rdi      # 0x14622
xorl %eax, %eax
callq 0x4050
leaq 0x4cad(%rip), %rdi      # 0x14b39
callq 0x4330
leaq 0x47e0(%rip), %rdi      # 0x14678
callq 0x4330
jmp 0xfe40
nop
// File: /workspace/github_cpp_makefile_star2_O3/CHEN-Zhihan[P]Compiler/Node.cpp
// Function: VarNode::check(std::vector<int, std::allocator<int>>&, int)
void VarNode::check(vector<int>& sList, int functionID) {
    if (global) {
        if (variableTable[GLOBAL].count(i) == 0) {
            cerr << "Undefined reference to global variable: " << reverseLookup[i] << endl;
            exit(-1);
        }
        if (functionID == GLOBAL) {
            cerr << "Refer to a global variable: " << reverseLookup[i] << " in the global scope" << endl;
            exit(-1);
        }
    } else {
        auto s = getDefinitionScope(sList, functionID);
        if (s == NOT_FOUND) {
            cerr << "Undefined reference to variable " << reverseLookup[i] << endl;
            exit(-1);
        }
    }
    for (auto & i : subscriptions) {
        i->check(sList, functionID);
        i->evaluate();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
cmpb $0x1, 0xc(%rdi)
jne 0x103b7
leaq 0xc056(%rip), %rdi      # 0x1c3a0
leaq 0xc173(%rip), %rsi      # 0x1c4c4
callq 0xb9ba
leaq 0x8(%r15), %r12
movq %rax, %rdi
movq %r12, %rsi
callq 0x11a64
testq %rax, %rax
je 0x103ff
cmpl %ebx, 0xc150(%rip)      # 0x1c4c4
jne 0x103cb
movq 0xbc6b(%rip), %rdi      # 0x1bfe8
leaq 0x4738(%rip), %rsi      # 0x14abc
callq 0x4200
movslq (%r12), %rsi
leaq 0xbf9c(%rip), %rcx      # 0x1c330
shlq $0x5, %rsi
addq (%rcx), %rsi
movq %rax, %rdi
callq 0x41d0
leaq 0x4524(%rip), %rsi      # 0x148ce
movq %rax, %rdi
callq 0x4200
jmp 0x10445
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0xce4e
cmpl $0x7d0, %eax            # imm = 0x7D0
je 0x10418
movq 0x10(%r15), %r12
movq 0x18(%r15), %r15
cmpq %r15, %r12
je 0x103f6
movq (%r12), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movl %ebx, %edx
callq *0x8(%rax)
movq (%r12), %rdi
callq 0xd472
addq $0x10, %r12
jmp 0x103d3
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0xbbe2(%rip), %rdi      # 0x1bfe8
leaq 0x4686(%rip), %rsi      # 0x14a93
callq 0x4200
movslq (%r12), %rsi
jmp 0x1042f
movq 0xbbc9(%rip), %rdi      # 0x1bfe8
leaq 0x46b3(%rip), %rsi      # 0x14ad9
callq 0x4200
movslq 0x8(%r15), %rsi
leaq 0xbefa(%rip), %rcx      # 0x1c330
shlq $0x5, %rsi
addq (%rcx), %rsi
movq %rax, %rdi
callq 0x41d0
movq %rax, %rdi
callq 0x4120
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x42a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/apps/msh2df/msh2df.cpp
// Function: IsManifold(gaps::R3Mesh*)
static RNBoolean
IsManifold(R3Mesh *mesh)
{
  // Check for boundary edges
  for (int i = 0; i < mesh->NEdges(); i++) {
    R3MeshEdge *edge = mesh->Edge(i);
    if (mesh->IsEdgeOnBoundary(edge)) return FALSE;
  }

  // Check connected components
  int ncomponents = mesh->ConnectedComponents();
  if (ncomponents != 1) return FALSE;

  // Passed all tests
  return TRUE;
}

// Assembly:
pushq %rax
movslq 0x24(%rdi), %rcx
testq %rcx, %rcx
jle 0x14c81
movq 0x18(%rdi), %rdx
xorl %eax, %eax
xorl %esi, %esi
movq (%rdx,%rsi,8), %r8
cmpq $0x0, 0x18(%r8)
je 0x14c90
cmpq $0x0, 0x20(%r8)
je 0x14c90
incq %rsi
cmpq %rsi, %rcx
jne 0x14c67
callq 0x24b12
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x1, %ecx
sete %al
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/apps/msh2df/../../pkgs/R3Shapes/R3Kdtree.cpp
// Function: gaps::R3Kdtree<Point*>::R3Kdtree(gaps::RNArray<Point*> const&, int)
R3Kdtree<PtrType>::
R3Kdtree(const RNArray<PtrType>& points, int position_offset)
  : position_offset(position_offset),
    position_callback(NULL),
    position_callback_data(NULL),
    npoints(points.NEntries()),
    nnodes(1)
{
  // Create root node
  root = new R3KdtreeNode<PtrType>(NULL);
  assert(root);

  // Determine bounding box 
  bbox = R3null_box;
  for (int i = 0; i < points.NEntries(); i++) {
    bbox.Union(Position(points[i]));
  }

  // Allocate copy of points array (so that it can be sorted)
  PtrType *copy = new PtrType [ points.NEntries() ];
  assert(copy);

  // Copy points
  for (int i = 0; i < points.NEntries(); i++) 
    copy[i] = points[i];

  // Insert points into root
  InsertPoints(root, bbox, copy, points.NEntries());

  // Delete copy of points array
  delete [] copy;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3aa44
movl %ebp, 0x38(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movl 0xc(%r14), %eax
movl %eax, 0x58(%rbx)
movl $0x1, 0x5c(%rbx)
movl $0x130, %edi            # imm = 0x130
callq 0xe440
xorl %ecx, %ecx
movl %ecx, 0x128(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movl %ecx, 0x20(%rax)
movq %rax, 0x50(%rbx)
leaq 0x8(%rbx), %rdi
leaq 0xdb3c7(%rip), %r15     # 0xf00b8
leaq 0x8(%r15), %rsi
callq 0x500a6
leaq 0x20(%rbx), %rdi
addq $0x20, %r15
movq %r15, %rsi
callq 0x500a6
movslq 0xc(%r14), %rax
testq %rax, %rax
jle 0x14d49
xorl %r12d, %r12d
leaq 0x8(%rsp), %r15
movq (%r14), %rax
movq (%rax,%r12,8), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x14f6e
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3b47a
incq %r12
movl 0xc(%r14), %ebp
movslq %ebp, %rax
cmpq %rax, %r12
jl 0x14d1b
jmp 0x14d4b
movl %eax, %ebp
shlq $0x3, %rax
testl %ebp, %ebp
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0xe030
movq %rax, %r15
testl %ebp, %ebp
jle 0x14d7f
movq (%r14), %rax
movl %ebp, %ecx
xorl %edx, %edx
movq (%rax,%rdx,8), %rsi
movq %rsi, (%r15,%rdx,8)
incq %rdx
cmpq %rdx, %rcx
jne 0x14d6f
movq 0x50(%rbx), %rsi
movq %rbx, %rdi
movq %rbx, %rdx
movq %r15, %rcx
movl %ebp, %r8d
callq 0x14fc2
movq %r15, %rdi
callq 0xe5b0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x14dad
jmp 0x14dad
movq %rax, %r14
movq %rbx, %rdi
callq 0x3b8a8
movq %r14, %rdi
callq 0xe7f0
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/apps/msh2df/../../pkgs/R3Shapes/R3Kdtree.cpp
// Function: gaps::R3Kdtree<Point*>::FindClosest(gaps::R3Point const&, double, double, int, gaps::RNArray<Point*>&, double*) const
int R3Kdtree<PtrType>::
FindClosest(const R3Point& query_position, RNScalar min_distance, RNScalar max_distance, int max_points, 
  RNArray<PtrType>& points, RNLength *distances) const
{
  // Check root
  if (!root) return 0;

  // Use squared distances for efficiency
  if (max_distance < 0) return 0;
  if (min_distance < 0) min_distance = 0;
  RNLength min_distance_squared = min_distance * min_distance;
  RNLength max_distance_squared = max_distance * max_distance;

  // Allocate temporary array of squared distances to max_points closest points
  RNLength *distances_squared = new RNLength [ max_points ];

  // Search nodes recursively
  FindClosest(root, bbox, 
    NULL, query_position, 
    min_distance_squared, max_distance_squared, max_points, 
    NULL, NULL, 
    points, distances_squared);

  // Update return distances
  if (distances) {
    for (int i = 0; i < points.NEntries(); i++) {
      distances[i] = sqrt(distances_squared[i]);
    }
  }

  // Delete temporary array of squared distances
  delete [] distances_squared;

  // Return number of points
  return points.NEntries();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %rbx
movl %edx, %ebp
movq 0x50(%rdi), %r12
testq %r12, %r12
sete %cl
xorpd %xmm2, %xmm2
ucomisd %xmm1, %xmm2
seta %dl
xorl %eax, %eax
orb %cl, %dl
jne 0x14eb1
movq %r8, %r14
movq %rdi, %r13
maxsd %xmm0, %xmm2
mulsd %xmm2, %xmm2
movsd %xmm2, 0x28(%rsp)
mulsd %xmm1, %xmm1
movsd %xmm1, 0x30(%rsp)
movl %ebp, %eax
shlq $0x3, %rax
testl %ebp, %ebp
movq $-0x1, %rdi
cmovnsq %rax, %rdi
movq %rsi, 0x20(%rsp)
callq 0xe030
movq %rax, %r15
movq %rax, 0x18(%rsp)
movq %rbx, 0x10(%rsp)
xorpd %xmm0, %xmm0
movupd %xmm0, (%rsp)
movq %r13, %rdi
movq %r12, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
movq 0x20(%rsp), %r8
movsd 0x28(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
movl %ebp, %r9d
callq 0x15362
testq %r14, %r14
je 0x14ea6
cmpl $0x0, 0xc(%rbx)
jle 0x14ea6
xorl %r12d, %r12d
xorpd %xmm1, %xmm1
movsd (%r15,%r12,8), %xmm0
ucomisd %xmm1, %xmm0
jb 0x14e8b
sqrtsd %xmm0, %xmm0
jmp 0x14e94
callq 0xe340
xorpd %xmm1, %xmm1
movsd %xmm0, (%r14,%r12,8)
incq %r12
movslq 0xc(%rbx), %rax
cmpq %rax, %r12
jl 0x14e79
movq %r15, %rdi
callq 0xe5b0
movl 0xc(%rbx), %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq