LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movq 0x30(%rdi), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq 0x30(%rdi), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x40(%rbp), %rdi
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rsi
movq 0x10(%rdi), %rdx
callq 0x7610
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x30(%rbp), %eax
jge 0x7545
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7506
movsd -0x20(%rbp), %xmm0
movsd 0x1dd36(%rip), %xmm1    # 0x25288
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x75fe
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x10(%rax), %rcx
movslq -0x14(%rbp), %rdx
mulsd (%rcx,%rdx,8), %xmm0
movq 0x10(%rax), %rcx
movslq -0x14(%rbp), %rdx
movsd %xmm0, (%rcx,%rdx,8)
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
movsd 0x1ca7f(%rip), %xmm0    # 0x24028
subsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x75ee
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
mulsd -0x38(%rbp), %xmm0
movsd -0x38(%rbp), %xmm2
movsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x75f0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7562
movsd -0x20(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq 0x30(%rdi), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq 0x30(%rdi), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, -0x30(%rbp)
movl $0x0, 0x28(%rax)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x77b4
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x1c(%rbp), %rcx
movsd 0x1c8ea(%rip), %xmm0    # 0x24028
ucomisd (%rax,%rcx,8), %xmm0
jbe 0x77a4
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rcx
movslq -0x1c(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq -0x28(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
mulsd (%rcx,%rdx,8), %xmm0
movq 0x10(%rax), %rcx
movslq -0x1c(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm1
movsd 0x1c8b0(%rip), %xmm2    # 0x24028
subsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movq 0x10(%rax), %rcx
movslq 0x28(%rax), %rdx
movsd %xmm0, (%rcx,%rdx,8)
movl -0x1c(%rbp), %esi
movq 0x20(%rax), %rcx
movslq 0x28(%rax), %rdx
movl %esi, (%rcx,%rdx,4)
movl 0x28(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rax)
jmp 0x77a6
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x771e
movq -0x38(%rbp), %rdi
movq 0x10(%rdi), %rsi
movq -0x18(%rbp), %rdx
callq 0x7820
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jge 0x780e
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
addsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x77cc
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, -0x20(%rbp)
movq 0x30(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x7881
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x785e
movl $0x0, -0x1c(%rbp)
movq -0x38(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x28(%rcx), %eax
jge 0x790f
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rax
movq 0x20(%rcx), %rcx
movslq -0x1c(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpl $-0x1, (%rax)
je 0x78ff
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x30(%rbp), %rax
movsd 0x8(%rax), %xmm2
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq -0x30(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x30(%rbp)
jmp 0x78b0
jmp 0x7901
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7888
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, -0x20(%rbp)
movslq 0x28(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq -0x30(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x7a70
movl $0x0, -0x1c(%rbp)
movq -0x30(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x28(%rcx), %eax
jge 0x79f6
movq -0x30(%rbp), %rcx
movq 0x8(%rcx), %rax
movq 0x20(%rcx), %rcx
movslq -0x1c(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
mulsd (%rax,%rcx,8), %xmm0
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x79ac
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x7820
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x7a50
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
addsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7a0e
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x7a67
movq -0x38(%rbp), %rdi
callq 0x33b0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x30(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x38(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x28(%rcx), %eax
jge 0x7b36
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rax
movq 0x20(%rcx), %rcx
movslq -0x1c(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq -0x30(%rbp), %rax
cmpl $-0x1, (%rax)
je 0x7b26
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x30(%rbp), %rax
movsd 0x8(%rax), %xmm2
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq -0x30(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x30(%rbp)
jmp 0x7ad7
jmp 0x7b28
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7a9b
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movq 0x30(%rdi), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq 0x30(%rdi), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x40(%rbp), %rdi
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rsi
movq 0x10(%rdi), %rdx
callq 0x7610
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x30(%rbp), %eax
jge 0x7c25
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7be6
movsd -0x20(%rbp), %xmm0
movsd 0x1d656(%rip), %xmm1    # 0x25288
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x7d32
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rcx
movslq -0x14(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq -0x28(%rbp), %rcx
movslq -0x14(%rbp), %rdx
subsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm1
movsd 0x38(%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x7cd5
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rcx
movslq -0x14(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movsd -0x38(%rbp), %xmm1
addsd 0x38(%rax), %xmm1
mulsd %xmm1, %xmm0
movsd -0x38(%rbp), %xmm2
addsd 0x38(%rax), %xmm2
movsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x7d22
movq -0x40(%rbp), %rax
movsd -0x38(%rbp), %xmm0
ucomisd 0x38(%rax), %xmm0
jbe 0x7d20
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rcx
movslq -0x14(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movsd -0x38(%rbp), %xmm1
subsd 0x38(%rax), %xmm1
mulsd %xmm1, %xmm0
movsd -0x38(%rbp), %xmm2
subsd 0x38(%rax), %xmm2
movsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x7d22
jmp 0x7d24
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7c42
movsd -0x20(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq 0x30(%rdi), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq 0x30(%rdi), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ecx
movq -0x40(%rbp), %rax
movl %ecx, -0x30(%rbp)
movl $0x0, 0x28(%rax)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x7e8e
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rcx
movslq -0x1c(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq -0x28(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
subsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm1
movsd 0x38(%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x7e29
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rcx
movslq -0x1c(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movsd -0x38(%rbp), %xmm1
addsd 0x38(%rax), %xmm1
mulsd %xmm1, %xmm0
movq 0x10(%rax), %rcx
movslq 0x28(%rax), %rdx
movsd %xmm0, (%rcx,%rdx,8)
movl -0x1c(%rbp), %esi
movq 0x20(%rax), %rcx
movslq 0x28(%rax), %rdx
movl %esi, (%rcx,%rdx,4)
movl 0x28(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rax)
jmp 0x7e7e
movq -0x40(%rbp), %rax
movsd -0x38(%rbp), %xmm0
ucomisd 0x38(%rax), %xmm0
jbe 0x7e7c
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rcx
movslq -0x1c(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movsd -0x38(%rbp), %xmm1
subsd 0x38(%rax), %xmm1
mulsd %xmm1, %xmm0
movq 0x10(%rax), %rcx
movslq 0x28(%rax), %rdx
movsd %xmm0, (%rcx,%rdx,8)
movl -0x1c(%rbp), %esi
movq 0x20(%rax), %rcx
movslq 0x28(%rax), %rdx
movl %esi, (%rcx,%rdx,4)
movl 0x28(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rax)
jmp 0x7e7e
jmp 0x7e80
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7d8e
movq -0x40(%rbp), %rdi
movq 0x10(%rdi), %rsi
movq -0x18(%rbp), %rdx
callq 0x7820
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jge 0x7ee8
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
addsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7ea6
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xe430
movq -0x10(%rbp), %rdi
callq 0xf380
movq -0x10(%rbp), %rdi
callq 0x3370
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0xb8(%rax)
je 0xf3aa
movq -0x8(%rbp), %rax
movq 0xb8(%rax), %rdi
callq 0x3370
movq -0x8(%rbp), %rax
cmpq $0x0, 0xc0(%rax)
je 0xf3c8
movq -0x8(%rbp), %rax
movq 0xc0(%rax), %rdi
callq 0x3370
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x98(%rax)
je 0xf3fa
movq -0x8(%rbp), %rax
movq 0x98(%rax), %rdi
callq 0x3370
movq -0x8(%rbp), %rax
cmpq $0x0, 0xa0(%rax)
je 0xf418
movq -0x8(%rbp), %rax
movq 0xa0(%rax), %rdi
callq 0x3370
addq $0x10, %rsp
popq %rbp
retq
nop
// File: qmmlib[P]QmmLibrary/linear.cpp
// Function: check_parameter
const char *check_parameter(const problem *prob, const parameter *param)
{
	if(param->eps <= 0)
		return "eps <= 0";

	if(param->C <= 0)
		return "C <= 0";
	
	if(param->p < 0)
		return "p < 0";

	if(param->solver_type != L2R_LR
		&& param->solver_type != L2R_L2LOSS_SVC_DUAL
		&& param->solver_type != L2R_L2LOSS_SVC
		&& param->solver_type != L2R_L1LOSS_SVC_DUAL
		&& param->solver_type != MCSVM_CS
		&& param->solver_type != L1R_L2LOSS_SVC
		&& param->solver_type != L1R_LR
		&& param->solver_type != L2R_LR_DUAL
		&& param->solver_type != L2R_L2LOSS_SVR
		&& param->solver_type != L2R_L2LOSS_SVR_DUAL
		&& param->solver_type != L2R_L1LOSS_SVR_DUAL
		&& param->solver_type != MMCD
		&& param->solver_type != MMCD_SM
		&& param->solver_type != MMCD_SG
		&& param->solver_type != MMGCD
		&& param->solver_type != MMCD_SIMPLE
		&& param->solver_type != MMCG)
		return "unknown solver type";

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
ucomisd 0x80(%rax), %xmm0
jb 0xf44d
leaq 0x16171(%rip), %rax     # 0x255b5
movq %rax, -0x8(%rbp)
jmp 0xf54d
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
ucomisd 0x88(%rax), %xmm0
jb 0xf46e
leaq 0x16159(%rip), %rax     # 0x255be
movq %rax, -0x8(%rbp)
jmp 0xf54d
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
ucomisd 0xa8(%rax), %xmm0
jbe 0xf48f
leaq 0x1613f(%rip), %rax     # 0x255c5
movq %rax, -0x8(%rbp)
jmp 0xf54d
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0xf545
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
je 0xf545
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
je 0xf545
movq -0x18(%rbp), %rax
cmpl $0x3, (%rax)
je 0xf545
movq -0x18(%rbp), %rax
cmpl $0x4, (%rax)
je 0xf545
movq -0x18(%rbp), %rax
cmpl $0x5, (%rax)
je 0xf545
movq -0x18(%rbp), %rax
cmpl $0x6, (%rax)
je 0xf545
movq -0x18(%rbp), %rax
cmpl $0x7, (%rax)
je 0xf545
movq -0x18(%rbp), %rax
cmpl $0xb, (%rax)
je 0xf545
movq -0x18(%rbp), %rax
cmpl $0xc, (%rax)
je 0xf545
movq -0x18(%rbp), %rax
cmpl $0xd, (%rax)
je 0xf545
movq -0x18(%rbp), %rax
cmpl $0x32, (%rax)
je 0xf545
movq -0x18(%rbp), %rax
cmpl $0x33, (%rax)
je 0xf545
movq -0x18(%rbp), %rax
cmpl $0x34, (%rax)
je 0xf545
movq -0x18(%rbp), %rax
cmpl $0x36, (%rax)
je 0xf545
movq -0x18(%rbp), %rax
cmpl $0x35, (%rax)
je 0xf545
movq -0x18(%rbp), %rax
cmpl $0x37, (%rax)
je 0xf545
leaq 0x1608c(%rip), %rax     # 0x255cb
movq %rax, -0x8(%rbp)
jmp 0xf54d
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: qmmlib[P]QmmLibrary/linear.cpp
// Function: shrink(double, double)
static double shrink(double w, double gamma) {
	if (w < gamma && w > -gamma)
		return 0;
	else if (w < 0)
		return w+gamma;
	else if (w > 0)
		return w-gamma;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd -0x10(%rbp), %xmm1
movsd -0x18(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x1f51f
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x1f51f
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x1f565
xorps %xmm0, %xmm0
ucomisd -0x10(%rbp), %xmm0
jbe 0x1f53a
movsd -0x10(%rbp), %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x1f565
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x1f559
movsd -0x10(%rbp), %xmm0
subsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x1f565
jmp 0x1f55b
jmp 0x1f55d
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movsbl -0x11(%rbp), %esi
callq 0x33c0
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x21e00
cmpq $-0x1, -0x20(%rbp)
je 0x21633
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x8(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
subq %rdx, %rcx
incq %rcx
leaq -0x48(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x32e0
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x21e20
jmp 0x215eb
leaq -0x48(%rbp), %rdi
callq 0x3170
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movb -0x11(%rbp), %al
movq -0x28(%rbp), %rdx
movsbl %al, %esi
callq 0x33c0
movq %rax, -0x20(%rbp)
jmp 0x2159e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3170
jmp 0x216da
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0xa8(%rbp)
callq 0x31a0
movq %rax, -0x80(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x55e0
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
movq (%rax), %rcx
movq -0x28(%rbp), %rax
subq %rax, %rcx
incq %rcx
leaq -0x78(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x32e0
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0x21e20
jmp 0x216aa
leaq -0x78(%rbp), %rdi
callq 0x3170
movq -0x10(%rbp), %rdi
callq 0x21e50
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x3170
movq -0x50(%rbp), %rdi
callq 0x34b0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x80, %rsp
leaq 0x3b216(%rip), %rax     # 0x51428
movq %rax, -0x8(%rbp)
leaq 0x3b20b(%rip), %rdi     # 0x51428
callq 0x16e00
movq %rax, -0x10(%rbp)
leaq 0x3b1fb(%rip), %rdi     # 0x51428
callq 0x16e30
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x16e60
testb $0x1, %al
jne 0x1624c
jmp 0x163a4
leaq -0x10(%rbp), %rdi
callq 0x16e90
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
leaq 0x3b11c(%rip), %rdi     # 0x51380
callq 0x16ec0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rsi
leaq 0x3b21d(%rip), %rdi     # 0x51498
callq 0x16ef0
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movl 0x4(%rax), %esi
leaq 0x203c1(%rip), %rdi     # 0x36654
movb $0x0, %al
callq 0x4040
cmpl $0x0, -0x2c(%rbp)
je 0x162db
movl -0x2c(%rbp), %esi
leaq 0x203b2(%rip), %rdi     # 0x3665c
movb $0x0, %al
callq 0x4040
leaq 0x203ae(%rip), %rdi     # 0x36666
movb $0x0, %al
callq 0x4040
leaq 0x203aa(%rip), %rdi     # 0x36670
movb $0x0, %al
callq 0x4040
leaq 0x203a2(%rip), %rdi     # 0x36676
movb $0x0, %al
callq 0x4040
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x5c(%rbp)
leaq -0x5c(%rbp), %rax
movq %rax, -0x58(%rbp)
movq $0x1, -0x50(%rbp)
leaq -0x5d(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x16f20
movq -0x78(%rbp), %rcx
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x16f40
jmp 0x16318
leaq -0x5d(%rbp), %rdi
callq 0x16fc0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %edx
leaq -0x48(%rbp), %rsi
movl $0x3e6, %r8d            # imm = 0x3E6
movl %r8d, %ecx
callq 0x256e0
jmp 0x1633f
leaq 0x20339(%rip), %rdi     # 0x3667f
xorl %eax, %eax
callq 0x4040
jmp 0x1634f
leaq 0x20332(%rip), %rdi     # 0x36688
xorl %eax, %eax
callq 0x4040
jmp 0x1635f
leaq -0x48(%rbp), %rdi
callq 0x16fe0
leaq -0x10(%rbp), %rdi
callq 0x17040
jmp 0x16236
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x5d(%rbp), %rdi
callq 0x16fc0
jmp 0x163ad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x16fe0
jmp 0x163ad
addq $0x80, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x43d0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x2f58b(%rip), %rdi     # 0x51460
leaq -0x8(%rbp), %rsi
callq 0x175b0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x28da0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x28dd0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x28e00
testb $0x1, %al
jne 0x21f12
jmp 0x21fec
leaq -0x20(%rbp), %rdi
callq 0x28e30
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x21f55
leaq 0x2f52e(%rip), %rdi     # 0x51460
leaq -0x8(%rbp), %rsi
callq 0x175b0
movq %rax, %rdi
movq -0x30(%rbp), %rsi
callq 0x28e60
movq -0x30(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x21ff3
movq -0x30(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0xc(%rbp), %eax
jle 0x21fda
leaq 0x2f4f8(%rip), %rdi     # 0x51460
leaq -0x8(%rbp), %rsi
callq 0x175b0
movq %rax, %rdi
movq -0x30(%rbp), %rsi
callq 0x28e60
leaq 0x2f4dc(%rip), %rdi     # 0x51460
leaq -0x8(%rbp), %rsi
callq 0x175b0
movq %rax, -0x58(%rbp)
movq -0x30(%rbp), %rax
movl (%rax), %eax
addl -0xc(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x30(%rbp), %rax
movl 0x4(%rax), %eax
subl -0xc(%rbp), %eax
movl %eax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x28ee0
movq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x28e90
movq %rax, -0x50(%rbp)
movb %dl, -0x48(%rbp)
movq -0x30(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x21ff3
jmp 0x21fdc
jmp 0x21fde
leaq -0x20(%rbp), %rdi
callq 0x28f10
jmp 0x21efc
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0xc0, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
leaq 0x2f480(%rip), %rdi     # 0x51498
leaq -0x4(%rbp), %rsi
callq 0x16ef0
movq %rax, %rdi
addq $0x8, %rdi
leaq -0x8(%rbp), %rsi
callq 0x28f40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x16e00
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x16e30
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x16e60
testb $0x1, %al
jne 0x22065
jmp 0x2218a
leaq -0x18(%rbp), %rdi
callq 0x16e90
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdx
leaq -0x48(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
leaq -0x8(%rbp), %rsi
callq 0x29050
movq -0xa8(%rbp), %rsi
leaq 0x2f448(%rip), %rdi     # 0x514e0
callq 0x28f70
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x29080
movq -0xa0(%rbp), %rdi
callq 0x291d0
movq -0xa0(%rbp), %rdi
movq %rax, -0x58(%rbp)
callq 0x29200
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rsi
movl $0x1, %edx
callq 0x29170
movl %eax, -0x94(%rbp)
jmp 0x220ea
movl -0x94(%rbp), %eax
movl %eax, -0x4c(%rbp)
movq -0x28(%rbp), %rsi
addq $0x4, %rsi
leaq -0x7c(%rbp), %rdi
leaq -0x4c(%rbp), %rdx
callq 0x29230
jmp 0x2210a
leaq 0x2f34f(%rip), %rdi     # 0x51460
leaq -0x4(%rbp), %rsi
callq 0x175b0
movq %rax, -0xb0(%rbp)
jmp 0x22123
movq -0xb0(%rbp), %rdi
leaq -0x7c(%rbp), %rsi
callq 0x29260
movb %dl, -0xb9(%rbp)
movq %rax, -0xb8(%rbp)
jmp 0x22142
movb -0xb9(%rbp), %al
movq -0xb8(%rbp), %rcx
movq %rcx, -0x90(%rbp)
movb %al, -0x88(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x16fe0
leaq -0x18(%rbp), %rdi
callq 0x17040
jmp 0x2204f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x16fe0
jmp 0x22193
addq $0xc0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x43d0
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movb %r9b, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
andb $0x1, %al
movb %al, -0x1d(%rbp)
callq 0x292f0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0xc(%rbp), %ecx
movl -0x10(%rbp), %r8d
movq (%rdi), %rax
callq *(%rax)
leaq 0x1429f(%rip), %rdi     # 0x367e7
movb $0x0, %al
callq 0x4040
testb $0x1, -0x1d(%rbp)
je 0x22565
leaq 0x14114(%rip), %rdi     # 0x36670
movb $0x0, %al
callq 0x4040
jmp 0x22573
leaq 0x14284(%rip), %rdi     # 0x367f0
movb $0x0, %al
callq 0x4040
movq -0x28(%rbp), %rdi
callq 0x292f0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x225a0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x29310
movq -0x48(%rbp), %rdi
leaq 0x2e4b5(%rip), %rax     # 0x50ab0
addq $0x10, %rax
movq %rax, (%rdi)
movl -0xc(%rbp), %eax
movl %eax, 0x8(%rdi)
addq $0x18, %rdi
callq 0x29330
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x4130
leaq -0x38(%rbp), %rdi
callq 0x29330
movq -0x48(%rbp), %rdi
addq $0x18, %rdi
leaq -0x38(%rbp), %rsi
callq 0x29380
leaq -0x38(%rbp), %rdi
callq 0x293f0
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x29440
movq -0x48(%rbp), %rdi
movq %rax, -0x40(%rbp)
addq $0x18, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x29460
movq -0x40(%rbp), %rsi
movq %rax, %rdi
callq 0x29490
movq -0x18(%rbp), %rdi
callq 0x294c0
cmpq $0x2, %rax
jne 0x226b1
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x29440
movq -0x48(%rbp), %rdi
movq %rax, -0x50(%rbp)
addq $0x18, %rdi
movl $0x1, %esi
callq 0x29460
movq -0x50(%rbp), %rsi
movq %rax, %rdi
callq 0x29490
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0xbb80
leaq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x29600
testb $0x1, %al
jne 0x22f2a
jmp 0x22f36
movl $0x1, -0x34(%rbp)
jmp 0x230ae
leaq -0x30(%rbp), %rdi
callq 0x292f0
testb $0x1, 0xd(%rax)
jne 0x230a7
leaq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x29630
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x55(%rbp)
jne 0x22f67
jmp 0x23007
leaq -0x30(%rbp), %rdi
callq 0x292f0
movq %rax, %rdi
callq 0x230d0
movl %eax, -0x5c(%rbp)
jmp 0x22f7d
movl -0x5c(%rbp), %eax
cltq
movq %rax, -0x68(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x292f0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x230f0
movl %eax, -0x60(%rbp)
jmp 0x22fa3
movl -0x60(%rbp), %eax
movl %eax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x292f0
movq %rax, %rdi
callq 0x231c0
movl %eax, -0x6c(%rbp)
jmp 0x22fbf
movl -0x6c(%rbp), %eax
movl %eax, -0x54(%rbp)
leaq -0x4c(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0x54(%rbp), %rdx
callq 0x28ee0
jmp 0x22fd8
leaq 0x2e501(%rip), %rdi     # 0x514e0
leaq -0x4c(%rbp), %rsi
callq 0x28f70
movq %rax, -0x78(%rbp)
jmp 0x22fee
movq -0x78(%rbp), %rdi
callq 0x29660
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
setne %al
movb %al, -0x55(%rbp)
movb -0x55(%rbp), %al
testb $0x1, %al
jne 0x23013
jmp 0x230a5
movq 0x2dfd6(%rip), %rdi     # 0x50ff0
leaq 0x137db(%rip), %rsi     # 0x367fc
callq 0x4210
movq %rax, -0x80(%rbp)
jmp 0x2302c
leaq -0x30(%rbp), %rdi
callq 0x292f0
movq %rax, %rdi
callq 0x231c0
movl %eax, -0x84(%rbp)
jmp 0x23045
movl -0x84(%rbp), %eax
movslq %eax, %rsi
leaq 0x2e2f3(%rip), %rdi     # 0x51348
callq 0x29680
movq -0x80(%rbp), %rdi
movq %rax, %rsi
callq 0x41f0
movq %rax, -0x90(%rbp)
jmp 0x2306f
movq -0x90(%rbp), %rdi
movq 0x2df23(%rip), %rsi     # 0x50fa0
callq 0x4240
jmp 0x23084
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x42c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xbc50
jmp 0x230c0
jmp 0x230a7
movl $0x0, -0x34(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xbc50
addq $0x90, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x43d0
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
testb $0x1, 0xc(%rax)
je 0x2311f
movl 0x2e3c5(%rip), %eax     # 0x514dc
movl %eax, -0x4(%rbp)
jmp 0x231ac
movq -0x18(%rbp), %rdi
callq 0x29660
subq $0x1, %rax
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x28(%rbp)
je 0x231aa
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x29be0
movq %rax, %rsi
leaq 0x2e26a(%rip), %rdi     # 0x513b8
callq 0x17400
movq -0x30(%rbp), %rsi
movq %rax, %rdi
addq $0x8, %rsi
callq 0x29540
cmpq $0x0, %rax
je 0x2317d
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x29be0
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x231ac
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x29be0
movl (%rax), %eax
cmpl -0x1c(%rbp), %eax
jne 0x2319a
movl $0x7d0, -0x4(%rbp)      # imm = 0x7D0
jmp 0x231ac
jmp 0x2319c
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x23130
ud2
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
addq $0x10, %rdi
callq 0x2a210
cmpq $0x0, %rax
jne 0x26603
movq -0x68(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x4130
movq -0x68(%rbp), %rdi
callq 0x299f0
jmp 0x266e9
movq -0x58(%rbp), %rdi
movb $0x0, -0x11(%rbp)
addq $0x10, %rdi
callq 0x2a210
movq %rax, -0x78(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x16f20
movq -0x68(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
callq 0x2a150
jmp 0x26638
leaq -0x12(%rbp), %rdi
callq 0x16fc0
movq -0x58(%rbp), %rdi
addq $0x10, %rdi
movq %rdi, -0x88(%rbp)
callq 0x2a680
movq -0x88(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x2a6b0
movq -0x68(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x291d0
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, -0x40(%rbp)
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x48(%rbp), %rcx
callq 0x27d50
movq %rax, -0x80(%rbp)
jmp 0x2669c
movq -0x80(%rbp), %rax
movq %rax, -0x50(%rbp)
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x266e7
jmp 0x266de
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x16fc0
jmp 0x266f6
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x16fe0
jmp 0x266f6
movq -0x68(%rbp), %rdi
callq 0x16fe0
jmp 0x266e9
movq -0x60(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x43d0
nop
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpl $0x3, 0x8(%rax)
jge 0x26806
movq 0x2a801(%rip), %rdi     # 0x50fc0
leaq 0x1001f(%rip), %rsi     # 0x367e5
callq 0x4210
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x50(%rbp)
movslq 0x8(%rax), %rsi
leaq 0x2ab67(%rip), %rdi     # 0x51348
callq 0x29680
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x41f0
movq %rax, %rdi
leaq 0xfa41(%rip), %rsi      # 0x3623d
callq 0x4210
jmp 0x26934
movq -0x48(%rbp), %rax
cmpl $0x9, 0x8(%rax)
jge 0x26889
movq -0x48(%rbp), %rdi
addq $0x10, %rdi
callq 0x2a640
movq %rax, %rdi
callq 0x299a0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
movl -0x1c(%rbp), %r8d
movq (%rdi), %rax
callq *(%rax)
movq 0x2a77e(%rip), %rdi     # 0x50fc0
leaq 0xff9c(%rip), %rsi      # 0x367e5
callq 0x4210
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x58(%rbp)
movslq 0x8(%rax), %rsi
leaq 0x2aae4(%rip), %rdi     # 0x51348
callq 0x29680
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x41f0
movq %rax, %rdi
leaq 0xf9be(%rip), %rsi      # 0x3623d
callq 0x4210
jmp 0x26932
movq -0x48(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2a680
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2a6b0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2a6e0
testb $0x1, %al
jne 0x268c2
jmp 0x268f9
leaq -0x30(%rbp), %rdi
callq 0x2a720
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x299a0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
movl -0x1c(%rbp), %r8d
movq (%rdi), %rax
callq *(%rax)
leaq -0x30(%rbp), %rdi
callq 0x2a740
jmp 0x268af
movq -0x48(%rbp), %rsi
addq $0x8, %rsi
leaq 0x2ab20(%rip), %rdi     # 0x51428
callq 0x2a760
movq -0x48(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x5c(%rbp)
addq $0x10, %rdi
callq 0x2a210
movl -0x5c(%rbp), %esi
movl %eax, %edx
leaq 0x1002b(%rip), %rdi     # 0x36956
movb $0x0, %al
callq 0x4040
jmp 0x26934
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH03_StringsVectorsAndArrays/examples/word_echo.cc
// Function: main
int main() 
{
	string word;
	while (cin >> word)       // read until end-of-file 
		cout << word << endl; // write each word followed by a new line
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1090
movq 0x2dc1(%rip), %rdi      # 0x3fe0
leaq -0x28(%rbp), %rsi
callq 0x1080
movq %rax, -0x40(%rbp)
jmp 0x122e
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x1070
movb %al, -0x41(%rbp)
jmp 0x1246
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x124f
jmp 0x1290
movq 0x2d7a(%rip), %rdi      # 0x3fd0
leaq -0x28(%rbp), %rsi
callq 0x1050
movq %rax, -0x50(%rbp)
jmp 0x1265
movq -0x50(%rbp), %rdi
movq 0x2d50(%rip), %rsi      # 0x3fc0
callq 0x1060
jmp 0x1277
jmp 0x1218
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1030
jmp 0x12a9
movl $0x0, -0x4(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1030
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x10b0
// File: iZhangHui[P]CppPrimer/CH10_GenericAlgorithms/examples/inserters.cc
// Function: print(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::list<int, std::allocator<int>> const&)
void print(const string &label, const list<int> &lst)
{
	cout << label << endl;
	for (auto iter : lst)
        cout << iter << " ";
    cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq 0x5d0d(%rip), %rdi      # 0x6fd8
callq 0x10b0
movq %rax, %rdi
movq 0x5cee(%rip), %rsi      # 0x6fc8
callq 0x10f0
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1a50
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1a80
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1ab0
testb $0x1, %al
jne 0x1314
jmp 0x134b
leaq -0x20(%rbp), %rdi
callq 0x1ae0
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %esi
movq 0x5cac(%rip), %rdi      # 0x6fd8
callq 0x1140
movq %rax, %rdi
leaq 0x2cc9(%rip), %rsi      # 0x4004
callq 0x10c0
leaq -0x20(%rbp), %rdi
callq 0x1b10
jmp 0x1301
movq 0x5c86(%rip), %rdi      # 0x6fd8
movq 0x5c6f(%rip), %rsi      # 0x6fc8
callq 0x10f0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x178a0
movl %eax, %ecx
movl (%rsp), %eax
cmpl %ecx, %eax
jge 0x134bb
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x17960
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x17990
cmpl $0x0, %eax
je 0x134ac
movl $0x0, 0x24(%rsp)
jmp 0x134e2
jmp 0x134ae
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x13461
movq 0x18(%rsp), %rdi
callq 0x39130
movl %eax, 0x4(%rsp)
cmpl $0x1, 0x4(%rsp)
je 0x134da
movl $0x0, 0x24(%rsp)
jmp 0x134e2
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/msh2df/msh2df.cpp
// Function: WriteGrid(gaps::R3Grid*, char const*)
static int 
WriteGrid(R3Grid *grid, const char *filename)
{
  // Start statistics
  RNTime start_time;
  start_time.Read();

  // Write grid
  if (!grid->WriteFile(filename)) return 0;

  // Print statistics
  if (print_verbose) {
    printf("Wrote grid ...\n");
    printf("  Time = %.2f seconds\n", start_time.Elapsed());
    printf("  # MBytes = %g\n", (double) (grid->NEntries() * sizeof(RNScalar)) / (1024.0 * 1024.0));
    fflush(stdout);
  }

  // Return success
  return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rsp, %rdi
callq 0xddf30
movq %rsp, %rdi
callq 0x17860
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x8a2b0
cmpl $0x0, %eax
jne 0x15ddf
movl $0x0, 0x24(%rsp)
jmp 0x15e78
cmpl $0x0, 0x170812(%rip)    # 0x1865f8
je 0x15e70
leaq 0x12a740(%rip), %rdi    # 0x140533
xorl %eax, %eax
callq 0xf070
movq %rsp, %rdi
callq 0xddff0
leaq 0x12a41a(%rip), %rdi    # 0x140223
movb $0x1, %al
callq 0xf070
movq 0x18(%rsp), %rdi
callq 0x184a0
cltq
shlq $0x3, %rax
movq %rax, %xmm0
movaps 0x12a244(%rip), %xmm1   # 0x140070
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x12a248(%rip), %xmm1   # 0x140080
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0x12a1f1(%rip), %xmm1   # 0x140040
divsd %xmm1, %xmm0
leaq 0x12a6e9(%rip), %rdi    # 0x140543
movb $0x1, %al
callq 0xf070
movq 0x167128(%rip), %rax    # 0x17cf90
movq (%rax), %rdi
callq 0xf5d0
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)