LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x9a08
testl %eax, %eax
je 0x99bb
movl 0x50(%r15), %r12d
xorl %r13d, %r13d
testl %r12d, %r12d
movl $0x0, %ebp
cmovgl %r12d, %ebp
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x97e6
movapd %xmm0, %xmm2
cmpl $0x2, %r12d
pushq $0x1
popq %r14
cmovnel %ebp, %r14d
movsd %xmm0, (%rsp)
cmpq %r13, %r14
je 0x99a2
movsd (%rbx,%r13,8), %xmm0
xorpd 0x3303(%rip), %xmm0     # 0xcc80
callq 0x22a0
movsd (%rsp), %xmm2
movsd 0x32b1(%rip), %xmm1     # 0xcc40
addsd %xmm1, %xmm0
divsd %xmm0, %xmm1
movsd %xmm1, (%rbx,%r13,8)
incq %r13
jmp 0x996a
cmpl $0x2, %r12d
jne 0x99d2
movsd 0x3290(%rip), %xmm0     # 0xcc40
subsd (%rbx), %xmm0
movsd %xmm0, 0x8(%rbx)
jmp 0x99bf
xorpd %xmm2, %xmm2
movapd %xmm2, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
testl %r12d, %r12d
cmovlel %eax, %r12d
xorpd %xmm0, %xmm0
cmpq %rax, %r12
je 0x99ee
addsd (%rbx,%rax,8), %xmm0
incq %rax
jmp 0x99df
xorl %eax, %eax
cmpq %rax, %r12
je 0x99bf
movsd (%rbx,%rax,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rbx,%rax,8)
incq %rax
jmp 0x99f0
// File: /workspace/github_cpp_makefile_star2_O2/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:
xorps %xmm0, %xmm0
testl %esi, %esi
js 0xa1e2
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
cmpl %esi, 0x54(%rdi)
jl 0xa1da
movl %edx, %ebx
movl (%rdi), %r12d
movl 0x50(%rdi), %r15d
movq 0x58(%rdi), %r14
callq 0x64dc
testl %eax, %eax
setne %al
cmpl $0x15, %r12d
sete %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0xa18e
movl %ebp, %eax
movsd (%r14,%rax,8), %xmm0
jmp 0xa1da
testl %ebx, %ebx
setns %al
cmpl %ebx, %r15d
setg %cl
andb %al, %cl
cmpb $0x1, %cl
xorps %xmm0, %xmm0
jne 0xa1da
cmpl $0x2, %r15d
sete %al
cmpl $0x4, %r12d
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0xa1cd
movl %ebp, %eax
movsd (%r14,%rax,8), %xmm0
testl %ebx, %ebx
je 0xa1da
xorps 0x2ab5(%rip), %xmm0     # 0xcc80
jmp 0xa1da
imull %ebp, %r15d
addl %ebx, %r15d
movsd (%r14,%r15,8), %xmm0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rax
cmpl $0x15, (%rdi)
je 0xa216
movsd 0x68(%rdi), %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jae 0xa214
movl %esi, %edx
movl 0x54(%rdi), %esi
movsd %xmm1, (%rsp)
callq 0xa145
movsd (%rsp), %xmm1
mulsd %xmm0, %xmm1
movapd %xmm1, %xmm0
popq %rax
retq
movq 0x6dc3(%rip), %rax      # 0x10fe0
movq (%rax), %rcx
leaq 0x2f12(%rip), %rdi      # 0xd139
pushq $0x43
popq %rsi
pushq $0x1
popq %rdx
callq 0x22f0
xorpd %xmm0, %xmm0
jmp 0xa214
// File: /workspace/github_cpp_makefile_star2_O2/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 0xa243
movsd 0x70(%rdi), %xmm0
retq
pushq %rax
movq 0x6d95(%rip), %rax      # 0x10fe0
movq (%rax), %rcx
leaq 0x2f28(%rip), %rdi      # 0xd17d
pushq $0x43
popq %rsi
pushq $0x1
popq %rdx
callq 0x22f0
xorps %xmm0, %xmm0
addq $0x8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movq 0x58(%rdi), %rdi
callq 0x21a0
andq $0x0, 0x58(%rbx)
movq 0x60(%rbx), %rdi
callq 0x21a0
andq $0x0, 0x60(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x21a0
andq $0x0, 0x20(%rbx)
movq 0x28(%rbx), %rdi
callq 0x21a0
andq $0x0, 0x28(%rbx)
movq 0x40(%rbx), %rdi
callq 0x21a0
andq $0x0, 0x40(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x38, %rsp
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r13
movl %ecx, 0x4(%rsp)
movq %rdi, 0x20(%rsp)
movslq %r14d, %rax
movq %rax, 0x30(%rsp)
shlq $0x4, %rax
addq %r13, %rax
movq %rax, 0x28(%rsp)
movl %r14d, 0x8(%rsp)
movl %ebp, %ebx
subl %r14d, %ebx
je 0xb41d
cmpl %ecx, %ebp
jl 0xb41d
callq 0x2090
incl %ebx
cltd
idivl %ebx
addl %r14d, %edx
movslq %edx, %rax
shlq $0x4, %rax
movl %ebp, 0xc(%rsp)
movslq %ebp, %rbx
movq %rbx, %rcx
shlq $0x4, %rcx
leaq (%rcx,%r13), %r12
movups (%r13,%rax), %xmm0
movaps %xmm0, 0x10(%rsp)
movups (%r13,%rcx), %xmm0
movups %xmm0, (%r13,%rax)
movaps 0x10(%rsp), %xmm0
movups %xmm0, (%r13,%rcx)
movq 0x28(%rsp), %r13
movq 0x30(%rsp), %rbp
movl %r14d, %r15d
movslq %r15d, %r14
cmpq %rbx, %rbp
jge 0xb3c7
movq %r13, %rdi
movq %r12, %rsi
callq 0xb42c
cmpl $-0x1, %eax
jne 0xb3be
shlq $0x4, %r14
movq 0x20(%rsp), %rax
movups (%rax,%r14), %xmm0
movaps %xmm0, 0x10(%rsp)
movups (%r13), %xmm0
movups %xmm0, (%rax,%r14)
movaps 0x10(%rsp), %xmm0
movups %xmm0, (%r13)
incl %r15d
incq %rbp
addq $0x10, %r13
jmp 0xb37c
movq %r14, %rax
shlq $0x4, %rax
movups (%r12), %xmm0
movaps %xmm0, 0x10(%rsp)
movq 0x20(%rsp), %r13
movups (%r13,%rax), %xmm0
movups %xmm0, (%r12)
movaps 0x10(%rsp), %xmm0
movups %xmm0, (%r13,%rax)
movl 0x4(%rsp), %ecx
cmpl %ecx, %r14d
movl 0xc(%rsp), %ebp
movl 0x8(%rsp), %r14d
je 0xb41d
jl 0xb412
decl %r15d
movl %r15d, %ebp
jmp 0xb314
incl %r15d
movl %r15d, %r14d
jmp 0xb2fb
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $-0x1
popq %rax
ucomisd %xmm0, %xmm1
ja 0xb458
ucomisd %xmm1, %xmm0
jne 0xb455
jp 0xb455
movl (%rdi), %ecx
movl (%rsi), %edx
cmpl %edx, %ecx
jl 0xb458
xorl %eax, %eax
cmpl %edx, %ecx
je 0xb458
pushq $0x1
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
xorpd %xmm0, %xmm0
movslq (%rsi), %rax
cmpq $-0x1, %rax
je 0xb47c
movsd -0x8(%rdi,%rax,8), %xmm1
mulsd 0x8(%rsi), %xmm1
addsd %xmm1, %xmm0
addq $0x10, %rsi
jmp 0xb45e
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
xorpd %xmm0, %xmm0
cmpl $-0x1, (%rdi)
je 0xb4d6
movsd 0x8(%rdi), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
addq $0x10, %rdi
jmp 0xb4be
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
xorpd %xmm0, %xmm0
movl (%rdi), %eax
cmpl $-0x1, %eax
je 0xb514
movl (%rsi), %ecx
cmpl $-0x1, %ecx
je 0xb514
cmpl %ecx, %eax
je 0xb4f6
jle 0xb50e
addq $0x10, %rsi
jmp 0xb4de
movsd 0x8(%rdi), %xmm1
mulsd 0x8(%rsi), %xmm1
addsd %xmm1, %xmm0
addq $0x10, %rdi
addq $0x10, %rsi
jmp 0xb4dc
addq $0x10, %rdi
jmp 0xb4dc
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/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 0xb6a2
movsd (%rsi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xb5fc
jnp 0xb6a2
movslq (%rcx), %rcx
movslq (%r9), %rsi
movl %ecx, %edi
xorl $0x1, %edi
movl %esi, %r9d
xorl $0x1, %r9d
orl %edi, %r9d
jne 0xb6a5
leaq -0x3(%rax), %rsi
xorl %ecx, %ecx
cmpq %rsi, %rcx
jge 0xb69d
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
jmp 0xb61d
movsd (%rdx,%rcx,8), %xmm1
mulsd %xmm0, %xmm1
addsd (%r8,%rcx,8), %xmm1
movsd %xmm1, (%r8,%rcx,8)
incq %rcx
cmpq %rax, %rcx
jl 0xb685
xorl %eax, %eax
retq
pushq $0x1
popq %rdi
subq %rax, %rdi
movq %rdi, %r9
imulq %rcx, %r9
xorl %r10d, %r10d
testl %ecx, %ecx
cmovnsq %r10, %r9
imulq %rsi, %rdi
testl %esi, %esi
cmovnsq %r10, %rdi
leaq (%r8,%rdi,8), %rdi
shlq $0x3, %rsi
leaq (%rdx,%r9,8), %rdx
shlq $0x3, %rcx
subq $0x1, %rax
jb 0xb6a2
movsd (%rdx), %xmm1
mulsd %xmm0, %xmm1
addsd (%rdi), %xmm1
movsd %xmm1, (%rdi)
addq %rsi, %rdi
addq %rcx, %rdx
jmp 0xb6d5
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xb793
movslq (%rdx), %rdx
movslq (%r8), %rdi
movl %edx, %r8d
xorl $0x1, %r8d
movl %edi, %r9d
xorl $0x1, %r9d
orl %r8d, %r9d
jne 0xb797
leaq -0x4(%rax), %rdi
xorpd %xmm0, %xmm0
xorl %edx, %edx
cmpq %rdi, %rdx
jge 0xb78d
movsd (%rsi,%rdx,8), %xmm1
movsd 0x8(%rsi,%rdx,8), %xmm2
mulsd 0x8(%rcx,%rdx,8), %xmm2
mulsd (%rcx,%rdx,8), %xmm1
movsd 0x10(%rsi,%rdx,8), %xmm3
mulsd 0x10(%rcx,%rdx,8), %xmm3
addsd %xmm2, %xmm1
movsd 0x18(%rsi,%rdx,8), %xmm2
mulsd 0x18(%rcx,%rdx,8), %xmm2
addsd %xmm1, %xmm3
movsd 0x20(%rsi,%rdx,8), %xmm1
mulsd 0x20(%rcx,%rdx,8), %xmm1
addsd %xmm3, %xmm2
addsd %xmm2, %xmm1
addsd %xmm1, %xmm0
addq $0x5, %rdx
jmp 0xb723
movsd (%rsi,%rdx,8), %xmm1
mulsd (%rcx,%rdx,8), %xmm1
addsd %xmm1, %xmm0
incq %rdx
cmpq %rax, %rdx
jl 0xb77c
retq
xorps %xmm0, %xmm0
retq
pushq $0x1
popq %r8
subq %rax, %r8
movq %r8, %r9
imulq %rdx, %r9
xorl %r10d, %r10d
testl %edx, %edx
cmovnsq %r10, %r9
imulq %rdi, %r8
testl %edi, %edi
cmovnsq %r10, %r8
leaq (%rsi,%r9,8), %rsi
shlq $0x3, %rdx
leaq (%rcx,%r8,8), %rcx
shlq $0x3, %rdi
xorpd %xmm0, %xmm0
subq $0x1, %rax
jb 0xb792
movsd (%rsi), %xmm1
mulsd (%rcx), %xmm1
addsd %xmm1, %xmm0
addq %rdx, %rsi
addq %rdi, %rcx
jmp 0xb7cc
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xb869
movsd (%rsi), %xmm0
cmpl $0x1, %ecx
jne 0xb86c
leaq -0x4(%rax), %rsi
movapd %xmm0, %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
xorl %ecx, %ecx
cmpq %rsi, %rcx
jge 0xb864
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
jmp 0xb81a
movsd (%rdx,%rcx,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rdx,%rcx,8)
incq %rcx
cmpq %rax, %rcx
jl 0xb853
xorl %eax, %eax
retq
movslq %ecx, %rcx
imulq %rcx, %rax
xorl %esi, %esi
cmpq %rax, %rsi
jge 0xb869
movsd (%rdx,%rsi,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rdx,%rsi,8)
addq %rcx, %rsi
jmp 0xb875
// File: /workspace/github_cpp_makefile_star2_O2/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 0x19ad2
movl %eax, (%rbx)
movslq %eax, %r12
cmpq $0x0, 0x8(%r14,%r12,8)
je 0x5ad7
movq %r14, %rdi
movl %eax, %esi
callq 0x5b2c
movslq (%rbx), %r12
jmp 0x5af5
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 0x5270
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 0x14d64
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_O2/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 0x5b67
movq (%rbx), %rdi
movl 0x80008(%rbx,%r14,4), %esi
movl 0xc0008(%rbx,%r14,4), %edx
movq 0x8(%rbx,%r14,8), %rcx
callq 0x147a6
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 0x14d9c
// File: /workspace/github_cpp_makefile_star2_O2/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 0x147f4
movl $0xc0008, %edi          # imm = 0xC0008
callq 0x53e0
movq %rax, %r14
movq %rbx, 0xc0000(%rax)
leaq 0x80000(%rax), %rdi
movl $0x40000, %edx          # imm = 0x40000
xorl %esi, %esi
callq 0x5270
movq %r14, 0x110008(%rbx)
movl $0x8000c, %edi          # imm = 0x8000C
callq 0x53e0
movq %rax, %r14
movq %rax, %rdi
callq 0x19a70
movq %r14, 0x110010(%rbx)
orl $-0x1, 0x110020(%rbx)
orq $-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 0x5270
movq %rax, %rbx
movl $0x8000c, %esi          # imm = 0x8000C
movq %r14, %rdi
callq 0x53f0
movq %rbx, %rdi
callq 0x56f0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
pushq $0x1
popq %r15
cmpq $0x10000, %r14          # imm = 0x10000
je 0x5c5f
movq %rbx, %rdi
movl %r14d, %esi
callq 0x5b2c
movq 0x8(%rbx,%r14,8), %rdi
movq %r15, %rsi
callq 0x53f0
incq %r14
jmp 0x5c39
movq 0x110008(%rbx), %rdi
movl $0xc0008, %esi          # imm = 0xC0008
callq 0x53f0
movq 0x110010(%rbx), %rdi
movl $0x8000c, %esi          # imm = 0x8000C
popq %rbx
popq %r14
popq %r15
jmp 0x53f0
movq %rax, %rdi
callq 0x5e9c
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5cbe
cmpl %ebp, 0x11001c(%rbx)
jne 0x5cbe
movq 0x110028(%rbx), %r15
jmp 0x5d3f
movl %r14d, 0x110018(%rbx)
movl %ebp, 0x11001c(%rbx)
movq 0x110008(%rbx), %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x14cf0
movl %eax, 0xc(%rsp)
movl %eax, 0x110020(%rbx)
cmpl $-0x1, %eax
je 0x5d06
movl %eax, %r15d
movq 0x110010(%rbx), %rdi
movl %eax, %esi
callq 0x19a8a
movslq %r15d, %rax
movq 0x8(%rbx,%rax,8), %r15
jmp 0x5d38
leaq 0xc(%rsp), %r12
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %edx
movq %r12, %rcx
callq 0x5a9c
movq %rax, %r15
movl (%r12), %eax
movl %eax, 0x110020(%rbx)
movq (%rbx), %rdi
movl %r14d, %esi
movl %ebp, %edx
movq %r15, %rcx
callq 0x14758
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_O2/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 %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl $0x20002, %r12d         # imm = 0x20002
pushq $0x1
popq %r15
cmpq $0x30002, %r12          # imm = 0x30002
je 0x5e90
cmpl %ebx, (%r14,%r12,4)
jne 0x5e8b
leal -0x20002(%r12), %esi
movq %r14, %rdi
callq 0x5b2c
movq -0x100008(%r14,%r12,8), %rdi
movq %r15, %rsi
callq 0x53f0
andq $0x0, -0x100008(%r14,%r12,8)
incq %r12
jmp 0x5e53
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %r13
movq %rdi, %rbx
xorl %esi, %esi
callq 0x7c48
leaq 0x28(%rsp), %rdi
movq %r13, %rsi
movq %rbx, (%rsp)
callq 0x7c64
leaq 0x32153(%rip), %rsi     # 0x3802e
movq %rbx, %rdi
callq 0x7c7e
leaq 0x28(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x7da0
movq %r15, %rdi
callq 0x7de0
leaq 0x820(%r13), %r15
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0x7dfa
leaq 0x2d7ae(%rip), %rsi     # 0x336c4
movq %rbx, %rdi
callq 0x7c7e
leaq 0x18(%rsp), %r12
movq %rax, %rdi
movq %r12, %rsi
callq 0x7da0
movq %r12, %rdi
callq 0x7de0
movq %r13, %r14
leaq 0x840(%r13), %rsi
leaq 0x8(%rsp), %rdi
callq 0x7e14
leaq 0x2d77d(%rip), %rsi     # 0x336ce
movq %rbx, %rdi
callq 0x7c7e
leaq 0x8(%rsp), %r12
movq %rax, %rdi
movq %r12, %rsi
callq 0x7da0
movq %r12, %rdi
callq 0x7de0
xorl %ebx, %ebx
leaq 0x2d758(%rip), %r12     # 0x336d2
leaq 0x38(%rsp), %r13
movl (%r15), %eax
cmpq %rax, %rbx
jae 0x5fbb
movq (%rsp), %rdi
movq %r12, %rsi
callq 0x7c7e
movq %rax, %rbp
movq 0x20(%r14,%rbx,8), %rsi
movq %r13, %rdi
callq 0x1abb2
movq %rbp, %rdi
movq %r13, %rsi
callq 0x7e2e
movq %r13, %rdi
callq 0x7de0
incq %rbx
jmp 0x5f7f
movq (%rsp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x5ff6
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
jmp 0x5ff6
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0x5ff6
jmp 0x5fff
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x7de0
jmp 0x6002
jmp 0x5fff
movq %rax, %rbx
movq (%rsp), %rdi
callq 0x7de0
movq %rbx, %rdi
callq 0x56f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x31fff(%rip), %rsi     # 0x3802e
movq %rbx, %rdi
callq 0x7c7e
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x7f18
movq (%r15), %rsi
movq %r14, %rdi
callq 0x53b0
movq %r15, %rdi
callq 0x5200
leaq 0x2d663(%rip), %rsi     # 0x336c4
movq %rbx, %rdi
callq 0x7c7e
movq %rax, %rdi
callq 0x7f58
movl %eax, 0x820(%r14)
leaq 0x2d64f(%rip), %rsi     # 0x336ce
movq %rbx, %rdi
callq 0x7c7e
movq %rax, %rdi
callq 0x7f72
movq %rax, 0x840(%r14)
xorl %r15d, %r15d
leaq 0x2d632(%rip), %r12     # 0x336d2
leaq 0x8(%rsp), %r13
movl 0x820(%r14), %eax
cmpq %rax, %r15
jae 0x60ff
movl $0x9fe8, %edi           # imm = 0x9FE8
callq 0x53e0
movq %rax, %rbp
movq %rbx, %rdi
movq %r12, %rsi
callq 0x7c7e
movq %rax, %rdi
movq %r15, %rsi
callq 0x7f8e
movq %r13, %rdi
movq %rax, %rsi
callq 0x80e2
movq %rbp, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x1b022
movq %rbp, 0x20(%r14,%r15,8)
movq %r13, %rdi
callq 0x7de0
incq %r15
jmp 0x60a5
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x7de0
jmp 0x6120
movq %rax, %rbx
movl $0x9fe8, %esi           # imm = 0x9FE8
movq %rbp, %rdi
callq 0x53f0
movq %rbx, %rdi
callq 0x56f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x53e0
movq %rax, %rbx
movq %rax, %rdi
callq 0x8396
movl 0x820(%r14), %esi
movl $0x1, (%rsp)
movq %rbx, %rdi
movq %r14, %rdx
movq %r12, %rcx
movl %ebp, %r8d
movq %r15, %r9
callq 0x1b786
testl %eax, %eax
je 0x653d
movq %rbx, %rdi
callq 0x1b666
movl $0x9fe8, %esi           # imm = 0x9FE8
movq %rbx, %rdi
callq 0x53f0
xorl %ebx, %ebx
jmp 0x655b
movl 0x820(%r14), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x820(%r14)
movq %rbx, 0x20(%r14,%rax,8)
movq %r14, %rdi
callq 0x6136
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 0x53f0
movq %r14, %rdi
callq 0x56f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rsi, %rbx
movq %rdi, %r14
movl 0x820(%rdi), %r12d
xorl %r13d, %r13d
cmpq %r13, %r12
je 0x65bc
movq 0x20(%r14,%r13,8), %r15
leaq 0x18(%r15), %rdi
movq %rbx, %rsi
callq 0x5560
incq %r13
testl %eax, %eax
jne 0x659d
jmp 0x65bf
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x84b8
movq %rbx, %rdi
movq %r15, %rsi
callq 0x66ac
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x5200
cmpl $-0x1, %ebp
je 0x6689
movslq %ebp, %rax
movq 0x20(%rbx,%rax,8), %r15
testq %r15, %r15
je 0x661f
movq %r15, %rdi
callq 0x1b666
movl $0x9fe8, %esi           # imm = 0x9FE8
movq %r15, %rdi
callq 0x53f0
movl 0x820(%rbx), %eax
decl %eax
movl %ebp, %ecx
cmpq %rax, %rcx
jae 0x664d
movq 0x28(%rbx,%rcx,8), %rdx
movq %rdx, 0x20(%rbx,%rcx,8)
movl %ecx, 0x50(%rdx)
incq %rcx
jmp 0x6636
movl %eax, 0x820(%rbx)
andq $0x0, 0x20(%rbx,%rax,8)
movq 0x828(%rbx), %r15
leaq 0x2d087(%rip), %rdx     # 0x336ee
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14944
movq %r15, %rdi
movq %rax, %rsi
callq 0x14750
movq %rbx, %rdi
callq 0x6136
xorl %eax, %eax
jmp 0x668c
pushq $-0x1
popq %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5200
movq %rbx, %rdi
callq 0x56f0
// File: /workspace/github_cpp_makefile_star2_O2/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
andq $0x0, 0x20(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq %rsp, %rdx
movl $0x14, (%rdx)
leaq 0x2cf9f(%rip), %rsi     # 0x336f3
leaq 0x30(%rsp), %rdi
callq 0x84f4
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x140da
leaq 0x30(%rsp), %rdi
callq 0x5200
leaq 0x58(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x8516
leaq 0x58(%rsp), %rdi
callq 0x19ef4
leaq 0x58(%rsp), %rdi
callq 0x8570
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %r14
movaps %xmm0, (%r14)
andq $0x0, 0x10(%r14)
xorl %ebp, %ebp
leaq 0x8(%rsp), %r15
movq %rsp, %r12
leaq 0x70(%rsp), %r13
movl 0x820(%rbx), %eax
cmpq %rax, %rbp
jae 0x6820
movq 0x20(%rbx,%rbp,8), %rax
addq $0x18, %rax
movq %rax, (%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x8592
movq %r14, %rdi
movq %r15, %rsi
callq 0x8ea0
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x67f8
movq (%rdi), %rax
callq *0x8(%rax)
movq %r13, %rdi
movq %r14, %rsi
callq 0x9158
movq %r13, %rdi
callq 0x1a1e4
movq %r13, %rdi
callq 0x9268
movq %r14, %rdi
callq 0x928a
incq %rbp
jmp 0x67ba
callq 0x1a388
leaq 0x30(%rsp), %rdi
callq 0x9268
leaq 0x10(%rsp), %rdi
callq 0x8570
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6883
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x8570
jmp 0x6890
jmp 0x686d
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x5200
jmp 0x6890
movq %rax, %rbx
jmp 0x6890
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x9268
jmp 0x6886
jmp 0x6883
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x9268
leaq 0x10(%rsp), %rdi
callq 0x8570
movq %rbx, %rdi
callq 0x56f0
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x6886
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x6886
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movl %r14d, %r15d
movzwl %r14w, %ebp
shrq $0x20, %r14
shrl $0x10, %r15d
movq 0x830(%rdi), %rdi
movl 0x838(%rbx), %esi
movl %r14d, %edx
callq 0x5c8e
leaq (%r15,%rax), %r12
leal 0x1(%rbp), %edi
callq 0x5040
movq %rax, %r13
movl $0x2000, %eax           # imm = 0x2000
subl %r15d, %eax
incl %r14d
movq %r13, (%rsp)
movl %ebp, %r15d
subl %eax, %r15d
jb 0x694b
movl %eax, %ebp
movq %r13, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x5350
addq %rbp, %r13
movq 0x830(%rbx), %rdi
movl 0x838(%rbx), %esi
movl %r14d, %edx
callq 0x5c8e
movq %rax, %r12
incl %r14d
movl $0x2000, %eax           # imm = 0x2000
movl %r15d, %ebp
jmp 0x690e
movl %ebp, %ebx
movq %r13, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x5350
movb $0x0, (%r13,%rbx)
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Konano[P]UselessDatabase/Database.cpp
// Function: Database::storeVarchar(char*)
uint64_t Database::storeVarchar(char* str) {
    uint size = strlen(str);
    uint64_t out = (mem << 16) + size;

    int index;
    uint page = mem >> 16;
    uint offset = mem & 0xffff;
    BufType buf = bpm->getPage(mem_file, page, index) + offset;
    while (true) {
        if (PAGE_SIZE - offset > size) {
            memcpy(buf, str, size);
            offset += size;
            break;
        } else {
            memcpy(buf, str, (PAGE_SIZE - offset));
            str += PAGE_SIZE - offset;
            size -= PAGE_SIZE - offset;
            page += 1;
            offset = 0;
            bpm->markDirty(index);
            buf = bpm->getPage(mem_file, page, index) + offset;
        }
    }
    bpm->markDirty(index);
    mem = ((uint64_t)page << 16) + offset;
    return out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x51e0
movq %rax, %r12
movq 0x840(%rbx), %r13
movq %r13, %r14
shrq $0x10, %r14
movzwl %r13w, %ebp
movq 0x830(%rbx), %rdi
movl 0x838(%rbx), %esi
leaq 0x4(%rsp), %rcx
movl %r14d, %edx
callq 0x5d50
movq %r13, 0x8(%rsp)
movzwl %r13w, %edi
addq %rax, %rdi
movq %r12, 0x10(%rsp)
movl %r12d, %r13d
movl $0x2000, %eax           # imm = 0x2000
subl %ebp, %eax
subl %eax, %r12d
jb 0x6a26
movl %eax, %ebp
movq %r15, %rsi
movq %rbp, %rdx
callq 0x5350
addq %rbp, %r15
incl %r14d
movq 0x830(%rbx), %rdi
movl 0x4(%rsp), %esi
callq 0x5e0a
movq 0x830(%rbx), %rdi
movl 0x838(%rbx), %esi
movl %r14d, %edx
leaq 0x4(%rsp), %rcx
callq 0x5d50
movq %rax, %rdi
xorl %ebp, %ebp
movl %r12d, %r13d
jmp 0x69d3
movq 0x8(%rsp), %rax
shlq $0x10, %rax
movl 0x10(%rsp), %r12d
addq %rax, %r12
movl %r13d, %edx
movq %r15, %rsi
callq 0x5350
addl %r13d, %ebp
movq 0x830(%rbx), %rdi
movl 0x4(%rsp), %esi
callq 0x5e0a
movl %r14d, %eax
shlq $0x10, %rax
addq %rax, %rbp
movq %rbp, 0x840(%rbx)
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
cmpl $0x5, %edi
ja 0x6ad1
movl %edi, %eax
leaq 0x2c59a(%rip), %rcx     # 0x33020
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rsi, %rdi
movq %rdx, %rsi
jmp 0x85ea
movq %rsi, %rdi
movq %rdx, %rsi
jmp 0x866e
movq %rsi, %rdi
movq %rdx, %rsi
jmp 0x865a
movq %rsi, %rdi
movq %rdx, %rsi
jmp 0x8664
movq %rsi, %rdi
movq %rdx, %rsi
jmp 0x8650
movq %rsi, %rdi
movq %rdx, %rsi
jmp 0x8700
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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>& 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>::operator[]<char const>(char const*)
JSON_HEDLEY_NON_NULL(2)
    reference operator[](T* key)
    {
        // implicitly convert null to object
        if (is_null())
        {
            m_type = value_t::object;
            m_value = value_t::object;
            assert_invariant();
        }

        // at only works for objects
        if (JSON_HEDLEY_LIKELY(is_object()))
        {
            return m_value.object->operator[](key);
        }

        JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name())));
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movb (%rdi), %al
testb %al, %al
jne 0x7caa
movb $0x1, (%r14)
callq 0xc41c
movq %rax, 0x8(%r14)
movq %r14, %rdi
callq 0xbd38
movb (%r14), %al
cmpb $0x1, %al
jne 0x7cea
movq 0x8(%r14), %r14
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rdx
movq %rbx, %rsi
callq 0x84b8
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0xc666
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5200
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x5240
movq %rax, %rbx
movq %r14, %rdi
callq 0xc6cc
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %rax, %rsi
callq 0x84b8
leaq 0x2c9ce(%rip), %rsi     # 0x346e4
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0xaa7f
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x131, %esi            # imm = 0x131
callq 0xa98c
xorl %ebp, %ebp
leaq 0x47c55(%rip), %rsi     # 0x4f998
leaq 0x7c1e(%rip), %rdx      # 0xf968
movq %rbx, %rdi
callq 0x56c0
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x5200
jmp 0x7d97
movq %rax, %r14
jmp 0x7d97
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x5200
jmp 0x7d7b
movq %rax, %r14
movb $0x1, %bpl
leaq 0x30(%rsp), %rdi
callq 0x5200
testb %bpl, %bpl
jne 0x7d8f
jmp 0x7d97
movq %rax, %r14
movq %rbx, %rdi
callq 0x5300
movq %r14, %rdi
callq 0x56f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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>::operator=(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>)
basic_json& operator=(basic_json other) noexcept (
        std::is_nothrow_move_constructible<value_t>::value and
        std::is_nothrow_move_assignable<value_t>::value and
        std::is_nothrow_move_constructible<json_value>::value and
        std::is_nothrow_move_assignable<json_value>::value
    )
    {
        // check that passed value is valid
        other.assert_invariant();

        using std::swap;
        swap(m_type, other.m_type);
        swap(m_value, other.m_value);

        assert_invariant();
        return *this;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0xbd38
movb (%r14), %al
movb (%rbx), %cl
movb %cl, (%r14)
movb %al, (%rbx)
movq 0x8(%r14), %rax
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%r14)
movq %rax, 0x8(%rbx)
movq %r14, %rdi
callq 0xbd38
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movzbl (%rdi), %eax
testl %eax, %eax
jne 0x7e5a
movb $0x2, (%r14)
callq 0xc470
movq %rax, 0x8(%r14)
movq %r14, %rdi
callq 0xbd38
jmp 0x7e5f
cmpl $0x2, %eax
jne 0x7e77
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0xc1ae
movb $0x0, (%rbx)
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x5240
movq %rax, %rbx
movq %r14, %rdi
callq 0xc6cc
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %rax, %rsi
callq 0x84b8
leaq 0x2caa3(%rip), %rsi     # 0x34946
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0xaa7f
movb $0x1, %bpl
leaq 0x30(%rsp), %rdx
movq %rbx, %rdi
movl $0x134, %esi            # imm = 0x134
callq 0xa98c
xorl %ebp, %ebp
leaq 0x47ac8(%rip), %rsi     # 0x4f998
leaq 0x7a91(%rip), %rdx      # 0xf968
movq %rbx, %rdi
callq 0x56c0
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x5200
jmp 0x7ef4
movq %rax, %r14
movb $0x1, %bpl
leaq 0x10(%rsp), %rdi
callq 0x5200
testb %bpl, %bpl
jne 0x7f08
jmp 0x7f10
movq %rax, %r14
movq %rbx, %rdi
callq 0x5300
movq %r14, %rdi
callq 0x56f0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
movq %rbx, %rsi
callq 0xcba8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x5200
movq %r14, %rdi
callq 0x56f0