LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movw %cx, %ax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movw %ax, -0x16(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movl $0x85, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x59400
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x867b9
movswl -0x16(%rbp), %eax
cmpl $0x0, %eax
jl 0x867a5
movswl -0x16(%rbp), %eax
movq -0x10(%rbp), %rcx
movswl 0x40(%rcx), %ecx
cmpl %ecx, %eax
je 0x867a5
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movswq -0x16(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %ecx
movswl -0x16(%rbp), %eax
addl %eax, %ecx
addl $0x1, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x2c(%rax)
movq -0x28(%rbp), %rax
movb 0x29(%rax), %cl
movq -0x20(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x8678e
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x6dc70
movq %rax, -0x20(%rbp)
jmp 0x867b7
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x2c(%rax)
movq -0x20(%rbp), %rax
movb $0x64, 0x1(%rax)
jmp 0x867b9
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/sqlite3.c
// Function: exprTableColumn
static Expr *exprTableColumn(
  sqlite3 *db,      /* The database connection */
  Table *pTab,      /* The table whose column is desired */
  int iCursor,      /* The open cursor on the table */
  i16 iCol          /* The column that is wanted */
){
  Expr *pExpr = sqlite3Expr(db, TK_COLUMN, 0);
  if( pExpr ){
    pExpr->pTab = pTab;
    pExpr->iTable = iCursor;
    pExpr->iColumn = iCol;
  }
  return pExpr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %cx, %ax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movw %ax, -0x16(%rbp)
movq -0x8(%rbp), %rdi
movl $0x99, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x59400
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x86829
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x40(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x2c(%rax)
movw -0x16(%rbp), %cx
movq -0x20(%rbp), %rax
movw %cx, 0x30(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movswl 0x40(%rax), %eax
cmpl $0x0, %eax
jl 0x884b4
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movswq 0x40(%rcx), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rcx
leaq 0x11e51(%rip), %rsi     # 0x9a2f1
movb $0x0, %al
callq 0x16a10
movq %rax, -0x20(%rbp)
movl $0x613, -0x24(%rbp)     # imm = 0x613
jmp 0x884db
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
leaq 0x13367(%rip), %rsi     # 0x9b830
movb $0x0, %al
callq 0x16a10
movq %rax, -0x20(%rbp)
movl $0xa13, -0x24(%rbp)     # imm = 0xA13
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %esi
movl -0xc(%rbp), %edx
movq -0x20(%rbp), %rcx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movl $0x2, %r9d
callq 0x677d0
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x63d40
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x85, %eax
je 0x892d0
movq -0x8(%rbp), %rcx
movl 0x58(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x58(%rcx)
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %edx
movl -0x28(%rbp), %ecx
movl $0x1e, %esi
callq 0x63980
movq -0x10(%rbp), %rdi
movl -0x28(%rbp), %esi
callq 0x67430
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x5e(%rax), %eax
movq -0x18(%rbp), %rcx
movzwl 0x5e(%rcx), %ecx
cmpl %ecx, %eax
je 0x893b0
movl $0x0, -0x4(%rbp)
jmp 0x894b9
movq -0x10(%rbp), %rax
movzbl 0x62(%rax), %eax
movq -0x18(%rbp), %rcx
movzbl 0x62(%rcx), %ecx
cmpl %ecx, %eax
je 0x893d0
movl $0x0, -0x4(%rbp)
jmp 0x894b9
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
movzwl 0x5e(%rcx), %ecx
cmpl %ecx, %eax
jge 0x8948a
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movswl (%rax,%rcx,2), %eax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movslq -0x1c(%rbp), %rdx
movswl (%rcx,%rdx,2), %ecx
cmpl %ecx, %eax
je 0x8941a
movl $0x0, -0x4(%rbp)
jmp 0x894b9
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x1c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movq 0x38(%rcx), %rcx
movslq -0x1c(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x89447
movl $0x0, -0x4(%rbp)
jmp 0x894b9
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x89320
cmpl $0x0, %eax
jne 0x8947a
movl $0x0, -0x4(%rbp)
jmp 0x894b9
jmp 0x8947c
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x893d7
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x68220
cmpl $0x0, %eax
je 0x894b2
movl $0x0, -0x4(%rbp)
jmp 0x894b9
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbcc0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl %eax, %edx
movl $0x2, %ecx
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x1c9d0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x8a088
movzbl -0x11(%rbp), %edx
movq -0x20(%rbp), %rax
movzwl 0x2(%rax), %ecx
orl %edx, %ecx
movw %cx, 0x2(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/sqlite3.c
// Function: collationMatch
static int collationMatch(const char *zColl, Index *pIndex){
  int i;
  assert( zColl!=0 );
  for(i=0; i<pIndex->nColumn; i++){
    const char *z = pIndex->azColl[i];
    assert( z!=0 || pIndex->aiColumn[i]<0 );
    if( pIndex->aiColumn[i]>=0 && 0==sqlite3StrICmp(z, zColl) ){
      return 1;
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
movzwl 0x60(%rcx), %ecx
cmpl %ecx, %eax
jge 0x8b6ca
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movswl (%rax,%rcx,2), %eax
cmpl $0x0, %eax
jl 0x8b6bd
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xf670
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x8b6bd
movl $0x1, -0x4(%rbp)
jmp 0x8b6d1
jmp 0x8b6bf
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x8b667
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/sqlite3.c
// Function: callStatGet
static void callStatGet(Vdbe *v, int regStat4, int iParam, int regOut){
  assert( regOut!=regStat4 && regOut!=regStat4+1 );
#ifdef SQLITE_ENABLE_STAT3_OR_STAT4
  sqlite3VdbeAddOp2(v, OP_Integer, iParam, regStat4+1);
#elif SQLITE_DEBUG
  assert( iParam==STAT_GET_STAT1 );
#else
  UNUSED_PARAMETER( iParam );
#endif
  sqlite3VdbeAddOp3(v, OP_Function, 0, regStat4, regOut);
  sqlite3VdbeChangeP4(v, -1, (char*)&statGetFuncdef, P4_FUNCDEF);
  sqlite3VdbeChangeP5(v, 1 + IsStat34);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %ecx
movl -0x14(%rbp), %r8d
movl $0x1, %esi
xorl %edx, %edx
callq 0x639b0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0x258e4(%rip), %rdx     # 0xb1b20
movl $0xfffffffb, %ecx       # imm = 0xFFFFFFFB
callq 0x16e40
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x63ec0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x133d0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x14840
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
cmpl $0x2, -0xc(%rbp)
jne 0x8ec81
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x133d0
movq %rax, -0x28(%rbp)
jmp 0x8ec89
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x8ecc5
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x38(%rbp), %rcx
callq 0x187d0
cmpl $0x0, %eax
je 0x8ecc5
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x13930
movq -0x38(%rbp), %rdi
callq 0xd0d0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x90b10
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jle 0x9003e
movq -0x18(%rbp), %rax
movb $0x1, 0x2a(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x90045
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/sqlite3.c
// Function: sqlite3StmtCurrentTime
SQLITE_PRIVATE sqlite3_int64 sqlite3StmtCurrentTime(sqlite3_context *p){
  Vdbe *v = p->pVdbe;
  int rc;
  if( v->iCurrentTime==0 ){
    rc = sqlite3OsCurrentTimeInt64(p->s.db->pVfs, &v->iCurrentTime);
    if( rc ) v->iCurrentTime = 0;
  }
  return v->iCurrentTime;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0xc8(%rax)
jne 0x90b6b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0xc8, %rsi
callq 0x365a0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x90b69
movq -0x10(%rbp), %rax
movq $0x0, 0xc8(%rax)
jmp 0x90b6b
movq -0x10(%rbp), %rax
movq 0xc8(%rax), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/sqlite3.c
// Function: osLocaltime
static int osLocaltime(time_t *t, struct tm *pTm){
  int rc;
#if (!defined(HAVE_LOCALTIME_R) || !HAVE_LOCALTIME_R) \
      && (!defined(HAVE_LOCALTIME_S) || !HAVE_LOCALTIME_S)
  struct tm *pX;
#if SQLITE_THREADSAFE>0
  sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
#endif
  sqlite3_mutex_enter(mutex);
  pX = localtime(t);
#ifndef SQLITE_OMIT_BUILTIN_TEST
  if( sqlite3GlobalConfig.bLocaltimeFault ) pX = 0;
#endif
  if( pX ) *pTm = *pX;
  sqlite3_mutex_leave(mutex);
  rc = pX==0;
#else
#ifndef SQLITE_OMIT_BUILTIN_TEST
  if( sqlite3GlobalConfig.bLocaltimeFault ) return 1;
#endif
#if defined(HAVE_LOCALTIME_R) && HAVE_LOCALTIME_R
  rc = localtime_r(t, pTm)==0;
#else
  rc = localtime_s(pTm, t);
#endif /* HAVE_LOCALTIME_R */
#endif /* HAVE_LOCALTIME_R || HAVE_LOCALTIME_S */
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x2, %edi
callq 0xcb40
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xc290
movq -0x8(%rbp), %rdi
callq 0x7200
movq %rax, -0x20(%rbp)
cmpl $0x0, 0x20c75(%rip)     # 0xb2470
je 0x91805
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x9181e
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x38, %edx
callq 0x7260
movq -0x28(%rbp), %rdi
callq 0xc870
cmpq $0x0, -0x20(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/sqlite3.c
// Function: sqlite3CloseExtensions
SQLITE_PRIVATE void sqlite3CloseExtensions(sqlite3 *db){
  int i;
  assert( sqlite3_mutex_held(db->mutex) );
  for(i=0; i<db->nExtension; i++){
    sqlite3OsDlClose(db->pVfs, db->aExtension[i]);
  }
  sqlite3DbFree(db, db->aExtension);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xac(%rcx), %eax
jge 0x9303c
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0xb0(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x4fef0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x93003
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0xb0(%rax), %rsi
callq 0xc760
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/sqlite3.c
// Function: invalidateCachedKeyInfo
static void invalidateCachedKeyInfo(sqlite3 *db){
  Db *pDb;                    /* A single database */
  int iDb;                    /* The database index number */
  HashElem *k;                /* For looping over tables in pDb */
  Table *pTab;                /* A table in the database */
  Index *pIdx;                /* Each index */

  for(iDb=0, pDb=db->aDb; iDb<db->nDb; iDb++, pDb++){
    if( pDb->pBt==0 ) continue;
    sqlite3BtreeEnter(pDb->pBt);
    for(k=sqliteHashFirst(&pDb->pSchema->tblHash);  k; k=sqliteHashNext(k)){
      pTab = (Table*)sqliteHashData(k);
      for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
        if( pIdx->pKeyInfo && pIdx->pKeyInfo->db==db ){
          sqlite3KeyInfoUnref(pIdx->pKeyInfo);
          pIdx->pKeyInfo = 0;
        }
      }
    }
    sqlite3BtreeLeave(pDb->pBt);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x9360e
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x9354f
jmp 0x935f4
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x10f50
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x935e7
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x935d8
movq -0x30(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x935c8
movq -0x30(%rbp), %rax
movq 0x50(%rax), %rax
movq 0x10(%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x935c8
movq -0x30(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x328e0
movq -0x30(%rbp), %rax
movq $0x0, 0x50(%rax)
jmp 0x935ca
movq -0x30(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x9358b
jmp 0x935da
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x9356c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x12630
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x10(%rbp)
jmp 0x9352f
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0xd0, %rsp
movq 0xb33e(%rip), %rdi      # 0xda70
movq 0xb367(%rip), %rsi      # 0xdaa0
callq 0x21d0
movq 0xb32b(%rip), %rdi      # 0xda70
callq 0x22b0
cmpl $0x0, %eax
je 0x281e
movq 0xb316(%rip), %rdi      # 0xda70
leaq -0xc0(%rbp), %rsi
callq 0x21f0
movl -0xc0(%rbp), %eax
addl $-0x2, %eax
movl %eax, %ecx
movq %rcx, -0xc8(%rbp)
subl $0x1f, %eax
ja 0x2819
movq -0xc8(%rbp), %rax
leaq 0x6875(%rip), %rcx      # 0x9004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x88(%rbp), %rax
cmpq 0xb2ea(%rip), %rax      # 0xda90
jne 0x27af
movb $0x0, 0xb301(%rip)      # 0xdab0
jmp 0x2819
movl 0xb2e1(%rip), %eax      # 0xda98
cmpl -0x88(%rbp), %eax
jne 0x27cd
movl 0xb2d7(%rip), %eax      # 0xda9c
cmpl -0x84(%rbp), %eax
je 0x27f6
movl -0x88(%rbp), %eax
movl %eax, 0xb2bf(%rip)      # 0xda98
movl -0x84(%rbp), %eax
movl %eax, 0xb2b7(%rip)      # 0xda9c
movl 0xb2ad(%rip), %edi      # 0xda98
movl 0xb2ab(%rip), %esi      # 0xda9c
callq 0x5e90
jmp 0x2819
leaq -0xc0(%rbp), %rdi
movl $0x1, %esi
callq 0x2830
jmp 0x2819
leaq -0xc0(%rbp), %rdi
xorl %esi, %esi
callq 0x2830
jmp 0x273e
addq $0xd0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x2030
cmpq $0xff51, %rax           # imm = 0xFF51
jne 0x285e
movb -0x9(%rbp), %al
movb %al, 0xb253(%rip)       # 0xdab1
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x2030
cmpq $0xff53, %rax           # imm = 0xFF53
jne 0x287a
movb -0x9(%rbp), %al
movb %al, 0xb238(%rip)       # 0xdab2
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x2030
cmpq $0xff52, %rax           # imm = 0xFF52
jne 0x2896
movb -0x9(%rbp), %al
movb %al, 0xb21d(%rip)       # 0xdab3
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x2030
cmpq $0xff54, %rax           # imm = 0xFF54
jne 0x28b2
movb -0x9(%rbp), %al
movb %al, 0xb202(%rip)       # 0xdab4
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x2030
cmpq $0x77, %rax
jne 0x28cc
movb -0x9(%rbp), %al
movb %al, 0xb1e9(%rip)       # 0xdab5
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x2030
cmpq $0x73, %rax
jne 0x28e6
movb -0x9(%rbp), %al
movb %al, 0xb1d0(%rip)       # 0xdab6
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x2030
cmpq $0x20, %rax
jne 0x2900
movb -0x9(%rbp), %al
movb %al, 0xb1b7(%rip)       # 0xdab7
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x2030
cmpq $0xffe1, %rax           # imm = 0xFFE1
jne 0x291c
movb -0x9(%rbp), %al
movb %al, 0xb19c(%rip)       # 0xdab8
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 0xb135(%rip), %rdi      # 0xda70
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x2040
movq 0xb122(%rip), %rdi      # 0xda70
movq 0xb153(%rip), %rsi      # 0xdaa8
callq 0x2140
movq 0xb10f(%rip), %rdi      # 0xda70
movq 0xb138(%rip), %rsi      # 0xdaa0
callq 0x21b0
movq 0xb0fc(%rip), %rdi      # 0xda70
callq 0x21c0
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x23d0
movb $0x0, %al
callq 0x54d0
movb $0x0, %al
callq 0x5810
movl $0x20, %edx
movl $0x4, %esi
movl %edx, %edi
callq 0x8760
movb $0x1, 0xabaf(%rip)      # 0xdab0
cmpb $0x0, 0xaba8(%rip)      # 0xdab0
je 0x2f97
movb $0x0, %al
callq 0x5500
movsd %xmm0, -0x18(%rbp)
movss 0x6182(%rip), %xmm0     # 0x90a4
movss 0x617e(%rip), %xmm1     # 0x90a8
callq 0x2980
leaq 0xabe2(%rip), %rdi      # 0xdb18
leaq 0xa2d3(%rip), %rsi      # 0xd210
leaq 0xabe0(%rip), %rdx      # 0xdb24
callq 0x7180
movss 0xa2af(%rip), %xmm0     # 0xd200
movss 0xa2ab(%rip), %xmm1     # 0xd204
movss 0xa2a7(%rip), %xmm2     # 0xd208
callq 0x6ed0
callq 0x2720
movb $0x0, %al
callq 0x5500
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm1
subsd -0x18(%rbp), %xmm1
movsd 0x610f(%rip), %xmm0     # 0x9098
subsd %xmm1, %xmm0
callq 0x5550
jmp 0x2f01
callq 0x2930
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x6371(%rip), %rsi      # 0x933b
callq 0x2120
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x2ff8
movq -0x10(%rbp), %rsi
leaq 0x620d(%rip), %rdi      # 0x91f2
movb $0x0, %al
callq 0x2060
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3119
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x20b0
movq -0x30(%rbp), %rdi
callq 0x2070
movl %eax, -0x24(%rbp)
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x20b0
movslq -0x24(%rbp), %rdi
callq 0x2110
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x24(%rbp), %rdx
movq -0x30(%rbp), %rcx
movl $0x1, %esi
callq 0x2230
movq -0x30(%rbp), %rdi
callq 0x2270
leaq 0xacc8(%rip), %rax      # 0xdd20
movq (%rax), %rax
movl -0x14(%rbp), %edi
callq *%rax
movl %eax, -0x34(%rbp)
leaq 0xb236(%rip), %rax      # 0xe2a0
movq (%rax), %rax
movl -0x34(%rbp), %edi
movl $0x1, %esi
leaq -0x20(%rbp), %rdx
leaq -0x24(%rbp), %rcx
callq *%rax
leaq 0xac2a(%rip), %rax      # 0xdcb0
movq (%rax), %rax
movl -0x34(%rbp), %edi
callq *%rax
leaq 0xaf7b(%rip), %rax      # 0xe010
movq (%rax), %rax
movl -0x34(%rbp), %edi
movl $0x8b81, %esi           # imm = 0x8B81
leaq -0x38(%rbp), %rdx
callq *%rax
cmpl $0x0, -0x38(%rbp)
jne 0x310a
leaq 0xaf5d(%rip), %rax      # 0xe010
movq (%rax), %rax
movl -0x34(%rbp), %edi
movl $0x8b84, %esi           # imm = 0x8B84
leaq -0x38(%rbp), %rdx
callq *%rax
movslq -0x38(%rbp), %rdi
callq 0x2110
movq %rax, -0x40(%rbp)
leaq 0xaf28(%rip), %rax      # 0xe000
movq (%rax), %rax
movl -0x34(%rbp), %edi
movl -0x38(%rbp), %esi
movq -0x40(%rbp), %rcx
leaq -0x38(%rbp), %rdx
callq *%rax
movq -0x10(%rbp), %rsi
movq -0x40(%rbp), %rdx
leaq 0x6116(%rip), %rdi      # 0x9210
movb $0x0, %al
callq 0x2060
movq -0x40(%rbp), %rdi
callq 0x2190
movq -0x20(%rbp), %rdi
callq 0x2190
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0xabcd(%rip), %rax      # 0xdd18
callq *(%rax)
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x317c
leaq 0xaa10(%rip), %rax      # 0xdb70
movq (%rax), %rax
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rcx
movl (%rcx), %esi
callq *%rax
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
jmp 0x3150
leaq 0xafbd(%rip), %rax      # 0xe140
movq (%rax), %rax
movl -0x14(%rbp), %edi
callq *%rax
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x31bf
leaq 0xabf5(%rip), %rax      # 0xdd98
movq (%rax), %rax
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rcx
movl (%rcx), %esi
callq *%rax
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
jmp 0x3193
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x56b0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, %rax
jge 0x3207
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x32b7
movl $0x1, %edi
leaq -0x24(%rbp), %rsi
leaq 0xaca1(%rip), %rax      # 0xdeb8
callq *(%rax)
leaq 0xa9b8(%rip), %rax      # 0xdbd8
movq (%rax), %rax
movl -0x24(%rbp), %esi
movl $0xde1, %edi            # imm = 0xDE1
callq *%rax
movl $0xde1, %edi            # imm = 0xDE1
movl $0x2801, %esi           # imm = 0x2801
movl $0x2600, %edx           # imm = 0x2600
leaq 0xb125(%rip), %rax      # 0xe368
callq *(%rax)
movl $0xde1, %edi            # imm = 0xDE1
movl $0x2800, %esi           # imm = 0x2800
movl $0x2600, %edx           # imm = 0x2600
leaq 0xb10d(%rip), %rax      # 0xe368
callq *(%rax)
leaq 0xb0c4(%rip), %rax      # 0xe328
movq (%rax), %rax
movl -0x14(%rbp), %ecx
movl -0x18(%rbp), %r8d
movq -0x20(%rbp), %r10
movl $0xde1, %edi            # imm = 0xDE1
xorl %r9d, %r9d
movl $0x8058, %edx           # imm = 0x8058
movl %r9d, %esi
movl $0x1908, (%rsp)         # imm = 0x1908
movl $0x1403, 0x8(%rsp)      # imm = 0x1403
movq %r10, 0x10(%rsp)
callq *%rax
movl $0xde1, %edi            # imm = 0xDE1
xorl %esi, %esi
leaq 0xa932(%rip), %rax      # 0xdbd8
callq *(%rax)
movq -0x20(%rbp), %rdi
callq 0x2190
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/k0n10pl4tr[P]minimal_crafter/glad.c
// Function: gladLoadGLLoader
int gladLoadGLLoader(GLADloadproc load) {
	GLVersion.major = 0; GLVersion.minor = 0;
	glGetString = (PFNGLGETSTRINGPROC)load("glGetString");
	if(glGetString == NULL) return 0;
	if(glGetString(GL_VERSION) == NULL) return 0;
	find_coreGL();
	load_GL_VERSION_1_0(load);
	load_GL_VERSION_1_1(load);
	load_GL_VERSION_1_2(load);
	load_GL_VERSION_1_3(load);
	load_GL_VERSION_1_4(load);
	load_GL_VERSION_1_5(load);
	load_GL_VERSION_2_0(load);
	load_GL_VERSION_2_1(load);
	load_GL_VERSION_3_0(load);
	load_GL_VERSION_3_1(load);
	load_GL_VERSION_3_2(load);
	load_GL_VERSION_3_3(load);

	if (!find_extensionsGL()) return 0;
	return GLVersion.major != 0 || GLVersion.minor != 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, 0xa85a(%rip)      # 0xdb30
movl $0x0, 0xa854(%rip)      # 0xdb34
leaq 0x5f5e(%rip), %rdi      # 0x9245
callq *-0x10(%rbp)
movq %rax, 0xad27(%rip)      # 0xe018
cmpq $0x0, 0xad1f(%rip)      # 0xe018
jne 0x3307
movl $0x0, -0x4(%rbp)
jmp 0x33ce
movl $0x1f02, %edi           # imm = 0x1F02
callq *0xad06(%rip)           # 0xe018
cmpq $0x0, %rax
jne 0x3324
movl $0x0, -0x4(%rbp)
jmp 0x33ce
callq 0x33e0
movq -0x10(%rbp), %rdi
callq 0x36f0
movq -0x10(%rbp), %rdi
callq 0x3a40
movq -0x10(%rbp), %rdi
callq 0x3b40
movq -0x10(%rbp), %rdi
callq 0x3bb0
movq -0x10(%rbp), %rdi
callq 0x3c70
movq -0x10(%rbp), %rdi
callq 0x3d30
movq -0x10(%rbp), %rdi
callq 0x3ea0
movq -0x10(%rbp), %rdi
callq 0x44f0
movq -0x10(%rbp), %rdi
callq 0x4580
movq -0x10(%rbp), %rdi
callq 0x4b40
movq -0x10(%rbp), %rdi
callq 0x4c60
movq -0x10(%rbp), %rdi
callq 0x4dd0
callq 0x51d0
cmpl $0x0, %eax
jne 0x33a8
movl $0x0, -0x4(%rbp)
jmp 0x33ce
movb $0x1, %al
cmpl $0x0, 0xa77f(%rip)      # 0xdb30
movb %al, -0x11(%rbp)
jne 0x33c3
cmpl $0x0, 0xa777(%rip)      # 0xdb34
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/k0n10pl4tr[P]minimal_crafter/glad.c
// Function: load_GL_VERSION_1_1
static void load_GL_VERSION_1_1(GLADloadproc load) {
	if(!GLAD_GL_VERSION_1_1) return;
	glad_glDrawArrays = (PFNGLDRAWARRAYSPROC)load("glDrawArrays");
	glad_glDrawElements = (PFNGLDRAWELEMENTSPROC)load("glDrawElements");
	glad_glPolygonOffset = (PFNGLPOLYGONOFFSETPROC)load("glPolygonOffset");
	glad_glCopyTexImage1D = (PFNGLCOPYTEXIMAGE1DPROC)load("glCopyTexImage1D");
	glad_glCopyTexImage2D = (PFNGLCOPYTEXIMAGE2DPROC)load("glCopyTexImage2D");
	glad_glCopyTexSubImage1D = (PFNGLCOPYTEXSUBIMAGE1DPROC)load("glCopyTexSubImage1D");
	glad_glCopyTexSubImage2D = (PFNGLCOPYTEXSUBIMAGE2DPROC)load("glCopyTexSubImage2D");
	glad_glTexSubImage1D = (PFNGLTEXSUBIMAGE1DPROC)load("glTexSubImage1D");
	glad_glTexSubImage2D = (PFNGLTEXSUBIMAGE2DPROC)load("glTexSubImage2D");
	glad_glBindTexture = (PFNGLBINDTEXTUREPROC)load("glBindTexture");
	glad_glDeleteTextures = (PFNGLDELETETEXTURESPROC)load("glDeleteTextures");
	glad_glGenTextures = (PFNGLGENTEXTURESPROC)load("glGenTextures");
	glad_glIsTexture = (PFNGLISTEXTUREPROC)load("glIsTexture");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0xa0e9(%rip)      # 0xdb3c
jne 0x3a5a
jmp 0x3b37
leaq 0x5a8d(%rip), %rdi      # 0x94ee
callq *-0x8(%rbp)
movq %rax, 0xa34d(%rip)      # 0xddb8
leaq 0x5a89(%rip), %rdi      # 0x94fb
callq *-0x8(%rbp)
movq %rax, 0xa35c(%rip)      # 0xddd8
leaq 0x5a87(%rip), %rdi      # 0x950a
callq *-0x8(%rbp)
movq %rax, 0xa77b(%rip)      # 0xe208
leaq 0x5a86(%rip), %rdi      # 0x951a
callq *-0x8(%rbp)
movq %rax, 0xa252(%rip)      # 0xdcf0
leaq 0x5a86(%rip), %rdi      # 0x952b
callq *-0x8(%rbp)
movq %rax, 0xa249(%rip)      # 0xdcf8
leaq 0x5a86(%rip), %rdi      # 0x953c
callq *-0x8(%rbp)
movq %rax, 0xa240(%rip)      # 0xdd00
leaq 0x5a89(%rip), %rdi      # 0x9550
callq *-0x8(%rbp)
movq %rax, 0xa237(%rip)      # 0xdd08
leaq 0x5a8c(%rip), %rdi      # 0x9564
callq *-0x8(%rbp)
movq %rax, 0xa896(%rip)      # 0xe378
leaq 0x5a8b(%rip), %rdi      # 0x9574
callq *-0x8(%rbp)
movq %rax, 0xa88d(%rip)      # 0xe380
leaq 0x5a8a(%rip), %rdi      # 0x9584
callq *-0x8(%rbp)
movq %rax, 0xa0d4(%rip)      # 0xdbd8
leaq 0x5a87(%rip), %rdi      # 0x9592
callq *-0x8(%rbp)
movq %rax, 0xa25b(%rip)      # 0xdd70
leaq 0x5a87(%rip), %rdi      # 0x95a3
callq *-0x8(%rbp)
movq %rax, 0xa392(%rip)      # 0xdeb8
leaq 0x5a84(%rip), %rdi      # 0x95b1
callq *-0x8(%rbp)
movq %rax, 0xa5f1(%rip)      # 0xe128
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/k0n10pl4tr[P]minimal_crafter/glad.c
// Function: load_GL_VERSION_1_2
static void load_GL_VERSION_1_2(GLADloadproc load) {
	if(!GLAD_GL_VERSION_1_2) return;
	glad_glDrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC)load("glDrawRangeElements");
	glad_glTexImage3D = (PFNGLTEXIMAGE3DPROC)load("glTexImage3D");
	glad_glTexSubImage3D = (PFNGLTEXSUBIMAGE3DPROC)load("glTexSubImage3D");
	glad_glCopyTexSubImage3D = (PFNGLCOPYTEXSUBIMAGE3DPROC)load("glCopyTexSubImage3D");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0x9fed(%rip)      # 0xdb40
jne 0x3b57
jmp 0x3b9b
leaq 0x5a5f(%rip), %rdi      # 0x95bd
callq *-0x8(%rbp)
movq %rax, 0xa290(%rip)      # 0xddf8
leaq 0x5a62(%rip), %rdi      # 0x95d1
callq *-0x8(%rbp)
movq %rax, 0xa7bf(%rip)      # 0xe338
leaq 0x5a5e(%rip), %rdi      # 0x95de
callq *-0x8(%rbp)
movq %rax, 0xa7fe(%rip)      # 0xe388
leaq 0x5a5d(%rip), %rdi      # 0x95ee
callq *-0x8(%rbp)
movq %rax, 0xa175(%rip)      # 0xdd10
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/k0n10pl4tr[P]minimal_crafter/glad.c
// Function: load_GL_VERSION_1_3
static void load_GL_VERSION_1_3(GLADloadproc load) {
	if(!GLAD_GL_VERSION_1_3) return;
	glad_glActiveTexture = (PFNGLACTIVETEXTUREPROC)load("glActiveTexture");
	glad_glSampleCoverage = (PFNGLSAMPLECOVERAGEPROC)load("glSampleCoverage");
	glad_glCompressedTexImage3D = (PFNGLCOMPRESSEDTEXIMAGE3DPROC)load("glCompressedTexImage3D");
	glad_glCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC)load("glCompressedTexImage2D");
	glad_glCompressedTexImage1D = (PFNGLCOMPRESSEDTEXIMAGE1DPROC)load("glCompressedTexImage1D");
	glad_glCompressedTexSubImage3D = (PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)load("glCompressedTexSubImage3D");
	glad_glCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)load("glCompressedTexSubImage2D");
	glad_glCompressedTexSubImage1D = (PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)load("glCompressedTexSubImage1D");
	glad_glGetCompressedTexImage = (PFNGLGETCOMPRESSEDTEXIMAGEPROC)load("glGetCompressedTexImage");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0x9f81(%rip)      # 0xdb44
jne 0x3bca
jmp 0x3c63
leaq 0x5a31(%rip), %rdi      # 0x9602
callq *-0x8(%rbp)
movq %rax, 0x9f8d(%rip)      # 0xdb68
leaq 0x5a30(%rip), %rdi      # 0x9612
callq *-0x8(%rbp)
movq %rax, 0xa65c(%rip)      # 0xe248
leaq 0x5a30(%rip), %rdi      # 0x9623
callq *-0x8(%rbp)
movq %rax, 0xa0cb(%rip)      # 0xdcc8
leaq 0x5a36(%rip), %rdi      # 0x963a
callq *-0x8(%rbp)
movq %rax, 0xa0b2(%rip)      # 0xdcc0
leaq 0x5a3c(%rip), %rdi      # 0x9651
callq *-0x8(%rbp)
movq %rax, 0xa099(%rip)      # 0xdcb8
leaq 0x5a42(%rip), %rdi      # 0x9668
callq *-0x8(%rbp)
movq %rax, 0xa0b0(%rip)      # 0xdce0
leaq 0x5a4b(%rip), %rdi      # 0x9682
callq *-0x8(%rbp)
movq %rax, 0xa097(%rip)      # 0xdcd8
leaq 0x5a54(%rip), %rdi      # 0x969c
callq *-0x8(%rbp)
movq %rax, 0xa07e(%rip)      # 0xdcd0
leaq 0x5a5d(%rip), %rdi      # 0x96b6
callq *-0x8(%rbp)
movq %rax, 0xa2dd(%rip)      # 0xdf40
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/k0n10pl4tr[P]minimal_crafter/glad.c
// Function: load_GL_VERSION_1_4
static void load_GL_VERSION_1_4(GLADloadproc load) {
	if(!GLAD_GL_VERSION_1_4) return;
	glad_glBlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC)load("glBlendFuncSeparate");
	glad_glMultiDrawArrays = (PFNGLMULTIDRAWARRAYSPROC)load("glMultiDrawArrays");
	glad_glMultiDrawElements = (PFNGLMULTIDRAWELEMENTSPROC)load("glMultiDrawElements");
	glad_glPointParameterf = (PFNGLPOINTPARAMETERFPROC)load("glPointParameterf");
	glad_glPointParameterfv = (PFNGLPOINTPARAMETERFVPROC)load("glPointParameterfv");
	glad_glPointParameteri = (PFNGLPOINTPARAMETERIPROC)load("glPointParameteri");
	glad_glPointParameteriv = (PFNGLPOINTPARAMETERIVPROC)load("glPointParameteriv");
	glad_glBlendColor = (PFNGLBLENDCOLORPROC)load("glBlendColor");
	glad_glBlendEquation = (PFNGLBLENDEQUATIONPROC)load("glBlendEquation");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0x9ec5(%rip)      # 0xdb48
jne 0x3c8a
jmp 0x3d23
leaq 0x5a3d(%rip), %rdi      # 0x96ce
callq *-0x8(%rbp)
movq %rax, 0x9f6d(%rip)      # 0xdc08
leaq 0x5a40(%rip), %rdi      # 0x96e2
callq *-0x8(%rbp)
movq %rax, 0xa4b4(%rip)      # 0xe160
leaq 0x5a41(%rip), %rdi      # 0x96f4
callq *-0x8(%rbp)
movq %rax, 0xa4ab(%rip)      # 0xe168
leaq 0x5a44(%rip), %rdi      # 0x9708
callq *-0x8(%rbp)
movq %rax, 0xa50a(%rip)      # 0xe1d8
leaq 0x5a45(%rip), %rdi      # 0x971a
callq *-0x8(%rbp)
movq %rax, 0xa501(%rip)      # 0xe1e0
leaq 0x5a47(%rip), %rdi      # 0x972d
callq *-0x8(%rbp)
movq %rax, 0xa4f8(%rip)      # 0xe1e8
leaq 0x5a48(%rip), %rdi      # 0x973f
callq *-0x8(%rbp)
movq %rax, 0xa4ef(%rip)      # 0xe1f0
leaq 0x5a4a(%rip), %rdi      # 0x9752
callq *-0x8(%rbp)
movq %rax, 0x9ed6(%rip)      # 0xdbe8
leaq 0x5a46(%rip), %rdi      # 0x975f
callq *-0x8(%rbp)
movq %rax, 0x9ecd(%rip)      # 0xdbf0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/k0n10pl4tr[P]minimal_crafter/glad.c
// Function: load_GL_VERSION_2_1
static void load_GL_VERSION_2_1(GLADloadproc load) {
	if(!GLAD_GL_VERSION_2_1) return;
	glad_glUniformMatrix2x3fv = (PFNGLUNIFORMMATRIX2X3FVPROC)load("glUniformMatrix2x3fv");
	glad_glUniformMatrix3x2fv = (PFNGLUNIFORMMATRIX3X2FVPROC)load("glUniformMatrix3x2fv");
	glad_glUniformMatrix2x4fv = (PFNGLUNIFORMMATRIX2X4FVPROC)load("glUniformMatrix2x4fv");
	glad_glUniformMatrix4x2fv = (PFNGLUNIFORMMATRIX4X2FVPROC)load("glUniformMatrix4x2fv");
	glad_glUniformMatrix3x4fv = (PFNGLUNIFORMMATRIX3X4FVPROC)load("glUniformMatrix3x4fv");
	glad_glUniformMatrix4x3fv = (PFNGLUNIFORMMATRIX4X3FVPROC)load("glUniformMatrix4x3fv");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0x9651(%rip)      # 0xdb54
jne 0x4507
jmp 0x456d
leaq 0x59ba(%rip), %rdi      # 0x9ec8
callq *-0x8(%rbp)
movq %rax, 0x9f50(%rip)      # 0xe468
leaq 0x59be(%rip), %rdi      # 0x9edd
callq *-0x8(%rbp)
movq %rax, 0x9f57(%rip)      # 0xe480
leaq 0x59c2(%rip), %rdi      # 0x9ef2
callq *-0x8(%rbp)
movq %rax, 0x9f36(%rip)      # 0xe470
leaq 0x59c6(%rip), %rdi      # 0x9f07
callq *-0x8(%rbp)
movq %rax, 0x9f4d(%rip)      # 0xe498
leaq 0x59ca(%rip), %rdi      # 0x9f1c
callq *-0x8(%rbp)
movq %rax, 0x9f2c(%rip)      # 0xe488
leaq 0x59ce(%rip), %rdi      # 0x9f31
callq *-0x8(%rbp)
movq %rax, 0x9f33(%rip)      # 0xe4a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/k0n10pl4tr[P]minimal_crafter/glad.c
// Function: load_GL_VERSION_3_1
static void load_GL_VERSION_3_1(GLADloadproc load) {
	if(!GLAD_GL_VERSION_3_1) return;
	glad_glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDPROC)load("glDrawArraysInstanced");
	glad_glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDPROC)load("glDrawElementsInstanced");
	glad_glTexBuffer = (PFNGLTEXBUFFERPROC)load("glTexBuffer");
	glad_glPrimitiveRestartIndex = (PFNGLPRIMITIVERESTARTINDEXPROC)load("glPrimitiveRestartIndex");
	glad_glCopyBufferSubData = (PFNGLCOPYBUFFERSUBDATAPROC)load("glCopyBufferSubData");
	glad_glGetUniformIndices = (PFNGLGETUNIFORMINDICESPROC)load("glGetUniformIndices");
	glad_glGetActiveUniformsiv = (PFNGLGETACTIVEUNIFORMSIVPROC)load("glGetActiveUniformsiv");
	glad_glGetActiveUniformName = (PFNGLGETACTIVEUNIFORMNAMEPROC)load("glGetActiveUniformName");
	glad_glGetUniformBlockIndex = (PFNGLGETUNIFORMBLOCKINDEXPROC)load("glGetUniformBlockIndex");
	glad_glGetActiveUniformBlockiv = (PFNGLGETACTIVEUNIFORMBLOCKIVPROC)load("glGetActiveUniformBlockiv");
	glad_glGetActiveUniformBlockName = (PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)load("glGetActiveUniformBlockName");
	glad_glUniformBlockBinding = (PFNGLUNIFORMBLOCKBINDINGPROC)load("glUniformBlockBinding");
	glad_glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)load("glBindBufferRange");
	glad_glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)load("glBindBufferBase");
	glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load("glGetIntegeri_v");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0x9009(%rip)      # 0xdb5c
jne 0x4b5a
jmp 0x4c59
leaq 0x5a3d(%rip), %rdi      # 0xa59e
callq *-0x8(%rbp)
movq %rax, 0x9255(%rip)      # 0xddc0
leaq 0x5a42(%rip), %rdi      # 0xa5b4
callq *-0x8(%rbp)
movq %rax, 0x926c(%rip)      # 0xdde8
leaq 0x5a49(%rip), %rdi      # 0xa5cc
callq *-0x8(%rbp)
movq %rax, 0x974b(%rip)      # 0xe2d8
leaq 0x5a44(%rip), %rdi      # 0xa5d8
callq *-0x8(%rbp)
movq %rax, 0x9672(%rip)      # 0xe210
leaq 0x5a4b(%rip), %rdi      # 0xa5f0
callq *-0x8(%rbp)
movq %rax, 0x9139(%rip)      # 0xdce8
leaq 0x5a4e(%rip), %rdi      # 0xa604
callq *-0x8(%rbp)
movq %rax, 0x94b8(%rip)      # 0xe078
leaq 0x5a51(%rip), %rdi      # 0xa618
callq *-0x8(%rbp)
movq %rax, 0x9327(%rip)      # 0xdef8
leaq 0x5a56(%rip), %rdi      # 0xa62e
callq *-0x8(%rbp)
movq %rax, 0x930e(%rip)      # 0xdef0
leaq 0x5a5c(%rip), %rdi      # 0xa645
callq *-0x8(%rbp)
movq %rax, 0x947d(%rip)      # 0xe070
leaq 0x5a62(%rip), %rdi      # 0xa65c
callq *-0x8(%rbp)
movq %rax, 0x92e4(%rip)      # 0xdee8
leaq 0x5a6b(%rip), %rdi      # 0xa676
callq *-0x8(%rbp)
movq %rax, 0x92cb(%rip)      # 0xdee0
leaq 0x5a76(%rip), %rdi      # 0xa692
callq *-0x8(%rbp)
movq %rax, 0x9832(%rip)      # 0xe458
leaq 0x5398(%rip), %rdi      # 0x9fc5
callq *-0x8(%rbp)
movq %rax, 0x8f71(%rip)      # 0xdba8
leaq 0x5399(%rip), %rdi      # 0x9fd7
callq *-0x8(%rbp)
movq %rax, 0x8f58(%rip)      # 0xdba0
leaq 0x5314(%rip), %rdi      # 0x9f63
callq *-0x8(%rbp)
movq %rax, 0x932f(%rip)      # 0xdf88
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/k0n10pl4tr[P]minimal_crafter/glad.c
// Function: find_extensionsGL
static int find_extensionsGL(void) {
	if (!get_exts()) return 0;
	(void)&has_ext;
	free_exts();
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x5200
cmpl $0x0, %eax
jne 0x51eb
movl $0x0, -0x4(%rbp)
jmp 0x51f7
callq 0x5470
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq