LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/skeeto[P]flappy/sqlite3.c
// Function: whereClauseInsert
static int whereClauseInsert(WhereClause *pWC, Expr *p, u8 wtFlags){
  WhereTerm *pTerm;
  int idx;
  testcase( wtFlags & TERM_VIRTUAL );
  if( pWC->nTerm>=pWC->nSlot ){
    WhereTerm *pOld = pWC->a;
    sqlite3 *db = pWC->pWInfo->pParse->db;
    pWC->a = sqlite3DbMallocRaw(db, sizeof(pWC->a[0])*pWC->nSlot*2 );
    if( pWC->a==0 ){
      if( wtFlags & TERM_DYNAMIC ){
        sqlite3ExprDelete(db, p);
      }
      pWC->a = pOld;
      return 0;
    }
    memcpy(pWC->a, pOld, sizeof(pWC->a[0])*pWC->nTerm);
    if( pOld!=pWC->aStatic ){
      sqlite3DbFree(db, pOld);
    }
    pWC->nSlot = sqlite3DbMallocSize(db, pWC->a)/sizeof(pWC->a[0]);
  }
  pTerm = &pWC->a[idx = pWC->nTerm++];
  if( p && ExprHasProperty(p, EP_Unlikely) ){
    pTerm->truthProb = sqlite3LogEst(p->iTable) - 99;
  }else{
    pTerm->truthProb = -1;
  }
  pTerm->pExpr = sqlite3ExprSkipCollate(p);
  pTerm->wtFlags = wtFlags;
  pTerm->pWC = pWC;
  pTerm->iParent = -1;
  return idx;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x14(%rdi), %r15d
movl 0x18(%rdi), %eax
cmpl %eax, %r15d
jl 0x5b32c
movq (%rbx), %rcx
movq 0x20(%rbx), %r12
movq (%rcx), %rcx
movq (%rcx), %r15
imull $0x70, %eax, %esi
movq %r15, %rdi
callq 0x11c9d
movq %rax, 0x20(%rbx)
testq %rax, %rax
je 0x5b3e2
movslq 0x14(%rbx), %rcx
imulq $0x38, %rcx, %rdx
movq %rax, %rdi
movq %r12, %rsi
callq 0x7230
leaq 0x28(%rbx), %rax
cmpq %rax, %r12
je 0x5b2dc
movq %r15, %rdi
movq %r12, %rsi
callq 0x9b42
movq 0x20(%rbx), %rdi
testq %r15, %r15
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x5b30c
cmpq %rdi, 0x160(%r15)
ja 0x5b30c
cmpq %rdi, 0x168(%r15)
jbe 0x5b30c
movzwl 0x140(%r15), %eax
jmp 0x5b312
callq *0x2efbe(%rip)          # 0x8a2d0
cltq
shrq $0x3, %rax
movabsq $0x2492492492492493, %rcx # imm = 0x2492492492492493
mulq %rcx
movl %edx, 0x18(%rbx)
movl 0x14(%rbx), %r15d
leal 0x1(%r15), %eax
movl %eax, 0x14(%rbx)
movslq %r15d, %rax
imulq $0x38, %rax, %r12
addq 0x20(%rbx), %r12
testq %r14, %r14
je 0x5b37a
testb $0x4, 0x6(%r14)
jne 0x5b384
movw $0xffff, 0x18(%r12)     # imm = 0xFFFF
movl 0x4(%r14), %eax
btl $0xc, %eax
jae 0x5b3bf
btl $0x12, %eax
jb 0x5b368
addq $0x10, %r14
jmp 0x5b370
movq 0x20(%r14), %rax
movq 0x8(%rax), %r14
movq (%r14), %r14
testq %r14, %r14
jne 0x5b352
jmp 0x5b3bc
movw $0xffff, 0x18(%r12)     # imm = 0xFFFF
jmp 0x5b3bc
movslq 0x2c(%r14), %rdi
callq 0x357b3
addl $-0x63, %eax
movw %ax, 0x18(%r12)
movl 0x4(%r14), %eax
btl $0xc, %eax
jae 0x5b3bf
btl $0x12, %eax
jb 0x5b3ac
addq $0x10, %r14
jmp 0x5b3b4
movq 0x20(%r14), %rax
movq 0x8(%rax), %r14
movq (%r14), %r14
testq %r14, %r14
jne 0x5b396
xorl %r14d, %r14d
movq %r14, (%r12)
movb %bpl, 0x1c(%r12)
movq %rbx, 0x20(%r12)
movl $0xffffffff, 0x8(%r12)  # imm = 0xFFFFFFFF
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
testb $0x1, %bpl
je 0x5b3f3
movq %r15, %rdi
movq %r14, %rsi
callq 0x35bca
movq %r12, 0x20(%rbx)
xorl %r15d, %r15d
jmp 0x5b3d6
// File: /workspace/github_c_makefile_star2_O3/skeeto[P]flappy/sqlite3.c
// Function: sqlite3LogEstAdd
SQLITE_PRIVATE LogEst sqlite3LogEstAdd(LogEst a, LogEst b){
  static const unsigned char x[] = {
     10, 10,                         /* 0,1 */
      9, 9,                          /* 2,3 */
      8, 8,                          /* 4,5 */
      7, 7, 7,                       /* 6,7,8 */
      6, 6, 6,                       /* 9,10,11 */
      5, 5, 5,                       /* 12-14 */
      4, 4, 4, 4,                    /* 15-18 */
      3, 3, 3, 3, 3, 3,              /* 19-24 */
      2, 2, 2, 2, 2, 2, 2,           /* 25-31 */
  };
  if( a>=b ){
    if( a>b+49 ) return a;
    if( a>b+31 ) return a+1;
    return a+x[a-b];
  }else{
    if( b>a+49 ) return b;
    if( b>a+31 ) return b+1;
    return b+x[b-a];
  }
}

// Assembly:
movl %edi, %eax
cmpw %si, %ax
jge 0x5dcae
leal 0x31(%rax), %ecx
cmpl %esi, %ecx
jge 0x5dcbf
movl %esi, %eax
retq
leal 0x31(%rsi), %ecx
cmpl %eax, %ecx
jl 0x5dcad
leal 0x1f(%rsi), %ecx
cmpl %eax, %ecx
jge 0x5dcca
incl %eax
retq
leal 0x1f(%rax), %ecx
cmpl %esi, %ecx
jge 0x5dcdf
leal 0x1(%rsi), %eax
retq
movl %eax, %ecx
subl %esi, %ecx
movslq %ecx, %rcx
leaq 0x177f8(%rip), %rdx     # 0x754d0
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
retq
movl %esi, %ecx
subl %eax, %ecx
movslq %ecx, %rax
leaq 0x177e3(%rip), %rcx     # 0x754d0
movzbl (%rax,%rcx), %eax
addl %esi, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/skeeto[P]flappy/sqlite3.c
// Function: whereLoopOutputAdjust
static void whereLoopOutputAdjust(WhereClause *pWC, WhereLoop *pLoop){
  WhereTerm *pTerm, *pX;
  Bitmask notAllowed = ~(pLoop->prereq|pLoop->maskSelf);
  int i, j;

  if( !OptimizationEnabled(pWC->pWInfo->pParse->db, SQLITE_AdjustOutEst) ){
    return;
  }
  for(i=pWC->nTerm, pTerm=pWC->a; i>0; i--, pTerm++){
    if( (pTerm->wtFlags & TERM_VIRTUAL)!=0 ) break;
    if( (pTerm->prereqAll & pLoop->maskSelf)==0 ) continue;
    if( (pTerm->prereqAll & notAllowed)!=0 ) continue;
    for(j=pLoop->nLTerm-1; j>=0; j--){
      pX = pLoop->aLTerm[j];
      if( pX==0 ) continue;
      if( pX==pTerm ) break;
      if( pX->iParent>=0 && (&pWC->a[pX->iParent])==pTerm ) break;
    }
    if( j<0 ) pLoop->nOut += pTerm->truthProb;
  }
}

// Assembly:
pushq %rbx
movq (%rdi), %rax
movq (%rax), %rax
movq (%rax), %rax
testb $0x10, 0x4d(%rax)
jne 0x5dd98
movl 0x14(%rdi), %eax
testl %eax, %eax
jle 0x5dd98
movq 0x8(%rsi), %rcx
movq (%rsi), %rdx
orq %rcx, %rdx
notq %rdx
movq 0x20(%rdi), %rdi
movq %rdi, %r8
testb $0x2, 0x1c(%r8)
jne 0x5dd98
movq 0x30(%r8), %r9
testq %rcx, %r9
je 0x5dd88
andq %rdx, %r9
jne 0x5dd88
movzwl 0x2c(%rsi), %r9d
testq %r9, %r9
je 0x5dd7e
movq 0x30(%rsi), %r10
movq -0x8(%r10,%r9,8), %r11
testq %r11, %r11
je 0x5dd79
cmpq %r8, %r11
je 0x5dd88
movl 0x8(%r11), %r11d
testl %r11d, %r11d
setns %bl
movl %r11d, %r11d
imulq $0x38, %r11, %r11
addq %rdi, %r11
cmpq %r8, %r11
sete %r11b
testb %r11b, %bl
jne 0x5dd88
decq %r9
jne 0x5dd4a
movzwl 0x18(%r8), %r9d
addw %r9w, 0x16(%rsi)
leal -0x1(%rax), %r9d
addq $0x38, %r8
cmpl $0x1, %eax
movl %r9d, %eax
jg 0x5dd27
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/skeeto[P]flappy/sqlite3.c
// Function: disableTerm
static void disableTerm(WhereLevel *pLevel, WhereTerm *pTerm){
  if( pTerm
      && (pTerm->wtFlags & TERM_CODED)==0
      && (pLevel->iLeftJoin==0 || ExprHasProperty(pTerm->pExpr, EP_FromJoin))
      && (pLevel->notReady & pTerm->prereqAll)==0
  ){
    pTerm->wtFlags |= TERM_CODED;
    if( pTerm->iParent>=0 ){
      WhereTerm *pOther = &pTerm->pWC->a[pTerm->iParent];
      if( (--pOther->nChild)==0 ){
        disableTerm(pLevel, pOther);
      }
    }
  }
}

// Assembly:
testq %rsi, %rsi
je 0x5ed95
movb 0x1c(%rsi), %al
testb $0x4, %al
jne 0x5ed95
cmpl $0x0, (%rdi)
je 0x5ed67
movq (%rsi), %rcx
testb $0x1, 0x4(%rcx)
je 0x5ed95
movq 0x30(%rsi), %rcx
testq %rcx, 0x48(%rdi)
jne 0x5ed95
orb $0x4, %al
movb %al, 0x1c(%rsi)
movslq 0x8(%rsi), %rax
testq %rax, %rax
js 0x5ed95
movq 0x20(%rsi), %rcx
movq 0x20(%rcx), %rcx
imulq $0x38, %rax, %rax
leaq (%rcx,%rax), %rsi
decb 0x1d(%rcx,%rax)
je 0x5ed4d
retq
// File: /workspace/github_c_makefile_star2_O3/skeeto[P]flappy/sqlite3.c
// Function: sqlite3ExprCodeIsNullJump
SQLITE_PRIVATE int sqlite3ExprCanBeNull(const Expr *p){
  u8 op;
  while( p->op==TK_UPLUS || p->op==TK_UMINUS ){ p = p->pLeft; }
  op = p->op;
  if( op==TK_REGISTER ) op = p->op2;
  switch( op ){
    case TK_INTEGER:
    case TK_STRING:
    case TK_FLOAT:
    case TK_BLOB:
      return 0;
    default:
      return 1;
  }
}

// Assembly:
movb (%rsi), %al
movzbl %al, %r8d
leal -0x9c(%r8), %r9d
cmpl $0x2, %r9d
jae 0x5f024
movq 0x10(%rsi), %rsi
jmp 0x5f00b
cmpl $0x85, %r8d
jne 0x5f030
movb 0x36(%rsi), %al
movzbl %al, %eax
addl $-0x5f, %eax
cmpl $0x25, %eax
ja 0x5f04c
movabsq $0x3800000001, %rsi     # imm = 0x3800000001
btq %rax, %rsi
jae 0x5f04c
retq
movl $0x4a, %esi
xorl %r8d, %r8d
jmp 0x487d8
// File: /workspace/github_c_makefile_star2_O3/skeeto[P]flappy/sqlite3.c
// Function: sqlite3FkRequired
SQLITE_PRIVATE int sqlite3FkRequired(
  Parse *pParse,                  /* Parse context */
  Table *pTab,                    /* Table being modified */
  int *aChange,                   /* Non-NULL for UPDATE operations */
  int chngRowid                   /* True for UPDATE that affects rowid */
){
  if( pParse->db->flags&SQLITE_ForeignKeys ){
    if( !aChange ){
      /* A DELETE operation. Foreign key processing is required if the 
      ** table in question is either the child or parent table for any 
      ** foreign key constraint.  */
      return (sqlite3FkReferences(pTab) || pTab->pFKey);
    }else{
      /* This is an UPDATE. Foreign key processing is only required if the
      ** operation modifies one or more child or parent key columns. */
      FKey *p;

      /* Check if any child key columns are being modified. */
      for(p=pTab->pFKey; p; p=p->pNextFrom){
        if( fkChildIsModified(pTab, p, aChange, chngRowid) ) return 1;
      }

      /* Check if any parent key columns are being modified. */
      for(p=sqlite3FkReferences(pTab); p; p=p->pNextTo){
        if( fkParentIsModified(pTab, p, aChange, chngRowid) ) return 1;
      }
    }
  }
  return 0;
}

// Assembly:
btl $0x13, %edi
jb 0x5fb3d
xorl %eax, %eax
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
testq %rdx, %rdx
je 0x5fbcb
movl %ecx, %ebp
movq 0x20(%rbx), %rcx
testq %rcx, %rcx
je 0x5fb9a
movl $0x1, %eax
movslq 0x28(%rcx), %rdx
testq %rdx, %rdx
jle 0x5fb91
shlq $0x4, %rdx
xorl %esi, %esi
movslq 0x40(%rcx,%rsi), %rdi
cmpl $0x0, (%r14,%rdi,4)
jns 0x5fbf1
testl %ebp, %ebp
je 0x5fb88
movswl 0x40(%rbx), %r8d
cmpl %r8d, %edi
je 0x5fbf1
addq $0x10, %rsi
cmpq %rsi, %rdx
jne 0x5fb6e
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
jne 0x5fb5f
movq %rbx, %rdi
callq 0x52fb1
testq %rax, %rax
je 0x5fbc7
movq %rax, %r15
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x60403
testl %eax, %eax
jne 0x5fbec
movq 0x18(%r15), %r15
testq %r15, %r15
jne 0x5fbaa
xorl %eax, %eax
jmp 0x5fbf1
movq %rbx, %rdi
callq 0x52fb1
movq %rax, %rcx
movl $0x1, %eax
testq %rcx, %rcx
jne 0x5fbf1
xorl %eax, %eax
cmpq $0x0, 0x20(%rbx)
setne %al
jmp 0x5fbf1
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/skeeto[P]flappy/sqlite3.c
// Function: fkParentIsModified
static int fkParentIsModified(
  Table *pTab, 
  FKey *p, 
  int *aChange, 
  int bChngRowid
){
  int i;
  for(i=0; i<p->nCol; i++){
    char *zKey = p->aCol[i].zCol;
    int iKey;
    for(iKey=0; iKey<pTab->nCol; iKey++){
      if( aChange[iKey]>=0 || (iKey==pTab->iPKey && bChngRowid) ){
        Column *pCol = &pTab->aCol[iKey];
        if( zKey ){
          if( 0==sqlite3StrICmp(pCol->zName, zKey) ) return 1;
        }else if( pCol->colFlags & COLFLAG_PRIMKEY ){
          return 1;
        }
      }
    }
  }
  return 0;
}

// Assembly:
movslq 0x28(%rsi), %rax
testq %rax, %rax
jle 0x604ea
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
addq $0x40, %rsi
movswq 0x42(%rdi), %r8
xorl %r9d, %r9d
leaq 0xdfa3(%rip), %r10      # 0x6e3d0
testw %r8w, %r8w
jle 0x604ca
movq %r9, %r11
shlq $0x4, %r11
movq 0x8(%rsi,%r11), %r11
xorl %ebx, %ebx
cmpl $0x0, (%rdx,%rbx,4)
jns 0x6045c
testl %ecx, %ecx
je 0x604be
movswq 0x40(%rdi), %r14
movl %r14d, %r14d
cmpq %r14, %rbx
jne 0x604be
leaq (%rbx,%rbx,2), %r14
shlq $0x4, %r14
addq 0x8(%rdi), %r14
testq %r11, %r11
je 0x604a1
movq (%r14), %r15
movb (%r15), %bpl
testb %bpl, %bpl
je 0x604aa
incq %r15
movq %r11, %r14
movzbl %bpl, %r12d
movb (%r12,%r10), %bpl
movzbl (%r14), %r13d
cmpb (%r13,%r10), %bpl
jne 0x604b0
incq %r14
movb (%r15), %bpl
incq %r15
testb %bpl, %bpl
jne 0x6047e
jmp 0x604ad
testb $0x1, 0x2b(%r14)
je 0x604be
jmp 0x604da
movq %r11, %r14
xorl %r12d, %r12d
movb (%r12,%r10), %bpl
movzbl (%r14), %r14d
cmpb (%r14,%r10), %bpl
je 0x604da
incq %rbx
cmpq %r8, %rbx
jne 0x60445
incq %r9
cmpq %rax, %r9
jne 0x6042d
xorl %eax, %eax
jmp 0x604df
movl $0x1, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/skeeto[P]flappy/sqlite3.c
// Function: sqlite3GenerateRowIndexDelete
SQLITE_PRIVATE void sqlite3GenerateRowIndexDelete(
  Parse *pParse,     /* Parsing and code generating context */
  Table *pTab,       /* Table containing the row to be deleted */
  int iDataCur,      /* Cursor of table holding data. */
  int iIdxCur,       /* First index cursor */
  int *aRegIdx       /* Only delete if aRegIdx!=0 && aRegIdx[i]>0 */
){
  int i;             /* Index loop counter */
  int r1;            /* Register holding an index key */
  int iPartIdxLabel; /* Jump destination for skipping partial index entries */
  Index *pIdx;       /* Current index */
  Vdbe *v;           /* The prepared statement under construction */
  Index *pPk;        /* PRIMARY KEY index, or NULL for rowid tables */

  v = pParse->pVdbe;
  pPk = HasRowid(pTab) ? 0 : sqlite3PrimaryKeyIndex(pTab);
  for(i=0, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){
    assert( iIdxCur+i!=iDataCur || pPk==pIdx );
    if( aRegIdx!=0 && aRegIdx[i]==0 ) continue;
    if( pIdx==pPk ) continue;
    VdbeModuleComment((v, "GenRowIdxDel for %s", pIdx->zName));
    r1 = sqlite3GenerateIndexKey(pParse, pIdx, iDataCur, 0, 1, &iPartIdxLabel);
    sqlite3VdbeAddOp3(v, OP_IdxDelete, iIdxCur+i, r1,
                      pIdx->uniqNotNull ? pIdx->nKeyCol : pIdx->nColumn);
    sqlite3VdbeResolveLabel(v, iPartIdxLabel);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r15
movl %ecx, %ebp
movl %edx, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
movq 0x10(%rdi), %r12
testb $0x20, 0x48(%rsi)
movq 0x10(%rsi), %r13
je 0x60cc6
testq %r13, %r13
je 0x60d5b
movq %r13, %r14
movb 0x63(%r14), %al
andb $0x3, %al
cmpb $0x2, %al
je 0x60cc9
movq 0x28(%r14), %r14
testq %r14, %r14
jne 0x60cb3
xorl %r14d, %r14d
testq %r13, %r13
je 0x60d5b
movq %r15, %rbx
testq %r15, %r15
je 0x60ce6
cmpq %r14, %r13
je 0x60d48
cmpl $0x0, (%rbx)
jne 0x60ceb
jmp 0x60d48
cmpq %r14, %r13
je 0x60d48
movq 0x10(%rsp), %rdi
movq %r13, %rsi
movl 0x8(%rsp), %edx
xorl %ecx, %ecx
movl $0x1, %r8d
leaq 0xc(%rsp), %r9
callq 0x526f0
xorl %ecx, %ecx
testb $0x8, 0x63(%r13)
sete %cl
movzwl 0x5e(%r13,%rcx,2), %r8d
movq %r12, %rdi
movl $0x6a, %esi
movl %ebp, %edx
movl %eax, %ecx
callq 0x487d8
movl 0xc(%rsp), %eax
testl %eax, %eax
jns 0x60d48
movq 0x40(%r12), %rcx
testq %rcx, %rcx
je 0x60d48
notl %eax
movl 0x34(%r12), %edx
movl %eax, %eax
movl %edx, (%rcx,%rax,4)
movq 0x28(%r13), %r13
incl %ebp
addq $0x4, %rbx
testq %r13, %r13
jne 0x60cd5
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/skeeto[P]flappy/sqlite3.c
// Function: exprTableRegister
static Expr *exprTableRegister(
  Parse *pParse,     /* Parsing and code generating context */
  Table *pTab,       /* The table whose content is at r[regBase]... */
  int regBase,       /* Contents of table pTab */
  i16 iCol           /* Which column of pTab is desired */
){
  Expr *pExpr;
  Column *pCol;
  const char *zColl;
  sqlite3 *db = pParse->db;

  pExpr = sqlite3Expr(db, TK_REGISTER, 0);
  if( pExpr ){
    if( iCol>=0 && iCol!=pTab->iPKey ){
      pCol = &pTab->aCol[iCol];
      pExpr->iTable = regBase + iCol + 1;
      pExpr->affinity = pCol->affinity;
      zColl = pCol->zColl;
      if( zColl==0 ) zColl = db->pDfltColl->zName;
      pExpr = sqlite3ExprAddCollateString(pParse, pExpr, zColl);
    }else{
      pExpr->iTable = regBase;
      pExpr->affinity = SQLITE_AFF_INTEGER;
    }
  }
  return pExpr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %rbx
movq (%rdi), %r14
movq %rsp, %rdx
movq $0x0, (%rdx)
movl $0x0, 0x8(%rdx)
movq %r14, %rdi
movl $0x85, %esi
xorl %ecx, %ecx
callq 0x51708
testq %rax, %rax
je 0x628cd
testw %bp, %bp
js 0x628c3
cmpw %bp, 0x40(%r12)
jne 0x628d1
movl %r15d, 0x2c(%rax)
movb $0x64, 0x1(%rax)
jmp 0x6290e
xorl %eax, %eax
jmp 0x6290e
movswl %bp, %ecx
movq 0x8(%r12), %rdx
movzwl %bp, %esi
leaq (%rsi,%rsi,2), %rsi
shll $0x4, %esi
addl %r15d, %ecx
incl %ecx
movl %ecx, 0x2c(%rax)
movb 0x29(%rdx,%rsi), %cl
movb %cl, 0x1(%rax)
movq 0x20(%rdx,%rsi), %rdx
testq %rdx, %rdx
jne 0x62903
movq 0x10(%r14), %rcx
movq (%rcx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4f8b6
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/skeeto[P]flappy/sqlite3.c
// Function: sqlite3RowidConstraint
SQLITE_PRIVATE void sqlite3RowidConstraint(
  Parse *pParse,    /* Parsing context */
  int onError,      /* Conflict resolution algorithm */
  Table *pTab       /* The table with the non-unique rowid */ 
){
  char *zMsg;
  int rc;
  if( pTab->iPKey>=0 ){
    zMsg = sqlite3MPrintf(pParse->db, "%s.%s", pTab->zName,
                          pTab->aCol[pTab->iPKey].zName);
    rc = SQLITE_CONSTRAINT_PRIMARYKEY;
  }else{
    zMsg = sqlite3MPrintf(pParse->db, "%s.rowid", pTab->zName);
    rc = SQLITE_CONSTRAINT_ROWID;
  }
  sqlite3HaltConstraint(pParse, rc, onError, zMsg, P4_DYNAMIC,
                        P5_ConstraintUnique);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rax
movl %esi, %ebx
movq %rdi, %r14
movswq 0x40(%rdx), %rcx
movq (%rdi), %rdi
movq (%rdx), %rdx
testq %rcx, %rcx
js 0x63d0f
movq 0x8(%rax), %rax
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
movq (%rax,%rcx), %rcx
leaq 0xeb87(%rip), %rsi      # 0x72885
xorl %eax, %eax
callq 0x11e78
movq %r14, %rdi
movl $0x613, %esi            # imm = 0x613
jmp 0x63d25
leaq 0x100a5(%rip), %rsi     # 0x73dbb
xorl %eax, %eax
callq 0x11e78
movq %r14, %rdi
movl $0xa13, %esi            # imm = 0xA13
movl %ebx, %edx
movq %rax, %rcx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movl $0x2, %r9d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4b546
// File: /workspace/github_c_makefile_star2_O3/skeeto[P]flappy/sqlite3.c
// Function: sqlite3ExprCodeAndCache
SQLITE_PRIVATE int sqlite3ExprCodeAndCache(Parse *pParse, Expr *pExpr, int target){
  Vdbe *v = pParse->pVdbe;
  int inReg;
  inReg = sqlite3ExprCode(pParse, pExpr, target);
  assert( target>0 );
  /* The only place, other than this routine, where expressions can be
  ** converted to TK_REGISTER is internal subexpressions in BETWEEN and
  ** CASE operators.  Neither ever calls this routine.  And this routine
  ** is never called twice on the same expression.  Hence it is impossible
  ** for the input to this routine to already be a register.  Nevertheless,
  ** it seems prudent to keep the ALWAYS() in case the conditions above
  ** change with future modifications or enhancements. */
  if( ALWAYS(pExpr->op!=TK_REGISTER) ){  
    int iMem;
    iMem = ++pParse->nMem;
    sqlite3VdbeAddOp2(v, OP_Copy, inReg, iMem);
    exprToRegister(pExpr, iMem);
  }
  return inReg;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r12
movq 0x10(%rdi), %r15
callq 0x4885f
cmpb $-0x7b, (%r14)
je 0x648e7
movl 0x58(%r12), %ebp
incl %ebp
movl %ebp, 0x58(%r12)
movq %r15, %rdi
movl $0x1e, %esi
movl %ebx, %edx
movl %ebp, %ecx
xorl %r8d, %r8d
callq 0x487d8
movb (%r14), %al
movb %al, 0x36(%r14)
movb $-0x7b, (%r14)
movl %ebp, 0x2c(%r14)
andb $-0x11, 0x5(%r14)
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/skeeto[P]flappy/sqlite3.c
// Function: xferCompatibleIndex
static int xferCompatibleIndex(Index *pDest, Index *pSrc){
  int i;
  assert( pDest && pSrc );
  assert( pDest->pTable!=pSrc->pTable );
  if( pDest->nKeyCol!=pSrc->nKeyCol ){
    return 0;   /* Different number of columns */
  }
  if( pDest->onError!=pSrc->onError ){
    return 0;   /* Different conflict resolution strategies */
  }
  for(i=0; i<pSrc->nKeyCol; i++){
    if( pSrc->aiColumn[i]!=pDest->aiColumn[i] ){
      return 0;   /* Different columns indexed */
    }
    if( pSrc->aSortOrder[i]!=pDest->aSortOrder[i] ){
      return 0;   /* Different sort orders */
    }
    if( !xferCompatibleCollation(pSrc->azColl[i],pDest->azColl[i]) ){
      return 0;   /* Different collating sequences */
    }
  }
  if( sqlite3ExprCompare(pSrc->pPartIdxWhere, pDest->pPartIdxWhere, -1) ){
    return 0;     /* Different WHERE clauses */
  }

  /* If no test above fails then the indices must be compatible */
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movzwl 0x5e(%rdi), %r12d
xorl %ebx, %ebx
cmpw 0x5e(%rsi), %r12w
jne 0x649fa
movq %rsi, %r15
movq %rdi, %r14
movb 0x62(%rdi), %al
cmpb 0x62(%rsi), %al
jne 0x649fa
testq %r12, %r12
je 0x649e1
movq 0x8(%r15), %rax
movq %rax, (%rsp)
movq 0x8(%r14), %rbp
xorl %ebx, %ebx
xorl %r13d, %r13d
movq (%rsp), %rax
movzwl (%rax,%r13,2), %eax
cmpw (%rbp,%r13,2), %ax
jne 0x649fa
movq 0x38(%r15), %rax
movb (%rax,%r13), %al
movq 0x38(%r14), %rcx
cmpb (%rcx,%r13), %al
jne 0x649fa
movq 0x40(%r15), %rax
movq (%rax,%r13,8), %rdi
movq 0x40(%r14), %rax
movq (%rax,%r13,8), %rsi
callq 0x648f2
testl %eax, %eax
je 0x649fa
incq %r13
cmpq %r13, %r12
jne 0x6499d
movq 0x48(%r15), %rdi
movq 0x48(%r14), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x4bb7c
xorl %ebx, %ebx
testl %eax, %eax
sete %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/skeeto[P]flappy/sqlite3.c
// Function: sqlite3BtreeSetMmapLimit
SQLITE_PRIVATE int sqlite3BtreeSetMmapLimit(Btree *p, sqlite3_int64 szMmap){
  BtShared *pBt = p->pBt;
  assert( sqlite3_mutex_held(p->db->mutex) );
  sqlite3BtreeEnter(p);
  sqlite3PagerSetMmapLimit(pBt->pPager, szMmap);
  sqlite3BtreeLeave(p);
  return SQLITE_OK;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %r15
callq 0xd3a2
movq (%r15), %rdi
movq %r14, 0xa0(%rdi)
callq 0x1e3e0
cmpb $0x0, 0x11(%rbx)
je 0x64d61
decl 0x14(%rbx)
jne 0x64d61
movq 0x8(%rbx), %rax
movq 0x50(%rax), %rdi
testq %rdi, %rdi
je 0x64d5d
callq *0x255cb(%rip)          # 0x8a328
movb $0x0, 0x12(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/skeeto[P]flappy/sqlite3.c
// Function: setLikeOptFlag
static void setLikeOptFlag(sqlite3 *db, const char *zName, u8 flagVal){
  FuncDef *pDef;
  pDef = sqlite3FindFunction(db, zName, sqlite3Strlen30(zName),
                             2, SQLITE_UTF8, 0);
  if( ALWAYS(pDef) ){
    pDef->funcFlags |= flagVal;
  }
}

// Assembly:
pushq %rbx
movl %edx, %ebx
testq %rsi, %rsi
je 0x65336
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rsi, %rax
incl %edx
cmpb $0x0, (%rax)
leaq 0x1(%rax), %rax
jne 0x65323
andl $0x3fffffff, %edx       # imm = 0x3FFFFFFF
jmp 0x65338
xorl %edx, %edx
movl $0x2, %ecx
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x162cf
testq %rax, %rax
je 0x65357
movzbl %bl, %ecx
orw %cx, 0x2(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/skeeto[P]flappy/sqlite3.c
// Function: pthreadMutexAlloc
static sqlite3_mutex *pthreadMutexAlloc(int iType){
  static sqlite3_mutex staticMutexes[] = {
    SQLITE3_MUTEX_INITIALIZER,
    SQLITE3_MUTEX_INITIALIZER,
    SQLITE3_MUTEX_INITIALIZER,
    SQLITE3_MUTEX_INITIALIZER,
    SQLITE3_MUTEX_INITIALIZER,
    SQLITE3_MUTEX_INITIALIZER
  };
  sqlite3_mutex *p;
  switch( iType ){
    case SQLITE_MUTEX_RECURSIVE: {
      p = sqlite3MallocZero( sizeof(*p) );
      if( p ){
#ifdef SQLITE_HOMEGROWN_RECURSIVE_MUTEX
        /* If recursive mutexes are not available, we will have to
        ** build our own.  See below. */
        pthread_mutex_init(&p->mutex, 0);
#else
        /* Use a recursive mutex if it is available */
        pthread_mutexattr_t recursiveAttr;
        pthread_mutexattr_init(&recursiveAttr);
        pthread_mutexattr_settype(&recursiveAttr, PTHREAD_MUTEX_RECURSIVE);
        pthread_mutex_init(&p->mutex, &recursiveAttr);
        pthread_mutexattr_destroy(&recursiveAttr);
#endif
#if SQLITE_MUTEX_NREF
        p->id = iType;
#endif
      }
      break;
    }
    case SQLITE_MUTEX_FAST: {
      p = sqlite3MallocZero( sizeof(*p) );
      if( p ){
#if SQLITE_MUTEX_NREF
        p->id = iType;
#endif
        pthread_mutex_init(&p->mutex, 0);
      }
      break;
    }
    default: {
      assert( iType-2 >= 0 );
      assert( iType-2 < ArraySize(staticMutexes) );
      p = &staticMutexes[iType-2];
#if SQLITE_MUTEX_NREF
      p->id = iType;
#endif
      break;
    }
  }
  return p;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testl %edi, %edi
je 0x67838
cmpl $0x1, %edi
jne 0x67868
movl $0x28, %edi
callq 0xa44e
testq %rax, %rax
je 0x6787f
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movq $0x0, 0x20(%rax)
leaq 0x4(%rsp), %r14
movq %r14, %rdi
callq 0x7040
movq %r14, %rdi
movl $0x1, %esi
callq 0x7400
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7430
movq %r14, %rdi
callq 0x7420
jmp 0x67881
movl $0x28, %edi
callq 0xa44e
testq %rax, %rax
je 0x6787f
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movq $0x0, 0x20(%rax)
movq %rax, %rdi
xorl %esi, %esi
callq 0x7430
jmp 0x67881
addl $-0x2, %edi
movslq %edi, %rax
leaq (%rax,%rax,4), %rax
leaq 0x24747(%rip), %rcx     # 0x8bfc0
leaq (%rcx,%rax,8), %rbx
jmp 0x67881
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/skeeto[P]flappy/sqlite3.c
// Function: loadExt
static void loadExt(sqlite3_context *context, int argc, sqlite3_value **argv){
  const char *zFile = (const char *)sqlite3_value_text(argv[0]);
  const char *zProc;
  sqlite3 *db = sqlite3_context_db_handle(context);
  char *zErrMsg = 0;

  if( argc==2 ){
    zProc = (const char *)sqlite3_value_text(argv[1]);
  }else{
    zProc = 0;
  }
  if( zFile && sqlite3_load_extension(db, zFile, zProc, &zErrMsg) ){
    sqlite3_result_error(context, zErrMsg, -1);
    sqlite3_free(zErrMsg);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdx), %rdi
movl $0x1, %esi
callq 0xf3c6
movq %rax, %r14
movq 0x8(%rbx), %r15
movq $0x0, 0x8(%rsp)
cmpl $0x2, %ebp
jne 0x68ecc
movq 0x8(%r12), %rdi
movl $0x1, %esi
callq 0xf3c6
movq %rax, %rdx
jmp 0x68ece
xorl %edx, %edx
testq %r14, %r14
je 0x68f1b
leaq 0x8(%rsp), %rcx
movq %r15, %rdi
movq %r14, %rsi
callq 0x13441
testl %eax, %eax
je 0x68f1b
leaq 0x8(%rbx), %rdi
movq 0x8(%rsp), %rsi
movl $0x1, 0x5c(%rbx)
movb $0x1, 0x61(%rbx)
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x1, %ecx
movq $-0x1, %r8
callq 0xf552
movq 0x8(%rsp), %rdi
callq 0xa4bf
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/skeeto[P]flappy/sqlite3.c
// Function: setDateTimeToCurrent
static int setDateTimeToCurrent(sqlite3_context *context, DateTime *p){
  p->iJD = sqlite3StmtCurrentTime(context);
  if( p->iJD>0 ){
    p->validJD = 1;
    return 0;
  }else{
    return 1;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x50(%rdi), %r14
movq 0xc8(%r14), %rax
testq %rax, %rax
je 0x6a7ff
movq %rax, (%rbx)
testq %rax, %rax
jle 0x6a821
movb $0x1, 0x2a(%rbx)
xorl %eax, %eax
jmp 0x6a826
addq $0xc8, %r14
movq 0x8(%rdi), %rax
movq (%rax), %rdi
movq %r14, %rsi
callq 0x26b69
testl %eax, %eax
je 0x6a82e
xorl %eax, %eax
movq %rax, (%r14)
movq %rax, (%rbx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%r14), %rax
jmp 0x6a7ef
// File: /workspace/github_c_makefile_star2_O3/skeeto[P]flappy/sqlite3.c
// Function: pcache1Pagecount
static int pcache1Pagecount(sqlite3_pcache *p){
  int n;
  PCache1 *pCache = (PCache1*)p;
  pcache1EnterMutex(pCache->pGroup);
  n = pCache->nPage;
  pcache1LeaveMutex(pCache->pGroup);
  return n;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x6b711
callq *0x1ec1d(%rip)          # 0x8a318
movq (%rbx), %rax
movq (%rax), %rdi
movl 0x28(%rbx), %ebx
testq %rdi, %rdi
je 0x6b714
callq *0x1ec19(%rip)          # 0x8a328
jmp 0x6b714
movl 0x28(%rbx), %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/skeeto[P]flappy/sqlite3.c
// Function: pcache1Rekey
static void pcache1Rekey(
  sqlite3_pcache *p,
  sqlite3_pcache_page *pPg,
  unsigned int iOld,
  unsigned int iNew
){
  PCache1 *pCache = (PCache1 *)p;
  PgHdr1 *pPage = (PgHdr1 *)pPg;
  PgHdr1 **pp;
  unsigned int h; 
  assert( pPage->iKey==iOld );
  assert( pPage->pCache==pCache );

  pcache1EnterMutex(pCache->pGroup);

  h = iOld%pCache->nHash;
  pp = &pCache->apHash[h];
  while( (*pp)!=pPage ){
    pp = &(*pp)->pNext;
  }
  *pp = pPage->pNext;

  h = iNew%pCache->nHash;
  pPage->iKey = iNew;
  pPage->pNext = pCache->apHash[h];
  pCache->apHash[h] = pPage;
  if( iNew>pCache->iMaxKey ){
    pCache->iMaxKey = iNew;
  }

  pcache1LeaveMutex(pCache->pGroup);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x6bb4d
callq *0x1e7cb(%rip)          # 0x8a318
movl 0x2c(%r14), %ecx
movl %ebp, %eax
xorl %edx, %edx
divl %ecx
shlq $0x3, %rdx
addq 0x30(%r14), %rdx
movq %rdx, %rax
movq (%rdx), %rsi
leaq 0x18(%rsi), %rdx
cmpq %r15, %rsi
jne 0x6bb5f
movq 0x18(%r15), %rdx
movq %rdx, (%rax)
movl %ebx, %eax
xorl %edx, %edx
divl %ecx
movl %ebx, 0x10(%r15)
movq 0x30(%r14), %rax
movq (%rax,%rdx,8), %rcx
movq %rcx, 0x18(%r15)
movq %r15, (%rax,%rdx,8)
cmpl %ebx, 0x20(%r14)
jae 0x6bb99
movl %ebx, 0x20(%r14)
movq (%r14), %rax
movq (%rax), %rdi
addq $0x8, %rsp
testq %rdi, %rdi
je 0x6bbb4
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *0x1e774(%rip)          # 0x8a328
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/skeeto[P]flappy/sqlite3.c
// Function: pcache1Truncate
static void pcache1Truncate(sqlite3_pcache *p, unsigned int iLimit){
  PCache1 *pCache = (PCache1 *)p;
  pcache1EnterMutex(pCache->pGroup);
  if( iLimit<=pCache->iMaxKey ){
    pcache1TruncateUnsafe(pCache, iLimit);
    pCache->iMaxKey = iLimit-1;
  }
  pcache1LeaveMutex(pCache->pGroup);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x6bbd4
callq *0x1e744(%rip)          # 0x8a318
cmpl %ebp, 0x20(%rbx)
jb 0x6bbe8
movq %rbx, %rdi
movl %ebp, %esi
callq 0x6bdaf
decl %ebp
movl %ebp, 0x20(%rbx)
movq (%rbx), %rax
movq (%rax), %rdi
addq $0x8, %rsp
testq %rdi, %rdi
je 0x6bbff
popq %rbx
popq %rbp
jmpq *0x1e729(%rip)          # 0x8a328
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/k0n10pl4tr[P]minimal_crafter/main.c
// Function: updateWindow
void
updateWindow()
{
	glXSwapBuffers(dpy, window);
	while(XPending(dpy)) {
		XEvent xev;
		XNextEvent(dpy, &xev);
		switch(xev.type) {
		case ClientMessage:
			if(xev.xclient.data.l[0] == wmDeleteWindow)
				running = 0;
			break;
		case ConfigureNotify:
			if(windowWidth != xev.xconfigure.width || windowHeight != xev.xconfigure.height) {
				windowWidth = xev.xconfigure.width;
				windowHeight = xev.xconfigure.height;

				resizeRenderingSystem(windowWidth, windowHeight);
			}
			break;

		case KeyPress:
			processKeyState(&xev, 1);
			break;
		case KeyRelease:
			processKeyState(&xev, 0);
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xc8, %rsp
movq 0x8ef8(%rip), %rdi      # 0xb5a0
movq 0x8f21(%rip), %rsi      # 0xb5d0
callq 0x21d0
movq 0x8ee5(%rip), %rdi      # 0xb5a0
callq 0x22a0
testl %eax, %eax
je 0x276b
leaq -0xc8(%rbp), %rbx
movq 0x8eca(%rip), %rdi      # 0xb5a0
movq %rbx, %rsi
callq 0x2200
movl -0xc8(%rbp), %eax
cmpl $0x15, %eax
jg 0x26fa
cmpl $0x2, %eax
je 0x271d
cmpl $0x3, %eax
jne 0x272a
movq %rbx, %rdi
xorl %esi, %esi
jmp 0x2725
cmpl $0x16, %eax
je 0x273c
cmpl $0x21, %eax
jne 0x272a
movq -0x90(%rbp), %rax
cmpq 0x8eae(%rip), %rax      # 0xb5c0
jne 0x272a
movb $0x0, 0x8ec5(%rip)      # 0xb5e0
jmp 0x272a
movq %rbx, %rdi
movl $0x1, %esi
callq 0x2775
movq 0x8e6f(%rip), %rdi      # 0xb5a0
callq 0x22a0
testl %eax, %eax
jne 0x26cf
jmp 0x276b
movl -0x90(%rbp), %edi
movl -0x8c(%rbp), %esi
cmpl %edi, 0x8e7a(%rip)      # 0xb5c8
jne 0x2758
cmpl %esi, 0x8e76(%rip)      # 0xb5cc
je 0x272a
movl %edi, 0x8e6a(%rip)      # 0xb5c8
movl %esi, 0x8e68(%rip)      # 0xb5cc
callq 0x518f
jmp 0x272a
addq $0xc8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/k0n10pl4tr[P]minimal_crafter/main.c
// Function: processKeyState
void
processKeyState(XEvent *xev, unsigned char state)
{
	if(XLookupKeysym(&xev->xkey, 0) == XK_Left)   keyLeft = state;
	if(XLookupKeysym(&xev->xkey, 0) == XK_Right)  keyRight = state;
	if(XLookupKeysym(&xev->xkey, 0) == XK_Up)     keyUp = state;
	if(XLookupKeysym(&xev->xkey, 0) == XK_Down)   keyDown = state;
	if(XLookupKeysym(&xev->xkey, 0) == XK_w)      keyFront = state;
	if(XLookupKeysym(&xev->xkey, 0) == XK_s)      keyBack = state;
	if(XLookupKeysym(&xev->xkey, 0) == XK_space)  keySpace = state;
	if(XLookupKeysym(&xev->xkey, 0) == XK_Shift_L) keyShift = state;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
xorl %esi, %esi
callq 0x2030
cmpq $0xff51, %rax           # imm = 0xFF51
jne 0x2798
movb %r14b, 0x8e49(%rip)     # 0xb5e1
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2030
cmpq $0xff53, %rax           # imm = 0xFF53
jne 0x27b1
movb %r14b, 0x8e31(%rip)     # 0xb5e2
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2030
cmpq $0xff52, %rax           # imm = 0xFF52
jne 0x27ca
movb %r14b, 0x8e19(%rip)     # 0xb5e3
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2030
cmpq $0xff54, %rax           # imm = 0xFF54
jne 0x27e3
movb %r14b, 0x8e01(%rip)     # 0xb5e4
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2030
cmpq $0x77, %rax
jne 0x27fa
movb %r14b, 0x8deb(%rip)     # 0xb5e5
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2030
cmpq $0x73, %rax
jne 0x2811
movb %r14b, 0x8dd5(%rip)     # 0xb5e6
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2030
cmpq $0x20, %rax
jne 0x2828
movb %r14b, 0x8dbf(%rip)     # 0xb5e7
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x2030
// File: /workspace/github_c_makefile_star2_O3/k0n10pl4tr[P]minimal_crafter/main.c
// Function: terminateWindow
void
terminateWindow()
{
	glXMakeCurrent(dpy, None, None);
	glXDestroyContext(dpy, glContext);
	XDestroyWindow(dpy, window);
	XCloseDisplay(dpy);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8d5f(%rip), %rdi      # 0xb5a0
xorl %esi, %esi
xorl %edx, %edx
callq 0x2040
movq 0x8d4f(%rip), %rdi      # 0xb5a0
movq 0x8d80(%rip), %rsi      # 0xb5d8
callq 0x2140
movq 0x8d3c(%rip), %rdi      # 0xb5a0
movq 0x8d65(%rip), %rsi      # 0xb5d0
callq 0x21b0
movq 0x8d29(%rip), %rdi      # 0xb5a0
popq %rbp
jmp 0x21c0
// File: /workspace/github_c_makefile_star2_O3/k0n10pl4tr[P]minimal_crafter/main.c
// Function: main
int
main(int argc, char *argv[])
{
	initWindow();
	startClock();
	initRenderingSystem();

	createWorld(32, 4, 32);

	running = 1;

	while(running) {
		double startProcess, endProcess;
		startProcess = getCurrentTimeNano();
		
		processCamera(1.0/60.0, 5.0/60.0);
		
		setCamera(cameraEye, cameraNormal, cameraLook);
		render(cameraPosition[0], cameraPosition[1], cameraPosition[2]);
		
		updateWindow();

		endProcess = getCurrentTimeNano();
		sleepNanosec((1.0 / FRAMES_PER_SEC) - (endProcess - startProcess));
	}
	terminateWindow();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
callq 0x23bc
xorl %eax, %eax
callq 0x4b4c
xorl %eax, %eax
callq 0x4dc4
movl $0x20, %edi
movl $0x4, %esi
movl $0x20, %edx
callq 0x68b3
movb $0x1, 0x8955(%rip)      # 0xb5e0
leaq 0x89b6(%rip), %rbx      # 0xb648
leaq 0x8563(%rip), %r14      # 0xb1fc
leaq 0x89b4(%rip), %r15      # 0xb654
xorl %eax, %eax
callq 0x4b7b
movsd %xmm0, -0x20(%rbp)
movss 0x4370(%rip), %xmm0     # 0x7024
movss 0x436c(%rip), %xmm1     # 0x7028
callq 0x287d
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x5b62
movss 0x8519(%rip), %xmm0     # 0xb1f0
movss 0x8515(%rip), %xmm1     # 0xb1f4
movss 0x8511(%rip), %xmm2     # 0xb1f8
callq 0x5903
callq 0x2695
xorl %eax, %eax
callq 0x4b7b
movsd -0x20(%rbp), %xmm1
subsd %xmm0, %xmm1
addsd 0x4307(%rip), %xmm1     # 0x7010
movapd %xmm1, %xmm0
callq 0x4bc4
cmpb $0x0, 0x88c7(%rip)      # 0xb5e0
jne 0x2ca0
callq 0x2836
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/k0n10pl4tr[P]minimal_crafter/glutil.c
// Function: loadShader
unsigned int
loadShader(const char *path, unsigned int type)
{
	char *fileData;
	int   size;

	FILE *fp = fopen(path, "r");
	if(!fp) {
		printf("Could not open the shader %s\n", path);
		return -1;
	}
	fseek(fp, 0, SEEK_END);
	size = ftell(fp);
	fseek(fp, 0, SEEK_SET);
	fileData = malloc(size);
	fread(fileData, 1, size, fp);
	fclose(fp);

	unsigned int shader = glCreateShader(type);
	glShaderSource(shader, 1, (const char* const*)&fileData, &size);
	glCompileShader(shader);
	
	int cmp;
	glGetShaderiv(shader, GL_COMPILE_STATUS, &cmp);
	if(!cmp) 
	{
		glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &cmp);
		char* data = malloc(cmp);
		glGetShaderInfoLog(shader, cmp, &cmp, data);
		printf("Shader compilation failure! Shader path: %s\nLog: %s\n", path, data);
		free(data);
	}
	
	free(fileData);
	return shader;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x4568(%rip), %rsi      # 0x72b6
callq 0x2120
testq %rax, %rax
je 0x2e69
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x20b0
movq %r15, %rdi
callq 0x2070
movq %rax, %r13
leaq -0x30(%rbp), %rax
movl %r13d, (%rax)
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x20b0
movslq %r13d, %r13
movq %r13, %rdi
callq 0x2110
leaq -0x38(%rbp), %r12
movq %rax, (%r12)
movl $0x1, %esi
movq %rax, %rdi
movq %r13, %rdx
movq %r15, %rcx
callq 0x2230
movq %r15, %rdi
callq 0x2260
leaq 0x8a8f(%rip), %rax      # 0xb850
movl %r14d, %edi
callq *(%rax)
movl %eax, %r14d
leaq 0x9000(%rip), %rax      # 0xbdd0
movl %r14d, %edi
movl $0x1, %esi
movq %r12, %rdx
leaq -0x30(%rbp), %rcx
callq *(%rax)
leaq 0x89f8(%rip), %rax      # 0xb7e0
movl %r14d, %edi
callq *(%rax)
leaq 0x8d4c(%rip), %r12      # 0xbb40
leaq -0x2c(%rbp), %r15
movl %r14d, %edi
movl $0x8b81, %esi           # imm = 0x8B81
movq %r15, %rdx
callq *(%r12)
cmpl $0x0, (%r15)
jne 0x2e5e
movl %r14d, %edi
movl $0x8b84, %esi           # imm = 0x8B84
movq %r15, %rdx
callq *(%r12)
movl (%r15), %eax
movslq %eax, %r12
movq %r12, %rdi
callq 0x2110
movq %rax, %r13
leaq 0x8cfc(%rip), %rax      # 0xbb30
movl %r14d, %edi
movl %r12d, %esi
movq %r15, %rdx
movq %r13, %rcx
callq *(%rax)
leaq 0x4342(%rip), %rdi      # 0x718b
movq %rbx, %rsi
movq %r13, %rdx
xorl %eax, %eax
callq 0x2060
movq %r13, %rdi
callq 0x2190
movq -0x38(%rbp), %rdi
callq 0x2190
jmp 0x2e80
leaq 0x42fd(%rip), %rdi      # 0x716d
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2060
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/k0n10pl4tr[P]minimal_crafter/glutil.c
// Function: createProgram
unsigned int
createProgram(unsigned int shaders[])
{
	unsigned int* shaderPtr = shaders;
	unsigned int program = glCreateProgram();

	while(*shaderPtr) {
		glAttachShader(program, *shaderPtr);
		shaderPtr++;
	}

	glLinkProgram(program);
	shaderPtr = shaders;

	while(*shaderPtr) {
		glDetachShader(program, *shaderPtr);
		shaderPtr++;
	}

	return program;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x89a1(%rip), %rax      # 0xb848
callq *(%rax)
movl %eax, %r14d
movl (%rbx), %esi
testl %esi, %esi
je 0x2ecf
leaq 0x4(%rbx), %r15
leaq 0x87e3(%rip), %r12      # 0xb6a0
movl %r14d, %edi
callq *(%r12)
movl (%r15), %esi
addq $0x4, %r15
testl %esi, %esi
jne 0x2ebd
leaq 0x8d9a(%rip), %rax      # 0xbc70
movl %r14d, %edi
callq *(%rax)
movl (%rbx), %esi
testl %esi, %esi
je 0x2efc
addq $0x4, %rbx
leaq 0x89dc(%rip), %r15      # 0xb8c8
movl %r14d, %edi
callq *(%r15)
movl (%rbx), %esi
addq $0x4, %rbx
testl %esi, %esi
jne 0x2eec
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/k0n10pl4tr[P]minimal_crafter/glutil.c
// Function: loadTextureFarbfeld
unsigned int
loadTextureFarbfeld(const char *path)
{
	unsigned int w, h;
	unsigned short *imageData = getFarbfeldImageData(path, &w, &h);
	if((intptr_t)imageData < 0) {
		return -2;
	}

	unsigned int texture;
	glGenTextures(1, &texture); 
	glBindTexture(GL_TEXTURE_2D, texture);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, w, h, 0, GL_RGBA, GL_UNSIGNED_SHORT, imageData);
	glBindTexture(GL_TEXTURE_2D, 0);
	
	free(imageData);
	return texture;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
leaq -0x28(%rbp), %rsi
leaq -0x24(%rbp), %rdx
callq 0x4cab
movq %rax, %rbx
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
testq %rbx, %rbx
js 0x2fd0
leaq 0x8aac(%rip), %rax      # 0xb9e8
leaq -0x2c(%rbp), %r14
movl $0x1, %edi
movq %r14, %rsi
callq *(%rax)
leaq 0x87b7(%rip), %r15      # 0xb708
movl (%r14), %esi
movl $0xde1, %edi            # imm = 0xDE1
callq *(%r15)
leaq 0x8f35(%rip), %r12      # 0xbe98
movl $0xde1, %edi            # imm = 0xDE1
movl $0x2801, %esi           # imm = 0x2801
movl $0x2600, %edx           # imm = 0x2600
callq *(%r12)
movl $0xde1, %edi            # imm = 0xDE1
movl $0x2800, %esi           # imm = 0x2800
movl $0x2600, %edx           # imm = 0x2600
callq *(%r12)
leaq 0x8ec8(%rip), %rax      # 0xbe58
movl -0x28(%rbp), %ecx
movl -0x24(%rbp), %r8d
subq $0x8, %rsp
movl $0xde1, %edi            # imm = 0xDE1
xorl %esi, %esi
movl $0x8058, %edx           # imm = 0x8058
xorl %r9d, %r9d
pushq %rbx
pushq $0x1403                 # imm = 0x1403
pushq $0x1908                 # imm = 0x1908
callq *(%rax)
addq $0x20, %rsp
movl $0xde1, %edi            # imm = 0xDE1
xorl %esi, %esi
callq *(%r15)
movq %rbx, %rdi
callq 0x2190
movl (%r14), %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/k0n10pl4tr[P]minimal_crafter/util.c
// Function: sleepNanosec
void
sleepNanosec(double time)
{
	struct timespec sleepTime;
	struct timespec sleptTime;

	sleepTime.tv_sec  = (unsigned long long)floor(time);
	sleepTime.tv_nsec = (time - sleepTime.tv_sec) * 1000000000.0;

	nanosleep(&sleepTime, &sleptTime);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm0, -0x8(%rbp)
callq 0x2270
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x3fd6(%rip), %xmm0     # 0x8bc0
cvttsd2si %xmm0, %rdx
andq %rcx, %rdx
orq %rax, %rdx
xorps %xmm0, %xmm0
cvtsi2sd %rdx, %xmm0
leaq -0x28(%rbp), %rdi
movsd -0x8(%rbp), %xmm1
subsd %xmm0, %xmm1
mulsd 0x3fa6(%rip), %xmm1     # 0x8bb8
movq %rdx, (%rdi)
cvttsd2si %xmm1, %rax
movq %rax, 0x8(%rdi)
leaq -0x18(%rbp), %rsi
callq 0x2240
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/k0n10pl4tr[P]minimal_crafter/util.c
// Function: getFarbfeldImageData
unsigned short *
getFarbfeldImageData(const char *path, unsigned int *wi, unsigned int *hi)
{
	char header[9];
	unsigned int w, h;
	unsigned short *imageData;
	
	FILE *fp = fopen(path, "r");
	if(!fp) {
		printf("Could not open the image: %s\n", path);
		return (unsigned short*)-1;
	}

	fread(header, 8, 1, fp);

	fread(&w, sizeof(w), 1, fp);
	fread(&h, sizeof(h), 1, fp);

	w = bigEndianToHost32(w);
	h = bigEndianToHost32(h);

	imageData = malloc(4 * w * h * sizeof(short));
	fread(imageData, 1, sizeof(short) * w * h * 4, fp);
	
	for(unsigned int i = 0; i < w * h * 4; i++) {
		imageData[i] = bigEndianToHost16(imageData[i]);
	}
	*wi = w;
	*hi = h;
	fclose(fp);
	return imageData;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
leaq 0x25ea(%rip), %rsi      # 0x72b6
callq 0x2120
testq %rax, %rax
je 0x4d98
movq %rax, %r15
movq %r14, -0x30(%rbp)
movq %rbx, -0x38(%rbp)
leaq -0x49(%rbp), %rdi
movl $0x8, %esi
movl $0x1, %edx
movq %rax, %rcx
callq 0x2230
leaq -0x40(%rbp), %r12
movl $0x4, %esi
movl $0x1, %edx
movq %r12, %rdi
movq %r15, %rcx
callq 0x2230
leaq -0x3c(%rbp), %r13
movl $0x4, %esi
movl $0x1, %edx
movq %r13, %rdi
movq %r15, %rcx
callq 0x2230
movl (%r12), %r14d
bswapl %r14d
movl (%r13), %r13d
bswapl %r13d
movl %r14d, %ebx
imull %r13d, %ebx
shll $0x2, %ebx
leaq (%rbx,%rbx), %rdi
callq 0x2110
movq %rax, %r12
movq %r13, %rdx
imulq %r14, %rdx
shlq $0x3, %rdx
movl $0x1, %esi
movq %rax, %rdi
movq %r15, %rcx
callq 0x2230
testl %ebx, %ebx
je 0x4d80
xorl %eax, %eax
rolw $0x8, (%r12,%rax,2)
incq %rax
cmpq %rax, %rbx
jne 0x4d72
movq -0x30(%rbp), %rax
movl %r14d, (%rax)
movq -0x38(%rbp), %rax
movl %r13d, (%rax)
movq %r15, %rdi
callq 0x2260
jmp 0x4db0
leaq 0x3e46(%rip), %rdi      # 0x8be5
movq %r12, %rsi
xorl %eax, %eax
callq 0x2060
movq $-0x1, %r12
movq %r12, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/k0n10pl4tr[P]minimal_crafter/rendering.c
// Function: resizeRenderingSystem
void
resizeRenderingSystem(int w, int h)
{
	printf("Resizing to %dx%d (aspect: %f\n", w, h, (float)w/h);
	mat4x4_perspective(projectionMatrix, TO_RADIANS(70.0), (float)w/h, 0.01, 1000.0);
	glUseProgram(cubeRenderingShader);
	glUniformMatrix4fv(cubeUniformProjectionLocation, 1, GL_FALSE, &projectionMatrix[0][0]);
	glUseProgram(0);

	glViewport(0, 0, w, h);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
cvtsi2ss %edi, %xmm1
movl %esi, %r14d
cvtsi2ss %esi, %xmm0
divss %xmm0, %xmm1
movss %xmm1, -0x24(%rbp)
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
leaq 0x3dff(%rip), %rdi      # 0x8fc1
movl %ebx, %esi
movl %r14d, %edx
movb $0x1, %al
callq 0x2060
movss 0x3a6a(%rip), %xmm0     # 0x8c40
divss -0x24(%rbp), %xmm0
movss %xmm0, 0x70bd(%rip)     # 0xc2a0
leaq 0x70b6(%rip), %r15      # 0xc2a0
xorps %xmm0, %xmm0
movups %xmm0, 0x70b0(%rip)     # 0xc2a4
movl $0x3fb6cd8e, 0x70b6(%rip) # imm = 0x3FB6CD8E
movups %xmm0, 0x70b3(%rip)     # 0xc2b8
movsd 0x3a13(%rip), %xmm0     # 0x8c20
movups %xmm0, 0x70b4(%rip)     # 0xc2c8
movl $0xbca3d776, %eax       # imm = 0xBCA3D776
movq %rax, 0x70b8(%rip)      # 0xc2d8
leaq 0x6db9(%rip), %r12      # 0xbfe0
movl 0x7053(%rip), %edi      # 0xc280
callq *(%r12)
leaq 0x6d88(%rip), %rax      # 0xbfc0
movl 0x704e(%rip), %edi      # 0xc28c
movl $0x1, %esi
xorl %edx, %edx
movq %r15, %rcx
callq *(%rax)
xorl %edi, %edi
callq *(%r12)
leaq 0x6fe1(%rip), %rax      # 0xc238
movq (%rax), %rax
xorl %edi, %edi
xorl %esi, %esi
movl %ebx, %edx
movl %r14d, %ecx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/k0n10pl4tr[P]minimal_crafter/rendering.c
// Function: generateChunkModelAroundPos
void 
generateChunkModelAroundPos(int x, int y, int z, unsigned int distance)
{
	int chunks = distance;
	x = x / WORLD_CHUNK_SIZE;
	y = y / WORLD_CHUNK_SIZE;
	z = z / WORLD_CHUNK_SIZE;

	for(int xc = x - chunks; xc < x + chunks; xc++) {
		for(int yc = y - chunks; yc < y + chunks; yc++) {
			for(int zc = z - chunks; zc < z + chunks; zc++) {
				const WorldChunk* chunk = getWorldChunk(xc, yc, zc);
				if(chunk == NULL) 
					continue;
				generateChunkModel(xc, yc, zc);
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leal 0xf(%rdi), %r8d
testl %edi, %edi
cmovnsl %edi, %r8d
sarl $0x4, %r8d
movl %r8d, %r14d
subl %ecx, %r14d
addl %ecx, %r8d
movl %r8d, -0x34(%rbp)
cmpl %r8d, %r14d
jge 0x58f4
movl %ecx, %eax
leal 0xf(%rdx), %ecx
testl %edx, %edx
cmovnsl %edx, %ecx
sarl $0x4, %ecx
leal 0xf(%rsi), %edx
testl %esi, %esi
cmovnsl %esi, %edx
sarl $0x4, %edx
movl %edx, %esi
subl %eax, %esi
movl %esi, -0x30(%rbp)
addl %eax, %edx
movl %edx, -0x2c(%rbp)
movl %ecx, %r13d
subl %eax, %r13d
addl %eax, %ecx
movl %ecx, -0x38(%rbp)
addl %eax, %eax
movl %eax, -0x3c(%rbp)
movl -0x30(%rbp), %eax
movl %eax, %r15d
cmpl -0x2c(%rbp), %eax
jge 0x58eb
movl -0x3c(%rbp), %ebx
movl %r13d, %r12d
cmpl -0x38(%rbp), %r13d
jge 0x58e2
movl %r14d, %edi
movl %r15d, %esi
movl %r12d, %edx
callq 0x6ade
testq %rax, %rax
je 0x58db
movl %r14d, %edi
movl %r15d, %esi
movl %r12d, %edx
callq 0x5271
incl %r12d
decl %ebx
jne 0x58ba
incl %r15d
cmpl -0x2c(%rbp), %r15d
jne 0x58ae
incl %r14d
cmpl -0x34(%rbp), %r14d
jne 0x58a3
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq