LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/cjlin1[P]liblinear/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(check_oneclass_model(model_))
		dec_values[0] -= model_->rho;

	if(nr_class==2)
	{
		if(check_regression_model(model_))
			return dec_values[0];
		else if(check_oneclass_model(model_))
			return (dec_values[0]>0)?1:-1;
		else
			return (dec_values[0]>0)?model_->label[0]:model_->label[1];
	}
	else
	{
		int dec_max_idx = 0;
		for(i=1;i<nr_class;i++)
		{
			if(dec_values[i] > dec_values[dec_max_idx])
				dec_max_idx = i;
		}
		return model_->label[dec_max_idx];
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movsd 0x68(%rdi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movl 0x50(%rdi), %r12d
movl 0x54(%rdi), %ebp
sbbl $-0x1, %ebp
movq 0x58(%rdi), %r13
cmpq $0x2, %r12
jne 0xb10d
xorl %ebx, %ebx
cmpl $0x4, (%rdi)
sete %bl
incl %ebx
jmp 0xb118
movl %r12d, %ebx
movl %r12d, %eax
testl %r12d, %r12d
jle 0xb132
movl %ebx, %edx
shlq $0x3, %rdx
movq %rdi, (%rsp)
movq %r14, %rdi
xorl %esi, %esi
callq 0x20c0
movq (%rsp), %rdi
movl %ebx, %eax
movl (%r15), %edx
cmpl $-0x1, %edx
je 0xb185
movl %eax, %ecx
cmpl %ebp, %edx
jg 0xb178
testl %eax, %eax
jle 0xb178
decl %edx
imull %eax, %edx
movslq %edx, %rdx
leaq (,%rdx,8), %rdx
addq %r13, %rdx
xorl %esi, %esi
movsd (%rdx,%rsi,8), %xmm0
mulsd 0x8(%r15), %xmm0
addsd (%r14,%rsi,8), %xmm0
movsd %xmm0, (%r14,%rsi,8)
incq %rsi
cmpq %rsi, %rcx
jne 0xb159
movl 0x10(%r15), %edx
addq $0x10, %r15
cmpl $-0x1, %edx
jne 0xb13c
movl (%rdi), %eax
cmpl $0x15, %eax
jne 0xb19b
movsd (%r14), %xmm0
subsd 0x70(%rdi), %xmm0
movsd %xmm0, (%r14)
cmpl $0x2, %r12d
jne 0xb1ce
leal -0xb(%rax), %ecx
movsd (%r14), %xmm0
cmpl $0x3, %ecx
jb 0xb214
xorpd %xmm1, %xmm1
cmpl $0x15, %eax
jne 0xb1ff
xorl %eax, %eax
ucomisd %xmm1, %xmm0
seta %al
leaq 0x3cf9(%rip), %rcx      # 0xeec0
movsd (%rcx,%rax,8), %xmm0
jmp 0xb214
xorl %eax, %eax
cmpl $0x2, %r12d
jl 0xb208
movl $0x1, %ecx
movsd (%r14,%rcx,8), %xmm0
movslq %eax, %rdx
ucomisd (%r14,%rdx,8), %xmm0
movl %ecx, %edx
ja 0xb1f0
movl %eax, %edx
incq %rcx
movl %edx, %eax
cmpq %rcx, %r12
jne 0xb1db
movslq %edx, %rax
jmp 0xb208
xorl %eax, %eax
ucomisd %xmm1, %xmm0
setbe %al
movq 0x60(%rdi), %rcx
xorps %xmm0, %xmm0
cvtsi2sdl (%rcx,%rax,4), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movl (%rdi), %eax
xorpd %xmm0, %xmm0
cmpl $0x7, %eax
ja 0xb306
movl $0xc1, %ecx
btl %eax, %ecx
jae 0xb306
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movl 0x50(%rdi), %r14d
cmpq $0x2, %r14
movl $0x1, %ebp
cmovnel %r14d, %ebp
callq 0xb0cf
movsd %xmm0, 0x8(%rsp)
testl %ebp, %ebp
jle 0xb2a6
movl %ebp, %r15d
xorl %r12d, %r12d
movsd (%rbx,%r12,8), %xmm0
xorpd 0x39fd(%rip), %xmm0     # 0xec80
callq 0x22a0
movsd 0x39b0(%rip), %xmm1     # 0xec40
addsd %xmm1, %xmm0
divsd %xmm0, %xmm1
movsd %xmm1, (%rbx,%r12,8)
incq %r12
cmpq %r12, %r15
jne 0xb275
cmpl $0x2, %r14d
jne 0xb2bf
movsd 0x398c(%rip), %xmm0     # 0xec40
subsd (%rbx), %xmm0
movsd %xmm0, 0x8(%rbx)
jmp 0xb2f4
testl %r14d, %r14d
jle 0xb2f4
xorpd %xmm0, %xmm0
xorl %eax, %eax
addsd (%rbx,%rax,8), %xmm0
incq %rax
cmpq %rax, %r14
jne 0xb2ca
testl %r14d, %r14d
jle 0xb2f4
xorl %eax, %eax
movsd (%rbx,%rax,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rbx,%rax,8)
incq %rax
cmpq %rax, %r14
jne 0xb2de
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movl (%rdi), %ecx
cmpl $0x15, %ecx
je 0xbb80
movsd 0x68(%rdi), %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jae 0xbba0
movslq 0x54(%rdi), %rax
testq %rax, %rax
js 0xbb98
movq 0x58(%rdi), %rdx
leal -0xb(%rcx), %r8d
cmpl $0x2, %r8d
ja 0xbb43
movsd (%rdx,%rax,8), %xmm0
jmp 0xbb98
movl 0x50(%rdi), %edi
testl %esi, %esi
setns %r8b
cmpl %esi, %edi
setg %r9b
andb %r8b, %r9b
cmpb $0x1, %r9b
jne 0xbb98
cmpl $0x2, %edi
setne %r8b
cmpl $0x4, %ecx
sete %cl
orb %r8b, %cl
jne 0xbb8e
movsd (%rdx,%rax,8), %xmm0
testl %esi, %esi
je 0xbb98
xorpd 0x3102(%rip), %xmm0     # 0xec80
jmp 0xbb98
pushq %rax
callq 0x2867
xorps %xmm0, %xmm0
addq $0x8, %rsp
retq
imull %eax, %edi
addl %esi, %edi
movsd (%rdx,%rdi,8), %xmm0
mulsd %xmm0, %xmm1
movapd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
cmpl $0x15, (%rdi)
jne 0xbbac
movsd 0x70(%rdi), %xmm0
retq
pushq %rax
callq 0x2883
xorps %xmm0, %xmm0
addq $0x8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebx
cmpl %edx, %esi
sete %al
cmpl %ecx, %edx
setl %cl
orb %al, %cl
je 0xcd45
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
movslq %r15d, %r12
movq %r12, %rax
negq %rax
movq %rax, 0x10(%rsp)
movq %r12, %r13
shlq $0x4, %r13
addq %r14, %r13
callq 0x2090
movl %ebp, %ecx
subl %r15d, %ecx
incl %ecx
cltd
idivl %ecx
addl %r15d, %edx
movslq %edx, %rax
shlq $0x4, %rax
movslq %ebp, %rdx
movq %rdx, %rsi
shlq $0x4, %rsi
leaq (%r14,%rsi), %rcx
movups (%r14,%rax), %xmm0
movaps %xmm0, (%rsp)
movups (%r14,%rsi), %xmm0
movups %xmm0, (%r14,%rax)
movapd (%rsp), %xmm0
movupd %xmm0, (%r14,%rsi)
movq %r12, %rsi
movl %r15d, %eax
cmpl %r15d, %edx
jle 0xce0f
addq 0x10(%rsp), %rdx
movq %r13, %rsi
movl %r15d, %eax
movsd 0x8(%rsi), %xmm0
movsd 0x8(%rcx), %xmm1
ucomisd %xmm0, %xmm1
ja 0xcdde
ucomisd %xmm1, %xmm0
jne 0xce03
jp 0xce03
movl (%rcx), %edi
cmpl %edi, (%rsi)
jge 0xce03
cltq
movq %rax, %rdi
shlq $0x4, %rdi
movups (%r14,%rdi), %xmm0
movaps %xmm0, (%rsp)
movups (%rsi), %xmm0
movups %xmm0, (%r14,%rdi)
movapd (%rsp), %xmm0
movupd %xmm0, (%rsi)
incl %eax
addq $0x10, %rsi
decq %rdx
jne 0xcdc0
movslq %eax, %rsi
shlq $0x4, %rsi
movups (%rcx), %xmm0
movaps %xmm0, (%rsp)
movups (%r14,%rsi), %xmm0
movups %xmm0, (%rcx)
movapd (%rsp), %xmm0
movupd %xmm0, (%r14,%rsi)
cmpl %ebx, %eax
je 0xcd36
jl 0xce50
leal -0x1(%rax), %ebp
cmpl %ebp, %r15d
je 0xcd36
cmpl %ebx, %eax
jg 0xcd65
jmp 0xcd36
incl %eax
cmpl %ebp, %eax
je 0xcd36
movl %eax, %r15d
cmpl %ebx, %ebp
jge 0xcd4d
jmp 0xcd36
// File: /workspace/github_cpp_makefile_star2_O3/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:
movsd 0x8(%rdi), %xmm0
movsd 0x8(%rsi), %xmm1
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
ucomisd %xmm0, %xmm1
ja 0xce9a
ucomisd %xmm1, %xmm0
jne 0xce95
jp 0xce95
movl (%rdi), %ecx
movl (%rsi), %edx
cmpl %edx, %ecx
jl 0xce9a
xorl %eax, %eax
cmpl %edx, %ecx
je 0xce9a
movl $0x1, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/cjlin1[P]liblinear/blas/daxpy.c
// Function: daxpy_
int daxpy_(int *n, double *sa, double *sx, int *incx, double *sy,
           int *incy)
{
  long int i, m, ix, iy, nn, iincx, iincy;
  register double ssa;

  /* constant times a vector plus a vector.
     uses unrolled loop for increments equal to one.
     jack dongarra, linpack, 3/11/78.
     modified 12/3/93, array(1) declarations changed to array(*) */

  /* Dereference inputs */
  nn = *n;
  ssa = *sa;
  iincx = *incx;
  iincy = *incy;

  if( nn > 0 && ssa != 0.0 )
  {
    if (iincx == 1 && iincy == 1) /* code for both increments equal to 1 */
    {
      m = nn-3;
      for (i = 0; i < m; i += 4)
      {
        sy[i] += ssa * sx[i];
        sy[i+1] += ssa * sx[i+1];
        sy[i+2] += ssa * sx[i+2];
        sy[i+3] += ssa * sx[i+3];
      }
      for ( ; i < nn; ++i) /* clean-up loop */
        sy[i] += ssa * sx[i];
    }
    else /* code for unequal increments or equal increments not equal to 1 */
    {
      ix = iincx >= 0 ? 0 : (1 - nn) * iincx;
      iy = iincy >= 0 ? 0 : (1 - nn) * iincy;
      for (i = 0; i < nn; i++)
      {
        sy[iy] += ssa * sx[ix];
        ix += iincx;
        iy += iincy;
      }
    }
  }

  return 0;
}

// Assembly:
movslq (%rdi), %rax
testq %rax, %rax
jle 0xd0a1
movsd (%rsi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xcfa0
jnp 0xd0a1
movslq (%rcx), %rcx
movslq (%r9), %rsi
movl %ecx, %edi
xorl $0x1, %edi
movl %esi, %r9d
xorl $0x1, %r9d
orl %edi, %r9d
jne 0xd02e
cmpl $0x4, %eax
jb 0xd07d
leaq -0x3(%rax), %rsi
xorl %ecx, %ecx
movsd (%rdx,%rcx,8), %xmm1
mulsd %xmm0, %xmm1
addsd (%r8,%rcx,8), %xmm1
movsd %xmm1, (%r8,%rcx,8)
movsd 0x8(%rdx,%rcx,8), %xmm1
mulsd %xmm0, %xmm1
addsd 0x8(%r8,%rcx,8), %xmm1
movsd %xmm1, 0x8(%r8,%rcx,8)
movsd 0x10(%rdx,%rcx,8), %xmm1
mulsd %xmm0, %xmm1
addsd 0x10(%r8,%rcx,8), %xmm1
movsd %xmm1, 0x10(%r8,%rcx,8)
movsd 0x18(%rdx,%rcx,8), %xmm1
mulsd %xmm0, %xmm1
addsd 0x18(%r8,%rcx,8), %xmm1
movsd %xmm1, 0x18(%r8,%rcx,8)
addq $0x4, %rcx
cmpq %rsi, %rcx
jl 0xcfc6
jmp 0xd07f
movl $0x1, %edi
subq %rax, %rdi
movq %rdi, %r9
imulq %rsi, %r9
xorl %r10d, %r10d
testl %esi, %esi
cmovnsq %r10, %r9
imulq %rcx, %rdi
testl %ecx, %ecx
cmovnsq %r10, %rdi
leaq (%rdx,%rdi,8), %rdx
shlq $0x3, %rcx
leaq (%r8,%r9,8), %rdi
shlq $0x3, %rsi
movsd (%rdx), %xmm1
mulsd %xmm0, %xmm1
addsd (%rdi), %xmm1
movsd %xmm1, (%rdi)
addq %rcx, %rdx
addq %rsi, %rdi
decq %rax
jne 0xd060
jmp 0xd0a1
xorl %ecx, %ecx
cmpq %rax, %rcx
jge 0xd0a1
movsd (%rdx,%rcx,8), %xmm1
mulsd %xmm0, %xmm1
addsd (%r8,%rcx,8), %xmm1
movsd %xmm1, (%r8,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0xd084
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/cjlin1[P]liblinear/blas/ddot.c
// Function: ddot_
double ddot_(int *n, double *sx, int *incx, double *sy, int *incy)
{
  long int i, m, nn, iincx, iincy;
  double stemp;
  long int ix, iy;

  /* forms the dot product of two vectors.
     uses unrolled loops for increments equal to one.
     jack dongarra, linpack, 3/11/78.
     modified 12/3/93, array(1) declarations changed to array(*) */

  /* Dereference inputs */
  nn = *n;
  iincx = *incx;
  iincy = *incy;

  stemp = 0.0;
  if (nn > 0)
  {
    if (iincx == 1 && iincy == 1) /* code for both increments equal to 1 */
    {
      m = nn-4;
      for (i = 0; i < m; i += 5)
        stemp += sx[i] * sy[i] + sx[i+1] * sy[i+1] + sx[i+2] * sy[i+2] +
                 sx[i+3] * sy[i+3] + sx[i+4] * sy[i+4];

      for ( ; i < nn; i++)        /* clean-up loop */
        stemp += sx[i] * sy[i];
    }
    else /* code for unequal increments or equal increments not equal to 1 */
    {
      ix = 0;
      iy = 0;
      if (iincx < 0)
        ix = (1 - nn) * iincx;
      if (iincy < 0)
        iy = (1 - nn) * iincy;
      for (i = 0; i < nn; i++)
      {
        stemp += sx[ix] * sy[iy];
        ix += iincx;
        iy += iincy;
      }
    }
  }

  return stemp;
}

// Assembly:
movslq (%rdi), %rax
testq %rax, %rax
jle 0xd135
movslq (%rdx), %rdx
movslq (%r8), %rdi
movl %edx, %r8d
xorl $0x1, %r8d
movl %edi, %r9d
xorl $0x1, %r9d
orl %r8d, %r9d
jne 0xd139
cmpl $0x5, %eax
jb 0xd189
leaq -0x4(%rax), %rdi
xorpd %xmm0, %xmm0
xorl %edx, %edx
movsd (%rsi,%rdx,8), %xmm1
movsd 0x8(%rsi,%rdx,8), %xmm2
mulsd 0x8(%rcx,%rdx,8), %xmm2
mulsd (%rcx,%rdx,8), %xmm1
addsd %xmm2, %xmm1
movsd 0x10(%rsi,%rdx,8), %xmm2
mulsd 0x10(%rcx,%rdx,8), %xmm2
addsd %xmm1, %xmm2
movsd 0x18(%rsi,%rdx,8), %xmm1
mulsd 0x18(%rcx,%rdx,8), %xmm1
addsd %xmm2, %xmm1
movsd 0x20(%rsi,%rdx,8), %xmm2
mulsd 0x20(%rcx,%rdx,8), %xmm2
addsd %xmm1, %xmm2
addsd %xmm2, %xmm0
addq $0x5, %rdx
cmpq %rdi, %rdx
jl 0xd0dc
jmp 0xd18f
xorps %xmm0, %xmm0
retq
movl $0x1, %r8d
subq %rax, %r8
movq %r8, %r9
imulq %rdi, %r9
xorl %r10d, %r10d
testl %edi, %edi
cmovnsq %r10, %r9
imulq %rdx, %r8
testl %edx, %edx
cmovnsq %r10, %r8
leaq (%rcx,%r9,8), %rcx
shlq $0x3, %rdi
leaq (%rsi,%r8,8), %rsi
shlq $0x3, %rdx
xorpd %xmm0, %xmm0
movsd (%rsi), %xmm1
mulsd (%rcx), %xmm1
addsd %xmm1, %xmm0
addq %rdi, %rcx
addq %rdx, %rsi
decq %rax
jne 0xd170
jmp 0xd1aa
xorpd %xmm0, %xmm0
xorl %edx, %edx
cmpq %rax, %rdx
jge 0xd1aa
movsd (%rsi,%rdx,8), %xmm1
mulsd (%rcx,%rdx,8), %xmm1
addsd %xmm1, %xmm0
incq %rdx
cmpq %rdx, %rax
jne 0xd194
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/cjlin1[P]liblinear/blas/dscal.c
// Function: dscal_
int dscal_(int *n, double *sa, double *sx, int *incx)
{
  long int i, m, nincx, nn, iincx;
  double ssa;

  /* scales a vector by a constant.
     uses unrolled loops for increment equal to 1.
     jack dongarra, linpack, 3/11/78.
     modified 3/93 to return if incx .le. 0.
     modified 12/3/93, array(1) declarations changed to array(*) */

  /* Dereference inputs */
  nn = *n;
  iincx = *incx;
  ssa = *sa;

  if (nn > 0 && iincx > 0)
  {
    if (iincx == 1) /* code for increment equal to 1 */
    {
      m = nn-4;
      for (i = 0; i < m; i += 5)
      {
        sx[i] = ssa * sx[i];
        sx[i+1] = ssa * sx[i+1];
        sx[i+2] = ssa * sx[i+2];
        sx[i+3] = ssa * sx[i+3];
        sx[i+4] = ssa * sx[i+4];
      }
      for ( ; i < nn; ++i) /* clean-up loop */
        sx[i] = ssa * sx[i];
    }
    else /* code for increment not equal to 1 */
    {
      nincx = nn * iincx;
      for (i = 0; i < nincx; i += iincx)
        sx[i] = ssa * sx[i];
    }
  }

  return 0;
}

// Assembly:
movslq (%rdi), %rax
testq %rax, %rax
setg %dil
movl (%rcx), %ecx
testl %ecx, %ecx
setg %r8b
andb %dil, %r8b
cmpb $0x1, %r8b
jne 0xd25e
movsd (%rsi), %xmm0
cmpl $0x1, %ecx
jne 0xd220
cmpl $0x5, %eax
jb 0xd241
leaq -0x4(%rax), %rsi
movapd %xmm0, %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
xorl %ecx, %ecx
movupd (%rdx,%rcx,8), %xmm2
movupd 0x10(%rdx,%rcx,8), %xmm3
mulpd %xmm1, %xmm2
movupd %xmm2, (%rdx,%rcx,8)
mulpd %xmm1, %xmm3
movupd %xmm3, 0x10(%rdx,%rcx,8)
movsd 0x20(%rdx,%rcx,8), %xmm2
mulsd %xmm0, %xmm2
movsd %xmm2, 0x20(%rdx,%rcx,8)
addq $0x5, %rcx
cmpq %rsi, %rcx
jl 0xd1e7
jmp 0xd243
movslq %ecx, %rcx
imulq %rcx, %rax
xorl %esi, %esi
movsd (%rdx,%rsi,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rdx,%rsi,8)
addq %rcx, %rsi
cmpq %rax, %rsi
jl 0xd229
jmp 0xd25e
xorl %ecx, %ecx
cmpq %rax, %rcx
jge 0xd25e
movsd (%rdx,%rcx,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rdx,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0xd248
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/Konano[P]UselessDatabase/./json.hpp
// Function: nlohmann::detail::lexer<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>>::get()
std::char_traits<char>::int_type get()
    {
        ++position.chars_read_total;
        ++position.chars_read_current_line;

        if (next_unget)
        {
            // just reset the next_unget variable and work with current
            next_unget = false;
        }
        else
        {
            current = ia->get_character();
        }

        if (JSON_HEDLEY_LIKELY(current != std::char_traits<char>::eof()))
        {
            token_string.push_back(std::char_traits<char>::to_char_type(current));
        }

        if (current == '\n')
        {
            ++position.lines_read;
            position.chars_read_current_line = 0;
        }

        return current;
    }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movdqu 0x18(%rdi), %xmm0
pcmpeqd %xmm1, %xmm1
psubq %xmm1, %xmm0
movdqu %xmm0, 0x18(%rdi)
cmpb $0x1, 0x14(%rdi)
jne 0x5819
movb $0x0, 0x14(%rbx)
movl 0x10(%rbx), %eax
jmp 0x5824
movq (%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, 0x10(%rbx)
cmpl $-0x1, %eax
je 0x5853
leaq 0x30(%rbx), %rdi
leaq 0xf(%rsp), %rsi
movb %al, (%rsi)
callq 0xfcba
movl 0x10(%rbx), %eax
cmpl $0xa, %eax
jne 0x584d
incq 0x28(%rbx)
andq $0x0, 0x20(%rbx)
pushq $0xa
popq %rax
addq $0x10, %rsp
popq %rbx
retq
pushq $-0x1
jmp 0x584c
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
movq 0x110010(%rdi), %rdi
callq 0x1e0e8
movl %eax, (%rbx)
movslq %eax, %r12
cmpq $0x0, 0x8(%r14,%r12,8)
je 0x6567
movq %r14, %rdi
movl %eax, %esi
callq 0x65bc
movslq (%rbx), %r12
jmp 0x6585
movl $0x2000, %edi           # imm = 0x2000
callq 0x5040
movq %rax, 0x8(%r14,%r12,8)
movl $0x2000, %edx           # imm = 0x2000
movq %rax, %rdi
xorl %esi, %esi
callq 0x5240
movl %r15d, 0x80008(%r14,%r12,4)
movslq (%rbx), %rax
movl %ebp, 0xc0008(%r14,%rax,4)
movq 0x110008(%r14), %rdi
movl (%rbx), %ecx
movl %r15d, %esi
movl %ebp, %edx
callq 0x1831a
movslq (%rbx), %rax
movq 0x8(%r14,%rax,8), %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq %esi, %r14
cmpb $0x1, 0x100008(%rdi,%r14)
jne 0x65f7
movq (%rbx), %rdi
movl 0x80008(%rbx,%r14,4), %esi
movl 0xc0008(%rbx,%r14,4), %edx
movq 0x8(%rbx,%r14,8), %rcx
callq 0x17dca
movb $0x0, 0x100008(%rbx,%r14)
movq 0x110008(%rbx), %rdi
movl 0x80008(%rbx,%r14,4), %esi
movl 0xc0008(%rbx,%r14,4), %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x18368
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, (%rdi)
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x17e0c
movl $0xc0008, %edi          # imm = 0xC0008
callq 0x5390
movq %rax, %r14
movq %rbx, 0xc0000(%rax)
leaq 0x80000(%rax), %rdi
movl $0x40000, %edx          # imm = 0x40000
xorl %esi, %esi
callq 0x5240
movq %r14, 0x110008(%rbx)
movl $0x8000c, %edi          # imm = 0x8000C
callq 0x5390
movq %rax, %r14
movq %rax, %rdi
callq 0x1e084
movq %r14, 0x110010(%rbx)
movl $0xffffffff, 0x110020(%rbx) # imm = 0xFFFFFFFF
movq $-0x1, 0x110018(%rbx)
addq $0x8, %rbx
movl $0x110000, %edx         # imm = 0x110000
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5240
movq %rax, %rbx
movl $0x8000c, %esi          # imm = 0x8000C
movq %r14, %rdi
callq 0x53a0
movq %rbx, %rdi
callq 0x56e0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x65bc
movq 0x8(%rbx,%r14,8), %rdi
movl $0x1, %esi
callq 0x53a0
incq %r14
cmpq $0x10000, %r14          # imm = 0x10000
jne 0x66ca
movq 0x110008(%rbx), %rdi
movl $0xc0008, %esi          # imm = 0xC0008
callq 0x53a0
movq 0x110010(%rbx), %rdi
movl $0x8000c, %esi          # imm = 0x8000C
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x53a0
movq %rax, %rdi
callq 0x6925
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
cmpl %esi, 0x110018(%rdi)
jne 0x6752
cmpl %ebp, 0x11001c(%rbx)
jne 0x6752
movq 0x110028(%rbx), %r15
jmp 0x67d3
movl %r14d, 0x110018(%rbx)
movl %ebp, 0x11001c(%rbx)
movq 0x110008(%rbx), %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x18284
movl %eax, 0xc(%rsp)
movl %eax, 0x110020(%rbx)
cmpl $-0x1, %eax
je 0x679a
movl %eax, %r15d
movq 0x110010(%rbx), %rdi
movl %eax, %esi
callq 0x1e0a0
movslq %r15d, %rax
movq 0x8(%rbx,%rax,8), %r15
jmp 0x67cc
leaq 0xc(%rsp), %r12
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %edx
movq %r12, %rcx
callq 0x652c
movq %rax, %r15
movl (%r12), %eax
movl %eax, 0x110020(%rbx)
movq (%rbx), %rdi
movl %r14d, %esi
movl %ebp, %edx
movq %r15, %rcx
callq 0x17d88
movq %r15, 0x110028(%rbx)
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl $0x20002, %r15d         # imm = 0x20002
cmpl %ebx, (%r14,%r15,4)
jne 0x6913
leal -0x20002(%r15), %esi
movq %r14, %rdi
callq 0x65bc
movq -0x100008(%r14,%r15,8), %rdi
movl $0x1, %esi
callq 0x53a0
movq $0x0, -0x100008(%r14,%r15,8)
incq %r15
cmpq $0x30002, %r15          # imm = 0x30002
jne 0x68e0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movb $0x0, (%rdi)
movq $0x0, 0x8(%rdi)
callq 0xd118
movq %rbx, %rdi
callq 0xd118
leaq 0x38(%rsp), %rdi
movq %r14, %rsi
movq %rbx, (%rsp)
callq 0x8e86
leaq 0x3a2d2(%rip), %rsi     # 0x40c46
movq %rbx, %rdi
callq 0x8eb2
movq %rax, %r15
leaq 0x38(%rsp), %r12
movq %r12, %rdi
callq 0xd118
movb (%r15), %al
movb (%r12), %cl
movb %cl, (%r15)
movb %al, (%r12)
leaq 0x40(%rsp), %r13
movq 0x8(%r15), %rax
movq (%r13), %rcx
movq %rcx, 0x8(%r15)
movq %rax, (%r13)
movq %r15, %rdi
callq 0xd118
movq %r12, %rdi
callq 0xd118
movzbl -0x8(%r13), %esi
movq %r13, %rdi
callq 0xd1ba
movl 0x820(%r14), %eax
leaq 0x28(%rsp), %r15
movb $0x6, (%r15)
movq %rax, 0x8(%r15)
movq %r15, %rdi
callq 0xd118
movq %r15, %rdi
callq 0xd118
leaq 0x35ccd(%rip), %rsi     # 0x3c6c4
movq %rbx, %rdi
callq 0x8eb2
movq %rax, %r15
leaq 0x30(%rsp), %r12
leaq 0x28(%rsp), %r13
movq %r13, %rdi
callq 0xd118
movb (%r15), %al
movb (%r13), %cl
movb %cl, (%r15)
movb %al, (%r13)
movq 0x8(%r15), %rax
movq 0x8(%r13), %rcx
movq %rcx, 0x8(%r15)
movq %rax, 0x8(%r13)
movq %r15, %rdi
callq 0xd118
movq %r13, %rdi
callq 0xd118
movzbl (%r13), %esi
movq %r12, %rdi
callq 0xd1ba
movq 0x840(%r14), %rax
leaq 0x18(%rsp), %r15
movb $0x6, (%r15)
movq %rax, 0x8(%r15)
movq %r15, %rdi
callq 0xd118
movq %r15, %rdi
callq 0xd118
leaq 0x35c54(%rip), %rsi     # 0x3c6ce
movq %rbx, %rdi
callq 0x8eb2
movq %rax, %r15
leaq 0x20(%rsp), %r12
leaq 0x18(%rsp), %r13
movq %r13, %rdi
callq 0xd118
movb (%r15), %al
movb (%r13), %cl
movb %cl, (%r15)
movb %al, (%r13)
movq 0x8(%r15), %rax
movq 0x8(%r13), %rcx
movq %rcx, 0x8(%r15)
movq %rax, 0x8(%r13)
movq %r15, %rdi
callq 0xd118
movq %r13, %rdi
callq 0xd118
movzbl (%r13), %esi
movq %r12, %rdi
callq 0xd1ba
cmpl $0x0, 0x820(%r14)
je 0x6b3a
leaq 0x10(%rsp), %r15
xorl %ebx, %ebx
leaq 0x35be8(%rip), %r12     # 0x3c6d2
leaq 0x8(%rsp), %r13
movq (%rsp), %rdi
movq %r12, %rsi
callq 0x8eb2
movq %rax, %rbp
movq 0x20(%r14,%rbx,8), %rsi
movq %r13, %rdi
callq 0x1fbf2
movq %rbp, %rdi
movq %r13, %rsi
callq 0x9096
movq %r13, %rdi
callq 0xd118
movzbl 0x8(%rsp), %esi
movq %r15, %rdi
callq 0xd1ba
incq %rbx
movl 0x820(%r14), %eax
cmpq %rax, %rbx
jb 0x6aef
movq (%rsp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x18(%rsp), %rdi
jmp 0x6b7c
movq %rax, %r14
leaq 0x28(%rsp), %rdi
jmp 0x6b7c
movq %rax, %r14
leaq 0x38(%rsp), %rdi
jmp 0x6b7c
jmp 0x6b6f
jmp 0x6b6f
movq %rax, %r14
jmp 0x6b81
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x907c
movq (%rsp), %rdi
callq 0x907c
movq %r14, %rdi
callq 0x56e0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x3a099(%rip), %rsi     # 0x40c46
movq %rbx, %rdi
callq 0x8eb2
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x91f2
movq (%r15), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x5360
leaq 0x28(%rsp), %rax
cmpq %rax, %r15
je 0x6bed
movq 0x28(%rsp), %rsi
incq %rsi
movq %r15, %rdi
callq 0x53a0
leaq 0x35ad0(%rip), %rsi     # 0x3c6c4
movq %rbx, %rdi
callq 0x8eb2
leaq 0x18(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0xdf5b
movl (%r15), %eax
movl %eax, 0x820(%r14)
leaq 0x35ab1(%rip), %rsi     # 0x3c6ce
movq %rbx, %rdi
callq 0x8eb2
leaq 0x18(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0xe980
movq (%r15), %rax
movq %rax, 0x840(%r14)
cmpl $0x0, 0x820(%r14)
je 0x6cbf
xorl %r12d, %r12d
leaq 0x35a7f(%rip), %r13     # 0x3c6d2
leaq 0x8(%rsp), %rbp
movl $0x9fe8, %edi           # imm = 0x9FE8
callq 0x5390
movq %rax, %r15
movq %rbx, %rdi
movq %r13, %rsi
callq 0x8eb2
movq %rax, %rdi
movq %r12, %rsi
callq 0x9240
movq %rbp, %rdi
movq %rax, %rsi
callq 0x942c
movq %r15, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x20352
movq %r15, 0x20(%r14,%r12,8)
movq %rbp, %rdi
callq 0xd118
movzbl 0x8(%rsp), %esi
leaq 0x10(%rsp), %rdi
callq 0xd1ba
incq %r12
movl 0x820(%r14), %eax
cmpq %rax, %r12
jb 0x6c58
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x907c
jmp 0x6ce0
movq %rax, %rbx
movl $0x9fe8, %esi           # imm = 0x9FE8
movq %r15, %rdi
callq 0x53a0
movq %rbx, %rdi
callq 0x56e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %r14
movl $0x9fe8, %edi           # imm = 0x9FE8
callq 0x5390
movq %rax, %rbx
movq %rax, %rdi
callq 0x979c
movl 0x820(%r14), %esi
movl $0x1, (%rsp)
movq %rbx, %rdi
movq %r14, %rdx
movq %r12, %rcx
movl %ebp, %r8d
movq %r15, %r9
callq 0x20d90
testl %eax, %eax
je 0x722d
movq %rbx, %rdi
callq 0x20bde
movl $0x9fe8, %esi           # imm = 0x9FE8
movq %rbx, %rdi
callq 0x53a0
xorl %ebx, %ebx
jmp 0x724b
movl 0x820(%r14), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x820(%r14)
movq %rbx, 0x20(%r14,%rax,8)
movq %r14, %rdi
callq 0x6cf6
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0x9fe8, %esi           # imm = 0x9FE8
movq %rbx, %rdi
callq 0x53a0
movq %r14, %rdi
callq 0x56e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl 0x820(%rdi), %r12d
testq %r12, %r12
je 0x72af
movq %rsi, %rbx
movq %rdi, %r14
xorl %r13d, %r13d
movq 0x20(%r14,%r13,8), %r15
leaq 0x18(%r15), %rdi
movq %rbx, %rsi
callq 0x5520
testl %eax, %eax
je 0x72b2
incq %r13
cmpq %r13, %r12
jne 0x7292
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Konano[P]UselessDatabase/Database.cpp
// Function: Database::deleteTable(char const*)
int Database::deleteTable(const char* name) { // -1: doesn't exist, 0: OK
    int num = this->findTable(std::string(name));
    if (num == -1) return -1;
    delete table[num];
    for (uint i = num; i < table_num - 1; i++) {
        table[i] = table[i + 1];
        table[i]->table_id = i;
    }
    table[--table_num] = nullptr;
    fm->deleteFile(dirPath(this->name, name, "usid"));
    update();
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
leaq 0x7(%rsp), %rdx
movq %r15, %rdi
callq 0x9860
movq %rbx, %rdi
movq %r15, %rsi
callq 0x73d4
movl %eax, %ebp
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x730a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53a0
cmpl $-0x1, %ebp
je 0x735c
movslq %ebp, %rax
movq 0x20(%rbx,%rax,8), %r15
testq %r15, %r15
je 0x7324
movq %r15, %rdi
callq 0x20bde
movl $0x9fe8, %esi           # imm = 0x9FE8
movq %r15, %rdi
callq 0x53a0
movl 0x820(%rbx), %eax
decl %eax
cmpl %eax, %ebp
jae 0x7363
movl %ebp, %edx
movl %eax, %ecx
movq 0x28(%rbx,%rdx,8), %rsi
movq %rsi, 0x20(%rbx,%rdx,8)
movl %edx, 0x50(%rsi)
leaq 0x1(%rdx), %rsi
movq %rsi, %rdx
cmpq %rsi, %rcx
jne 0x7341
jmp 0x7365
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x73a2
movl %eax, %ecx
movl %eax, 0x820(%rbx)
movq $0x0, 0x20(%rbx,%rcx,8)
movq 0x828(%rbx), %r15
leaq 0x3536c(%rip), %rdx     # 0x3c6ee
movq %rbx, %rdi
movq %r14, %rsi
callq 0x17f62
movq %r15, %rdi
movq %rax, %rsi
callq 0x17d80
movq %rbx, %rdi
callq 0x6cf6
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x73cb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53a0
movq %rbx, %rdi
callq 0x56e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Konano[P]UselessDatabase/Database.cpp
// Function: Database::showTables()
void Database::showTables() {
    std::vector<std::pair<std::string, int> > v;
    v.push_back(std::pair<std::string, int>("Table", 20));
    Print::title(v);
    Anys d;
    for (uint i = 0; i < table_num; i++) {
        d.push_back(Any((char*)table[i]->name));
        Print::row(d);
        d.clear();
    }
    Print::end();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movq $0x0, 0x50(%rsp)
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x35216(%rip), %rsi     # 0x3c6f3
leaq 0x35214(%rip), %rdx     # 0x3c6f8
leaq 0x10(%rsp), %rdi
callq 0xa960
leaq 0x10(%rsp), %rsi
movl $0x14, 0x20(%rsi)
leaq 0x40(%rsp), %rdi
callq 0x1755c
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x751b
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x53a0
leaq 0x58(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x989e
leaq 0x58(%rsp), %rdi
callq 0x1ea24
leaq 0x58(%rsp), %rdi
callq 0x9938
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
cmpl $0x0, 0x820(%rbx)
je 0x7619
xorl %r13d, %r13d
leaq 0x10(%rsp), %rbp
leaq 0x70(%rsp), %r12
movq 0x20(%rbx,%r13,8), %r14
movl $0x10, %edi
callq 0x5390
addq $0x18, %r14
leaq 0x4b4cd(%rip), %rcx     # 0x52a50
movq %rcx, (%rax)
movq %r14, 0x8(%rax)
movq %rax, 0x8(%rsp)
movq %rbp, %rdi
leaq 0x8(%rsp), %rsi
callq 0x9f9a
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x75ac
movq (%rdi), %rax
callq *0x8(%rax)
movq %r12, %rdi
movq %rbp, %rsi
callq 0xa26a
movq %r12, %rdi
callq 0x1f028
movq %r12, %rdi
callq 0xa37e
movq 0x10(%rsp), %r14
movq 0x18(%rsp), %r15
cmpq %r14, %r15
je 0x7607
movq %rbx, %r12
movq %rbp, %rbx
movq %r14, %rbp
movq (%rbp), %rdi
testq %rdi, %rdi
je 0x75ee
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %rbp
cmpq %r15, %rbp
jne 0x75df
movq %r14, 0x18(%rsp)
movq %rbx, %rbp
movq %r12, %rbx
leaq 0x70(%rsp), %r12
incq %r13
movl 0x820(%rbx), %eax
cmpq %rax, %r13
jb 0x7569
callq 0x1f368
leaq 0x10(%rsp), %rdi
callq 0xa37e
leaq 0x40(%rsp), %rdi
callq 0x9938
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x768f
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x9938
jmp 0x76ab
jmp 0x7673
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x76ab
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x53a0
jmp 0x76ab
movq %rax, %rbx
jmp 0x76ab
jmp 0x768f
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x76a1
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x76a1
movq %rax, %rbx
jmp 0x76a1
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xa37e
leaq 0x10(%rsp), %rdi
callq 0xa37e
leaq 0x40(%rsp), %rdi
callq 0x9938
movq %rbx, %rdi
callq 0x56e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Konano[P]UselessDatabase/Database.cpp
// Function: Database::getVarchar(unsigned long)
char* Database::getVarchar(uint64_t idx) {
    uint page = idx >> 32;
    uint offset = (idx & 0xffffffff) >> 16;
    uint size = idx & 0xffff;
    BufType buf = bpm->getPage(mem_file, page) + offset;
    char* str = new char[size + 1]; 
    char* _str = str;
    while (true) {
        if (PAGE_SIZE - offset > size) {
            memcpy(str, buf, size);
            offset += size;
            break;
        } else {
            memcpy(str, buf, (PAGE_SIZE - offset));
            str += PAGE_SIZE - offset;
            size -= PAGE_SIZE - offset;
            page += 1;
            offset = 0;
            buf = bpm->getPage(mem_file, page) + offset;
        }
    }
    
    str[size] = '\0';
    return _str;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbp
movl %r14d, %r13d
movzwl %r14w, %r15d
shrq $0x20, %r14
shrl $0x10, %r13d
movq 0x830(%rdi), %rdi
movl 0x838(%rbp), %esi
movl %r14d, %edx
callq 0x6722
leaq (%rax,%r13), %r12
leal 0x1(%r15), %edi
callq 0x5040
movl $0x2000, %ebx           # imm = 0x2000
subl %r13d, %ebx
cmpl %r15d, %ebx
movq %rax, (%rsp)
jbe 0x7719
movq %rax, %r13
movq %r12, %rax
jmp 0x7767
incl %r14d
movq %rax, %r13
movq %r12, %rax
movq %rbp, %r12
movl %ebx, %ebp
movq %r13, %rdi
movq %rax, %rsi
movq %rbp, %rdx
callq 0x5310
addq %rbp, %r13
movq %r12, %rbp
subl %ebx, %r15d
movq 0x830(%r12), %rdi
movl 0x838(%r12), %esi
movl %r14d, %edx
callq 0x6722
incl %r14d
movl $0x2000, %ebx           # imm = 0x2000
cmpl $0x2000, %r15d          # imm = 0x2000
jae 0x7722
movl %r15d, %ebx
movq %r13, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x5310
movb $0x0, (%r13,%rbx)
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Konano[P]UselessDatabase/Database.cpp
// Function: cmpCol(enumOp, Anys&, Anys&)
bool cmpCol(enumOp op, Anys &a, Anys &b) {
    switch (op) {
    case OP_EQ: return a == b;
    case OP_NEQ: return a != b;
    case OP_LE: return a <= b;
    case OP_GE: return a >= b;
    case OP_LS: return a < b;
    case OP_GT: return a > b;
    default: return false;
    }
}

// Assembly:
pushq %rax
cmpl $0x5, %edi
ja 0x790e
movl %edi, %eax
leaq 0x34768(%rip), %rcx     # 0x3c020
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rsi, %rdi
movq %rdx, %rsi
popq %rax
jmp 0x9996
movq %rsi, %rdi
movq %rdx, %rsi
popq %rax
jmp 0x9a04
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x9aa6
jmp 0x78fe
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x9a04
jmp 0x78fe
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x9996
xorb $0x1, %al
jmp 0x7910
movq %rsi, %rdi
movq %rdx, %rsi
popq %rax
jmp 0x9aa6
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O3/Konano[P]UselessDatabase/./json.hpp
// Function: 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>::push_back(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 push_back(basic_json&& val)
    {
        // push_back only works for null objects or arrays
        if (JSON_HEDLEY_UNLIKELY(not(is_null() or is_array())))
        {
            JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));
        }

        // transform null object into an array
        if (is_null())
        {
            m_type = value_t::array;
            m_value = value_t::array;
            assert_invariant();
        }

        // add element to array (move semantics)
        m_value.array->push_back(std::move(val));
        // invalidate object: mark it null so we do not call the destructor
        // cppcheck-suppress accessMoved
        val.m_type = value_t::null;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movzbl (%rdi), %eax
testl %eax, %eax
jne 0x90d7
movb $0x2, (%r14)
movl $0x18, %edi
callq 0x5390
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x8(%r14)
movq %r14, %rdi
callq 0xd118
jmp 0x90dc
cmpl $0x2, %eax
jne 0x90f6
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0xd5e8
movb $0x0, (%rbx)
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x5210
movq %rax, %rbx
movzbl (%r14), %eax
cmpq $0x8, %rax
ja 0x911a
leaq 0x499a4(%rip), %rcx     # 0x52ab8
movq (%rcx,%rax,8), %r14
jmp 0x9121
leaq 0x343d4(%rip), %r14     # 0x3d4f5
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq %r14, %rdi
callq 0x51f0
leaq (%rax,%r14), %rdx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0xa960
leaq 0x34437(%rip), %rsi     # 0x3d581
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0xbd1e
movb $0x1, %bpl
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
movl $0x134, %esi            # imm = 0x134
callq 0xbb5e
xorl %ebp, %ebp
leaq 0x496c1(%rip), %rsi     # 0x52838
leaq 0x8714(%rip), %rdx      # 0x11892
movq %rbx, %rdi
callq 0x56b0
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x91a4
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x53a0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x91bb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53a0
testb %bpl, %bpl
jne 0x91e1
jmp 0x91e9
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x91e1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53a0
jmp 0x91e1
movq %rax, %r14
movq %rbx, %rdi
callq 0x52d0
movq %r14, %rdi
callq 0x56e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Konano[P]UselessDatabase/./json.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> 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>::get<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 0>() const
ValueType get() const noexcept(noexcept(
                                       JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), std::declval<ValueType&>())))
    {
        // we cannot static_assert on ValueTypeCV being non-const, because
        // there is support for get<const basic_json_t>(), which is why we
        // still need the uncvref
        static_assert(not std::is_reference<ValueTypeCV>::value,
                      "get() cannot be used with reference types, you might want to use get_ref()");
        static_assert(std::is_default_constructible<ValueType>::value,
                      "types must be DefaultConstructible when used with get()");

        ValueType ret;
        JSONSerializer<ValueType>::from_json(*this, ret);
        return ret;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
movq %rbx, %rsi
callq 0xde35
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x9237
movq (%r15), %rsi
incq %rsi
callq 0x53a0
movq %r14, %rdi
callq 0x56e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Konano[P]UselessDatabase/./json.hpp
// Function: nlohmann::detail::serializer<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>>::dump_float(double)
void dump_float(number_float_t x)
    {
        // NaN / inf
        if (not std::isfinite(x))
        {
            o->write_characters("null", 4);
            return;
        }

        // If number_float_t is an IEEE-754 single or double precision number,
        // use the Grisu2 algorithm to produce short numbers which are
        // guaranteed to round-trip, using strtof and strtod, resp.
        //
        // NB: The test below works if <long double> == <double>.
        static constexpr bool is_ieee_single_or_double
            = (std::numeric_limits<number_float_t>::is_iec559 and std::numeric_limits<number_float_t>::digits == 24 and std::numeric_limits<number_float_t>::max_exponent == 128) or
              (std::numeric_limits<number_float_t>::is_iec559 and std::numeric_limits<number_float_t>::digits == 53 and std::numeric_limits<number_float_t>::max_exponent == 1024);

        dump_float(x, std::integral_constant<bool, is_ieee_single_or_double>());
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
jl 0xbb31
movq (%rbx), %rdi
movq (%rdi), %rax
movq 0x8(%rax), %rax
leaq 0x30e0c(%rip), %rsi     # 0x3c92f
movl $0x4, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
leaq 0x10(%rbx), %r14
leaq 0x50(%rbx), %rsi
movq %r14, %rdi
callq 0xc32c
movq (%rbx), %rdi
subq %r14, %rax
movq (%rdi), %rcx
movq 0x8(%rcx), %rcx
movq %r14, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rcx
nop