LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/qmmlib[P]QmmLibrary/train.c
// Function: readline(_IO_FILE*, int)
static char* readline(FILE *input, int max_idx) 
{
	int len;
	
	if(fgets(line,max_line_len,input) == NULL)
		return NULL;

	while(strrchr(line,'\n') == NULL)
	{
		max_line_len *= 2;
		line = (char *) realloc(line,max_line_len);
		len = (int) strlen(line);
		if(fgets(line+len,max_line_len-len,input) == NULL)
			break;
	}

	if(max_idx>0 && (param.structured_w=='s' || param.structured_w=='a' || param.structured_w=='f')) 
	{
		int y;
		double * read_line = (double*) malloc(sizeof(double)*(max_idx+1));
		memset(read_line, 0, sizeof(double)*(max_idx+1));
		split(line, read_line, &y);
		transform_line(read_line,y,max_idx,line, param.structured_w,param.transform_matrix,param.tmx_r,param.tmx_c);
		free(read_line);
	}
	
	return line;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x168ad(%rip), %rdi     # 0x1b348
movl 0x168af(%rip), %esi     # 0x1b350
movq %r14, %rdx
callq 0x3380
testq %rax, %rax
je 0x4bba
movq 0x1688f(%rip), %r15     # 0x1b348
movq %r15, %rdi
movl $0xa, %esi
callq 0x3230
testq %rax, %rax
jne 0x4b14
movslq 0x1687e(%rip), %r12     # 0x1b350
addq %r12, %r12
movl %r12d, 0x16874(%rip)    # 0x1b350
movq %r15, %rdi
movq %r12, %rsi
callq 0x33c0
movq %rax, %r15
movq %rax, 0x16857(%rip)     # 0x1b348
movq %rax, %rdi
callq 0x30e0
cltq
addq %rax, %r15
subl %eax, %r12d
movq %r15, %rdi
movl %r12d, %esi
movq %r14, %rdx
callq 0x3380
testq %rax, %rax
jne 0x4ab2
testl %ebx, %ebx
jle 0x4bb1
movzbl 0x167a1(%rip), %eax     # 0x1b2c4
addl $-0x61, %eax
cmpl $0x12, %eax
ja 0x4bb1
movl $0x40021, %ecx          # imm = 0x40021
btl %eax, %ecx
jae 0x4bb1
movl %ebx, %eax
leaq 0x8(,%rax,8), %r15
movq %r15, %rdi
callq 0x32e0
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x3110
movq 0x167e6(%rip), %rdi     # 0x1b348
leaq 0x4(%rsp), %r15
movq %r14, %rsi
movq %r15, %rdx
callq 0x14ef2
movl (%r15), %esi
movq 0x167cc(%rip), %rcx     # 0x1b348
movsbl 0x16740(%rip), %r8d     # 0x1b2c4
movq 0x1673d(%rip), %r9      # 0x1b2c8
movl 0x1673f(%rip), %eax     # 0x1b2d0
movl 0x1673c(%rip), %r10d    # 0x1b2d4
movq %r14, %rdi
movl %ebx, %edx
pushq %r10
pushq %rax
callq 0x1509c
addq $0x10, %rsp
movq %r14, %rdi
callq 0x3280
movq 0x16790(%rip), %rax     # 0x1b348
jmp 0x4bbc
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/qmmlib[P]QmmLibrary/train.c
// Function: endofline(_IO_FILE*)
int endofline(FILE *ifp)
{
	int c = fgetc(ifp);
	int d = c;
    int eol = (c == '\r' || c == '\n');
    if (c == '\r')
    {
        c = getc(ifp);
        if (c != '\n' && c != EOF)
            ungetc(c, ifp);
    }
    return(eol);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x3370
movl %eax, %ebx
cmpl $0xd, %eax
jne 0x4bf7
movq %r14, %rdi
callq 0x30b0
cmpl $-0x1, %eax
je 0x4bf7
cmpl $0xa, %eax
je 0x4bf7
movl %eax, %edi
movq %r14, %rsi
callq 0x3080
cmpl $0xd, %ebx
sete %al
cmpl $0xa, %ebx
sete %cl
orb %al, %cl
movzbl %cl, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/qmmlib[P]QmmLibrary/tron.cpp
// Function: TRON::TRON(function const*, double, int)
TRON::TRON(const function *fun_obj, double eps, int max_iter)
{
	this->fun_obj=const_cast<function *>(fun_obj);
	this->eps=eps;
	this->max_iter=max_iter;
	tron_print_string = default_print;
}

// Assembly:
movq %rsi, 0x10(%rdi)
movsd %xmm0, (%rdi)
movl %edx, 0x8(%rdi)
leaq 0x5(%rip), %rax         # 0x4e05
movq %rax, 0x18(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/qmmlib[P]QmmLibrary/tron.cpp
// Function: TRON::norm_inf(int, double*)
double TRON::norm_inf(int n, double *x)
{
	double dmax = fabs(x[0]);
	for (int i=1; i<n; i++)
		if (fabs(x[i]) >= dmax)
			dmax = fabs(x[i]);
	return(dmax);
}

// Assembly:
movsd (%rdx), %xmm1
andpd 0x11730(%rip), %xmm1    # 0x170f0
cmpl $0x2, %esi
jl 0x59ff
movl %esi, %eax
movl $0x1, %ecx
movapd 0x1171c(%rip), %xmm2    # 0x170f0
movapd %xmm1, %xmm0
movsd (%rdx,%rcx,8), %xmm3
andpd %xmm2, %xmm3
cmplesd %xmm3, %xmm0
andpd %xmm0, %xmm3
andnpd %xmm1, %xmm0
orpd %xmm3, %xmm0
incq %rcx
movapd %xmm0, %xmm1
cmpq %rcx, %rax
jne 0x59d8
retq
movapd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/qmmlib[P]QmmLibrary/linear.cpp
// Function: l2r_lr_fun::l2r_lr_fun(problem const*, double*)
l2r_lr_fun::l2r_lr_fun(const problem *prob, double *C)
{
	int l=prob->l;

	this->prob = prob;

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x150b2(%rip), %rax     # 0x1aad0
movq %rax, (%rdi)
movslq (%rsi), %rax
leaq (,%rax,8), %rcx
testq %rax, %rax
movq %rsi, 0x20(%rdi)
movq $-0x1, %r15
cmovnsq %rcx, %r15
movq %r15, %rdi
callq 0x3030
movq %rax, 0x10(%r14)
movq %r15, %rdi
callq 0x3030
movq %rax, 0x18(%r14)
movq %rbx, 0x8(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/qmmlib[P]QmmLibrary/linear.cpp
// Function: l2r_lr_fun::fun(double*)
double l2r_lr_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++)
	{
		double yz = y[i]*z[i];
		if (yz >= 0)
			f += C[i]*log(1 + exp(-yz));
		else
			f += C[i]*(-yz+log(1 + exp(yz)));
	}

	return(f);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x20(%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 0x5bba
testl %ebp, %ebp
jle 0x5b06
movl %ebp, %eax
xorpd %xmm1, %xmm1
xorl %ecx, %ecx
movsd (%r14,%rcx,8), %xmm0
mulsd %xmm0, %xmm0
addsd %xmm0, %xmm1
incq %rcx
cmpq %rcx, %rax
jne 0x5ae6
mulsd 0x115cc(%rip), %xmm1    # 0x170d0
jmp 0x5b0a
xorpd %xmm1, %xmm1
testl %r12d, %r12d
jle 0x5ba9
xorl %r14d, %r14d
movsd %xmm1, 0x8(%rsp)
movsd (%r15,%r14,8), %xmm0
movq 0x10(%rbx), %rax
mulsd (%rax,%r14,8), %xmm0
ucomisd 0x104dc(%rip), %xmm0    # 0x16010
jae 0x5b65
movq 0x8(%rbx), %rax
movsd (%rax,%r14,8), %xmm1
movsd %xmm1, (%rsp)
movapd %xmm0, 0x10(%rsp)
callq 0x33f0
addsd 0x11710(%rip), %xmm0    # 0x17268
callq 0x3190
subsd 0x10(%rsp), %xmm0
jmp 0x5b8e
movq 0x8(%rbx), %rax
movsd (%rax,%r14,8), %xmm1
movsd %xmm1, (%rsp)
xorpd 0x11584(%rip), %xmm0    # 0x17100
callq 0x33f0
addsd 0x116df(%rip), %xmm0    # 0x17268
callq 0x3190
mulsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
incq %r14
cmpq %r14, %r12
jne 0x5b16
movapd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/qmmlib[P]QmmLibrary/linear.cpp
// Function: l2r_lr_fun::Xv(double*, double*)
void l2r_lr_fun::Xv(double *v, double *Xv)
{
	int i;
	int l=prob->l;
	feature_node **x=prob->x;

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

// Assembly:
movq 0x20(%rdi), %rcx
movslq (%rcx), %rax
testq %rax, %rax
jle 0x5c18
movq 0x10(%rcx), %rcx
xorl %edi, %edi
movq (%rcx,%rdi,8), %r8
movq $0x0, (%rdx,%rdi,8)
movl (%r8), %r9d
cmpl $-0x1, %r9d
je 0x5c10
movsd (%rdx,%rdi,8), %xmm0
addq $0x10, %r8
movslq %r9d, %r9
movsd -0x8(%rsi,%r9,8), %xmm1
mulsd -0x8(%r8), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%rdx,%rdi,8)
movl (%r8), %r9d
addq $0x10, %r8
cmpl $-0x1, %r9d
jne 0x5bea
incq %rdi
cmpq %rax, %rdi
jne 0x5bcc
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/qmmlib[P]QmmLibrary/linear.cpp
// Function: l2r_lr_fun::grad(double*, double*)
void l2r_lr_fun::grad(double *w, double *g)
{
	int i;
	double *y=prob->y;
	int l=prob->l;
	int w_size=get_nr_variable();

	for(i=0;i<l;i++)
	{
		z[i] = 1/(1 + exp(-y[i]*z[i]));
		D[i] = z[i]*(1-z[i]);
		z[i] = C[i]*(z[i]-1)*y[i];
	}
	XTv(z, g);

	for(i=0;i<w_size;i++)
		g[i] = w[i] + 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 0x20(%rdi), %rcx
movq 0x8(%rcx), %r12
movslq (%rcx), %r13
callq *0x18(%rax)
movl %eax, 0x4(%rsp)
testq %r13, %r13
jle 0x5cc1
xorl %ebp, %ebp
movsd (%r12,%rbp,8), %xmm0
xorpd 0x114a8(%rip), %xmm0    # 0x17100
movq 0x10(%r15), %rax
mulsd (%rax,%rbp,8), %xmm0
callq 0x33f0
movsd 0x115fa(%rip), %xmm2    # 0x17268
addsd %xmm2, %xmm0
movapd %xmm2, %xmm1
divsd %xmm0, %xmm1
movq 0x10(%r15), %rax
movsd %xmm1, (%rax,%rbp,8)
movapd %xmm2, %xmm0
subsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
movq 0x18(%r15), %rcx
movsd %xmm0, (%rcx,%rbp,8)
movq 0x8(%r15), %rcx
movsd (%rax,%rbp,8), %xmm0
addsd 0x115c7(%rip), %xmm0    # 0x17270
mulsd (%rcx,%rbp,8), %xmm0
mulsd (%r12,%rbp,8), %xmm0
movsd %xmm0, (%rax,%rbp,8)
incq %rbp
cmpq %rbp, %r13
jne 0x5c4a
movq 0x10(%r15), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x5d04
movl 0x4(%rsp), %eax
testl %eax, %eax
jle 0x5cf4
movl %eax, %eax
xorl %ecx, %ecx
movsd (%r14,%rcx,8), %xmm0
addsd (%rbx,%rcx,8), %xmm0
movsd %xmm0, (%rbx,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x5cdc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/qmmlib[P]QmmLibrary/linear.cpp
// Function: l2r_lr_fun::XTv(double*, double*)
void l2r_lr_fun::XTv(double *v, double *XTv)
{
	int i;
	int l=prob->l;
	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<l;i++)
	{
		feature_node *s=x[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
movq 0x20(%rdi), %rcx
movl (%rcx), %r12d
callq *0x18(%rax)
movq 0x20(%r15), %rcx
movq 0x10(%rcx), %r15
testl %eax, %eax
jle 0x5d3e
movl %eax, %edx
shlq $0x3, %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3110
testl %r12d, %r12d
jle 0x5d81
xorl %eax, %eax
movq (%r15,%rax,8), %rcx
movl (%rcx), %edx
cmpl $-0x1, %edx
je 0x5d79
addq $0x10, %rcx
movsd (%r14,%rax,8), %xmm0
movslq %edx, %rdx
mulsd -0x8(%rcx), %xmm0
addsd -0x8(%rbx,%rdx,8), %xmm0
movsd %xmm0, -0x8(%rbx,%rdx,8)
movl (%rcx), %edx
addq $0x10, %rcx
cmpl $-0x1, %edx
jne 0x5d54
incq %rax
cmpq %r12, %rax
jne 0x5d45
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/qmmlib[P]QmmLibrary/linear.cpp
// Function: l2r_lr_fun::Hv(double*, double*)
void l2r_lr_fun::Hv(double *s, double *Hs)
{
	int i;
	int l=prob->l;
	int w_size=get_nr_variable();
	double *wa = new double[l];

	Xv(s, wa);
	for(i=0;i<l;i++)
		wa[i] = C[i]*D[i]*wa[i];

	XTv(wa, Hs);
	for(i=0;i<w_size;i++)
		Hs[i] = s[i] + 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
movq 0x20(%rdi), %rcx
movslq (%rcx), %r13
callq *0x18(%rax)
movl %eax, %ebp
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 0x5bba
testq %r13, %r13
jle 0x5e14
movq 0x8(%r12), %rax
movq 0x18(%r12), %rcx
xorl %edx, %edx
movsd (%rax,%rdx,8), %xmm0
mulsd (%rcx,%rdx,8), %xmm0
mulsd (%r15,%rdx,8), %xmm0
movsd %xmm0, (%r15,%rdx,8)
incq %rdx
cmpq %rdx, %r13
jne 0x5df6
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x5d04
testl %ebp, %ebp
jle 0x5e42
movl %ebp, %eax
xorl %ecx, %ecx
movsd (%r14,%rcx,8), %xmm0
addsd (%rbx,%rcx,8), %xmm0
movsd %xmm0, (%rbx,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x5e2a
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x32c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x14ca3(%rip), %rax     # 0x1ab10
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_O1/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 0x5fa2
testl %ebp, %ebp
jle 0x5f42
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 0x5f22
mulsd 0x11190(%rip), %xmm0    # 0x170d0
jmp 0x5f46
xorpd %xmm0, %xmm0
testl %r12d, %r12d
jle 0x5f98
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
xorl %edx, %edx
movsd 0x1130b(%rip), %xmm1    # 0x17268
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 0x5f90
movsd (%rax,%rdx,8), %xmm4
mulsd %xmm3, %xmm4
mulsd %xmm3, %xmm4
addsd %xmm4, %xmm0
incq %rdx
cmpq %rdx, %r12
jne 0x5f61
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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)
testq %r13, %r13
jle 0x608a
movq 0x8(%r15), %rax
movq 0x10(%r15), %rcx
movq 0x20(%r15), %rdx
xorl %esi, %esi
movsd 0x1121c(%rip), %xmm0    # 0x17268
movsd 0x1121c(%rip), %xmm1    # 0x17270
movsd (%rcx,%rsi,8), %xmm2
ucomisd %xmm2, %xmm0
jbe 0x6082
movsd (%rax,%rsi,8), %xmm3
mulsd (%r12,%rsi,8), %xmm3
addsd %xmm1, %xmm2
mulsd %xmm3, %xmm2
movslq 0x28(%r15), %rdi
movsd %xmm2, (%rcx,%rdi,8)
movl %esi, (%rdx,%rdi,4)
incl 0x28(%r15)
incq %rsi
cmpq %rsi, %r13
jne 0x6054
movq 0x10(%r15), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x60cc
testl %ebp, %ebp
jle 0x60bd
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 0x60a1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x60ff
movl %eax, %edx
shlq $0x3, %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3110
movslq 0x28(%r15), %rax
testq %rax, %rax
jle 0x614e
movq 0x20(%r15), %rcx
xorl %edx, %edx
movslq (%rcx,%rdx,4), %rsi
movq (%r12,%rsi,8), %rsi
movl (%rsi), %edi
cmpl $-0x1, %edi
je 0x6146
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 0x6121
incq %rdx
cmpq %rax, %rdx
jne 0x610e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6226
testq %r13, %r13
jle 0x61dd
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 0x61c0
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x60cc
testl %ebp, %ebp
jle 0x620f
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 0x61f3
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x32c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6290
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 0x6288
movsd (%rdx,%r8,8), %xmm0
addq $0x10, %r9
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 0x6261
incq %r8
cmpq %rax, %r8
jne 0x623e
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5fa2
testl %ebp, %ebp
jle 0x631c
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 0x62fc
mulsd 0x10db6(%rip), %xmm0    # 0x170d0
jmp 0x6320
xorpd %xmm0, %xmm0
testl %r12d, %r12d
jle 0x637a
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
movsd 0x38(%rbx), %xmm1
movapd 0x10dc6(%rip), %xmm2    # 0x17100
xorpd %xmm1, %xmm2
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm3
subsd (%r15,%rdx,8), %xmm3
ucomisd %xmm3, %xmm2
jbe 0x6357
addsd %xmm1, %xmm3
jmp 0x6361
ucomisd %xmm1, %xmm3
jbe 0x6372
subsd %xmm1, %xmm3
movsd (%rax,%rdx,8), %xmm4
mulsd %xmm3, %xmm4
mulsd %xmm3, %xmm4
addsd %xmm4, %xmm0
incq %rdx
cmpq %rdx, %r12
jne 0x6340
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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)
testq %r13, %r13
jle 0x641a
movq 0x8(%r15), %rax
movq 0x10(%r15), %rcx
movq 0x20(%r15), %rdx
xorl %esi, %esi
movapd 0x10d32(%rip), %xmm0    # 0x17100
movsd (%rcx,%rsi,8), %xmm1
subsd (%r12,%rsi,8), %xmm1
movsd 0x38(%r15), %xmm2
movapd %xmm2, %xmm3
xorpd %xmm0, %xmm3
ucomisd %xmm1, %xmm3
jbe 0x63f3
addsd %xmm2, %xmm1
jmp 0x63fd
ucomisd %xmm2, %xmm1
jbe 0x6412
subsd %xmm2, %xmm1
mulsd (%rax,%rsi,8), %xmm1
movslq 0x28(%r15), %rdi
movsd %xmm1, (%rcx,%rdi,8)
movl %esi, (%rdx,%rdi,4)
incl 0x28(%r15)
incq %rsi
cmpq %rsi, %r13
jne 0x63ce
movq 0x10(%r15), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x60cc
testl %ebp, %ebp
jle 0x644d
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 0x6431
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x12926
movq %rbx, %rdi
callq 0x133e1
movq %rbx, %rdi
popq %rbx
jmp 0x3280
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movsd 0xc8(%rdi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movl 0xb0(%rdi), %esi
movl 0xb4(%rdi), %ebp
sbbl $-0x1, %ebp
cmpq $0x2, %rsi
jne 0x1296c
movl $0x1, %r13d
cmpl $0x4, (%rdi)
jne 0x1296f
movl %esi, %r13d
movq 0xb8(%rdi), %rbx
movl %r13d, %r12d
testl %r13d, %r13d
jle 0x129a4
leaq (,%r12,8), %rdx
movq %rdi, 0x10(%rsp)
movq %r14, %rdi
movq %rsi, 0x8(%rsp)
xorl %esi, %esi
callq 0x3110
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
movl (%r15), %eax
cmpl $-0x1, %eax
je 0x129f2
testl %r13d, %r13d
setle %cl
cmpl %ebp, %eax
setg %dl
orb %cl, %dl
jne 0x129e8
decl %eax
imull %r13d, %eax
cltq
leaq (%rbx,%rax,8), %rax
xorl %ecx, %ecx
movsd (%rax,%rcx,8), %xmm0
mulsd 0x8(%r15), %xmm0
addsd (%r14,%rcx,8), %xmm0
movsd %xmm0, (%r14,%rcx,8)
incq %rcx
cmpq %rcx, %r12
jne 0x129c9
movl 0x10(%r15), %eax
addq $0x10, %r15
jmp 0x129a7
cmpl $0x2, %esi
jne 0x12a18
movl (%rdi), %eax
addl $-0xb, %eax
movsd (%r14), %xmm0
cmpl $0x3, %eax
jb 0x12a58
xorpd %xmm1, %xmm1
xorl %eax, %eax
ucomisd %xmm1, %xmm0
setbe %al
shll $0x2, %eax
jmp 0x12a4a
xorl %eax, %eax
cmpl $0x2, %esi
jl 0x12a46
movl $0x1, %ecx
movsd (%r14,%rcx,8), %xmm0
movslq %eax, %rdx
ucomisd (%r14,%rdx,8), %xmm0
movl %ecx, %edx
ja 0x12a39
movl %eax, %edx
incq %rcx
movl %edx, %eax
cmpq %rcx, %rsi
jne 0x12a24
movslq %edx, %rax
shlq $0x2, %rax
addq 0xc0(%rdi), %rax
xorps %xmm0, %xmm0
cvtsi2sdl (%rax), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x133f6
callq 0x3280
movq 0xc0(%rbx), %rdi
testq %rdi, %rdi
je 0x13408
popq %rbx
jmp 0x3280
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1341f
callq 0x3280
movq 0xa0(%rbx), %rdi
testq %rdi, %rdi
je 0x13431
popq %rbx
jmp 0x3280
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x32d0
movq %rax, %r15
movq (%r13), %rsi
movq %r13, (%rsp)
movq %r13, %rdi
callq 0x154e4
cmpq $-0x1, %r15
je 0x14e59
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 0x3220
movq (%rsp), %rdi
movq %r13, %rsi
callq 0x155c6
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x14e34
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3210
leaq 0x1(%rbx), %r12
movq %r14, %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0x32d0
movq %rax, %r15
movq %rbx, %rax
notq %rax
cmpq $-0x1, %r15
jne 0x14df4
negq %rbx
jmp 0x14e5e
movl $0x1, %ebx
addq 0x8(%r14), %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x3220
movq (%rsp), %rdi
movq %r15, %rsi
callq 0x155c6
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x14e9f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3210
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 0x14ed8
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x14eea
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3210
movq %rbx, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x68, %rsp
movq %rdx, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdi, %rsi
movabsq $0x400000000002600, %rax # imm = 0x400000000002600
movq %rdi, %rcx
movzbl (%rcx), %edx
cmpq $0x3a, %rdx
ja 0x14f2c
btq %rdx, %rax
jae 0x14f31
movb $0x20, (%rcx)
incq %rcx
jmp 0x14f1a
testq %rdx, %rdx
jne 0x14f2c
xorpd %xmm0, %xmm0
movapd %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x153ba
leaq 0x48(%rsp), %rdi
movq %rsp, %rsi
movl $0x20, %edx
callq 0x14dac
movq (%rsp), %rax
cmpq %rax, 0x8(%rsp)
je 0x15035
xorl %r12d, %r12d
movl $0x8, %r13d
leaq 0x38(%rsp), %rbp
leaq 0x28(%rsp), %r15
xorl %r14d, %r14d
xorl %ebx, %ebx
movq %rbp, 0x28(%rsp)
movq -0x8(%rax,%r13), %rsi
movq (%rax,%r13), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x15454
movq %r15, %rdi
movl $0x20, %esi
xorl %edx, %edx
callq 0x31d0
cmpq $-0x1, %rax
je 0x14ffe
testb $0x1, %bl
je 0x14fd9
movq 0x28(%rsp), %rdi
callq 0x32a0
testl %r14d, %r14d
jne 0x14fee
cvttsd2si %xmm0, %r14d
jmp 0x14ffe
movq 0x28(%rsp), %rdi
callq 0x3350
movq 0x20(%rsp), %rcx
movl %eax, (%rcx)
movb $0x1, %bl
jmp 0x14ffe
movslq %r14d, %rax
movq 0x18(%rsp), %rcx
movsd %xmm0, (%rcx,%rax,8)
xorl %r14d, %r14d
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x15015
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3210
incq %r12
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
addq $0x20, %r13
cmpq %r12, %rcx
ja 0x14f90
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x15050
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x3210
movq %rsp, %rdi
callq 0x153f8
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1506e
movq %rax, %rbx
jmp 0x1508c
movq %rax, %rbx
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1508c
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x3210
movq %rsp, %rdi
callq 0x153f8
movq %rbx, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x11ff0(%rip), %r15     # 0x1c420
testq %r15, %r15
je 0xa519
leaq -0x48(%rbp), %r12
leaq 0x8(%r15), %r13
leaq 0x11f20(%rip), %rdi     # 0x1c368
movq %r13, %rsi
callq 0xb30c
movq (%rax), %rbx
leaq 0x12026(%rip), %rdi     # 0x1c480
movq %r13, %rsi
callq 0xb5dc
movl (%rax), %r14d
movl 0xc(%r15), %esi
leaq 0xa1aa(%rip), %rdi      # 0x1461a
xorl %eax, %eax
callq 0x4050
testl %r14d, %r14d
je 0xa4b1
leaq 0xa19f(%rip), %rdi      # 0x14622
movl %r14d, %esi
xorl %eax, %eax
callq 0x4050
leaq 0xa1db(%rip), %rdi      # 0x1466f
callq 0x4330
leaq 0xa1d8(%rip), %rdi      # 0x14678
callq 0x4330
leaq 0xa1d1(%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 0xad1e
movl (%r13), %edx
movq %rbx, %rdi
movq %r12, %rsi
movl $0x3e6, %ecx            # imm = 0x3E6
movl $0x3e6, %r8d            # imm = 0x3E6
callq 0xe98e
leaq 0xa174(%rip), %rdi      # 0x14662
callq 0x4330
leaq 0xa170(%rip), %rdi      # 0x1466a
callq 0x4330
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0xa50d
callq 0x41e0
movq (%r15), %r15
testq %r15, %r15
jne 0xa43d
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 0xa539
callq 0x41e0
movq %rbx, %rdi
callq 0x43b0
// File: /workspace/github_cpp_makefile_star2_O1/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, %ebx
leaq -0x2c(%rbp), %rsi
movl %edi, (%rsi)
leaq 0xfcb0(%rip), %rdi      # 0x1c448
callq 0xc456
movq %rax, %r15
movq 0x18(%rax), %r12
addq $0x8, %r15
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %r15, %r12
je 0xc872
leaq 0x20(%r12), %r13
cmpl %ebx, 0x24(%r12)
jne 0xc7ed
leaq 0xfc7f(%rip), %rdi      # 0x1c448
leaq -0x2c(%rbp), %rsi
callq 0xc456
movq %rax, %r14
movq %rax, %rdi
movq %r13, %rsi
callq 0x115a0
movq %r14, %rdi
movq %rax, %rsi
callq 0x1167e
jmp 0xc84a
movb $0x1, %al
jle 0xc850
leaq 0xfc50(%rip), %rdi      # 0x1c448
leaq -0x2c(%rbp), %rsi
callq 0xc456
movq %rax, %r14
movq %rax, %rdi
movq %r13, %rsi
callq 0x115a0
movq %r14, %rdi
movq %rax, %rsi
callq 0x1167e
leaq 0xfc27(%rip), %rdi      # 0x1c448
leaq -0x2c(%rbp), %rsi
callq 0xc456
movl 0x20(%r12), %ecx
addl %ebx, %ecx
movl 0x24(%r12), %edx
subl %ebx, %edx
movl %ecx, -0x34(%rbp)
movl %edx, -0x30(%rbp)
movq %rax, %rdi
leaq -0x34(%rbp), %rsi
callq 0x11700
movl (%r13), %r14d
xorl %eax, %eax
testb %al, %al
je 0xc86f
movq %r12, %rdi
callq 0x4270
movq %rax, %r12
cmpq %r15, %rax
jne 0xc7b6
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0xc872
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xfbdb(%rip), %rdi      # 0x1c480
movq %rax, %rsi
callq 0xb5dc
leaq 0x8(%rax), %rdi
movq %rbx, %rsi
callq 0x11870
movq 0x10(%rax), %rbx
testq %rbx, %rbx
je 0xc94f
leaq -0x30(%rbp), %r14
leaq -0x50(%rbp), %r15
leaq 0xfb73(%rip), %r12      # 0x1c448
leaq -0x38(%rbp), %r13
movl -0x34(%rbp), %eax
movl %eax, -0x30(%rbp)
movl 0x8(%rbx), %eax
movl %eax, -0x2c(%rbp)
leaq 0xfbdc(%rip), %rdi      # 0x1c4c8
movq %r14, %rsi
callq 0x10bf4
movq %r15, %rdi
movq %rax, %rsi
callq 0x10c84
movq -0x50(%rbp), %rcx
movq -0x48(%rbp), %rdx
movl $0x1, %eax
cmpq %rdx, %rcx
je 0xc91a
imull (%rcx), %eax
addq $0x4, %rcx
jmp 0xc90c
movl 0xc(%rbx), %ecx
movl %ecx, -0x30(%rbp)
movl %eax, -0x2c(%rbp)
movq %r12, %rdi
movq %r13, %rsi
callq 0xc456
movq %rax, %rdi
movq %r14, %rsi
callq 0x11e60
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0xc947
callq 0x41e0
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0xc8d9
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 0xc96f
callq 0x41e0
movq %rbx, %rdi
callq 0x43b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7f64(%rip), %rdi      # 0x14b1f
callq 0x4330
leaq 0x7ab1(%rip), %rax      # 0x14678
leaq 0x7f59(%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 0xf91c
// File: /workspace/github_cpp_makefile_star2_O1/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 0xeeb8(%rip), %rax      # 0x1bad0
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 0xcc58
callq 0x896e
addq $0x10, %r15
cmpq $0x20, %r15
jne 0xcc34
movl $0x20, %r15d
movq -0x48(%rbp,%r15), %rdi
testq %rdi, %rdi
je 0xcc77
callq 0x896e
addq $-0x10, %r15
jne 0xcc68
movq (%r14), %rsi
movq (%rsi), %rax
movq %rax, 0x18(%rbx)
leaq 0x20(%rbx), %rdi
addq $0x8, %rsi
callq 0x114dc
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
cmpq $0x20, %rax
jne 0xccbc
movq 0x10(%rsi), %rax
movq %rax, 0x28(%rbx)
addq $0x30, %rbx
addq $0x18, %rsi
movq %rbx, %rdi
callq 0x114dc
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %rbx
movl %edx, %r15d
movq %rsi, %r12
movq (%rcx), %rdi
testq %rdi, %rdi
je 0xd29b
leaq 0xe6c8(%rip), %rsi      # 0x1b950
leaq 0xea59(%rip), %rdx      # 0x1bce8
xorl %ecx, %ecx
callq 0x4250
movq %rax, %r14
jmp 0xd29e
xorl %r14d, %r14d
testq %r14, %r14
je 0xd2bd
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
je 0xd2c8
movq 0xed0d(%rip), %rax      # 0x1bfc0
cmpb $0x0, (%rax)
je 0xd2c4
incl 0x8(%rbx)
jmp 0xd2c8
xorl %ebx, %ebx
xorl %r14d, %r14d
jmp 0xd2c8
lock
incl 0x8(%rbx)
testq %r14, %r14
je 0xd31a
cmpb $0x0, 0xd(%r14)
jne 0xd31a
movq 0x18(%r14), %r13
subq 0x10(%r14), %r13
movq %r14, %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0xd3b6
movl 0x8(%r14), %ecx
leaq -0x30(%rbp), %rsi
movl %eax, (%rsi)
movl %ecx, 0x4(%rsi)
leaq 0xf1ca(%rip), %rdi      # 0x1c4c8
callq 0x10bf4
shrq $0x4, %r13
movslq %r13d, %rcx
movq 0x8(%rax), %rdx
subq (%rax), %rdx
sarq $0x2, %rdx
cmpq %rcx, %rdx
jne 0xd336
testq %rbx, %rbx
je 0xd327
movq %rbx, %rdi
callq 0x896e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xecb3(%rip), %rdi      # 0x1bff0
leaq 0x74c7(%rip), %rsi      # 0x1480b
movl $0x1b, %edx
callq 0x4260
movslq 0x8(%r14), %rax
leaq 0xefd7(%rip), %rcx      # 0x1c330
movq (%rcx), %rcx
shlq $0x5, %rax
movq (%rcx,%rax), %rsi
movq 0x8(%rcx,%rax), %rdx
movq 0xec80(%rip), %rdi      # 0x1bff0
callq 0x4260
movq %rax, %rdi
callq 0x4120
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x42a0
jmp 0xd38b
jmp 0xd38b
movq %rax, %r14
testq %rbx, %rbx
je 0xd39b
movq %rbx, %rdi
callq 0x896e
movq %r14, %rdi
callq 0x43b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpb $0x1, 0xc(%rdi)
jne 0xd3c3
movl 0xf102(%rip), %eax      # 0x1c4c4
retq
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rsi), %r13
subq (%rsi), %r13
addq $0x8, %r15
addq $-0x4, %r13
leaq 0xefb1(%rip), %r12      # 0x1c3a0
movq (%r14), %rsi
addq %r13, %rsi
movq %r12, %rdi
callq 0xbe56
movq %rax, %rdi
movq %r15, %rsi
callq 0x12038
movq %rax, %rcx
movq (%r14), %rax
movl (%rax,%r13), %eax
testq %rcx, %rcx
jne 0xd424
addq $-0x4, %r13
cmpl %ebx, %eax
jne 0xd3ef
movl $0x7d0, %eax            # imm = 0x7D0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xf3b5
sarq $0x4, %rsi
leaq -0x29(%rbp), %rdx
movq %rdi, -0x38(%rbp)
callq 0x10e54
movq 0x10(%rbx), %r13
movq %rbx, -0x40(%rbp)
movq 0x18(%rbx), %rbx
cmpq %rbx, %r13
je 0xf3af
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 0xf364
movq 0xcc6c(%rip), %rax      # 0x1bfc0
cmpb $0x0, (%rax)
je 0xf35f
incl 0x8(%r14)
jmp 0xf364
lock
incl 0x8(%r14)
testq %r12, %r12
je 0xf380
movq %r12, %rdi
callq 0xd9d8
cmpb $0x0, 0x14(%r12)
je 0xf3d5
movl 0x10(%r12), %eax
jmp 0xf382
xorl %eax, %eax
movq -0x48(%rbp), %rcx
movl %eax, (%rcx,%r15)
testq %r14, %r14
je 0xf397
movq %r14, %rdi
callq 0x896e
leaq (,%r15,4), %rax
addq %r13, %rax
addq $0x4, %r15
addq $0x10, %rax
cmpq %rbx, %rax
jne 0xf33e
movq -0x38(%rbp), %rax
jmp 0xf3c6
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 0xcc14(%rip), %rdi      # 0x1bff0
leaq 0x5720(%rip), %rsi      # 0x14b03
movl $0x16, %edx
callq 0x4260
movq -0x40(%rbp), %rax
movslq 0x8(%rax), %rax
leaq 0xcf34(%rip), %rcx      # 0x1c330
movq (%rcx), %rcx
shlq $0x5, %rax
movq (%rcx,%rax), %rsi
movq 0x8(%rcx,%rax), %rdx
movq 0xcbdd(%rip), %rdi      # 0x1bff0
callq 0x4260
movq %rax, %rdi
callq 0x4120
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x42a0
jmp 0xf42c
movq %rax, %r15
testq %r14, %r14
je 0xf43c
movq %r14, %rdi
callq 0x896e
movq -0x38(%rbp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0xf44d
callq 0x41e0
movq %r15, %rdi
callq 0x43b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xf4f3
movq 0xcb08(%rip), %rbx      # 0x1bfc8
leaq 0x5342(%rip), %rsi      # 0x14809
movl $0x1, %edx
movq %rbx, %rdi
callq 0x4260
movslq (%r14), %rax
leaq 0xce52(%rip), %rcx      # 0x1c330
movq (%rcx), %rcx
shlq $0x5, %rax
movq (%rcx,%rax), %rsi
movq 0x8(%rcx,%rax), %rdx
movq %rbx, %rdi
jmp 0xf54d
movl %r8d, %r12d
movl %ecx, %r13d
movq %rdi, %r15
cmpl $0x8, %eax
jg 0xf574
movq 0x18(%r15), %rax
movq -0x10(%rax), %rdi
movq (%rdi), %rax
movl %r13d, %ecx
movl %r12d, %r8d
callq *(%rax)
movq 0xcaad(%rip), %r14      # 0x1bfc8
leaq 0x52e7(%rip), %rsi      # 0x14809
movl $0x1, %edx
movq %r14, %rdi
callq 0x4260
movslq 0x8(%r15), %rax
leaq 0xcdf6(%rip), %rcx      # 0x1c330
movq (%rcx), %rcx
shlq $0x5, %rax
movq (%rcx,%rax), %rsi
movq 0x8(%rcx,%rax), %rdx
movq %r14, %rdi
callq 0x4260
leaq 0x4cbc(%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 0xf5b4
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 0xf58d
leaq 0xce55(%rip), %rdi      # 0x1c410
movq -0x30(%rbp), %rsi
callq 0x12922
movl (%rax), %esi
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rdx
subq 0x10(%rax), %rdx
shrq $0x4, %rdx
leaq 0x5388(%rip), %rdi      # 0x14965
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4050