LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
movslq %r15d, %r12
movq %r12, %rax
negq %rax
movq %rax, 0x10(%rsp)
shlq $0x4, %r12
addq %r14, %r12
movl %ebp, %r13d
subl %r15d, %r13d
je 0xc2d6
cmpl %ebx, %ebp
jl 0xc2d6
callq 0x2090
leal 0x1(%r13), %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)
movl %r15d, %eax
cmpl %r15d, %ebp
jle 0xc299
addq 0x10(%rsp), %rdx
movq %r12, %rsi
movl %r15d, %eax
movsd 0x8(%rsi), %xmm0
movsd 0x8(%rcx), %xmm1
ucomisd %xmm0, %xmm1
ja 0xc26b
ucomisd %xmm1, %xmm0
jne 0xc290
jp 0xc290
movl (%rcx), %edi
cmpl %edi, (%rsi)
jge 0xc290
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 0xc24d
movslq %eax, %rdx
movq %rdx, %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, %edx
je 0xc2d6
jl 0xc2cc
decl %eax
movl %eax, %ebp
jmp 0xc1e4
incl %eax
movl %eax, %r15d
jmp 0xc1cf
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc315
ucomisd %xmm1, %xmm0
jne 0xc310
jp 0xc310
movl (%rdi), %ecx
movl (%rsi), %edx
cmpl %edx, %ecx
jl 0xc315
xorl %eax, %eax
cmpl %edx, %ecx
je 0xc315
movl $0x1, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/cjlin1[P]liblinear/blas/dnrm2.c
// Function: dnrm2_
double dnrm2_(int *n, double *x, int *incx)
{
  long int ix, nn, iincx;
  double norm, scale, absxi, ssq, temp;

/*  DNRM2 returns the euclidean norm of a vector via the function
    name, so that

       DNRM2 := sqrt( x'*x )

    -- This version written on 25-October-1982.
       Modified on 14-October-1993 to inline the call to SLASSQ.
       Sven Hammarling, Nag Ltd.   */

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

  if( nn > 0 && iincx > 0 )
  {
    if (nn == 1)
    {
      norm = fabs(x[0]);
    }
    else
    {
      scale = 0.0;
      ssq = 1.0;

      /* The following loop is equivalent to this call to the LAPACK
         auxiliary routine:   CALL SLASSQ( N, X, INCX, SCALE, SSQ ) */

      for (ix=(nn-1)*iincx; ix>=0; ix-=iincx)
      {
        if (x[ix] != 0.0)
        {
          absxi = fabs(x[ix]);
          if (scale < absxi)
          {
            temp = scale / absxi;
            ssq = ssq * (temp * temp) + 1.0;
            scale = absxi;
          }
          else
          {
            temp = absxi / scale;
            ssq += temp * temp;
          }
        }
      }
      norm = scale * sqrt(ssq);
    }
  }
  else
    norm = 0.0;

  return norm;

}

// Assembly:
movslq (%rdi), %rax
testq %rax, %rax
setg %dil
movl (%rdx), %ecx
testl %ecx, %ecx
setg %dl
andb %dil, %dl
xorpd %xmm6, %xmm6
cmpb $0x1, %dl
jne 0xc3f9
cmpl $0x1, %eax
jne 0xc362
movsd (%rsi), %xmm0
andps 0x18df(%rip), %xmm0     # 0xdc40
retq
movslq %ecx, %rcx
decq %rax
imulq %rcx, %rax
xorpd %xmm1, %xmm1
testq %rax, %rax
js 0xc3cd
xorpd %xmm2, %xmm2
movsd 0x1897(%rip), %xmm3     # 0xdc18
movapd 0x18b7(%rip), %xmm4     # 0xdc40
movapd %xmm3, %xmm0
movsd (%rsi,%rax,8), %xmm5
ucomisd %xmm2, %xmm5
jne 0xc39a
jnp 0xc3c6
andpd %xmm4, %xmm5
ucomisd %xmm6, %xmm5
jbe 0xc3ba
divsd %xmm5, %xmm6
mulsd %xmm6, %xmm6
mulsd %xmm6, %xmm0
addsd %xmm3, %xmm0
movapd %xmm5, %xmm6
jmp 0xc3c6
divsd %xmm6, %xmm5
mulsd %xmm5, %xmm5
addsd %xmm5, %xmm0
subq %rcx, %rax
jns 0xc38d
jmp 0xc3d5
movsd 0x1843(%rip), %xmm0     # 0xdc18
ucomisd %xmm1, %xmm0
jb 0xc3e1
sqrtsd %xmm0, %xmm0
jmp 0xc3f5
pushq %rax
movsd %xmm6, (%rsp)
callq 0x20e0
movsd (%rsp), %xmm6
addq $0x8, %rsp
mulsd %xmm0, %xmm6
movapd %xmm6, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc521
movsd (%rsi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xc420
jnp 0xc521
movslq (%rcx), %rcx
movslq (%r9), %rsi
movl %ecx, %edi
xorl $0x1, %edi
movl %esi, %r9d
xorl $0x1, %r9d
orl %edi, %r9d
jne 0xc4ae
cmpl $0x4, %eax
jl 0xc4fd
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 0xc446
jmp 0xc4ff
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 0xc4e0
jmp 0xc521
xorl %ecx, %ecx
cmpq %rax, %rcx
jge 0xc521
movsd (%rdx,%rcx,8), %xmm1
mulsd %xmm0, %xmm1
addsd (%r8,%rcx,8), %xmm1
movsd %xmm1, (%r8,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0xc504
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc5b5
movslq (%rdx), %rdx
movslq (%r8), %rdi
movl %edx, %r8d
xorl $0x1, %r8d
movl %edi, %r9d
xorl $0x1, %r9d
orl %r8d, %r9d
jne 0xc5b9
cmpl $0x5, %eax
jl 0xc609
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 0xc55c
jmp 0xc60f
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 0xc5f0
jmp 0xc62a
xorpd %xmm0, %xmm0
xorl %edx, %edx
cmpq %rax, %rdx
jge 0xc62a
movsd (%rsi,%rdx,8), %xmm1
mulsd (%rcx,%rdx,8), %xmm1
addsd %xmm1, %xmm0
incq %rdx
cmpq %rdx, %rax
jne 0xc614
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc6fa
movsd (%rsi), %xmm0
cmpl $0x1, %ecx
jne 0xc6bc
cmpl $0x5, %eax
jl 0xc6dd
leaq -0x4(%rax), %rsi
xorl %ecx, %ecx
movsd (%rdx,%rcx,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rdx,%rcx,8)
movsd 0x8(%rdx,%rcx,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rdx,%rcx,8)
movsd 0x10(%rdx,%rcx,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rdx,%rcx,8)
movsd 0x18(%rdx,%rcx,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x18(%rdx,%rcx,8)
movsd 0x20(%rdx,%rcx,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x20(%rdx,%rcx,8)
addq $0x5, %rcx
cmpq %rsi, %rcx
jl 0xc663
jmp 0xc6df
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 0xc6c5
jmp 0xc6fa
xorl %ecx, %ecx
cmpq %rax, %rcx
jge 0xc6fa
movsd (%rdx,%rcx,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rdx,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0xc6e4
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
incq 0x18(%rdi)
incq 0x20(%rdi)
cmpb $0x1, 0x14(%rdi)
jne 0x580e
movb $0x0, 0x14(%rbx)
jmp 0x5819
movq (%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, 0x10(%rbx)
movl 0x10(%rbx), %eax
cmpl $-0x1, %eax
je 0x5831
leaq 0x30(%rbx), %rdi
leaq 0xf(%rsp), %rsi
movb %al, (%rsi)
callq 0x100fe
movl 0x10(%rbx), %eax
cmpl $0xa, %eax
jne 0x5842
incq 0x28(%rbx)
andq $0x0, 0x20(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1e778
movl %eax, (%rbx)
movslq %eax, %r12
cmpq $0x0, 0x8(%r14,%r12,8)
je 0x6594
movq %r14, %rdi
movl %eax, %esi
callq 0x65ec
jmp 0x65b2
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
movslq (%rbx), %rax
movl %r15d, 0x80008(%r14,%rax,4)
movslq (%rbx), %rax
movl %ebp, 0xc0008(%r14,%rax,4)
movq 0x110008(%r14), %rdi
movl (%rbx), %ecx
movl %r15d, %esi
movl %ebp, %edx
callq 0x18ab0
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_O1/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 0x6627
movq (%rbx), %rdi
movl 0x80008(%rbx,%r14,4), %esi
movl 0xc0008(%rbx,%r14,4), %edx
movq 0x8(%rbx,%r14,8), %rcx
callq 0x1852a
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 0x18afe
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1856c
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 0x1e714
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_O1/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 0x65ec
movq 0x8(%rbx,%r14,8), %rdi
testq %rdi, %rdi
je 0x6719
movl $0x1, %esi
callq 0x53a0
incq %r14
cmpq $0x10000, %r14          # imm = 0x10000
jne 0x66fa
movq 0x110008(%rbx), %rdi
testq %rdi, %rdi
je 0x673b
movl $0xc0008, %esi          # imm = 0xC0008
callq 0x53a0
movq 0x110010(%rbx), %rdi
testq %rdi, %rdi
je 0x6758
movl $0x8000c, %esi          # imm = 0x8000C
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x53a0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x697a
// File: /workspace/github_cpp_makefile_star2_O1/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 0x67a2
cmpl %ebp, 0x11001c(%rbx)
jne 0x67a2
movl 0x110020(%rbx), %eax
movl %eax, 0xc(%rsp)
movq 0x110028(%rbx), %r15
jmp 0x6823
movl %r14d, 0x110018(%rbx)
movl %ebp, 0x11001c(%rbx)
movq 0x110008(%rbx), %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x18a14
movl %eax, 0xc(%rsp)
movl %eax, 0x110020(%rbx)
cmpl $-0x1, %eax
je 0x67ea
movl %eax, %r15d
movq 0x110010(%rbx), %rdi
movl %eax, %esi
callq 0x1e730
movslq %r15d, %rax
movq 0x8(%rbx,%rax,8), %r15
jmp 0x681c
leaq 0xc(%rsp), %r12
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %edx
movq %r12, %rcx
callq 0x655c
movq %rax, %r15
movl (%r12), %eax
movl %eax, 0x110020(%rbx)
movq (%rbx), %rdi
movl %r14d, %esi
movl %ebp, %edx
movq %r15, %rcx
callq 0x184e8
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_O1/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 0x6968
leal -0x20002(%r15), %esi
movq %r14, %rdi
callq 0x65ec
movq -0x100008(%r14,%r15,8), %rdi
testq %rdi, %rdi
je 0x695c
movl $0x1, %esi
callq 0x53a0
movq $0x0, -0x100008(%r14,%r15,8)
incq %r15
cmpq $0x30002, %r15          # imm = 0x30002
jne 0x6930
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xd52a
movq %rbx, %rdi
callq 0xd52a
leaq 0x38(%rsp), %rdi
movq %r14, %rsi
movq %rbx, (%rsp)
callq 0x8f74
leaq 0x3b24a(%rip), %rsi     # 0x41c16
movq %rbx, %rdi
callq 0x8fa0
movq %rax, %r15
leaq 0x38(%rsp), %r12
movq %r12, %rdi
callq 0xd52a
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 0xd52a
movq %r12, %rdi
callq 0xd52a
movzbl -0x8(%r13), %esi
movq %r13, %rdi
callq 0xd5cc
leaq 0x28(%rsp), %r15
movb $0x0, (%r15)
movq $0x0, 0x8(%r15)
movl 0x820(%r14), %eax
movb $0x6, (%r15)
movq %rax, 0x8(%r15)
movq %r15, %rdi
callq 0xd52a
movq %r15, %rdi
callq 0xd52a
leaq 0x36c69(%rip), %rsi     # 0x3d6c4
movq %rbx, %rdi
callq 0x8fa0
movq %rax, %r15
leaq 0x30(%rsp), %r12
leaq 0x28(%rsp), %r13
movq %r13, %rdi
callq 0xd52a
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 0xd52a
movq %r13, %rdi
callq 0xd52a
movzbl (%r13), %esi
movq %r12, %rdi
callq 0xd5cc
leaq 0x18(%rsp), %r15
movb $0x0, (%r15)
movq $0x0, 0x8(%r15)
movq 0x840(%r14), %rax
movb $0x6, (%r15)
movq %rax, 0x8(%r15)
movq %r15, %rdi
callq 0xd52a
movq %r15, %rdi
callq 0xd52a
leaq 0x36be4(%rip), %rsi     # 0x3d6ce
movq %rbx, %rdi
callq 0x8fa0
movq %rax, %r15
leaq 0x20(%rsp), %r12
leaq 0x18(%rsp), %r13
movq %r13, %rdi
callq 0xd52a
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 0xd52a
movq %r13, %rdi
callq 0xd52a
movzbl (%r13), %esi
movq %r12, %rdi
callq 0xd5cc
cmpl $0x0, 0x820(%r14)
je 0x6baa
leaq 0x10(%rsp), %r15
xorl %ebx, %ebx
leaq 0x36b78(%rip), %r12     # 0x3d6d2
leaq 0x8(%rsp), %r13
movq (%rsp), %rdi
movq %r12, %rsi
callq 0x8fa0
movq %rax, %rbp
movq 0x20(%r14,%rbx,8), %rsi
movq %r13, %rdi
callq 0x202aa
movq %rbp, %rdi
movq %r13, %rsi
callq 0x9178
movq %r13, %rdi
callq 0xd52a
movzbl 0x8(%rsp), %esi
movq %r15, %rdi
callq 0xd5cc
incq %rbx
movl 0x820(%r14), %eax
cmpq %rax, %rbx
jb 0x6b5f
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 0x6bec
movq %rax, %r14
leaq 0x28(%rsp), %rdi
jmp 0x6bec
movq %rax, %r14
leaq 0x38(%rsp), %rdi
jmp 0x6bec
jmp 0x6bdf
jmp 0x6bdf
movq %rax, %r14
jmp 0x6bf1
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x915e
movq (%rsp), %rdi
callq 0x915e
movq %r14, %rdi
callq 0x56e0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3aff9(%rip), %rsi     # 0x41c16
movq %rbx, %rdi
callq 0x8fa0
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x92c0
movq (%r15), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x5360
leaq 0x28(%rsp), %rax
cmpq %rax, %r15
je 0x6c5d
movq 0x28(%rsp), %rsi
incq %rsi
movq %r15, %rdi
callq 0x53a0
leaq 0x36a60(%rip), %rsi     # 0x3d6c4
movq %rbx, %rdi
callq 0x8fa0
leaq 0x18(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0xe350
movl (%r15), %eax
movl %eax, 0x820(%r14)
leaq 0x36a41(%rip), %rsi     # 0x3d6ce
movq %rbx, %rdi
callq 0x8fa0
leaq 0x18(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0xed56
movq (%r15), %rax
movq %rax, 0x840(%r14)
cmpl $0x0, 0x820(%r14)
je 0x6d2f
xorl %r12d, %r12d
leaq 0x36a0f(%rip), %r13     # 0x3d6d2
leaq 0x8(%rsp), %rbp
movl $0x9fe8, %edi           # imm = 0x9FE8
callq 0x5390
movq %rax, %r15
movq %rbx, %rdi
movq %r13, %rsi
callq 0x8fa0
movq %rax, %rdi
movq %r12, %rsi
callq 0x930e
movq %rbp, %rdi
movq %rax, %rsi
callq 0x94e0
movq %r15, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x20a60
movq %r15, 0x20(%r14,%r12,8)
movq %rbp, %rdi
callq 0xd52a
movzbl 0x8(%rsp), %esi
leaq 0x10(%rsp), %rdi
callq 0xd5cc
incq %r12
movl 0x820(%r14), %eax
cmpq %rax, %r12
jb 0x6cc8
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x915e
jmp 0x6d50
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_O1/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 0x98c6
movl 0x820(%r14), %esi
movl $0x1, (%rsp)
movq %rbx, %rdi
movq %r14, %rdx
movq %r12, %rcx
movl %ebp, %r8d
movq %r15, %r9
callq 0x21422
testl %eax, %eax
je 0x724f
movq %rbx, %rdi
callq 0x21276
movl $0x9fe8, %esi           # imm = 0x9FE8
movq %rbx, %rdi
callq 0x53a0
xorl %ebx, %ebx
jmp 0x726d
movl 0x820(%r14), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x820(%r14)
movq %rbx, 0x20(%r14,%rax,8)
movq %r14, %rdi
callq 0x6d66
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_O1/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 0x72d1
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 0x72d4
incq %r13
cmpq %r13, %r12
jne 0x72b4
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x998a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x73f6
movl %eax, %ebp
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x732c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53a0
cmpl $-0x1, %ebp
je 0x73bf
movslq %ebp, %rax
movq 0x20(%rbx,%rax,8), %r15
testq %r15, %r15
je 0x7357
movq %r15, %rdi
callq 0x21276
movl $0x9fe8, %esi           # imm = 0x9FE8
movq %r15, %rdi
callq 0x53a0
movl 0x820(%rbx), %eax
decl %eax
movl %eax, %ecx
cmpl %eax, %ebp
jae 0x7380
movl %ebp, %edx
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 0x7367
movl %eax, 0x820(%rbx)
movq $0x0, 0x20(%rbx,%rcx,8)
movq 0x828(%rbx), %r15
leaq 0x36351(%rip), %rdx     # 0x3d6ee
movq %rbx, %rdi
movq %r14, %rsi
callq 0x186c1
movq %r15, %rdi
movq %rax, %rsi
callq 0x184e0
movq %rbx, %rdi
callq 0x6d66
xorl %eax, %eax
jmp 0x73c4
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
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 0x73ed
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53a0
movq %rbx, %rdi
callq 0x56e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x361fa(%rip), %rsi     # 0x3d6f3
leaq 0x361f8(%rip), %rdx     # 0x3d6f8
leaq 0x10(%rsp), %rdi
callq 0xaccc
leaq 0x10(%rsp), %rsi
movl $0x14, 0x20(%rsi)
leaq 0x40(%rsp), %rdi
callq 0x17cb2
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x7537
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x53a0
leaq 0x58(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x99c8
leaq 0x58(%rsp), %rdi
callq 0x1f11e
leaq 0x58(%rsp), %rdi
callq 0x9a62
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
cmpl $0x0, 0x820(%rbx)
je 0x7635
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 0x4c4b1(%rip), %rcx     # 0x53a50
movq %rcx, (%rax)
movq %r14, 0x8(%rax)
movq %rax, 0x8(%rsp)
movq %rbp, %rdi
leaq 0x8(%rsp), %rsi
callq 0xa1bc
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x75c8
movq (%rdi), %rax
callq *0x8(%rax)
movq %r12, %rdi
movq %rbp, %rsi
callq 0xa450
movq %r12, %rdi
callq 0x1f722
movq %r12, %rdi
callq 0xa564
movq 0x10(%rsp), %r14
movq 0x18(%rsp), %r15
cmpq %r14, %r15
je 0x7623
movq %rbx, %r12
movq %rbp, %rbx
movq %r14, %rbp
movq (%rbp), %rdi
testq %rdi, %rdi
je 0x760a
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %rbp
cmpq %r15, %rbp
jne 0x75fb
movq %r14, 0x18(%rsp)
movq %rbx, %rbp
movq %r12, %rbx
leaq 0x70(%rsp), %r12
incq %r13
movl 0x820(%rbx), %eax
cmpq %rax, %r13
jb 0x7585
callq 0x1fa62
leaq 0x10(%rsp), %rdi
callq 0xa564
leaq 0x40(%rsp), %rdi
callq 0x9a62
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x76ab
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x9a62
jmp 0x76c7
jmp 0x768f
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x76c7
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x53a0
jmp 0x76c7
movq %rax, %rbx
jmp 0x76c7
jmp 0x76ab
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x76bd
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x76bd
movq %rax, %rbx
jmp 0x76bd
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xa564
leaq 0x10(%rsp), %rdi
callq 0xa564
leaq 0x40(%rsp), %rdi
callq 0x9a62
movq %rbx, %rdi
callq 0x56e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6768
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 0x7735
movq %rax, %r13
movq %r12, %rax
jmp 0x7783
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 0x6768
incl %r14d
movl $0x2000, %ebx           # imm = 0x2000
cmpl $0x2000, %r15d          # imm = 0x2000
jae 0x773e
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_O1/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 0x51f0
movq %rax, 0x10(%rsp)
movl %eax, %r12d
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 0x6834
movq %rax, %rcx
movq %r13, 0x8(%rsp)
movzwl %r13w, %eax
addq %rcx, %rax
movl $0x2000, %r13d          # imm = 0x2000
subl %ebp, %r13d
cmpl %r12d, %r13d
ja 0x7870
movl %r13d, %ebp
movq %rax, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x5310
addq %rbp, %r15
subl %r13d, %r12d
incl %r14d
movq 0x830(%rbx), %rdi
movl 0x4(%rsp), %esi
callq 0x68ee
movq 0x830(%rbx), %rdi
movl 0x838(%rbx), %esi
movl %r14d, %edx
leaq 0x4(%rsp), %rcx
callq 0x6834
movl $0x2000, %r13d          # imm = 0x2000
cmpl $0x2000, %r12d          # imm = 0x2000
jae 0x781b
xorl %ebp, %ebp
movq 0x8(%rsp), %rcx
shlq $0x10, %rcx
movl 0x10(%rsp), %r13d
addq %rcx, %r13
movl %r12d, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x5310
addl %r12d, %ebp
movq 0x830(%rbx), %rdi
movl 0x4(%rsp), %esi
callq 0x68ee
movl %r14d, %eax
shlq $0x10, %rax
addq %rax, %rbp
movq %rbp, 0x840(%rbx)
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x792a
movl %edi, %eax
leaq 0x3574c(%rip), %rcx     # 0x3d020
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rsi, %rdi
movq %rdx, %rsi
popq %rax
jmp 0x9abe
movq %rsi, %rdi
movq %rdx, %rsi
popq %rax
jmp 0x9b3e
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x9be2
jmp 0x791a
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x9b3e
jmp 0x791a
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x9abe
xorb $0x1, %al
jmp 0x792c
movq %rsi, %rdi
movq %rdx, %rsi
popq %rax
jmp 0x9be2
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x0, (%rdi)
jne 0x8ff1
movb $0x1, (%r14)
movl $0x30, %edi
callq 0x5390
leaq 0x8(%rax), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, (%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq %rax, 0x8(%r14)
movq %r14, %rdi
callq 0xd52a
cmpb $0x1, (%r14)
jne 0x9052
movq 0x8(%r14), %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq %rbx, %rdi
callq 0x51f0
leaq (%rax,%rbx), %rdx
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0xaccc
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0xddd6
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x9044
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53a0
movq %rbx, %rax
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 0x9076
leaq 0x4aa48(%rip), %rcx     # 0x53ab8
movq (%rcx,%rax,8), %r14
jmp 0x907d
leaq 0x3547b(%rip), %r14     # 0x3e4f8
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq %r14, %rdi
callq 0x51f0
leaq (%rax,%r14), %rdx
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0xaccc
leaq 0x353f9(%rip), %rsi     # 0x3e49f
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0xc0ee
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x131, %esi            # imm = 0x131
callq 0xbf2e
xorl %ebp, %ebp
leaq 0x4a765(%rip), %rsi     # 0x53838
leaq 0x8d32(%rip), %rdx      # 0x11e0c
movq %rbx, %rdi
callq 0x56b0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x9155
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53a0
jmp 0x9155
movq %rax, %r14
jmp 0x9155
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9129
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53a0
jmp 0x9129
movq %rax, %r14
movb $0x1, %bpl
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x9148
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x53a0
jmp 0x9148
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x9155
movq %rbx, %rdi
callq 0x52d0
movq %r14, %rdi
callq 0x56e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
je 0x91b8
cmpl $0x2, %eax
je 0x91e0
movl $0x20, %edi
callq 0x5210
movq %rax, %rbx
movzbl (%r14), %eax
cmpq $0x8, %rax
ja 0x91fa
leaq 0x4a906(%rip), %rcx     # 0x53ab8
movq (%rcx,%rax,8), %r14
jmp 0x9201
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 0xd52a
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0xd9f0
movb $0x0, (%rbx)
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x352f7(%rip), %r14     # 0x3e4f8
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 0xaccc
leaq 0x3535a(%rip), %rsi     # 0x3e584
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0xc0ee
movb $0x1, %bpl
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
movl $0x134, %esi            # imm = 0x134
callq 0xbf2e
xorl %ebp, %ebp
leaq 0x4a5e1(%rip), %rsi     # 0x53838
leaq 0x8bae(%rip), %rdx      # 0x11e0c
movq %rbx, %rdi
callq 0x56b0
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x928c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x53a0
jmp 0x928c
movq %rax, %r14
movb $0x1, %bpl
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x92ab
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53a0
jmp 0x92ab
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x92b8
movq %rbx, %rdi
callq 0x52d0
movq %r14, %rdi
callq 0x56e0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xe23b
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x9305
movq (%r15), %rsi
incq %rsi
callq 0x53a0
movq %r14, %rdi
callq 0x56e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xbf01
movq (%rbx), %rdi
movq (%rdi), %rax
movq 0x8(%rax), %rax
leaq 0x31a3f(%rip), %rsi     # 0x3d932
movl $0x4, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
leaq 0x10(%rbx), %r14
leaq 0x50(%rbx), %rsi
movq %r14, %rdi
callq 0xc6fe
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