LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: rankValueFunc
static void rankValueFunc(sqlite3_context *pCtx){
  struct CallCount *p;
  p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p));
  if( p ){
    sqlite3_result_int64(pCtx, p->nValue);
    p->nValue = 0;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x18
popq %rsi
callq 0x225797
testq %rax, %rax
je 0x288528
movq %rax, %r14
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x22493c
andq $0x0, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: percent_rankValueFunc
static void percent_rankValueFunc(sqlite3_context *pCtx){
  struct CallCount *p;
  p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p));
  if( p ){
    p->nValue = p->nStep;
    if( p->nTotal>1 ){
      double r = (double)p->nValue / (double)(p->nTotal-1);
      sqlite3_result_double(pCtx, r);
    }else{
      sqlite3_result_double(pCtx, 0.0);
    }
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x18
popq %rsi
callq 0x225797
testq %rax, %rax
je 0x28856c
movq 0x8(%rax), %rdx
movq 0x10(%rax), %rcx
movq %rdx, (%rax)
cmpq $0x2, %rcx
jge 0x28856e
xorpd %xmm0, %xmm0
jmp 0x28857f
popq %rbx
retq
cvtsi2sd %rdx, %xmm0
decq %rcx
cvtsi2sd %rcx, %xmm1
divsd %xmm1, %xmm0
movq %rbx, %rdi
popq %rbx
jmp 0x22467f
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: cume_distValueFunc
static void cume_distValueFunc(sqlite3_context *pCtx){
  struct CallCount *p;
  p = (struct CallCount*)sqlite3_aggregate_context(pCtx, 0);
  if( p ){
    double r = (double)(p->nStep) / (double)(p->nTotal);
    sqlite3_result_double(pCtx, r);
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorl %esi, %esi
callq 0x225797
testq %rax, %rax
je 0x2885d4
cvtsi2sdq 0x8(%rax), %xmm0
cvtsi2sdq 0x10(%rax), %xmm1
divsd %xmm1, %xmm0
movq %rbx, %rdi
popq %rbx
jmp 0x22467f
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: ntileStepFunc
static void ntileStepFunc(
  sqlite3_context *pCtx,
  int nArg,
  sqlite3_value **apArg
){
  struct NtileCtx *p;
  assert( nArg==1 ); UNUSED_PARAMETER(nArg);
  p = (struct NtileCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p));
  if( p ){
    if( p->nTotal==0 ){
      p->nParam = sqlite3_value_int64(apArg[0]);
      if( p->nParam<=0 ){
        sqlite3_result_error(
            pCtx, "argument of ntile must be a positive integer", -1
        );
      }
    }
    p->nTotal++;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rdi, %rbx
pushq $0x18
popq %rsi
callq 0x225797
testq %rax, %rax
je 0x28862c
movq %rax, %r14
cmpq $0x0, (%rax)
jne 0x288629
movq (%r15), %rdi
callq 0x224451
movq %rax, 0x8(%r14)
testq %rax, %rax
jg 0x288629
leaq 0xf1f15(%rip), %rsi     # 0x37a533
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0x2246d3
incq (%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: ntileValueFunc
static void ntileValueFunc(sqlite3_context *pCtx){
  struct NtileCtx *p;
  p = (struct NtileCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p));
  if( p && p->nParam>0 ){
    int nSize = (p->nTotal / p->nParam);
    if( nSize==0 ){
      sqlite3_result_int64(pCtx, p->iRow+1);
    }else{
      i64 nLarge = p->nTotal - p->nParam*nSize;
      i64 iSmall = nLarge*(nSize+1);
      i64 iRow = p->iRow;

      assert( (nLarge*(nSize+1) + (p->nParam-nLarge)*nSize)==p->nTotal );

      if( iRow<iSmall ){
        sqlite3_result_int64(pCtx, 1 + iRow/(nSize+1));
      }else{
        sqlite3_result_int64(pCtx, 1 + nLarge + (iRow-iSmall)/nSize);
      }
    }
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x18
popq %rsi
callq 0x225797
testq %rax, %rax
je 0x28868c
movq %rax, %rcx
movq 0x8(%rax), %rdi
testq %rdi, %rdi
jle 0x28868c
movq (%rcx), %rsi
movq %rsi, %rax
cqto
idivq %rdi
testl %eax, %eax
je 0x28868e
movslq %eax, %r8
imulq %r8, %rdi
subq %rdi, %rsi
leal 0x1(%r8), %eax
movslq %eax, %rdi
movq %rsi, %rdx
imulq %rdi, %rdx
movq 0x10(%rcx), %rax
movq %rax, %rcx
subq %rdx, %rcx
jge 0x288697
cqto
idivq %rdi
movq %rax, %rsi
jmp 0x288692
popq %rbx
retq
movq 0x10(%rcx), %rsi
incq %rsi
jmp 0x2886a5
movq %rcx, %rax
cqto
idivq %r8
addq %rax, %rsi
incq %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x22493c
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: last_valueStepFunc
static void last_valueStepFunc(
  sqlite3_context *pCtx,
  int nArg,
  sqlite3_value **apArg
){
  struct LastValueCtx *p;
  UNUSED_PARAMETER(nArg);
  p = (struct LastValueCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p));
  if( p ){
    sqlite3_value_free(p->pVal);
    p->pVal = sqlite3_value_dup(apArg[0]);
    if( p->pVal==0 ){
      sqlite3_result_error_nomem(pCtx);
    }else{
      p->nVal++;
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rdi, %rbx
pushq $0x10
popq %rsi
callq 0x225797
testq %rax, %rax
je 0x2886f4
movq %rax, %r14
movq (%rax), %rdi
callq 0x2245fd
movq (%r15), %rdi
callq 0x224530
movq %rax, (%r14)
testq %rax, %rax
je 0x2886fa
incl 0x8(%r14)
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x224b94
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: last_valueFinalizeFunc
static void last_valueFinalizeFunc(sqlite3_context *pCtx){
  struct LastValueCtx *p;
  p = (struct LastValueCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p));
  if( p && p->pVal ){
    sqlite3_result_value(pCtx, p->pVal);
    sqlite3_value_free(p->pVal);
    p->pVal = 0;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x10
popq %rsi
callq 0x225797
testq %rax, %rax
je 0x28873a
movq %rax, %rbx
movq (%rax), %rsi
testq %rsi, %rsi
je 0x28873a
movq %r14, %rdi
callq 0x224a29
movq (%rbx), %rdi
callq 0x2245fd
andq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: last_valueValueFunc
static void last_valueValueFunc(sqlite3_context *pCtx){
  struct LastValueCtx *p;
  p = (struct LastValueCtx*)sqlite3_aggregate_context(pCtx, 0);
  if( p && p->pVal ){
    sqlite3_result_value(pCtx, p->pVal);
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorl %esi, %esi
callq 0x225797
testq %rax, %rax
je 0x288763
movq (%rax), %rsi
testq %rsi, %rsi
je 0x288763
movq %rbx, %rdi
popq %rbx
jmp 0x224a29
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: nth_valueStepFunc
static void nth_valueStepFunc(
  sqlite3_context *pCtx,
  int nArg,
  sqlite3_value **apArg
){
  struct NthValueCtx *p;
  p = (struct NthValueCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p));
  if( p ){
    i64 iVal;
    switch( sqlite3_value_numeric_type(apArg[1]) ){
      case SQLITE_INTEGER:
        iVal = sqlite3_value_int64(apArg[1]);
        break;
      case SQLITE_FLOAT: {
        double fVal = sqlite3_value_double(apArg[1]);
        if( ((i64)fVal)!=fVal ) goto error_out;
        iVal = (i64)fVal;
        break;
      }
      default:
        goto error_out;
    }
    if( iVal<=0 ) goto error_out;

    p->nStep++;
    if( iVal==p->nStep ){
      p->pValue = sqlite3_value_dup(apArg[0]);
      if( !p->pValue ){
        sqlite3_result_error_nomem(pCtx);
      }
    }
  }
  UNUSED_PARAMETER(nArg);
  UNUSED_PARAMETER(apArg);
  return;

 error_out:
  sqlite3_result_error(
      pCtx, "second argument to nth_value must be a positive integer", -1
  );
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
pushq $0x10
popq %rsi
callq 0x225797
testq %rax, %rax
je 0x288801
movq %rax, %r15
movq 0x8(%r14), %rdi
callq 0x22656f
cmpl $0x2, %eax
je 0x2887c2
cmpl $0x1, %eax
jne 0x288807
movq 0x8(%r14), %rdi
callq 0x224451
jmp 0x2887dd
movq 0x8(%r14), %rdi
callq 0x22442c
cvttsd2si %xmm0, %rax
cvtsi2sd %rax, %xmm1
ucomisd %xmm1, %xmm0
jne 0x288807
jp 0x288807
testq %rax, %rax
jle 0x288807
movq (%r15), %rcx
incq %rcx
movq %rcx, (%r15)
cmpq %rcx, %rax
jne 0x288801
movq (%r14), %rdi
callq 0x224530
movq %rax, 0x8(%r15)
testq %rax, %rax
je 0x28881e
popq %rbx
popq %r14
popq %r15
retq
leaq 0xf0736(%rip), %rsi     # 0x378f44
pushq $-0x1
popq %rdx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2246d3
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x224b94
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: nth_valueFinalizeFunc
static void nth_valueFinalizeFunc(sqlite3_context *pCtx){
  struct NthValueCtx *p;
  p = (struct NthValueCtx*)sqlite3_aggregate_context(pCtx, 0);
  if( p && p->pValue ){
    sqlite3_result_value(pCtx, p->pValue);
    sqlite3_value_free(p->pValue);
    p->pValue = 0;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %esi, %esi
callq 0x225797
testq %rax, %rax
je 0x288860
movq %rax, %rbx
movq 0x8(%rax), %rsi
testq %rsi, %rsi
je 0x288860
movq %r14, %rdi
callq 0x224a29
movq 0x8(%rbx), %rdi
callq 0x2245fd
andq $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: first_valueStepFunc
static void first_valueStepFunc(
  sqlite3_context *pCtx,
  int nArg,
  sqlite3_value **apArg
){
  struct NthValueCtx *p;
  p = (struct NthValueCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p));
  if( p && p->pValue==0 ){
    p->pValue = sqlite3_value_dup(apArg[0]);
    if( !p->pValue ){
      sqlite3_result_error_nomem(pCtx);
    }
  }
  UNUSED_PARAMETER(nArg);
  UNUSED_PARAMETER(apArg);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
pushq $0x10
popq %rsi
callq 0x225797
testq %rax, %rax
je 0x28889c
movq %rax, %r15
cmpq $0x0, 0x8(%rax)
jne 0x28889c
movq (%r14), %rdi
callq 0x224530
movq %rax, 0x8(%r15)
testq %rax, %rax
je 0x2888a2
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x224b94
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: first_valueFinalizeFunc
static void first_valueFinalizeFunc(sqlite3_context *pCtx){
  struct NthValueCtx *p;
  p = (struct NthValueCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p));
  if( p && p->pValue ){
    sqlite3_result_value(pCtx, p->pValue);
    sqlite3_value_free(p->pValue);
    p->pValue = 0;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x10
popq %rsi
callq 0x225797
testq %rax, %rax
je 0x2888e5
movq %rax, %rbx
movq 0x8(%rax), %rsi
testq %rsi, %rsi
je 0x2888e5
movq %r14, %rdi
callq 0x224a29
movq 0x8(%rbx), %rdi
callq 0x2245fd
andq $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: computeJD
static void computeJD(DateTime *p){
  int Y, M, D, A, B, X1, X2;

  if( p->validJD ) return;
  if( p->validYMD ){
    Y = p->Y;
    M = p->M;
    D = p->D;
  }else{
    Y = 2000;  /* If no YMD specified, assume 2000-Jan-01 */
    M = 1;
    D = 1;
  }
  if( Y<-4713 || Y>9999 || p->rawS ){
    datetimeError(p);
    return;
  }
  if( M<=2 ){
    Y--;
    M += 12;
  }
  A = Y/100;
  B = 2 - A + (A/4);
  X1 = 36525*(Y+4716)/100;
  X2 = 306001*(M+1)/10000;
  p->iJD = (sqlite3_int64)((X1 + X2 + D + B - 1524.5 ) * 86400000);
  p->validJD = 1;
  if( p->validHMS ){
    p->iJD += p->h*3600000 + p->m*60000 + (sqlite3_int64)(p->s*1000);
    if( p->validTZ ){
      p->iJD -= p->tz*60000;
      p->validYMD = 0;
      p->validHMS = 0;
      p->validTZ = 0;
    }
  }
}

// Assembly:
cmpb $0x0, 0x28(%rdi)
je 0x2896fb
retq
cmpb $0x0, 0x2a(%rdi)
je 0x289719
movl 0x8(%rdi), %ecx
leal -0x2710(%rcx), %eax
cmpl $0xffffc687, %eax       # imm = 0xFFFFC687
jb 0x289729
movl 0xc(%rdi), %eax
movl 0x10(%rdi), %esi
jmp 0x289723
pushq $0x1
popq %rax
movl $0x7d0, %ecx            # imm = 0x7D0
movl %eax, %esi
cmpb $0x0, 0x29(%rdi)
je 0x28973c
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movb $0x1, 0x2e(%rdi)
retq
leal 0xc(%rax), %r8d
xorl %edx, %edx
cmpl $0x3, %eax
setl %dl
cmovgel %eax, %r8d
subl %edx, %ecx
movw $0xff9c, %r9w           # imm = 0xFF9C
movl %ecx, %eax
cwtd
idivw %r9w
addl $0x2, %eax
movswl %ax, %r9d
movw $0x190, %r10w           # imm = 0x190
movl %ecx, %eax
cwtd
idivw %r10w
movswl %ax, %r10d
imull $0x8ead, %ecx, %eax     # imm = 0x8EAD
addl $0xa445afc, %eax        # imm = 0xA445AFC
pushq $0x64
popq %rcx
xorl %edx, %edx
divl %ecx
movl %eax, %ecx
imull $0x4ab51, %r8d, %eax    # imm = 0x4AB51
addl $0x4ab51, %eax          # imm = 0x4AB51
movl $0x2710, %r8d           # imm = 0x2710
cltd
idivl %r8d
addl %esi, %eax
addl %r10d, %ecx
addl %eax, %ecx
addl %r9d, %ecx
cvtsi2sd %ecx, %xmm0
addsd 0xec485(%rip), %xmm0    # 0x375c38
mulsd 0xec42d(%rip), %xmm0    # 0x375be8
cvttsd2si %xmm0, %rax
movq %rax, (%rdi)
movb $0x1, 0x28(%rdi)
cmpb $0x0, 0x2b(%rdi)
je 0x2896fa
movslq 0x14(%rdi), %rcx
imulq $0x36ee80, %rcx, %rcx   # imm = 0x36EE80
movslq 0x18(%rdi), %rdx
imulq $0xea60, %rdx, %rdx     # imm = 0xEA60
movsd 0x20(%rdi), %xmm0
mulsd 0x9aec4(%rip), %xmm0    # 0x3246b8
addq %rcx, %rdx
cvttsd2si %xmm0, %rcx
addq %rdx, %rcx
addq %rax, %rcx
movq %rcx, (%rdi)
cmpb $0x0, 0x2c(%rdi)
je 0x2896fa
movslq 0x1c(%rdi), %rax
imulq $0xea60, %rax, %rax     # imm = 0xEA60
subq %rax, %rcx
movq %rcx, (%rdi)
andw $0x0, 0x2a(%rdi)
movb $0x0, 0x2c(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: setRawDateNumber
static void setRawDateNumber(DateTime *p, double r){
  p->s = r;
  p->rawS = 1;
  if( r>=0.0 && r<5373484.5 ){
    p->iJD = (sqlite3_int64)(r*86400000.0 + 0.5);
    p->validJD = 1;
  }
}

// Assembly:
movsd %xmm0, 0x20(%rdi)
movb $0x1, 0x29(%rdi)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x2898bd
movsd 0xec3a5(%rip), %xmm1    # 0x375c40
ucomisd %xmm0, %xmm1
jbe 0x2898bd
mulsd 0xec33f(%rip), %xmm0    # 0x375be8
addsd 0x6c5a7(%rip), %xmm0    # 0x2f5e58
cvttsd2si %xmm0, %rax
movq %rax, (%rdi)
movb $0x1, 0x28(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: parseHhMmSs
static int parseHhMmSs(const char *zDate, DateTime *p){
  int h, m, s;
  double ms = 0.0;
  if( getDigits(zDate, "20c:20e", &h, &m)!=2 ){
    return 1;
  }
  zDate += 5;
  if( *zDate==':' ){
    zDate++;
    if( getDigits(zDate, "20e", &s)!=1 ){
      return 1;
    }
    zDate += 2;
    if( *zDate=='.' && sqlite3Isdigit(zDate[1]) ){
      double rScale = 1.0;
      zDate++;
      while( sqlite3Isdigit(*zDate) ){
        ms = ms*10.0 + *zDate - '0';
        rScale *= 10.0;
        zDate++;
      }
      ms /= rScale;
    }
  }else{
    s = 0;
  }
  p->validJD = 0;
  p->rawS = 0;
  p->validHMS = 1;
  p->h = h;
  p->m = m;
  p->s = s + ms;
  if( parseTimezone(zDate, p) ) return 1;
  p->validTZ = (p->tz!=0)?1:0;
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r15
leaq 0xf0ce1(%rip), %rsi     # 0x37a5b8
leaq 0x14(%rsp), %rdx
leaq 0x10(%rsp), %rcx
xorl %eax, %eax
callq 0x289af7
pushq $0x1
popq %rbp
cmpl $0x2, %eax
jne 0x289a5a
cmpb $0x3a, 0x5(%r15)
jne 0x28998d
leaq 0x6(%r15), %rdi
leaq 0xf0bc6(%rip), %rsi     # 0x37a4d0
leaq 0xc(%rsp), %rdx
xorl %eax, %eax
callq 0x289af7
cmpl $0x1, %eax
jne 0x289a5a
leaq 0x8(%r15), %r14
xorpd %xmm0, %xmm0
cmpb $0x2e, 0x8(%r15)
jne 0x28999d
movzbl 0x9(%r15), %eax
leaq -0x3a(%rax), %rcx
cmpq $-0xa, %rcx
jb 0x28999d
addq $0x9, %r15
movsd 0x5c8df(%rip), %xmm1    # 0x2e6228
movsd 0x6b65f(%rip), %xmm2    # 0x2f4fb0
movsd 0xec2ef(%rip), %xmm3    # 0x375c48
movq %r15, %r14
movzbl %al, %ecx
addq $-0x3a, %rcx
cmpq $-0xa, %rcx
jb 0x289a69
movsbl %al, %eax
cvtsi2sd %eax, %xmm4
mulsd %xmm2, %xmm0
addsd %xmm4, %xmm0
addsd %xmm3, %xmm0
mulsd %xmm2, %xmm1
movb 0x1(%r14), %al
incq %r14
jmp 0x28995c
andl $0x0, 0xc(%rsp)
addq $0x5, %r15
xorpd %xmm0, %xmm0
movq %r15, %r14
andw $0x0, 0x28(%rbx)
movb $0x1, 0x2b(%rbx)
movl 0x14(%rsp), %eax
movl %eax, 0x14(%rbx)
movl 0x10(%rsp), %eax
movl %eax, 0x18(%rbx)
cvtsi2sdl 0xc(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x20(%rbx)
leaq 0xe7e86(%rip), %r15     # 0x371850
movzbl (%r14), %eax
incq %r14
testb $0x1, (%rax,%r15)
jne 0x2899ca
andl $0x0, 0x1c(%rbx)
movzbl -0x1(%r14), %ecx
cmpl $0x2d, %ecx
je 0x2899ef
cmpl $0x2b, %ecx
jne 0x289a2f
pushq $0x1
jmp 0x2899f1
pushq $-0x1
popq %r12
leaq 0xf0bc6(%rip), %rsi     # 0x37a5c0
leaq 0x1c(%rsp), %rdx
leaq 0x18(%rsp), %rcx
movq %r14, %rdi
xorl %eax, %eax
callq 0x289af7
cmpl $0x2, %eax
jne 0x289a5a
addq $0x5, %r14
imull $0x3c, 0x1c(%rsp), %eax
addl 0x18(%rsp), %eax
imull %eax, %r12d
movl %r12d, 0x1c(%rbx)
testl %eax, %eax
setne %al
jmp 0x289a3b
movl %ecx, %edx
andb $-0x21, %dl
xorl %eax, %eax
cmpb $0x5a, %dl
jne 0x289a51
movzbl (%r14), %ecx
incq %r14
testb $0x1, (%rcx,%r15)
jne 0x289a3b
movb $0x1, 0x2d(%rbx)
movb -0x1(%r14), %cl
testb %cl, %cl
jne 0x289a5a
movb %al, 0x2c(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
divsd %xmm1, %xmm0
jmp 0x28999d
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3NotPureFunc
SQLITE_PRIVATE int sqlite3NotPureFunc(sqlite3_context *pCtx){
  const VdbeOp *pOp;
#ifdef SQLITE_ENABLE_STAT4
  if( pCtx->pVdbe==0 ) return 1;
#endif
  pOp = pCtx->pVdbe->aOp + pCtx->iOp;
  if( pOp->opcode==OP_PureFunc ){
    const char *zContext;
    char *zMsg;
    if( pOp->p5 & NC_IsCheck ){
      zContext = "a CHECK constraint";
    }else if( pOp->p5 & NC_GenCol ){
      zContext = "a generated column";
    }else{
      zContext = "an index";
    }
    zMsg = sqlite3_mprintf("non-deterministic use of %s() in %s",
                           pCtx->pFunc->zName, zContext);
    sqlite3_result_error(pCtx, zMsg, -1);
    sqlite3_free(zMsg);
    return 0;
  }
  return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq 0x18(%rdi), %rax
movq 0x88(%rax), %rax
movslq 0x20(%rdi), %rcx
imulq $0x18, %rcx, %rcx
cmpb $0x3f, (%rax,%rcx)
jne 0x289aed
movq %rdi, %rbx
addq %rcx, %rax
movzwl 0x2(%rax), %eax
testb $0x8, %al
leaq 0x72eb2(%rip), %rcx     # 0x2fc954
leaq 0xeeada(%rip), %rsi     # 0x378583
cmoveq %rcx, %rsi
testb $0x4, %al
leaq 0xf0b12(%rip), %rdx     # 0x37a5c8
cmoveq %rsi, %rdx
movq 0x8(%rdi), %rax
movq 0x38(%rax), %rsi
leaq 0xf0b12(%rip), %rdi     # 0x37a5db
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x22132b
movq %rax, %r14
pushq $-0x1
popq %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2246d3
movq %r14, %rdi
callq 0x21f7f9
jmp 0x289af0
pushq $0x1
popq %rbp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: getDigits
static int getDigits(const char *zDate, const char *zFormat, ...){
  /* The aMx[] array translates the 3rd character of each format
  ** spec into a max size:    a   b   c   d   e     f */
  static const u16 aMx[] = { 12, 14, 24, 31, 59, 9999 };
  va_list ap;
  int cnt = 0;
  char nextC;
  va_start(ap, zFormat);
  do{
    char N = zFormat[0] - '0';
    char min = zFormat[1] - '0';
    int val = 0;
    u16 max;

    assert( zFormat[2]>='a' && zFormat[2]<='f' );
    max = aMx[zFormat[2] - 'a'];
    nextC = zFormat[3];
    val = 0;
    while( N-- ){
      if( !sqlite3Isdigit(*zDate) ){
        goto end_getDigits;
      }
      val = val*10 + *zDate - '0';
      zDate++;
    }
    if( val<(int)min || val>(int)max || (nextC!=0 && nextC!=*zDate) ){
      goto end_getDigits;
    }
    *va_arg(ap,int*) = val;
    zDate++;
    cnt++;
    zFormat += 4;
  }while( nextC );
end_getDigits:
  va_end(ap);
  return cnt;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
leaq -0x60(%rsp), %r10
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x289b42
movaps %xmm0, -0x30(%rsp)
movaps %xmm1, -0x20(%rsp)
movaps %xmm2, -0x10(%rsp)
movaps %xmm3, (%rsp)
movaps %xmm4, 0x10(%rsp)
movaps %xmm5, 0x20(%rsp)
movaps %xmm6, 0x30(%rsp)
movaps %xmm7, 0x40(%rsp)
movq %r10, -0x70(%rsp)
leaq 0x80(%rsp), %rax
movq %rax, -0x78(%rsp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, -0x80(%rsp)
xorl %eax, %eax
leaq 0xebfb8(%rip), %rcx     # 0x375b24
movb (%rsi), %r8b
movb 0x1(%rsi), %r10b
addb $-0x30, %r8b
addb $-0x30, %r10b
movsbq 0x2(%rsi), %rdx
movzwl -0xc2(%rcx,%rdx,2), %r11d
movb 0x3(%rsi), %dl
movzbl %r8b, %ebx
leaq (%rdi,%rbx), %r8
xorl %r14d, %r14d
xorl %r9d, %r9d
cmpb %r14b, %bl
je 0x289bc2
movzbl (%rdi,%r14), %r15d
leaq -0x3a(%r15), %r12
cmpq $-0xa, %r12
jb 0x289c1f
movsbl %r15b, %r15d
imull $0xa, %r9d, %r9d
addl %r15d, %r9d
addl $-0x30, %r9d
incq %r14
jmp 0x289b9a
movsbl %r10b, %edi
cmpl %edi, %r9d
jl 0x289c1f
cmpl %r11d, %r9d
jg 0x289c1f
testb %dl, %dl
je 0x289bd9
cmpb (%r8), %dl
jne 0x289c1f
movl -0x80(%rsp), %r10d
cmpq $0x28, %r10
ja 0x289bf7
movq %r10, %rdi
addq -0x70(%rsp), %rdi
addl $0x8, %r10d
movl %r10d, -0x80(%rsp)
jmp 0x289c05
movq -0x78(%rsp), %rdi
leaq 0x8(%rdi), %r10
movq %r10, -0x78(%rsp)
incq %r8
incl %eax
addq $0x4, %rsi
movq (%rdi), %rdi
movl %r9d, (%rdi)
movq %r8, %rdi
testb %dl, %dl
jne 0x289b6c
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: computeYMD
static void computeYMD(DateTime *p){
  int Z, A, B, C, D, E, X1;
  if( p->validYMD ) return;
  if( !p->validJD ){
    p->Y = 2000;
    p->M = 1;
    p->D = 1;
  }else if( !validJulianDay(p->iJD) ){
    datetimeError(p);
    return;
  }else{
    Z = (int)((p->iJD + 43200000)/86400000);
    A = (int)((Z - 1867216.25)/36524.25);
    A = Z + 1 + A - (A/4);
    B = A + 1524;
    C = (int)((B - 122.1)/365.25);
    D = (36525*(C&32767))/100;
    E = (int)((B-D)/30.6001);
    X1 = (int)(30.6001*E);
    p->D = B - D - X1;
    p->M = E<14 ? E-1 : E-13;
    p->Y = p->M>2 ? C - 4716 : C - 4715;
  }
  p->validYMD = 1;
}

// Assembly:
cmpb $0x0, 0x2a(%rdi)
je 0x289d99
retq
cmpb $0x0, 0x28(%rdi)
je 0x289dcc
movq (%rdi), %rax
movabsq $0x1a6401072fe00, %rcx  # imm = 0x1A6401072FE00
cmpq %rcx, %rax
jb 0x289de4
xorpd %xmm0, %xmm0
movupd %xmm0, 0x20(%rdi)
movupd %xmm0, 0x10(%rdi)
movupd %xmm0, (%rdi)
addq $0x2e, %rdi
jmp 0x289ea8
movabsq $0x1000007d0, %rax      # imm = 0x1000007D0
movq %rax, 0x8(%rdi)
pushq $0x1
popq %rax
pushq $0x10
jmp 0x289ea0
addq $0x2932e00, %rax        # imm = 0x2932E00
movl $0x5265c00, %ecx        # imm = 0x5265C00
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
cvtsi2sd %ecx, %xmm0
addsd 0xebe4d(%rip), %xmm0    # 0x375c50
divsd 0xebe4d(%rip), %xmm0    # 0x375c58
cvttsd2si %xmm0, %esi
pushq $-0x4
popq %r8
movl %esi, %eax
cltd
idivl %r8d
addl %esi, %ecx
leal (%rax,%rcx), %esi
addl $0x5f5, %esi            # imm = 0x5F5
cvtsi2sd %esi, %xmm0
addsd 0xebe30(%rip), %xmm0    # 0x375c60
divsd 0xebe30(%rip), %xmm0    # 0x375c68
cvttsd2si %xmm0, %ecx
movl %ecx, %eax
andl $0x7fff, %eax           # imm = 0x7FFF
imull $0x8ead, %eax, %eax     # imm = 0x8EAD
pushq $0x64
popq %r8
xorl %edx, %edx
divl %r8d
subl %eax, %esi
cvtsi2sd %esi, %xmm0
movsd 0xebe10(%rip), %xmm1    # 0x375c70
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
cvttpd2dq %xmm0, %xmm0
cvtdq2pd %xmm0, %xmm0
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %edx
subl %edx, %esi
movl %esi, 0x10(%rdi)
xorl %edx, %edx
cmpl $0xe, %eax
setl %dl
negl %edx
orl $-0xd, %edx
addl %eax, %edx
movl %edx, 0xc(%rdi)
xorl %eax, %eax
cmpl $0x3, %edx
setge %al
xorl $0xffffed95, %eax       # imm = 0xFFFFED95
addl %ecx, %eax
pushq $0x8
popq %rcx
movl %eax, (%rdi,%rcx)
addq $0x2a, %rdi
movb $0x1, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3MemMalloc
static void *sqlite3MemMalloc(int nByte){
#ifdef SQLITE_MALLOCSIZE
  void *p;
  testcase( ROUND8(nByte)==nByte );
  p = SQLITE_MALLOC( nByte );
  if( p==0 ){
    testcase( sqlite3GlobalConfig.xLog!=0 );
    sqlite3_log(SQLITE_NOMEM, "failed to allocate %u bytes of memory", nByte);
  }
  return p;
#else
  sqlite3_int64 *p;
  assert( nByte>0 );
  testcase( ROUND8(nByte)!=nByte );
  p = SQLITE_MALLOC( nByte+8 );
  if( p ){
    p[0] = nByte;
    p++;
  }else{
    testcase( sqlite3GlobalConfig.xLog!=0 );
    sqlite3_log(SQLITE_NOMEM, "failed to allocate %u bytes of memory", nByte);
  }
  return (void *)p;
#endif
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %r14d
leal 0x8(%r14), %eax
movslq %eax, %rdi
callq 0x17f50
testq %rax, %rax
je 0x289f8b
movq %rax, %rbx
movslq %r14d, %rax
movq %rax, (%rbx)
addq $0x8, %rbx
jmp 0x289fa1
leaq 0xf06f0(%rip), %rsi     # 0x37a682
xorl %ebx, %ebx
pushq $0x7
popq %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x2214a3
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: pcache1Create
static sqlite3_pcache *pcache1Create(int szPage, int szExtra, int bPurgeable){
  PCache1 *pCache;      /* The newly created page cache */
  PGroup *pGroup;       /* The group the new page cache will belong to */
  int sz;               /* Bytes of memory required to allocate the new cache */

  assert( (szPage & (szPage-1))==0 && szPage>=512 && szPage<=65536 );
  assert( szExtra < 300 );

  sz = sizeof(PCache1) + sizeof(PGroup)*pcache1.separateCache;
  pCache = (PCache1 *)sqlite3MallocZero(sz);
  if( pCache ){
    if( pcache1.separateCache ){
      pGroup = (PGroup*)&pCache[1];
      pGroup->mxPinned = 10;
    }else{
      pGroup = &pcache1.grp;
    }
    pcache1EnterMutex(pGroup);
    if( pGroup->lru.isAnchor==0 ){
      pGroup->lru.isAnchor = 1;
      pGroup->lru.pLruPrev = pGroup->lru.pLruNext = &pGroup->lru;
    }
    pCache->pGroup = pGroup;
    pCache->szPage = szPage;
    pCache->szExtra = szExtra;
    pCache->szAlloc = szPage + szExtra + ROUND8(sizeof(PgHdr1));
    pCache->bPurgeable = (bPurgeable ? 1 : 0);
    pcache1ResizeHash(pCache);
    if( bPurgeable ){
      pCache->nMin = 10;
      pGroup->nMinPage += pCache->nMin;
      pGroup->mxPinned = pGroup->nMaxPage + 10 - pGroup->nMinPage;
      pCache->pnPurgeable = &pGroup->nPurgeable;
    }else{
      pCache->pnPurgeable = &pCache->nPurgeableDummy;
    }
    pcache1LeaveMutex(pGroup);
    if( pCache->nHash==0 ){
      pcache1Destroy((sqlite3_pcache*)pCache);
      pCache = 0;
    }
  }
  return (sqlite3_pcache *)pCache;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movl %esi, %r14d
movl %edi, %r15d
imull $0x50, 0x1b3d22(%rip), %eax # 0x43ddb4
addl $0x58, %eax
movslq %eax, %rdi
callq 0x2227e2
testq %rax, %rax
je 0x28a150
movq %rax, %rbx
cmpl $0x0, 0x1b3d04(%rip)    # 0x43ddb4
je 0x28a0bf
leaq 0x58(%rbx), %r12
movl $0xa, 0x68(%rbx)
jmp 0x28a0c6
leaq 0x1b3c9a(%rip), %r12    # 0x43dd60
cmpw $0x0, 0x2e(%r12)
jne 0x28a0e6
leaq 0x18(%r12), %rax
movw $0x1, 0x2e(%r12)
movq %rax, 0x40(%r12)
movq %rax, 0x48(%r12)
movq %r12, (%rbx)
movl %r15d, 0x10(%rbx)
movl %r14d, 0x14(%rbx)
leal (%r15,%r14), %eax
addl $0x38, %eax
movl %eax, 0x18(%rbx)
xorl %eax, %eax
testl %ebp, %ebp
setne %al
movl %eax, 0x1c(%rbx)
movq %rbx, %rdi
callq 0x28a309
testl %ebp, %ebp
je 0x28a137
movl $0xa, 0x20(%rbx)
movl 0x8(%r12), %eax
movl 0xc(%r12), %ecx
leal 0xa(%rcx), %edx
movl %edx, 0xc(%r12)
subl %ecx, %eax
movl %eax, 0x10(%r12)
addq $0x14, %r12
jmp 0x28a13e
movq %rbx, %r12
addq $0x30, %r12
movq %r12, 0x8(%rbx)
cmpl $0x0, 0x3c(%rbx)
jne 0x28a152
movq %rbx, %rdi
callq 0x28a285
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: pcache1Fetch
static sqlite3_pcache_page *pcache1Fetch(
  sqlite3_pcache *p,
  unsigned int iKey,
  int createFlag
){
#if PCACHE1_MIGHT_USE_GROUP_MUTEX || defined(SQLITE_DEBUG)
  PCache1 *pCache = (PCache1 *)p;
#endif

  assert( offsetof(PgHdr1,page)==0 );
  assert( pCache->bPurgeable || createFlag!=1 );
  assert( pCache->bPurgeable || pCache->nMin==0 );
  assert( pCache->bPurgeable==0 || pCache->nMin==10 );
  assert( pCache->nMin==0 || pCache->bPurgeable );
  assert( pCache->nHash>0 );
#if PCACHE1_MIGHT_USE_GROUP_MUTEX
  if( pCache->pGroup->mutex ){
    return (sqlite3_pcache_page*)pcache1FetchWithMutex(p, iKey, createFlag);
  }else
#endif
  {
    return (sqlite3_pcache_page*)pcache1FetchNoMutex(p, iKey, createFlag);
  }
}

// Assembly:
pushq %rbx
movl %edx, %ecx
movl %esi, %eax
xorl %edx, %edx
divl 0x3c(%rdi)
movl %edx, %ebx
shlq $0x3, %rbx
addq 0x40(%rdi), %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x28a1bc
cmpl %esi, 0x10(%rbx)
je 0x28a1c8
addq $0x18, %rbx
jmp 0x28a1a9
testl %ecx, %ecx
je 0x28a1d9
movl %ecx, %edx
popq %rbx
jmp 0x28a481
cmpq $0x0, 0x28(%rbx)
je 0x28a1db
movq %rbx, %rdi
callq 0x28a406
jmp 0x28a1db
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: pcache1Destroy
static void pcache1Destroy(sqlite3_pcache *p){
  PCache1 *pCache = (PCache1 *)p;
  PGroup *pGroup = pCache->pGroup;
  assert( pCache->bPurgeable || (pCache->nMax==0 && pCache->nMin==0) );
  pcache1EnterMutex(pGroup);
  if( pCache->nPage ) pcache1TruncateUnsafe(pCache, 0);
  assert( pGroup->nMaxPage >= pCache->nMax );
  pGroup->nMaxPage -= pCache->nMax;
  assert( pGroup->nMinPage >= pCache->nMin );
  pGroup->nMinPage -= pCache->nMin;
  pGroup->mxPinned = pGroup->nMaxPage + 10 - pGroup->nMinPage;
  pcache1EnforceMaxPage(pCache);
  pcache1LeaveMutex(pGroup);
  sqlite3_free(pCache->pBulk);
  sqlite3_free(pCache->apHash);
  sqlite3_free(pCache);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
cmpl $0x0, 0x38(%rdi)
je 0x28a29f
movq %rbx, %rdi
xorl %esi, %esi
callq 0x28a726
movl 0x8(%r14), %eax
subl 0x24(%rbx), %eax
movl 0xc(%r14), %ecx
movl %eax, 0x8(%r14)
subl 0x20(%rbx), %ecx
movl %ecx, 0xc(%r14)
subl %ecx, %eax
addl $0xa, %eax
movl %eax, 0x10(%r14)
movq %rbx, %rdi
callq 0x28a3a6
movq 0x50(%rbx), %rdi
callq 0x21f7f9
movq 0x40(%rbx), %rdi
callq 0x21f7f9
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21f7f9
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: pcache1Shrink
static void pcache1Shrink(sqlite3_pcache *p){
  PCache1 *pCache = (PCache1*)p;
  if( pCache->bPurgeable ){
    PGroup *pGroup = pCache->pGroup;
    int savedMaxPage;
    pcache1EnterMutex(pGroup);
    savedMaxPage = pGroup->nMaxPage;
    pGroup->nMaxPage = 0;
    pcache1EnforceMaxPage(pCache);
    pGroup->nMaxPage = savedMaxPage;
    pcache1LeaveMutex(pGroup);
  }
}

// Assembly:
cmpl $0x0, 0x1c(%rdi)
je 0x28a308
pushq %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rbx
movl 0x8(%rbx), %ebp
andl $0x0, 0x8(%rbx)
callq 0x28a3a6
movl %ebp, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: pcache1ResizeHash
static void pcache1ResizeHash(PCache1 *p){
  PgHdr1 **apNew;
  unsigned int nNew;
  unsigned int i;

  assert( sqlite3_mutex_held(p->pGroup->mutex) );

  nNew = p->nHash*2;
  if( nNew<256 ){
    nNew = 256;
  }

  pcache1LeaveMutex(p->pGroup);
  if( p->nHash ){ sqlite3BeginBenignMalloc(); }
  apNew = (PgHdr1 **)sqlite3MallocZero(sizeof(PgHdr1 *)*nNew);
  if( p->nHash ){ sqlite3EndBenignMalloc(); }
  pcache1EnterMutex(p->pGroup);
  if( apNew ){
    for(i=0; i<p->nHash; i++){
      PgHdr1 *pPage;
      PgHdr1 *pNext = p->apHash[i];
      while( (pPage = pNext)!=0 ){
        unsigned int h = pPage->iKey % nNew;
        pNext = pPage->pNext;
        pPage->pNext = apNew[h];
        apNew[h] = pPage;
      }
    }
    sqlite3_free(p->apHash);
    p->apHash = apNew;
    p->nHash = nNew;
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x3c(%rdi), %eax
leal (%rax,%rax), %ecx
cmpl $0x101, %ecx            # imm = 0x101
movl $0x100, %ebp            # imm = 0x100
cmovael %ecx, %ebp
testl %eax, %eax
je 0x28a336
movq 0x1b3ac9(%rip), %rax    # 0x43ddf8
testq %rax, %rax
je 0x28a336
callq *%rax
movl %ebp, %edi
shlq $0x3, %rdi
callq 0x2227e2
movq %rax, %r14
cmpl $0x0, 0x3c(%rbx)
je 0x28a358
movq 0x1b3aaf(%rip), %rax    # 0x43de00
testq %rax, %rax
je 0x28a358
callq *%rax
testq %r14, %r14
je 0x28a3a1
movl 0x3c(%rbx), %ecx
xorl %esi, %esi
movq 0x40(%rbx), %rdi
cmpq %rcx, %rsi
je 0x28a395
movq (%rdi,%rsi,8), %rdi
testq %rdi, %rdi
je 0x28a390
movl 0x10(%rdi), %eax
xorl %edx, %edx
divl %ebp
movq 0x18(%rdi), %rax
movq (%r14,%rdx,8), %r8
movq %r8, 0x18(%rdi)
movq %rdi, (%r14,%rdx,8)
movq %rax, %rdi
jmp 0x28a36f
incq %rsi
jmp 0x28a362
callq 0x21f7f9
movq %r14, 0x40(%rbx)
movl %ebp, 0x3c(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: pcache1EnforceMaxPage
static void pcache1EnforceMaxPage(PCache1 *pCache){
  PGroup *pGroup = pCache->pGroup;
  PgHdr1 *p;
  assert( sqlite3_mutex_held(pGroup->mutex) );
  while( pGroup->nPurgeable>pGroup->nMaxPage
      && (p=pGroup->lru.pLruPrev)->isAnchor==0
  ){
    assert( p->pCache->pGroup==pGroup );
    assert( PAGE_IS_UNPINNED(p) );
    pcache1PinPage(p);
    pcache1RemoveFromHash(p, 1);
  }
  if( pCache->nPage==0 && pCache->pBulk ){
    sqlite3_free(pCache->pBulk);
    pCache->pBulk = pCache->pFree = 0;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r15
pushq $0x1
popq %rbp
movl 0x14(%r15), %eax
cmpl 0x8(%r15), %eax
jbe 0x28a3e0
movq 0x48(%r15), %r14
cmpw $0x0, 0x16(%r14)
jne 0x28a3e0
movq %r14, %rdi
callq 0x28a406
movq %r14, %rdi
movl %ebp, %esi
callq 0x28a426
jmp 0x28a3b6
cmpl $0x0, 0x38(%rbx)
jne 0x28a3fb
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x28a3fb
callq 0x21f7f9
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: pcache1RemoveFromHash
static void pcache1RemoveFromHash(PgHdr1 *pPage, int freeFlag){
  unsigned int h;
  PCache1 *pCache = pPage->pCache;
  PgHdr1 **pp;

  assert( sqlite3_mutex_held(pCache->pGroup->mutex) );
  h = pPage->iKey % pCache->nHash;
  for(pp=&pCache->apHash[h]; (*pp)!=pPage; pp=&(*pp)->pNext);
  *pp = (*pp)->pNext;

  pCache->nPage--;
  if( freeFlag ) pcache1FreePage(pPage);
}

// Assembly:
movq 0x20(%rdi), %rcx
movl 0x10(%rdi), %eax
xorl %edx, %edx
divl 0x3c(%rcx)
shlq $0x3, %rdx
addq 0x40(%rcx), %rdx
movq %rdx, %rax
movq (%rdx), %r8
leaq 0x18(%r8), %rdx
cmpq %rdi, %r8
jne 0x28a43a
movq (%rdx), %rdx
movq %rdx, (%rax)
decl 0x38(%rcx)
testl %esi, %esi
jne 0x28a457
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: pcache1TruncateUnsafe
static void pcache1TruncateUnsafe(
  PCache1 *pCache,             /* The cache to truncate */
  unsigned int iLimit          /* Drop pages with this pgno or larger */
){
  TESTONLY( int nPage = 0; )  /* To assert pCache->nPage is correct */
  unsigned int h, iStop;
  assert( sqlite3_mutex_held(pCache->pGroup->mutex) );
  assert( pCache->iMaxKey >= iLimit );
  assert( pCache->nHash > 0 );
  if( pCache->iMaxKey - iLimit < pCache->nHash ){
    /* If we are just shaving the last few pages off the end of the
    ** cache, then there is no point in scanning the entire hash table.
    ** Only scan those hash slots that might contain pages that need to
    ** be removed. */
    h = iLimit % pCache->nHash;
    iStop = pCache->iMaxKey % pCache->nHash;
    TESTONLY( nPage = -10; )  /* Disable the pCache->nPage validity check */
  }else{
    /* This is the general case where many pages are being removed.
    ** It is necessary to scan the entire hash table */
    h = pCache->nHash/2;
    iStop = h - 1;
  }
  for(;;){
    PgHdr1 **pp;
    PgHdr1 *pPage;
    assert( h<pCache->nHash );
    pp = &pCache->apHash[h];
    while( (pPage = *pp)!=0 ){
      if( pPage->iKey>=iLimit ){
        pCache->nPage--;
        *pp = pPage->pNext;
        if( PAGE_IS_UNPINNED(pPage) ) pcache1PinPage(pPage);
        pcache1FreePage(pPage);
      }else{
        pp = &pPage->pNext;
        TESTONLY( if( nPage>=0 ) nPage++; )
      }
    }
    if( h==iStop ) break;
    h = (h+1) % pCache->nHash;
  }
  assert( nPage<0 || pCache->nPage==(unsigned)nPage );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl 0x2c(%rdi), %ecx
movl 0x3c(%rdi), %esi
movl %ecx, %eax
subl %ebx, %eax
cmpl %esi, %eax
jae 0x28a757
movl %ebx, %eax
xorl %edx, %edx
divl %esi
movl %edx, %ebp
movl %ecx, %eax
xorl %edx, %edx
divl %esi
movl %edx, %r15d
jmp 0x28a76d
shrl %esi
leal -0x1(%rsi), %r15d
movl %esi, %ebp
jmp 0x28a76d
incl %ebp
movl %ebp, %eax
xorl %edx, %edx
divl 0x3c(%r14)
movl %edx, %ebp
movl %ebp, %r13d
shlq $0x3, %r13
addq 0x40(%r14), %r13
movq (%r13), %r12
testq %r12, %r12
je 0x28a7b8
cmpl %ebx, 0x10(%r12)
jb 0x28a7af
decl 0x38(%r14)
movq 0x18(%r12), %rax
movq %rax, (%r13)
cmpq $0x0, 0x28(%r12)
je 0x28a7a5
movq %r12, %rdi
callq 0x28a406
movq %r12, %rdi
callq 0x28a457
jmp 0x28a778
addq $0x18, %r12
movq %r12, %r13
jmp 0x28a778
cmpl %r15d, %ebp
jne 0x28a761
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: functionDestroy
static void functionDestroy(sqlite3 *db, FuncDef *p){
  FuncDestructor *pDestructor = p->u.pDestructor;
  if( pDestructor ){
    pDestructor->nRef--;
    if( pDestructor->nRef==0 ){
      pDestructor->xDestroy(pDestructor->pUserData);
      sqlite3DbFree(db, pDestructor);
    }
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x40(%rsi), %rbx
testq %rbx, %rbx
je 0x28a840
decl (%rbx)
je 0x28a848
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rdi, %r14
movq 0x10(%rbx), %rdi
callq *0x8(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x22d0fc
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: rtrimCollFunc
static int rtrimCollFunc(
  void *pUser,
  int nKey1, const void *pKey1,
  int nKey2, const void *pKey2
){
  const u8 *pK1 = (const u8*)pKey1;
  const u8 *pK2 = (const u8*)pKey2;
  while( nKey1 && pK1[nKey1-1]==' ' ) nKey1--;
  while( nKey2 && pK2[nKey2-1]==' ' ) nKey2--;
  return binCollFunc(pUser, nKey1, pKey1, nKey2, pKey2);
}

// Assembly:
movslq %esi, %rax
movq %rax, %rsi
subq $0x1, %rax
jb 0x28a8da
cmpb $0x20, -0x1(%rdx,%rsi)
je 0x28a8c8
jmp 0x28a8dc
xorl %esi, %esi
movslq %ecx, %rax
movq %rax, %rcx
subq $0x1, %rax
jb 0x28a8f5
cmpb $0x20, -0x1(%r8,%rcx)
je 0x28a8df
jmp 0x2764ed
xorl %ecx, %ecx
jmp 0x2764ed
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/bitpackstringop.c
// Function: gt_requiredUInt32Bits
int
gt_requiredUInt32Bits(uint32_t v)
{
  int r;
  static const int MultiplyDeBruijnBitPosition[32] = {
    1, 2, 29, 3, 30, 15, 25, 4, 31, 23, 21, 16, 26, 18, 5, 9,
    32, 28, 14, 24, 22, 20, 17, 8, 27, 13, 19, 7, 12, 6, 11, 10
  };
  v |= v >> 1; /* first round down to power of 2 */
  v |= v >> 2;
  v |= v >> 4;
  v |= v >> 8;
  v |= v >> 16;
  v = (v >> 1) + 1;
  r = MultiplyDeBruijnBitPosition[(v * (uint32_t)0x077CB531UL) >> 27];
  return r;
}

// Assembly:
movl %edi, %eax
shrl %eax
orl %edi, %eax
movl %eax, %ecx
shrl $0x2, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x4, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x8, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x11, %eax
shrl %ecx
orl %eax, %ecx
imull $0x77cb531, %ecx, %eax  # imm = 0x77CB531
addl $0x77cb531, %eax        # imm = 0x77CB531
shrl $0x1b, %eax
leaq 0xf01cb(%rip), %rcx     # 0x37ab00
movl (%rcx,%rax,4), %eax
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/bitpackstringop.c
// Function: gt_requiredUInt64Bits
int
gt_requiredUInt64Bits(uint64_t v)
{
  int r;
  static const int MultiplyDeBruijnBitPosition[64] = {
    1, 2, 3, 57, 4, 33, 58, 47, 30, 5, 21, 34, 8, 59, 12, 48,
    63, 31, 19, 6, 17, 22, 35, 24, 54, 9, 60, 37, 26, 13, 49, 40,
    64, 56, 32, 46, 29, 20, 7, 11, 62, 18, 16, 23, 53, 36, 25, 39,
    55, 45, 28, 10, 61, 15, 52, 38, 44, 27, 14, 51, 43, 50, 42, 41
  };
  v |= v >> 1; /* first round down to power of 2 */
  v |= v >> 2;
  v |= v >> 4;
  v |= v >> 8;
  v |= v >> 16;
  v |= v >> 32;
  v = (v >> 1) + 1;
  r = MultiplyDeBruijnBitPosition[(v * (uint64_t)0x26752B916FC7B0DULL) >> 58];
  return r;
}

// Assembly:
movq %rdi, %rax
shrq %rax
orq %rdi, %rax
movq %rax, %rcx
shrq $0x2, %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x4, %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x8, %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x10, %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x21, %rcx
shrq %rax
orq %rcx, %rax
movabsq $0x26752b916fc7b0d, %rcx # imm = 0x26752B916FC7B0D
imulq %rcx, %rax
addq %rcx, %rax
shrq $0x3a, %rax
leaq 0xf01ed(%rip), %rcx     # 0x37ab80
movl (%rcx,%rax,4), %eax
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/bitpackstringop.c
// Function: gt_bsClear
void
gt_bsClear(BitString str, BitOffset offset, BitOffset numBits, int bitVal)
{
  unsigned bitsLeft = numBits,
    bitTop = offset%bitElemBits;
  size_t elemStart = offset/bitElemBits;
  BitElem *p = str + elemStart;
  GtUword bitPatSource = 0UL;
  gt_assert(str);
  if (bitVal)
    bitPatSource = ~0UL;
  if (bitTop)
  {
    GtUword mask = ~0UL;
    if (bitElemBits < (sizeof (GtUword)*CHAR_BIT))
    {
      mask <<= bitElemBits;
    }
    else
    {
      mask = 0;
    }
    mask = (~mask) >> bitTop;
    if (numBits < bitElemBits - bitTop)
    {
      unsigned backShift = bitElemBits - numBits - bitTop;
      mask &= ~0UL << backShift;
      *p = (*p & ~mask) | (bitPatSource & mask);
      return;
    }
    else
    {
      bitsLeft -= bitElemBits - bitTop;
      *p = (*p & ~mask) | (bitPatSource & mask);
      ++p;
    }
  }
  {
    size_t fullElems = bitsLeft / bitElemBits;
    memset(p, bitPatSource, sizeof (BitElem) * fullElems);
    p += fullElems;
    bitsLeft -= fullElems * bitElemBits;
  }
  if (bitsLeft)
  {
    GtUword mask = ((~0UL)<<(bitElemBits - bitsLeft));
    if (bitElemBits < (sizeof (GtUword)*CHAR_BIT))
      mask &= (~(~0UL<<bitElemBits));
    *p = (*p & ~mask) | (bitPatSource & mask);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x28b136
movl %ecx, %ebp
movq %rdx, %r14
movq %rdi, %rbx
movl %esi, %edx
andl $0x7, %edx
movq %rsi, %rax
shrq $0x3, %rax
addq %rax, %rbx
testl %edx, %edx
je 0x28b0e7
andl $0x7, %esi
movl $0xff, %eax
movl %esi, %ecx
shrq %cl, %rax
pushq $0x8
popq %rcx
subl %edx, %ecx
cmpq %r14, %rcx
jbe 0x28b0c7
addl %r14d, %esi
movb $0x8, %cl
subb %sil, %cl
pushq $-0x1
popq %rdx
shlq %cl, %rdx
andl %edx, %eax
movzbl (%rbx), %ecx
movl %eax, %edx
notl %edx
andl %ecx, %edx
testl %ebp, %ebp
cmovel %ebp, %eax
orl %edx, %eax
movb %al, (%rbx)
jmp 0x28b12b
subl %ecx, %r14d
movzbl (%rbx), %edx
movq $-0x100, %rdi
movl %esi, %ecx
sarq %cl, %rdi
andl %edx, %edi
testl %ebp, %ebp
cmovel %ebp, %eax
orl %edi, %eax
movb %al, (%rbx)
incq %rbx
movl %r14d, %r15d
shrl $0x3, %r15d
xorl %esi, %esi
movl %ebp, %eax
negl %eax
sbbl %esi, %esi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x17380
andl $0x7, %r14d
je 0x28b12b
movb $0x8, %cl
subb %r14b, %cl
movl $0xfe, %eax
shrl %cl, %eax
shll %cl, %eax
movzbl (%rbx,%r15), %ecx
movl %eax, %edx
notl %edx
andl %ecx, %edx
testl %ebp, %ebp
cmovel %ebp, %eax
orl %edx, %eax
movb %al, (%rbx,%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x1ace2b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x59ecc(%rip), %rsi     # 0x2e5013
leaq 0x86ed6(%rip), %rdx     # 0x312024
leaq 0xefb69(%rip), %rcx     # 0x37acbe
leaq 0xefb31(%rip), %r8      # 0x37ac8d
movl $0x190, %r9d            # imm = 0x190
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/bitpackstringop.c
// Function: bits2buf
static inline void
bits2buf(char *buf, uint32_t v, unsigned numBits)
{
  unsigned i = numBits;
  uint32_t mask = 1;
  buf[i] = '\0';
  while (i)
  {
    --i;
    buf[i] = ((v & mask)?'1':'0');
    mask <<= 1;
  }
}

// Assembly:
movl %edx, %eax
movb $0x0, (%rdi,%rax)
pushq $0x1
popq %rcx
movq %rax, %rdx
subq $0x1, %rdx
jb 0x28b437
testl %esi, %ecx
sete %r8b
xorb $0x31, %r8b
movb %r8b, -0x1(%rdi,%rax)
addl %ecx, %ecx
movq %rdx, %rax
jmp 0x28b41b
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/affinealign.c
// Function: gt_affinealign
GtAlignment* gt_affinealign(const GtUchar *u, GtUword ulen,
                            const GtUchar *v, GtUword vlen,
                            GtUword matchcost, GtUword mismatchcost,
                            GtUword gap_opening,
                            GtUword gap_extension)
{
  GtAffinealignDPentry **dptable;
  GtAlignment *align;

  gt_assert(u && v);
  gt_array2dim_malloc(dptable, ulen+1, vlen+1);
  affinealign_fill_table(dptable, u, ulen, v, vlen, matchcost, mismatchcost,
                         gap_opening, gap_extension, Affine_X, NULL);
  align = gt_alignment_new_with_seqs(u, ulen,  v, vlen);
  gt_affinealign_traceback(align, dptable, ulen, vlen);
  gt_array2dim_delete(dptable);
  return align;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movq %r8, 0x8(%rsp)
testq %rdi, %rdi
je 0x294a4c
testq %rdx, %rdx
je 0x294a4c
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r13
movq %rdx, (%rsp)
leaq 0x1(%rsi), %rbp
leaq 0x8(,%rsi,8), %rdi
leaq 0xe7ab3(%rip), %rsi     # 0x37c41c
movl $0xc5, %edx
callq 0x93160
movq %rax, %r12
leaq 0x1(%rbx), %r15
movq %rbp, %rax
imulq %r15, %rax
imulq $0x30, %rax, %rdi
leaq 0xe7a90(%rip), %rsi     # 0x37c41c
movl $0xc5, %edx
callq 0x93160
movq %rax, (%r12)
pushq $0x1
popq %rax
imulq $0x30, %r15, %rcx
cmpq %rbp, %rax
jae 0x2949b7
movq -0x8(%r12,%rax,8), %rdx
addq %rcx, %rdx
movq %rdx, (%r12,%rax,8)
incq %rax
jmp 0x2949a1
subq $0x8, %rsp
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq 0x8(%rsp), %r15
movq %r15, %rcx
movq %rbx, %r8
movq 0x10(%rsp), %r9
pushq $0x0
pushq $0x3
pushq 0x70(%rsp)
pushq 0x70(%rsp)
pushq 0x38(%rsp)
callq 0x294a84
addq $0x30, %rsp
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0xb4ea1
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x2946d4
movq (%r12), %rdi
leaq 0xe79ff(%rip), %rbx     # 0x37c41c
movq %rbx, %rsi
movl $0xca, %edx
callq 0x936f9
movq %r12, %rdi
movq %rbx, %rsi
movl $0xca, %edx
callq 0x936f9
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x1a3515(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x505b6(%rip), %rsi     # 0x2e5013
leaq 0xe7b4c(%rip), %rdx     # 0x37c5b0
leaq 0xe79ed(%rip), %rcx     # 0x37c458
leaq 0xe79aa(%rip), %r8      # 0x37c41c
movl $0xc4, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390