LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: cjlin1[P]liblinear/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();
	feature_node **x=prob->x;

	for(i=0;i<w_size;i++)
		Hs[i]=0;
	for(i=0;i<sizeI;i++)
	{
		feature_node * const xi=x[I[i]];
		double xTs = sparse_operator::dot(s, xi);

		xTs = C[I[i]]*xTs;

		sparse_operator::axpy(xTs, xi, Hs);
	}
	for(i=0;i<w_size;i++)
		Hs[i] = s[i] + 2*Hs[i];
	if(regularize_bias == 0)
		Hs[w_size-1] -= s[w_size-1];
}

// 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 (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ecx
movq -0x40(%rbp), %rax
movl %ecx, -0x20(%rbp)
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x5721
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 0x56fe
movl $0x0, -0x1c(%rbp)
movq -0x40(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x40(%rcx), %eax
jge 0x57a2
movq -0x40(%rbp), %rcx
movq -0x28(%rbp), %rax
movq 0x38(%rcx), %rcx
movslq -0x1c(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x11520
movq -0x40(%rbp), %rcx
movsd %xmm0, -0x38(%rbp)
movq 0x8(%rcx), %rax
movq 0x38(%rcx), %rcx
movslq -0x1c(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movsd (%rax,%rcx,8), %xmm0
mulsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x11590
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5728
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x57eb
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 0x57a9
movq -0x40(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x5822
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: cjlin1[P]liblinear/linear.cpp
// Function: l2r_l2_svr_fun::C_times_loss(int, double)
double l2r_l2_svr_fun::C_times_loss(int i, double wx_i)
{
	double d = wx_i - prob->y[i];
	if(d < -p)
		return C[i]*(d+p)*(d+p);
	else if(d > p)
		return C[i]*(d-p)*(d-p);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movsd -0x20(%rbp), %xmm0
movq 0x10(%rax), %rcx
movq 0x8(%rcx), %rcx
movslq -0x14(%rbp), %rdx
subsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm1
movsd 0x48(%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x592e
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rcx
movslq -0x14(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movsd -0x28(%rbp), %xmm1
addsd 0x48(%rax), %xmm1
mulsd %xmm1, %xmm0
movsd -0x28(%rbp), %xmm1
addsd 0x48(%rax), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x597c
movq -0x30(%rbp), %rax
movsd -0x28(%rbp), %xmm0
ucomisd 0x48(%rax), %xmm0
jbe 0x5972
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rcx
movslq -0x14(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movsd -0x28(%rbp), %xmm1
subsd 0x48(%rax), %xmm1
mulsd %xmm1, %xmm0
movsd -0x28(%rbp), %xmm1
subsd 0x48(%rax), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x597c
jmp 0x5974
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: cjlin1[P]liblinear/linear.cpp
// Function: Solver_MCSVM_CS::Solver_MCSVM_CS(problem const*, int, double*, double, int)
Solver_MCSVM_CS::Solver_MCSVM_CS(const problem *prob, int nr_class, double *weighted_C, double eps, int max_iter)
{
	this->w_size = prob->n;
	this->l = prob->l;
	this->nr_class = nr_class;
	this->eps = eps;
	this->max_iter = max_iter;
	this->prob = prob;
	this->B = new double[nr_class];
	this->G = new double[nr_class];
	this->C = weighted_C;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movsd %xmm0, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x1c(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x20(%rax)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, 0x28(%rax)
movl -0x2c(%rbp), %ecx
movl %ecx, 0x24(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x30(%rax)
movslq -0x14(%rbp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movslq -0x14(%rbp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: cjlin1[P]liblinear/linear.cpp
// Function: compare_double(void const*, void const*)
int compare_double(const void *a, const void *b)
{
	if(*(double *)a > *(double *)b)
		return -1;
	if(*(double *)a < *(double *)b)
		return 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x18(%rbp), %rax
ucomisd (%rax), %xmm0
jbe 0x5cc7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5ced
movq -0x10(%rbp), %rax
movsd (%rax), %xmm1
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x5ce6
movl $0x1, -0x4(%rbp)
jmp 0x5ced
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: cjlin1[P]liblinear/linear.cpp
// Function: Solver_MCSVM_CS::solve_sub_problem(double, int, double, int, double*)
void Solver_MCSVM_CS::solve_sub_problem(double A_i, int yi, double C_yi, int active_i, double *alpha_new)
{
	int r;
	double *D;

	clone(D, B, active_i);
	if(yi < active_i)
		D[yi] += A_i*C_yi;
	qsort(D, active_i, sizeof(double), compare_double);

	double beta = D[0] - A_i*C_yi;
	for(r=1;r<active_i && beta<r*D[r];r++)
		beta += D[r];
	beta /= r;

	for(r=0;r<active_i;r++)
	{
		if(r == yi)
			alpha_new[r] = min(C_yi, (beta-B[r])/A_i);
		else
			alpha_new[r] = min((double)0, (beta - B[r])/A_i);
	}
	delete[] D;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movsd %xmm1, -0x20(%rbp)
movl %edx, -0x24(%rbp)
movq %rcx, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq (%rax), %rsi
movl -0x24(%rbp), %edx
leaq -0x40(%rbp), %rdi
callq 0x5ed0
movl -0x14(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x5d63
movsd -0x10(%rbp), %xmm0
movsd -0x20(%rbp), %xmm2
movq -0x40(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq -0x40(%rbp), %rdi
movslq -0x24(%rbp), %rsi
movl $0x8, %edx
leaq -0xd7(%rip), %rcx       # 0x5ca0
callq 0x22b0
movq -0x40(%rbp), %rax
movsd (%rax), %xmm1
movsd -0x10(%rbp), %xmm0
movsd -0x20(%rbp), %xmm2
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movl $0x1, -0x34(%rbp)
movl -0x34(%rbp), %ecx
xorl %eax, %eax
cmpl -0x24(%rbp), %ecx
movb %al, -0x51(%rbp)
jge 0x5de7
movsd -0x48(%rbp), %xmm1
cvtsi2sdl -0x34(%rbp), %xmm0
movq -0x40(%rbp), %rax
movslq -0x34(%rbp), %rcx
mulsd (%rax,%rcx,8), %xmm0
ucomisd %xmm1, %xmm0
seta %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x5df0
jmp 0x5e12
movq -0x40(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
addsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x5db9
cvtsi2sdl -0x34(%rbp), %xmm1
movsd -0x48(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x5eab
movl -0x34(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x5e6f
movq -0x50(%rbp), %rax
movsd -0x20(%rbp), %xmm0
movsd -0x48(%rbp), %xmm1
movq (%rax), %rax
movslq -0x34(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm1
divsd -0x10(%rbp), %xmm1
callq 0x5f30
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0x5e9e
movq -0x50(%rbp), %rax
movsd -0x48(%rbp), %xmm1
movq (%rax), %rax
movslq -0x34(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm1
divsd -0x10(%rbp), %xmm1
xorps %xmm0, %xmm0
callq 0x5f30
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0x5ea0
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x5e2c
movq -0x40(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0x5ec2
movq -0x60(%rbp), %rdi
callq 0x21b0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: cjlin1[P]liblinear/linear.cpp
// Function: Solver_MCSVM_CS::be_shrunk(int, int, int, double, double)
bool Solver_MCSVM_CS::be_shrunk(int i, int m, int yi, double alpha_i, double minG)
{
	double bound = 0;
	if(m == yi)
		bound = C[GETI(i)];
	if(alpha_i == bound && G[m] < minG)
		return true;
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movsd %xmm0, -0x28(%rbp)
movsd %xmm1, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x5fc9
movq -0x40(%rbp), %rcx
movq 0x8(%rcx), %rax
movq 0x30(%rcx), %rcx
movq 0x8(%rcx), %rcx
movslq -0x14(%rbp), %rdx
cvttsd2si (%rcx,%rdx,8), %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x28(%rbp), %xmm0
ucomisd -0x38(%rbp), %xmm0
jne 0x5ff9
jp 0x5ff9
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movsd -0x30(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x5ff9
movb $0x1, -0x1(%rbp)
jmp 0x5ffd
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: cjlin1[P]liblinear/linear.cpp
// Function: predict
double predict(const model *model_, const feature_node *x)
{
	double *dec_values = Malloc(double, model_->nr_class);
	double label=predict_values(model_, x, dec_values);
	free(dec_values);
	return label;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movslq 0x50(%rax), %rdi
shlq $0x3, %rdi
callq 0x21c0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xac70
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2180
movsd -0x20(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: cjlin1[P]liblinear/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);
		*model_ptr_ptr = NULL;
	}
}

// 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 0x9bdb
movq -0x10(%rbp), %rdi
callq 0xbe80
movq -0x10(%rbp), %rdi
callq 0x2180
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: cjlin1[P]liblinear/linear.cpp
// Function: calc_max_p(problem const*)
static double calc_max_p(const problem *prob)
{
	int i;
	double max_p = 0.0;
	for(i = 0; i < prob->l; i++)
		max_p = max(max_p, fabs(prob->y[i]));

	return max_p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0xac2c
movsd -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movaps 0x808d(%rip), %xmm2     # 0x12ca0
pand %xmm2, %xmm1
callq 0x7070
movsd %xmm0, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xabeb
movsd -0x18(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: cjlin1[P]liblinear/linear.cpp
// Function: predict_probability
double predict_probability(const struct model *model_, const struct feature_node *x, double* prob_estimates)
{
	if(check_probability_model(model_))
	{
		int i;
		int nr_class=model_->nr_class;
		int nr_w;
		if(nr_class==2)
			nr_w = 1;
		else
			nr_w = nr_class;

		double label=predict_values(model_, x, prob_estimates);
		for(i=0;i<nr_w;i++)
			prob_estimates[i]=1/(1+exp(-prob_estimates[i]));

		if(nr_class==2) // for binary classification
			prob_estimates[1]=1.-prob_estimates[0];
		else
		{
			double sum=0;
			for(i=0; i<nr_class; i++)
				sum+=prob_estimates[i];

			for(i=0; i<nr_class; i++)
				prob_estimates[i]=prob_estimates[i]/sum;
		}

		return label;
	}
	else
		return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb040
cmpl $0x0, %eax
je 0xb024
movq -0x10(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, -0x28(%rbp)
cmpl $0x2, -0x28(%rbp)
jne 0xaeff
movl $0x1, -0x2c(%rbp)
jmp 0xaf05
movl -0x28(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xac70
movsd %xmm0, -0x38(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0xaf83
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
callq 0x2270
movsd 0x70cd(%rip), %xmm1     # 0x12028
addsd %xmm0, %xmm1
movsd 0x70c1(%rip), %xmm0     # 0x12028
divsd %xmm1, %xmm0
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xaf22
cmpl $0x2, -0x28(%rbp)
jne 0xafa4
movq -0x20(%rbp), %rax
movsd 0x7093(%rip), %xmm0     # 0x12028
subsd (%rax), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x8(%rax)
jmp 0xb018
xorps %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0xafdd
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
addsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xafb3
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0xb016
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
divsd -0x40(%rbp), %xmm0
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xafe4
jmp 0xb018
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xb02c
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: cjlin1[P]liblinear/linear.cpp
// Function: get_w_value(model const*, int, int)
static inline double get_w_value(const struct model *model_, int idx, int label_idx)
{
	int nr_class = model_->nr_class;
	int solver_type = model_->param.solver_type;
	const double *w = model_->w;

	if(idx < 0 || idx > model_->nr_feature)
		return 0;
	if(check_regression_model(model_) || check_oneclass_model(model_))
		return w[idx];
	else
	{
		if(label_idx < 0 || label_idx >= nr_class)
			return 0;
		if(nr_class == 2 && solver_type != MCSVM_CS)
		{
			if(label_idx == 0)
				return w[idx];
			else
				return -w[idx];
		}
		else
			return w[idx*nr_class+label_idx];
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0xbca3
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x54(%rcx), %eax
jle 0xbcb0
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xbd67
movq -0x10(%rbp), %rdi
callq 0x7ae0
cmpl $0x0, %eax
jne 0xbccc
movq -0x10(%rbp), %rdi
callq 0x84b0
cmpl $0x0, %eax
je 0xbce3
movq -0x28(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xbd67
cmpl $0x0, -0x18(%rbp)
jl 0xbcf1
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jl 0xbcfb
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xbd67
cmpl $0x2, -0x1c(%rbp)
jne 0xbd4c
cmpl $0x4, -0x20(%rbp)
je 0xbd4c
cmpl $0x0, -0x18(%rbp)
jne 0xbd21
movq -0x28(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xbd67
movq -0x28(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xbd67
movq -0x28(%rbp), %rax
movl -0x14(%rbp), %ecx
imull -0x1c(%rbp), %ecx
addl -0x18(%rbp), %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: cjlin1[P]liblinear/linear.cpp
// Function: get_decfun_bias
double get_decfun_bias(const struct model *model_, int label_idx)
{
	if(check_oneclass_model(model_))
	{
		fprintf(stderr, "ERROR: get_decfun_bias can not be called for a one-class SVM model\n");
		return 0;
	}
	int bias_idx = model_->nr_feature;
	double bias = model_->bias;
	if(bias <= 0)
		return 0;
	else
		return bias*get_w_value(model_, bias_idx, label_idx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x84b0
cmpl $0x0, %eax
je 0xbdbf
movq 0xa23c(%rip), %rax      # 0x15fe0
movq (%rax), %rdi
leaq 0x733f(%rip), %rsi      # 0x130ed
movb $0x0, %al
callq 0x21f0
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xbe15
movq -0x10(%rbp), %rax
movl 0x54(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsd 0x68(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x20(%rbp), %xmm0
jb 0xbdeb
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xbe15
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0xbc60
movaps %xmm0, %xmm1
movsd -0x28(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
// File: cjlin1[P]liblinear/linear.cpp
// Function: get_decfun_rho
double get_decfun_rho(const struct model *model_)
{
	if(check_oneclass_model(model_))
		return model_->rho;
	else
	{
		fprintf(stderr, "ERROR: get_decfun_rho can be called only for a one-class SVM model\n");
		return 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x84b0
cmpl $0x0, %eax
je 0xbe4a
movq -0x10(%rbp), %rax
movsd 0x70(%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xbe6a
movq 0xa18f(%rip), %rax      # 0x15fe0
movq (%rax), %rdi
leaq 0x72d6(%rip), %rsi      # 0x13131
movb $0x0, %al
callq 0x21f0
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: cjlin1[P]liblinear/linear.cpp
// Function: free_model_content
void free_model_content(struct model *model_ptr)
{
	free(model_ptr->w);
	model_ptr->w = NULL;
	free(model_ptr->label);
	model_ptr->label = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x2180
movq -0x8(%rbp), %rax
movq $0x0, 0x58(%rax)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x2180
movq -0x8(%rbp), %rax
movq $0x0, 0x60(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: cjlin1[P]liblinear/linear.cpp
// Function: destroy_param
void destroy_param(parameter* param)
{
	free(param->weight_label);
	param->weight_label = NULL;
	free(param->weight);
	param->weight = NULL;
	free(param->init_sol);
	param->init_sol = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2180
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2180
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x2180
movq -0x8(%rbp), %rax
movq $0x0, 0x40(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: cjlin1[P]liblinear/linear.cpp
// Function: quick_select_min_k(feature_node*, int, int, int)
static void quick_select_min_k(feature_node *nodes, int low, int high, int k)
{
	int pivot;
	if(low == high || high < k)
		return;
	pivot = partition(nodes, low, high);
	if(pivot == k)
		return;
	else if(k-1 < pivot)
		return quick_select_min_k(nodes, low, pivot-1, k);
	else
		return quick_select_min_k(nodes, pivot+1, high, k);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
je 0x112a5
movl -0x10(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x112a7
jmp 0x112fa
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x113a0
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x112c3
jmp 0x112fa
movl -0x14(%rbp), %eax
subl $0x1, %eax
cmpl -0x18(%rbp), %eax
jge 0x112e5
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x18(%rbp), %edx
subl $0x1, %edx
movl -0x14(%rbp), %ecx
callq 0x11280
jmp 0x112fa
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
addl $0x1, %esi
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
callq 0x11280
addq $0x20, %rsp
popq %rbp
retq
// File: cjlin1[P]liblinear/linear.cpp
// Function: compare_feature_node(void const*, void const*)
static int compare_feature_node(const void *a, const void *b)
{
	double a_value = (*(feature_node *)a).value;
	double b_value = (*(feature_node *)b).value;
	int a_index = (*(feature_node *)a).index;
	int b_index = (*(feature_node *)b).index;

	if(a_value < b_value)
		return -1;
	else if(a_value == b_value)
	{
		if(a_index < b_index)
			return -1;
		else if(a_index == b_index)
			return 0;
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x30(%rbp)
movsd -0x20(%rbp), %xmm1
movsd -0x28(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x11353
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x11390
movsd -0x20(%rbp), %xmm0
ucomisd -0x28(%rbp), %xmm0
jne 0x11387
jp 0x11387
movl -0x2c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jge 0x11372
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x11390
movl -0x2c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jne 0x11383
movl $0x0, -0x4(%rbp)
jmp 0x11390
jmp 0x11385
jmp 0x11387
jmp 0x11389
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: cjlin1[P]liblinear/linear.cpp
// Function: partition(feature_node*, int, int)
static int partition(feature_node *nodes, int low, int high)
{
	int i;
	int index;

	swap(nodes[low + rand()%(high-low+1)], nodes[high]); // select and move pivot to the end

	index = low;
	for(i = low; i < high; i++)
		if (compare_feature_node(&nodes[i], &nodes[high]) == -1)
		{
			swap(nodes[index], nodes[i]);
			index++;
		}

	swap(nodes[high], nodes[index]);
	return index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
callq 0x2090
movq -0x28(%rbp), %rdi
movl -0x10(%rbp), %ecx
subl -0xc(%rbp), %ecx
addl $0x1, %ecx
cltd
idivl %ecx
movl -0x1c(%rbp), %eax
addl %edx, %eax
cltq
shlq $0x4, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movslq -0x10(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rsi
callq 0x114a0
movl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x1146c
movq -0x8(%rbp), %rdi
movslq -0x14(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movslq -0x10(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rsi
callq 0x11300
cmpl $-0x1, %eax
jne 0x1145f
movq -0x8(%rbp), %rdi
movslq -0x18(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movslq -0x14(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rsi
callq 0x114a0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x11461
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x11403
movq -0x8(%rbp), %rdi
movslq -0x10(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movslq -0x18(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rsi
callq 0x114a0
movl -0x18(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: cjlin1[P]liblinear/linear.cpp
// Function: sparse_operator::dot(double const*, feature_node const*)
static double dot(const double *s, const feature_node *x)
	{
		double ret = 0;
		while(x->index != -1)
		{
			ret += s[x->index-1]*x->value;
			x++;
		}
		return ret;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, (%rax)
je 0x1157b
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm2
movsd -0x18(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
jmp 0x11534
movsd -0x18(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: cjlin1[P]liblinear/linear.cpp
// Function: sparse_operator::nrm2_sq(feature_node const*)
static double nrm2_sq(const feature_node *x)
	{
		double ret = 0;
		while(x->index != -1)
		{
			ret += x->value*x->value;
			x++;
		}
		return ret;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $-0x1, (%rax)
je 0x1168b
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm2
movsd -0x10(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
jmp 0x11650
movsd -0x10(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: cjlin1[P]liblinear/linear.cpp
// Function: sparse_operator::sparse_dot(feature_node const*, feature_node const*)
static double sparse_dot(const feature_node *x1, const feature_node *x2)
	{
		double ret = 0;
		while(x1->index != -1 && x2->index != -1)
		{
			if(x1->index == x2->index)
			{
				ret += x1->value * x2->value;
				++x1;
				++x2;
			}
			else
			{
				if(x1->index > x2->index)
					++x2;
				else
					++x1;
			}
		}
		return ret;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpl $-0x1, (%rcx)
movb %al, -0x19(%rbp)
je 0x116cf
movq -0x10(%rbp), %rax
cmpl $-0x1, (%rax)
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x116d8
jmp 0x11753
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x11724
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm2
movsd -0x18(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
jmp 0x1174e
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jle 0x11740
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
jmp 0x1174c
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
jmp 0x1174e
jmp 0x116b4
movsd -0x18(%rbp), %xmm0
popq %rbp
retq
nopw (%rax,%rax)
// File: Konano[P]UselessDatabase/BufPageManager.cpp
// Function: BufPageManager::fetchPage(int, int, int&)
BufType BufPageManager::fetchPage(int fileID, int pageID, int& index) {
    index = pool->alloc();

    if (addr[index] != nullptr) {
        writeBack(index);
    } else {
        addr[index] = new uint8_t[PAGE_SIZE];
        memset(addr[index], 0, PAGE_SIZE);
    }
    file_id[index] = fileID;
    page_id[index] = pageID;
    hash->add(fileID, pageID, index);
    
    return addr[index];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x110010(%rax), %rdi
callq 0x44b90
movl %eax, %edx
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movl %edx, (%rcx)
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
cmpq $0x0, 0x8(%rax,%rcx,8)
je 0x6d86
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0x6e10
jmp 0x6dbb
movl $0x2000, %edi           # imm = 0x2000
callq 0x6040
movq %rax, %rdx
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq %rdx, 0x8(%rax,%rcx,8)
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq 0x8(%rax,%rcx,8), %rdi
xorl %esi, %esi
movl $0x2000, %edx           # imm = 0x2000
callq 0x62c0
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movl %edx, 0x80008(%rax,%rcx,4)
movl -0x10(%rbp), %edx
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movl %edx, 0xc0008(%rax,%rcx,4)
movq 0x110008(%rax), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movq -0x18(%rbp), %rax
movl (%rax), %ecx
callq 0x35b50
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq 0x8(%rax,%rcx,8), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Konano[P]UselessDatabase/BufPageManager.cpp
// Function: BufPageManager::writeBack(int)
void BufPageManager::writeBack(int index) {
    if (dirty[index]) {
        fm->writePage(file_id[index], page_id[index], addr[index]);
        dirty[index] = false;
    }
    hash->del(file_id[index], page_id[index]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movslq -0xc(%rbp), %rcx
testb $0x1, 0x100008(%rax,%rcx)
je 0x6e70
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movslq -0xc(%rbp), %rcx
movl 0x80008(%rax,%rcx,4), %esi
movslq -0xc(%rbp), %rcx
movl 0xc0008(%rax,%rcx,4), %edx
movslq -0xc(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rcx
callq 0x34fb0
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb $0x0, 0x100008(%rax,%rcx)
movq -0x18(%rbp), %rax
movq 0x110008(%rax), %rdi
movslq -0xc(%rbp), %rcx
movl 0x80008(%rax,%rcx,4), %esi
movslq -0xc(%rbp), %rcx
movl 0xc0008(%rax,%rcx,4), %edx
callq 0x35bc0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Konano[P]UselessDatabase/BufPageManager.cpp
// Function: BufPageManager::BufPageManager(FileManager*)
BufPageManager::BufPageManager(FileManager* fm) : fm(fm) {
    fm->setBPM(this);
    hash = new Hash(this);
    pool = new MemPool();
    lastFileID = lastPageID = lastIndex = -1;
    memset(addr, 0, sizeof(addr));
    memset(file_id, 0, sizeof(file_id));
    memset(page_id, 0, sizeof(page_id));
    memset(dirty, 0, sizeof(dirty));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, (%rsi)
movq -0x10(%rbp), %rdi
callq 0x35030
movl $0xc0008, %edi          # imm = 0xC0008
callq 0x64a0
movq -0x30(%rbp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
callq 0x7420
jmp 0x6ee7
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x110008(%rax)
movl $0x8000c, %edi          # imm = 0x8000C
callq 0x64a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0x44ad0
jmp 0x6f11
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rax
movq %rax, 0x110010(%rdi)
movl $0xffffffff, 0x110020(%rdi) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x11001c(%rdi) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x110018(%rdi) # imm = 0xFFFFFFFF
addq $0x8, %rdi
xorl %esi, %esi
movl $0x80000, %edx          # imm = 0x80000
callq 0x62c0
movq -0x30(%rbp), %rdi
addq $0x80008, %rdi          # imm = 0x80008
xorl %esi, %esi
movl $0x40000, %edx          # imm = 0x40000
callq 0x62c0
movq -0x30(%rbp), %rdi
addq $0xc0008, %rdi          # imm = 0xC0008
xorl %esi, %esi
movl $0x40000, %edx          # imm = 0x40000
callq 0x62c0
movq -0x30(%rbp), %rdi
addq $0x100008, %rdi         # imm = 0x100008
xorl %esi, %esi
movl $0x10000, %edx          # imm = 0x10000
callq 0x62c0
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0xc0008, %esi          # imm = 0xC0008
callq 0x64b0
jmp 0x6fcf
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x8000c, %esi          # imm = 0x8000C
callq 0x64b0
movq -0x18(%rbp), %rdi
callq 0x6890
nopl (%rax,%rax)
// File: Konano[P]UselessDatabase/BufPageManager.cpp
// Function: BufPageManager::~BufPageManager()
BufPageManager::~BufPageManager() {
    for (int i = 0; i < MAX_BUF_NUM; i++) {
        writeBack(i);
        delete addr[i];
    }
    delete hash;
    delete pool;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x10000, -0xc(%rbp)    # imm = 0x10000
jge 0x7044
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x6e10
jmp 0x7012
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x7037
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x64b0
jmp 0x7039
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6ffb
movq -0x18(%rbp), %rax
movq 0x110008(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x7070
movq -0x28(%rbp), %rdi
callq 0x7470
movq -0x28(%rbp), %rdi
movl $0xc0008, %esi          # imm = 0xC0008
callq 0x64b0
movq -0x18(%rbp), %rax
movq 0x110010(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x7093
movq -0x30(%rbp), %rdi
movl $0x8000c, %esi          # imm = 0x8000C
callq 0x64b0
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x7460
nopw %cs:(%rax,%rax)
// File: Konano[P]UselessDatabase/BufPageManager.cpp
// Function: BufPageManager::getPage(int, int)
BufType BufPageManager::getPage(int fileID, int pageID) {
    int index;
    if (fileID == lastFileID && pageID == lastPageID) {
        index = lastIndex;
        return lastBuf;
    }
    lastFileID = fileID;
    lastPageID = pageID;
    lastIndex = index = hash->find(fileID, pageID);
    if (index != -1) {
        pool->access(index);
        return lastBuf = addr[index];
    } else {
        BufType buf = fetchPage(fileID, pageID, index);
        lastIndex = index;
        fm->readPage(fileID, pageID, buf);
        return lastBuf = buf;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x110018(%rcx), %eax
jne 0x7101
movq -0x30(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x11001c(%rcx), %eax
jne 0x7101
movq -0x30(%rbp), %rax
movl 0x110020(%rax), %ecx
movl %ecx, -0x1c(%rbp)
movq 0x110028(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x71b7
movq -0x30(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x110018(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0x11001c(%rax)
movq 0x110008(%rax), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x35a90
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, -0x1c(%rbp)
movl %ecx, 0x110020(%rax)
cmpl $-0x1, -0x1c(%rbp)
je 0x716b
movq -0x30(%rbp), %rax
movq 0x110010(%rax), %rdi
movl -0x1c(%rbp), %esi
callq 0x44b00
movq -0x30(%rbp), %rcx
movslq -0x1c(%rbp), %rax
movq 0x8(%rcx,%rax,8), %rax
movq %rax, 0x110028(%rcx)
movq %rax, -0x8(%rbp)
jmp 0x71b7
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
leaq -0x1c(%rbp), %rcx
callq 0x6d30
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x28(%rbp)
movl -0x1c(%rbp), %ecx
movl %ecx, 0x110020(%rax)
movq (%rax), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movq -0x28(%rbp), %rcx
callq 0x34f30
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rax, 0x110028(%rcx)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Konano[P]UselessDatabase/BufPageManager.cpp
// Function: BufPageManager::closeFile(int)
void BufPageManager::closeFile(int fileID) {
    for (int i = 0; i < MAX_BUF_NUM; i++) {
        if (file_id[i] == fileID) {
            writeBack(i);
            delete addr[i];
            addr[i] = nullptr;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x10000, -0x10(%rbp)   # imm = 0x10000
jge 0x741a
movq -0x18(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl 0x80008(%rax,%rcx,4), %eax
cmpl -0xc(%rbp), %eax
jne 0x740d
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x6e10
movq -0x18(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x73fc
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x64b0
movq -0x18(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq $0x0, 0x8(%rax,%rcx,8)
jmp 0x740f
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x73ae
addq $0x20, %rsp
popq %rbp
retq
// File: Konano[P]UselessDatabase/Database.cpp
// Function: Database::toJson[abi:cxx11]()
json Database::toJson() {
    json j;
    j["name"] = name;
    j["table_num"] = table_num;
    j["mem"] = mem;
    for (uint i = 0; i < table_num; i++) {
        j["table"].push_back(table[i]->toJson());
    }
    return j;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movb $0x0, -0x11(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0xadd0
movq -0x78(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0xae10
jmp 0x74c5
movq -0x88(%rbp), %rdi
leaq 0x7c743(%rip), %rsi     # 0x83c16
callq 0xae60
movq %rax, -0x90(%rbp)
jmp 0x74e1
movq -0x90(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movq %rsi, -0xa0(%rbp)
callq 0xb0a0
movq -0xa0(%rbp), %rdi
callq 0xb110
movq -0x78(%rbp), %rsi
addq $0x820, %rsi            # imm = 0x820
leaq -0x48(%rbp), %rdi
callq 0xb150
movq -0x88(%rbp), %rdi
leaq 0x774e2(%rip), %rsi     # 0x7ea08
callq 0xae60
movq %rax, -0x98(%rbp)
jmp 0x7534
movq -0x98(%rbp), %rdi
leaq -0x48(%rbp), %rsi
movq %rsi, -0xb0(%rbp)
callq 0xb0a0
movq -0xb0(%rbp), %rdi
callq 0xb110
movq -0x78(%rbp), %rsi
addq $0x840, %rsi            # imm = 0x840
leaq -0x58(%rbp), %rdi
callq 0xb1a0
movq -0x88(%rbp), %rdi
leaq 0x77499(%rip), %rsi     # 0x7ea12
callq 0xae60
movq %rax, -0xa8(%rbp)
jmp 0x7587
movq -0xa8(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xb0a0
leaq -0x58(%rbp), %rdi
callq 0xb110
movl $0x0, -0x5c(%rbp)
movq -0x78(%rbp), %rcx
movl -0x5c(%rbp), %eax
cmpl 0x820(%rcx), %eax
jae 0x767d
movq -0x88(%rbp), %rdi
leaq 0x7744e(%rip), %rsi     # 0x7ea16
callq 0xae60
movq %rax, -0xb8(%rbp)
jmp 0x75d6
movq -0x78(%rbp), %rax
movl -0x5c(%rbp), %ecx
movq 0x20(%rax,%rcx,8), %rsi
leaq -0x70(%rbp), %rdi
callq 0x473d0
jmp 0x75ed
movq -0xb8(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0xb1f0
jmp 0x75ff
leaq -0x70(%rbp), %rdi
callq 0xb110
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x75a7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x76a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xb110
jmp 0x76a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xb110
jmp 0x76a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xb110
jmp 0x76a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xb110
jmp 0x76a0
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x7693
movq -0x88(%rbp), %rdi
callq 0xb110
movq -0x80(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0xb110
movq -0x30(%rbp), %rdi
callq 0x6890
nopw %cs:(%rax,%rax)
// File: Konano[P]UselessDatabase/Database.cpp
// Function: Database::fromJson(nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>)
void Database::fromJson(json j) {
    strcpy(name, j["name"].get<std::string>().c_str());
    table_num = j["table_num"].get<int>();
    mem = j["mem"].get<uint64_t>();
    for (uint i = 0; i < table_num; i++) {
        table[i] = new Table(this, j["table"][i]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x70(%rbp)
movq %rdi, %rax
movq -0x70(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq 0x7c525(%rip), %rsi     # 0x83c16
callq 0xae60
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0xb390
leaq -0x30(%rbp), %rdi
callq 0x6210
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x6460
leaq -0x30(%rbp), %rdi
callq 0x6340
movq -0x68(%rbp), %rdi
leaq 0x772dd(%rip), %rsi     # 0x7ea08
callq 0xae60
movq %rax, %rdi
callq 0xb410
movq -0x68(%rbp), %rdi
movl %eax, %ecx
movq -0x60(%rbp), %rax
movl %ecx, 0x820(%rax)
leaq 0x772c3(%rip), %rsi     # 0x7ea12
callq 0xae60
movq %rax, %rdi
callq 0xb440
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, 0x840(%rax)
movl $0x0, -0x34(%rbp)
movq -0x60(%rbp), %rcx
movl -0x34(%rbp), %eax
cmpl 0x820(%rcx), %eax
jae 0x784e
movl $0x9fe8, %edi           # imm = 0x9FE8
callq 0x64a0
movq -0x68(%rbp), %rdi
movq %rax, -0x80(%rbp)
movb $0x1, -0x55(%rbp)
leaq 0x77275(%rip), %rsi     # 0x7ea16
callq 0xae60
movq %rax, -0x78(%rbp)
jmp 0x77ac
movq -0x78(%rbp), %rdi
movl -0x34(%rbp), %eax
movl %eax, %esi
callq 0xb470
movq %rax, -0x88(%rbp)
jmp 0x77c3
movq -0x88(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0xb700
jmp 0x77d5
movq -0x60(%rbp), %rsi
movq -0x80(%rbp), %rdi
leaq -0x48(%rbp), %rdx
callq 0x47b80
jmp 0x77e8
movq -0x60(%rbp), %rax
movq -0x80(%rbp), %rdx
movb $0x0, -0x55(%rbp)
movl -0x34(%rbp), %ecx
movq %rdx, 0x20(%rax,%rcx,8)
leaq -0x48(%rbp), %rdi
callq 0xb110
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x7771
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x7836
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xb110
testb $0x1, -0x55(%rbp)
jne 0x783e
jmp 0x784c
movq -0x80(%rbp), %rdi
movl $0x9fe8, %esi           # imm = 0x9FE8
callq 0x64b0
jmp 0x7857
addq $0x90, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x6890
// File: Konano[P]UselessDatabase/Database.cpp
// Function: Database::~Database()
Database::~Database() {
    update();
    fm->closeFile(mem_file);
    for (int i = 0; i < MAX_TABLE_NUM; i++) if (table[i] != nullptr) {
        delete table[i];
    }
    delete fm;
    delete bpm;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x7860
jmp 0x7d1b
movq -0x18(%rbp), %rax
movq 0x828(%rax), %rdi
movl 0x838(%rax), %esi
callq 0x34df0
jmp 0x7d33
movl $0x0, -0xc(%rbp)
cmpl $0x100, -0xc(%rbp)      # imm = 0x100
jge 0x7d90
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, 0x20(%rax,%rcx,8)
je 0x7d83
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x20(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x7d81
movq -0x20(%rbp), %rdi
callq 0x48750
movq -0x20(%rbp), %rdi
movl $0x9fe8, %esi           # imm = 0x9FE8
callq 0x64b0
jmp 0x7d83
jmp 0x7d85
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7d3a
movq -0x18(%rbp), %rax
movq 0x828(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x7dbc
movq -0x28(%rbp), %rdi
callq 0x34d50
movq -0x28(%rbp), %rdi
movl $0x220, %esi            # imm = 0x220
callq 0x64b0
movq -0x18(%rbp), %rax
movq 0x830(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x7de8
movq -0x30(%rbp), %rdi
callq 0x6fe0
movq -0x30(%rbp), %rdi
movl $0x110030, %esi         # imm = 0x110030
callq 0x64b0
movq -0x18(%rbp), %rax
addq $0x848, %rax            # imm = 0x848
movq %rax, -0x40(%rbp)
addq $0x8000, %rax           # imm = 0x8000
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
addq $-0x80, %rdi
movq %rdi, -0x48(%rbp)
callq 0xbce0
movq -0x40(%rbp), %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x38(%rbp)
jne 0x7e00
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x7460
// File: Konano[P]UselessDatabase/Database.cpp
// Function: Database::createTable(char const*, int, Type*)
Table* Database::createTable(const char* name, int col_num, Type* col_ty) {
    Table* new_table = new Table();
    if (new_table->createTable(table_num, this, name, col_num, col_ty, true)) {
        delete new_table;
        return nullptr;
    }
    table[table_num++] = new_table;
    update();
    return new_table;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x9fe8, %edi           # imm = 0x9FE8
callq 0x64a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
callq 0xbd40
jmp 0x7e6a
movq -0x50(%rbp), %rdx
movq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movl 0x820(%rdx), %esi
movq -0x18(%rbp), %rcx
movl -0x1c(%rbp), %r8d
movq -0x28(%rbp), %r9
movl $0x1, (%rsp)
callq 0x48940
cmpl $0x0, %eax
je 0x7ee8
movq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0x7ec2
movq -0x58(%rbp), %rdi
callq 0x48750
movq -0x58(%rbp), %rdi
movl $0x9fe8, %esi           # imm = 0x9FE8
callq 0x64b0
movq $0x0, -0x8(%rbp)
jmp 0x7f15
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0x9fe8, %esi           # imm = 0x9FE8
callq 0x64b0
jmp 0x7f1f
movq -0x50(%rbp), %rdi
movq -0x30(%rbp), %rcx
movl 0x820(%rdi), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x820(%rdi)
movl %eax, %eax
movq %rcx, 0x20(%rdi,%rax,8)
callq 0x7860
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x6890
nopl (%rax,%rax)
// File: Konano[P]UselessDatabase/Database.cpp
// Function: Database::openTable(char const*)
Table* Database::openTable(const char* name) {
    for (uint i = 0; i < table_num; i++) {
        if (strcmp(table[i]->name, name) == 0) {
            return table[i];
        }
    }
    return nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x820(%rcx), %eax
jae 0x7f9b
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
movq 0x20(%rax,%rcx,8), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
callq 0x66e0
cmpl $0x0, %eax
jne 0x7f8e
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
movq 0x20(%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x7fa3
jmp 0x7f90
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7f4f
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)