LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3IndexAffinityStr
SQLITE_PRIVATE const char *sqlite3IndexAffinityStr(sqlite3 *db, Index *pIdx){
  if( !pIdx->zColAff ){
    /* The first time a column affinity string for a particular index is
    ** required, it is allocated and populated here. It is then stored as
    ** a member of the Index structure for subsequent use.
    **
    ** The column affinity string will eventually be deleted by
    ** sqliteDeleteIndex() when the Index structure itself is cleaned
    ** up.
    */
    int n;
    Table *pTab = pIdx->pTable;
    pIdx->zColAff = (char *)sqlite3DbMallocRaw(0, pIdx->nColumn+1);
    if( !pIdx->zColAff ){
      db->mallocFailed = 1;
      return 0;
    }
    for(n=0; n<pIdx->nColumn; n++){
      i16 x = pIdx->aiColumn[n];
      if( x>=0 ){
        pIdx->zColAff[n] = pTab->aCol[x].affinity;
      }else if( x==XN_ROWID ){
        pIdx->zColAff[n] = SQLITE_AFF_INTEGER;
      }else{
        char aff;
        assert( x==XN_EXPR );
        assert( pIdx->aColExpr!=0 );
        aff = sqlite3ExprAffinity(pIdx->aColExpr->a[n].pExpr);
        if( aff==0 ) aff = SQLITE_AFF_BLOB;
        pIdx->zColAff[n] = aff;
      }
    }
    pIdx->zColAff[n] = 0;
  }
 
  return pIdx->zColAff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpq $0x0, 0x20(%rsi)
jne 0x6a346
movq %rdi, %r15
movq 0x18(%rbx), %r12
movzwl 0x60(%rbx), %edi
incq %rdi
callq 0xbf9b
movq %rax, %r14
movq %rax, 0x20(%rbx)
testq %rax, %rax
je 0x6a32e
cmpw $0x0, 0x60(%rbx)
je 0x6a335
xorl %r13d, %r13d
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movswq (%rax,%r15,2), %rax
testq %rax, %rax
js 0x6a305
movq 0x8(%r12), %rcx
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
movb 0x29(%rcx,%rax), %cl
movq 0x20(%rbx), %rax
movb %cl, (%rax,%r15)
incq %r15
movzwl 0x60(%rbx), %eax
addq $0x20, %r13
cmpq %rax, %r15
jb 0x6a2cc
jmp 0x6a338
cmpw $-0x1, %ax
je 0x6a32a
movq 0x50(%rbx), %rax
movq 0x8(%rax), %rax
movq (%rax,%r13), %rdi
callq 0x5534e
movl $0x41, %ecx
testb %al, %al
je 0x6a2eb
movzbl %al, %ecx
jmp 0x6a2eb
movb $0x44, %cl
jmp 0x6a2eb
movb $0x1, 0x51(%r15)
jmp 0x6a341
xorl %r15d, %r15d
movq 0x20(%rbx), %rax
movb $0x0, (%rax,%r15)
testq %r14, %r14
je 0x6a359
movq 0x20(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x6a34a
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3MaterializeView
SQLITE_PRIVATE void sqlite3MaterializeView(
  Parse *pParse,       /* Parsing context */
  Table *pView,        /* View definition */
  Expr *pWhere,        /* Optional WHERE clause to be added */
  int iCur             /* Cursor number for ephemeral table */
){
  SelectDest dest;
  Select *pSel;
  SrcList *pFrom;
  sqlite3 *db = pParse->db;
  int iDb = sqlite3SchemaToIndex(db, pView->pSchema);
  pWhere = sqlite3ExprDup(db, pWhere, 0);
  pFrom = sqlite3SrcListAppend(db, 0, 0, 0);
  if( pFrom ){
    assert( pFrom->nSrc==1 );
    pFrom->a[0].zName = sqlite3DbStrDup(db, pView->zName);
    pFrom->a[0].zDatabase = sqlite3DbStrDup(db, db->aDb[iDb].zName);
    assert( pFrom->a[0].pOn==0 );
    assert( pFrom->a[0].pUsing==0 );
  }
  pSel = sqlite3SelectNew(pParse, 0, pFrom, pWhere, 0, 0, 0, 
                          SF_IncludeHidden, 0, 0);
  sqlite3SelectDestInit(&dest, SRT_EphemTab, iCur);
  sqlite3Select(pParse, pSel, &dest);
  sqlite3SelectDelete(db, pSel);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
movq (%rdi), %rbx
movq 0x68(%rsi), %rax
testq %rax, %rax
movl %ecx, -0x2c(%rbp)
movq %rsi, -0x38(%rbp)
je 0x6afcf
movl 0x28(%rbx), %edi
testl %edi, %edi
jle 0x6afd7
movq 0x20(%rbx), %rsi
addq $0x18, %rsi
xorl %r12d, %r12d
cmpq %rax, (%rsi)
je 0x6afda
incq %r12
addq $0x20, %rsi
cmpq %r12, %rdi
jne 0x6afb9
movl %edi, %r12d
jmp 0x6afda
movl $0xfff0bdc0, %r12d      # imm = 0xFFF0BDC0
jmp 0x6afda
xorl %r12d, %r12d
movq %rbx, %rdi
movq %rdx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x54a6f
movq %rax, %r13
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x47880
movq %rax, %r15
testq %rax, %rax
je 0x6b030
movq -0x38(%rbp), %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x12d08
movq %rax, 0x18(%r15)
movq 0x20(%rbx), %rax
movslq %r12d, %rcx
shlq $0x5, %rcx
movq (%rax,%rcx), %rsi
movq %rbx, %rdi
callq 0x12d08
movq %rax, 0x10(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsp)
xorl %r12d, %r12d
movq %r12, (%rsp)
movl $0x8000, 0x8(%rsp)      # imm = 0x8000
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r13, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x47453
movq %rax, %r15
leaq -0x50(%rbp), %rdx
movw $0xc, (%rdx)
movl -0x2c(%rbp), %eax
movl %eax, 0x4(%rdx)
movq %r12, 0x8(%rdx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x45a6e
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x3d9e2
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3VtabMakeWritable
SQLITE_PRIVATE void sqlite3VtabMakeWritable(Parse *pParse, Table *pTab){
  Parse *pToplevel = sqlite3ParseToplevel(pParse);
  int i, n;
  Table **apVtabLock;

  assert( IsVirtual(pTab) );
  for(i=0; i<pToplevel->nVtabLock; i++){
    if( pTab==pToplevel->apVtabLock[i] ) return;
  }
  n = (pToplevel->nVtabLock+1)*sizeof(pToplevel->apVtabLock[0]);
  apVtabLock = sqlite3_realloc64(pToplevel->apVtabLock, n);
  if( apVtabLock ){
    pToplevel->apVtabLock = apVtabLock;
    pToplevel->apVtabLock[pToplevel->nVtabLock++] = pTab;
  }else{
    pToplevel->db->mallocFailed = 1;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq 0x1c0(%rdi), %r15
testq %r15, %r15
cmoveq %rdi, %r15
movslq 0x1f0(%r15), %r12
testq %r12, %r12
jle 0x6b2d0
movq 0x268(%r15), %rax
xorl %ecx, %ecx
cmpq %rbx, (%rax,%rcx,8)
je 0x6b321
incq %rcx
cmpq %rcx, %r12
jne 0x6b2c2
movq 0x268(%r15), %r14
callq 0xa080
testl %eax, %eax
je 0x6b2e4
xorl %eax, %eax
jmp 0x6b2f7
leal 0x8(,%r12,8), %eax
movslq %eax, %rsi
movq %r14, %rdi
callq 0xc1a4
testq %rax, %rax
je 0x6b31a
movq %rax, 0x268(%r15)
movslq 0x1f0(%r15), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x1f0(%r15)
movq %rbx, (%rax,%rcx,8)
jmp 0x6b321
movq (%r15), %rax
movb $0x1, 0x51(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: targetSrcList
static SrcList *targetSrcList(
  Parse *pParse,       /* The parsing context */
  TriggerStep *pStep   /* The trigger containing the target token */
){
  sqlite3 *db = pParse->db;
  int iDb;             /* Index of the database to use */
  SrcList *pSrc;       /* SrcList to be returned */

  pSrc = sqlite3SrcListAppend(db, 0, 0, 0);
  if( pSrc ){
    assert( pSrc->nSrc>0 );
    pSrc->a[pSrc->nSrc-1].zName = sqlite3DbStrDup(db, pStep->zTarget);
    iDb = sqlite3SchemaToIndex(db, pStep->pTrig->pSchema);
    if( iDb==0 || iDb>=2 ){
      assert( iDb<db->nDb );
      pSrc->a[pSrc->nSrc-1].zDatabase = sqlite3DbStrDup(db, db->aDb[iDb].zName);
    }
  }
  return pSrc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq (%rdi), %rbx
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x47880
movq %rax, %r14
testq %rax, %rax
je 0x6d02b
movq 0x18(%r15), %rsi
movq %rbx, %rdi
callq 0x12d08
movslq (%r14), %rcx
imulq $0x70, %rcx, %rcx
movq %rax, -0x58(%rcx,%r14)
movq 0x8(%r15), %rax
movq 0x28(%rax), %rcx
testq %rcx, %rcx
je 0x6cfea
movl 0x28(%rbx), %edx
testl %edx, %edx
jle 0x6cff1
movq 0x20(%rbx), %rsi
addq $0x18, %rsi
xorl %eax, %eax
cmpq %rcx, (%rsi)
je 0x6cff3
incq %rax
addq $0x20, %rsi
cmpq %rax, %rdx
jne 0x6cfd5
movl %edx, %eax
jmp 0x6cff3
movl $0xfff0bdc0, %eax       # imm = 0xFFF0BDC0
jmp 0x6cff3
xorl %eax, %eax
testl %eax, %eax
setne %cl
cmpl $0x2, %eax
setl %dl
testb %dl, %cl
jne 0x6d02b
movq %r14, %r15
addq $0x8, %r15
movq 0x20(%rbx), %rcx
movl %eax, %eax
shlq $0x5, %rax
movq (%rcx,%rax), %rsi
movq %rbx, %rdi
callq 0x12d08
movslq (%r14), %rcx
imulq $0x70, %rcx, %rcx
movq %rax, -0x68(%rcx,%r15)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3ExprCodeAndCache
SQLITE_PRIVATE void sqlite3ExprCodeAndCache(Parse *pParse, Expr *pExpr, int target){
  Vdbe *v = pParse->pVdbe;
  int iMem;

  assert( target>0 );
  assert( pExpr->op!=TK_REGISTER );
  sqlite3ExprCode(pParse, pExpr, target);
  iMem = ++pParse->nMem;
  sqlite3VdbeAddOp2(v, OP_Copy, target, iMem);
  exprToRegister(pExpr, iMem);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rdi), %r12
callq 0x50a8d
movl 0x54(%r15), %r13d
incl %r13d
movl %r13d, 0x54(%r15)
movq %r12, %rdi
movl $0x1f, %esi
movl %ebx, %edx
movl %r13d, %ecx
xorl %r8d, %r8d
callq 0x3fa9e
movb (%r14), %al
movb %al, 0x36(%r14)
movb $-0x63, (%r14)
movl %r13d, 0x2c(%r14)
andb $-0x11, 0x5(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3ExprCodeFactorable
SQLITE_PRIVATE void sqlite3ExprCodeFactorable(Parse *pParse, Expr *pExpr, int target){
  if( pParse->okConstFactor && sqlite3ExprIsConstant(pExpr) ){
    sqlite3ExprCodeAtInit(pParse, pExpr, target, 0);
  }else{
    sqlite3ExprCode(pParse, pExpr, target);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
cmpb $0x0, 0x23(%rdi)
je 0x6ff9d
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %r12
movaps %xmm0, 0x20(%r12)
movaps %xmm0, (%r12)
movaps %xmm0, 0x10(%r12)
movb $0x1, 0x24(%r12)
leaq -0x1b829(%rip), %rax    # 0x54737
movq %rax, (%r12)
leaq -0x1b7be(%rip), %rax    # 0x547ad
movq %rax, 0x8(%r12)
movl $0x0, 0x28(%r12)
movq %r12, %rdi
movq %r14, %rsi
callq 0x547bc
cmpb $0x0, 0x24(%r12)
je 0x6ff9d
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
xorl %ecx, %ecx
callq 0x546c4
jmp 0x6ffaa
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x50a8d
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: returnSingleText
static void returnSingleText(
  Vdbe *v,                /* Prepared statement under construction */
  const char *zLabel,     /* Name of the result column */
  const char *zValue      /* Value to be returned */
){
  if( zValue ){
    sqlite3VdbeLoadString(v, 1, (const char*)zValue);
    setOneColumnName(v, zLabel);
    sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);
  }
}

// Assembly:
testq %rdx, %rdx
je 0x70121
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movl $0x61, %esi
xorl %edx, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x3fa9e
movq %rbx, %rdi
movl %eax, %esi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x14ab9
leaq -0x20(%rbp), %rdx
movq %r14, (%rdx)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x70730
movq %rbx, %rdi
movl $0x22, %esi
movl $0x1, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3fa9e
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: setAllColumnNames
static void setAllColumnNames(
  Vdbe *v,               /* The query under construction */
  int N,                 /* Number of columns */
  const char **azCol     /* Names of columns */
){
  int i;
  sqlite3VdbeSetNumCols(v, N);
  for(i=0; i<N; i++){
    sqlite3VdbeSetColName(v, i, COLNAME_NAME, azCol[i], SQLITE_STATIC);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r14
callq 0x406ed
testl %r15d, %r15d
jle 0x7078a
movl %r15d, %eax
imulq $0x38, %rax, %r15
xorl %r12d, %r12d
movq (%r14), %rax
cmpb $0x0, 0x51(%rax)
jne 0x7077d
movq (%rbx), %rsi
movq 0x20(%r14), %rdi
addq %r12, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x11b32
addq $0x8, %rbx
addq $0x38, %r12
cmpq %r12, %r15
jne 0x70758
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3VdbeMultiLoad
SQLITE_PRIVATE void sqlite3VdbeMultiLoad(Vdbe *p, int iDest, const char *zTypes, ...){
  va_list ap;
  int i;
  char c;
  va_start(ap, zTypes);
  for(i=0; (c = zTypes[i])!=0; i++){
    if( c=='s' ){
      const char *z = va_arg(ap, const char*);
      int addr = sqlite3VdbeAddOp2(p, z==0 ? OP_Null : OP_String8, 0, iDest++);
      if( z ) sqlite3VdbeChangeP4(p, addr, z, 0);
    }else{
      assert( c=='i' );
      sqlite3VdbeAddOp2(p, OP_Integer, va_arg(ap, int), iDest++);
    }
  }
  va_end(ap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
leaq -0xf0(%rbp), %rdx
movq %rcx, 0x18(%rdx)
movq %r8, 0x20(%rdx)
movq %r9, 0x28(%rdx)
testb %al, %al
je 0x707f1
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %rdx, -0x30(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, -0x40(%rbp)
movzbl (%rbx), %eax
cmpl $0x73, %eax
je 0x70833
testl %eax, %eax
je 0x708bb
movl -0x40(%rbp), %ecx
cmpq $0x28, %rcx
ja 0x7088f
movq %rcx, %rax
addq -0x30(%rbp), %rax
addl $0x8, %ecx
movl %ecx, -0x40(%rbp)
jmp 0x7089b
movl -0x40(%rbp), %ecx
cmpq $0x28, %rcx
ja 0x7084b
movq %rcx, %rax
addq -0x30(%rbp), %rax
addl $0x8, %ecx
movl %ecx, -0x40(%rbp)
jmp 0x70857
movq -0x38(%rbp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq (%rax), %r12
movl $0x1a, %esi
testq %r12, %r12
je 0x70869
movl $0x61, %esi
movq %r15, %rdi
xorl %edx, %edx
movl %r14d, %ecx
xorl %r8d, %r8d
callq 0x3fa9e
testq %r12, %r12
je 0x708b0
movq %r15, %rdi
movl %eax, %esi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x14ab9
jmp 0x708b0
movq -0x38(%rbp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x38(%rbp)
movl (%rax), %edx
movq %r15, %rdi
movl $0x17, %esi
movl %r14d, %ecx
xorl %r8d, %r8d
callq 0x3fa9e
incl %r14d
incq %rbx
jmp 0x7080b
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: triggerStepAllocate
static TriggerStep *triggerStepAllocate(
  sqlite3 *db,                /* Database connection */
  u8 op,                      /* Trigger opcode */
  Token *pName                /* The target name */
){
  TriggerStep *pTriggerStep;

  pTriggerStep = sqlite3DbMallocZero(db, sizeof(TriggerStep) + pName->n + 1);
  if( pTriggerStep ){
    char *z = (char*)&pTriggerStep[1];
    memcpy(z, pName->z, pName->n);
    sqlite3Dequote(z);
    pTriggerStep->zTarget = z;
    pTriggerStep->op = op;
  }
  return pTriggerStep;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movl %esi, %ebx
movl 0x8(%rdx), %r12d
addq $0x49, %r12
movq %r12, %rsi
callq 0x144ee
movq %rax, %r14
testq %rax, %rax
je 0x70cf4
movq %r14, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0xa210
movq %r14, %r12
addq $0x48, %r12
movq (%r15), %rsi
movl 0x8(%r15), %edx
movq %r12, %rdi
callq 0xa310
movq %r12, %rdi
callq 0x56136
movq %r12, 0x18(%r14)
movb %bl, (%r14)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: printfFunc
static void printfFunc(
  sqlite3_context *context,
  int argc,
  sqlite3_value **argv
){
  PrintfArguments x;
  StrAccum str;
  const char *zFormat;
  int n;
  sqlite3 *db = sqlite3_context_db_handle(context);

  if( argc>=1 && (zFormat = (const char*)sqlite3_value_text(argv[0]))!=0 ){
    x.nArg = argc-1;
    x.nUsed = 0;
    x.apArg = argv+1;
    sqlite3StrAccumInit(&str, db, 0, 0, db->aLimit[SQLITE_LIMIT_LENGTH]);
    sqlite3XPrintf(&str, SQLITE_PRINTF_SQLFUNC, zFormat, &x);
    n = str.nChar;
    sqlite3_result_text(context, sqlite3StrAccumFinish(&str), n,
                        SQLITE_DYNAMIC);
  }
}

// Assembly:
testl %esi, %esi
jle 0x73c87
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x28(%rax), %r12
movq (%rdx), %rdi
movl $0x1, %esi
callq 0x11820
testq %rax, %rax
je 0x73c7b
decl %r15d
leaq -0x30(%rbp), %rcx
movl %r15d, (%rcx)
movl $0x0, 0x4(%rcx)
addq $0x8, %r14
movq %r14, 0x8(%rcx)
movl 0x68(%r12), %edx
xorps %xmm0, %xmm0
leaq -0x58(%rbp), %r14
movups %xmm0, 0x8(%r14)
movq %r12, (%r14)
movq $0x0, 0x18(%r14)
movl %edx, 0x20(%r14)
movw $0x0, 0x24(%r14)
movq %r14, %rdi
movl $0x2, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3e833
movl 0x18(%r14), %r15d
movq %r14, %rdi
callq 0xda95
leaq -0x67afe(%rip), %r8     # 0xc16a
movq %rbx, %rdi
movq %rax, %rsi
movl %r15d, %edx
movl $0x1, %ecx
callq 0x119e9
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: groupConcatStep
static void groupConcatStep(
  sqlite3_context *context,
  int argc,
  sqlite3_value **argv
){
  const char *zVal;
  StrAccum *pAccum;
  const char *zSep;
  int nVal, nSep;
  assert( argc==1 || argc==2 );
  if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
  pAccum = (StrAccum*)sqlite3_aggregate_context(context, sizeof(*pAccum));

  if( pAccum ){
    sqlite3 *db = sqlite3_context_db_handle(context);
    int firstTerm = pAccum->mxAlloc==0;
    pAccum->mxAlloc = db->aLimit[SQLITE_LIMIT_LENGTH];
    if( !firstTerm ){
      if( argc==2 ){
        zSep = (char*)sqlite3_value_text(argv[1]);
        nSep = sqlite3_value_bytes(argv[1]);
      }else{
        zSep = ",";
        nSep = 1;
      }
      if( nSep ) sqlite3StrAccumAppend(pAccum, zSep, nSep);
    }
    zVal = (char*)sqlite3_value_text(argv[0]);
    nVal = sqlite3_value_bytes(argv[0]);
    if( zVal ) sqlite3StrAccumAppend(pAccum, zVal, nVal);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq (%rdx), %rax
movl 0x8(%rax), %eax
movl $0xaaaaaaaa, %ecx       # imm = 0xAAAAAAAA
btl %eax, %ecx
jb 0x74f17
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %r12
movq 0x10(%rdi), %rax
testb $0x20, 0x9(%rax)
jne 0x74e4c
movq %r12, %rdi
movl $0x28, %esi
callq 0x12d99
movq %rax, %rbx
jmp 0x74e50
movq 0x10(%rax), %rbx
testq %rbx, %rbx
je 0x74f17
movq (%r12), %rax
movq 0x28(%rax), %rax
cmpl $0x0, 0x20(%rbx)
movl 0x68(%rax), %eax
movl %eax, 0x20(%rbx)
je 0x74ed0
cmpl $0x2, %r15d
jne 0x74e94
movq 0x8(%r14), %rdi
movl $0x1, %esi
callq 0x11820
movq %rax, %r15
movq 0x8(%r14), %rdi
movl $0x1, %esi
callq 0x116f1
jmp 0x74ea0
leaq 0xa48c(%rip), %r15      # 0x7f327
movl $0x1, %eax
testl %eax, %eax
je 0x74ed0
movl 0x18(%rbx), %edi
leal (%rdi,%rax), %ecx
cmpl 0x1c(%rbx), %ecx
jae 0x74ec3
movl %ecx, 0x18(%rbx)
addq 0x10(%rbx), %rdi
movslq %eax, %rdx
movq %r15, %rsi
callq 0xa310
jmp 0x74ed0
movq %rbx, %rdi
movq %r15, %rsi
movl %eax, %edx
callq 0x1be64
movq (%r14), %rdi
movl $0x1, %esi
callq 0x11820
movq %rax, %r15
movq (%r14), %rdi
movl $0x1, %esi
callq 0x116f1
testq %r15, %r15
je 0x74f17
movl 0x18(%rbx), %edi
leal (%rdi,%rax), %ecx
cmpl 0x1c(%rbx), %ecx
jae 0x74f20
movl %ecx, 0x18(%rbx)
addq 0x10(%rbx), %rdi
movslq %eax, %rdx
movq %r15, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xa310
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r15, %rsi
movl %eax, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1be64
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: pcache1Init
static int pcache1Init(void *NotUsed){
  UNUSED_PARAMETER(NotUsed);
  assert( pcache1.isInit==0 );
  memset(&pcache1, 0, sizeof(pcache1));


  /*
  ** The pcache1.separateCache variable is true if each PCache has its own
  ** private PGroup (mode-1).  pcache1.separateCache is false if the single
  ** PGroup in pcache1.grp is used for all page caches (mode-2).
  **
  **   *  Always use a unified cache (mode-2) if ENABLE_MEMORY_MANAGEMENT
  **
  **   *  Use a unified cache in single-threaded applications that have
  **      configured a start-time buffer for use as page-cache memory using
  **      sqlite3_config(SQLITE_CONFIG_PAGECACHE, pBuf, sz, N) with non-NULL 
  **      pBuf argument.
  **
  **   *  Otherwise use separate caches (mode-1)
  */
#if defined(SQLITE_ENABLE_MEMORY_MANAGEMENT)
  pcache1.separateCache = 0;
#elif SQLITE_THREADSAFE
  pcache1.separateCache = sqlite3GlobalConfig.pPage==0
                          || sqlite3GlobalConfig.bCoreMutex>0;
#else
  pcache1.separateCache = sqlite3GlobalConfig.pPage==0;
#endif

#if SQLITE_THREADSAFE
  if( sqlite3GlobalConfig.bCoreMutex ){
    pcache1.grp.mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_LRU);
    pcache1.mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_PMEM);
  }
#endif
  if( pcache1.separateCache
   && sqlite3GlobalConfig.nPage!=0
   && sqlite3GlobalConfig.pPage==0
  ){
    pcache1.nInitPage = sqlite3GlobalConfig.nPage;
  }else{
    pcache1.nInitPage = 0;
  }
  pcache1.grp.mxPinned = 10;
  pcache1.isInit = 1;
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x1e2b4(%rip), %rdi     # 0x95440
xorl %ebx, %ebx
movl $0x90, %edx
xorl %esi, %esi
callq 0xa210
cmpq $0x0, 0x1c2ce(%rip)     # 0x93470
sete %al
movl 0x1c179(%rip), %ecx     # 0x93324
testl %ecx, %ecx
setg %dl
orb %al, %dl
movzbl %dl, %eax
movl %eax, 0x1e2d9(%rip)     # 0x95494
testl %ecx, %ecx
je 0x771fd
callq 0xbd1c
testl %eax, %eax
je 0x771cc
xorl %eax, %eax
jmp 0x771d7
movl $0x6, %edi
callq *0x1c1c1(%rip)          # 0x93398
movq %rax, 0x1e262(%rip)     # 0x95440
callq 0xbd1c
testl %eax, %eax
je 0x771eb
xorl %eax, %eax
jmp 0x771f6
movl $0x7, %edi
callq *0x1c1a2(%rip)          # 0x93398
movq %rax, 0x1e2bb(%rip)     # 0x954b8
movl 0x1c279(%rip), %eax     # 0x9347c
cmpq $0x0, 0x1c265(%rip)     # 0x93470
cmovel %eax, %ebx
testl %eax, %eax
cmovel %eax, %ebx
movl 0x1e27b(%rip), %eax     # 0x95494
testl %eax, %eax
cmovel %eax, %ebx
movl %ebx, 0x1e274(%rip)     # 0x95498
movl $0xa, 0x1e222(%rip)     # 0x95450
movl $0x1, 0x1e258(%rip)     # 0x95490
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: pcache1EnforceMaxPage
static void pcache1EnforceMaxPage(PCache1 *pCache){
  PGroup *pGroup = pCache->pGroup;
  PgHdr1 *p;
  assert( sqlite3_mutex_held(pGroup->mutex) );
  while( pGroup->nCurrentPage>pGroup->nMaxPage
      && (p=pGroup->lru.pLruPrev)->isAnchor==0
  ){
    assert( p->pCache->pGroup==pGroup );
    assert( p->isPinned==0 );
    pcache1PinPage(p);
    pcache1RemoveFromHash(p, 1);
  }
  if( pCache->nPage==0 && pCache->pBulk ){
    sqlite3_free(pCache->pBulk);
    pCache->pBulk = pCache->pFree = 0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
movl 0x14(%r14), %eax
cmpl 0x8(%r14), %eax
jbe 0x77646
movq 0x48(%r14), %rdi
cmpb $0x0, 0x16(%rdi)
jne 0x77646
movq 0x20(%rdi), %rax
movq 0x28(%rdi), %rcx
movq 0x30(%rdi), %rdx
movq %rcx, 0x28(%rdx)
movq 0x28(%rdi), %rcx
movq %rdx, 0x30(%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
movb $0x1, 0x14(%rdi)
decl 0x28(%rax)
movl $0x1, %esi
callq 0x77666
jmp 0x77600
cmpl $0x0, 0x2c(%rbx)
jne 0x77661
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x77661
callq 0xa620
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: pcache1FreePage
static void pcache1FreePage(PgHdr1 *p){
  PCache1 *pCache;
  assert( p!=0 );
  pCache = p->pCache;
  assert( sqlite3_mutex_held(p->pCache->pGroup->mutex) );
  if( p->isBulkLocal ){
    p->pNext = pCache->pFree;
    pCache->pFree = p;
  }else{
    pcache1Free(p->page.pBuf);
#ifdef SQLITE_PCACHE_SEPARATE_HEADER
    sqlite3_free(p);
#endif
  }
  if( pCache->bPurgeable ){
    pCache->pGroup->nCurrentPage--;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x20(%rdi), %rbx
cmpb $0x0, 0x15(%rdi)
je 0x776be
movq 0x40(%rbx), %rax
movq %rax, 0x18(%rdi)
movq %rdi, 0x40(%rbx)
jmp 0x776c6
movq (%rdi), %rdi
callq 0x21d0f
cmpl $0x0, 0x14(%rbx)
je 0x776d2
movq (%rbx), %rax
decl 0x14(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: binCollFunc
static int binCollFunc(
  void *padFlag,
  int nKey1, const void *pKey1,
  int nKey2, const void *pKey2
){
  int rc, n;
  n = nKey1<nKey2 ? nKey1 : nKey2;
  /* EVIDENCE-OF: R-65033-28449 The built-in BINARY collation compares
  ** strings byte by byte using the memcmp() function from the standard C
  ** library. */
  rc = memcmp(pKey1, pKey2, n);
  if( rc==0 ){
    if( padFlag
     && allSpaces(((char*)pKey1)+n, nKey1-n)
     && allSpaces(((char*)pKey2)+n, nKey2-n)
    ){
      /* EVIDENCE-OF: R-31624-24737 RTRIM is like BINARY except that extra
      ** spaces at the end of either string do not change the result. In other
      ** words, strings will compare equal to one another as long as they
      ** differ only in the number of spaces at the end.
      */
    }else{
      rc = nKey1 - nKey2;
    }
  }
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebx
movl %esi, %r12d
movq %rdi, -0x30(%rbp)
movl %esi, %r14d
subl %ecx, %r14d
movl %ecx, %r13d
cmovll %esi, %r13d
movslq %r13d, %r15
movq %rdx, -0x38(%rbp)
movq %rdx, %rdi
movq %r8, -0x40(%rbp)
movq %r8, %rsi
movq %r15, %rdx
callq 0xa260
testl %eax, %eax
jne 0x77c74
movq -0x38(%rbp), %rax
cmpq $0x0, -0x30(%rbp)
movq -0x40(%rbp), %rsi
je 0x77c71
subl %r13d, %r12d
jle 0x77c48
addq %r15, %rax
decq %rax
movl %r12d, %ecx
cmpb $0x20, (%rax,%rcx)
jne 0x77c48
leal -0x1(%r12), %ecx
cmpl $0x1, %r12d
movl %ecx, %r12d
jg 0x77c2e
xorl %r12d, %r12d
testl %r12d, %r12d
jne 0x77c71
subl %r13d, %ebx
jle 0x77c6d
leaq (%rsi,%r15), %rax
decq %rax
movl %ebx, %ecx
cmpb $0x20, (%rax,%rcx)
jne 0x77c6d
leal -0x1(%rbx), %ecx
cmpl $0x1, %ebx
movl %ecx, %ebx
jg 0x77c59
xorl %ebx, %ebx
testl %ebx, %ebx
je 0x77c83
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x77c74
// File: /workspace/github_c_makefile_star2_O1/antonblanchard[P]will-it-scale/tests/lseek1.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	char buf[BUFLEN];
	char tmpfile[] = "/tmp/willitscale.XXXXXX";
	int fd = mkstemp(tmpfile);

	assert(fd >= 0);
	unlink(tmpfile);

	assert(write(fd, buf, sizeof(buf)) == sizeof(buf));

	while (1) {
		lseek(fd, 0, SEEK_SET);

		(*iterations)++;
	}
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x1028, %rsp           # imm = 0x1028
movq %rdi, %rbx
movaps 0x711(%rip), %xmm0      # 0x3300
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movabsq $0x5858585858582e, %rax # imm = 0x5858585858582E
movq %rax, 0x10(%rdi)
callq 0x21d0
testl %eax, %eax
js 0x2c3f
movl %eax, %ebp
movq %rsp, %rdi
callq 0x2080
leaq 0x20(%rsp), %rsi
movl $0x1000, %edx           # imm = 0x1000
movl %ebp, %edi
callq 0x20d0
cmpq $0x1000, %rax           # imm = 0x1000
jne 0x2c5e
movl %ebp, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2120
incq (%rbx)
jmp 0x2c2f
leaq 0x636(%rip), %rdi       # 0x327c
leaq 0x637(%rip), %rsi       # 0x3284
leaq 0x63f(%rip), %rcx       # 0x3293
movl $0x10, %edx
callq 0x2130
leaq 0x661(%rip), %rdi       # 0x32c6
leaq 0x618(%rip), %rsi       # 0x3284
leaq 0x620(%rip), %rcx       # 0x3293
movl $0x13, %edx
callq 0x2130
// File: /workspace/github_c_makefile_star2_O1/mloar[P]charset/fromucs.c
// Function: charset_from_unicode
int charset_from_unicode(const wchar_t **input, int *inlen,
			 char *output, int outlen,
			 int charset, charset_state *state, int *error)
{
    charset_spec const *spec = charset_find_spec(charset);
    charset_state localstate = CHARSET_INIT_STATE;
    struct charset_emit_param param;
    int locallen;

    if (!input) {
	locallen = 1;
	inlen = &locallen;
    }

    param.output = output;
    param.outlen = outlen;
    param.writtenlen = 0;
    param.stopped = 0;

    if (state)
	localstate = *state;	       /* structure copy */
    if (error)
	*error = FALSE;

    while (*inlen > 0) {
	int lenbefore = param.writtenlen;
	int ret;

	if (input)
	    ret = spec->write(spec, **input, &localstate,
			      charset_emit, &param);
	else
	    ret = spec->write(spec, -1, &localstate, charset_emit, &param);
	if (error && !ret) {
	    /*
	     * We have hit a difficult character, which the user
	     * wants to know about. Leave now.
	     */
	    *error = TRUE;
	    return lenbefore;
	}
	if (param.stopped) {
	    /*
	     * The emit function has _tried_ to output some
	     * characters, but ran up against the end of the
	     * buffer. Leave immediately, and return what happened
	     * _before_ attempting to process this character.
	     */
	    return lenbefore;
	}
	if (state)
	    *state = localstate;       /* structure copy */
	if (input)
	    (*input)++;
	(*inlen)--;
    }
    return param.writtenlen;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %rbx
movl %ecx, 0x8(%rsp)
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r14
movl %r8d, %edi
callq 0x6a4c
movq %rax, %r12
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
testq %r14, %r14
jne 0x677e
leaq 0x44(%rsp), %r15
movl $0x1, (%r15)
movq 0x80(%rsp), %rbp
movq %r13, 0x28(%rsp)
movl 0x8(%rsp), %eax
movl %eax, 0x30(%rsp)
movq $0x0, 0x34(%rsp)
testq %rbx, %rbx
je 0x67a9
movups (%rbx), %xmm0
movaps %xmm0, 0x10(%rsp)
movq %rbx, 0x8(%rsp)
testq %rbp, %rbp
je 0x67ba
movl $0x0, (%rbp)
cmpl $0x0, (%r15)
movl 0x34(%rsp), %r13d
jle 0x683b
testq %r14, %r14
je 0x67d5
movq (%r14), %rax
movslq (%rax), %rsi
movq %r12, %rdi
jmp 0x67df
movq %r12, %rdi
movq $-0x1, %rsi
leaq 0x10(%rsp), %rdx
leaq 0x64(%rip), %rcx        # 0x684f
leaq 0x28(%rsp), %r8
callq *0x10(%r12)
testq %rbp, %rbp
je 0x6807
testl %eax, %eax
jne 0x6807
movl $0x1, (%rbp)
jmp 0x680e
cmpl $0x0, 0x38(%rsp)
je 0x6819
xorl %eax, %eax
movl %r13d, %ebx
testb %al, %al
jne 0x67ba
jmp 0x683e
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x682b
movaps 0x10(%rsp), %xmm0
movups %xmm0, (%rax)
testq %r14, %r14
je 0x6834
addq $0x4, (%r14)
decl (%r15)
movb $0x1, %al
jmp 0x6813
movl %r13d, %ebx
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mloar[P]charset/fromucs.c
// Function: charset_emit
static void charset_emit(void *ctx, long int output)
{
    struct charset_emit_param *param = (struct charset_emit_param *)ctx;

    if (param->outlen != 0) {
	if (param->output)
	    *param->output++ = output;
	if (param->outlen > 0)
	    param->outlen--;
	param->writtenlen++;
    } else {
	param->stopped = 1;
    }
}

// Assembly:
cmpl $0x0, 0x8(%rdi)
je 0x6877
movq (%rdi), %rax
testq %rax, %rax
je 0x6867
leaq 0x1(%rax), %rcx
movq %rcx, (%rdi)
movb %sil, (%rax)
movl 0x8(%rdi), %eax
testl %eax, %eax
jle 0x6873
decl %eax
movl %eax, 0x8(%rdi)
incl 0xc(%rdi)
retq
movl $0x1, 0x10(%rdi)
retq
nop
// File: /workspace/github_c_makefile_star2_O1/eiselekd[P]MinimalLisp/./lf1.c
// Function: lf_eval
v *
lf_eval(lfctx *lfctx) 
{
    fctx *cctx = (fctx *)lfctx;
    v *r = 0, *f; v *e = POP;
    switch(e->tag) {
    case INT: case STR:
        PUSH(e);
        PUSH(mkInt(0));
        break;
    case SYM:
        if ((r = assq(e, TOSE))) {
            r = cdr(r);
        } else {
            fprintf(stderr, "Undefined symbol \"%s\"\n", str(e));
        }
        PUSH(r);
        PUSH(mkInt(0));
        break;
    case FUNC:
        break;
    case CONS:
        PUSH(cdr(e));
        PUSH(car(e));
        PUSH(mkInt(1));
        break;
    }
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x120(%rdi), %rax
testq %rax, %rax
je 0xea89
movq 0x10(%rax), %rcx
movq %rcx, 0x120(%rbx)
movq 0x8(%rax), %r14
jmp 0xea97
movq $0x0, 0x120(%rbx)
xorl %r14d, %r14d
movl (%r14), %eax
andl $0xf, %eax
leal -0x1(%rax), %ecx
cmpl $0x2, %ecx
jb 0xeac0
testl %eax, %eax
je 0xead1
cmpl $0x3, %eax
jne 0xeb0d
movq 0x178(%rbx), %rax
testq %rax, %rax
je 0xeb15
movq 0x8(%rax), %rax
jmp 0xeb33
movq 0x120(%rbx), %r12
movq $0x0, -0x30(%rbp)
jmp 0xeb08
movq 0x10(%r14), %r15
movq 0x120(%rbx), %r13
movl $0x18, %edi
callq 0x2100
movq %rax, %r12
andb $-0x10, (%rax)
movq %r15, 0x8(%rax)
movq %r13, 0x10(%rax)
movq %rax, 0x120(%rbx)
movq 0x8(%r14), %r14
movl $0x1, %eax
movq %rax, -0x30(%rbp)
xorl %r15d, %r15d
jmp 0xeb59
xorl %r15d, %r15d
jmp 0xebb3
xorl %eax, %eax
jmp 0xeb33
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0xeb28
movq 0x8(%rcx), %rdx
jmp 0xeb2a
xorl %edx, %edx
cmpq %r14, %rdx
je 0xeb3a
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0xeb19
xorl %ecx, %ecx
testq %rcx, %rcx
je 0xebc5
movq 0x10(%rcx), %r14
movq 0x120(%rbx), %r12
movq $0x0, -0x30(%rbp)
movq %r14, %r15
movl $0x18, %edi
callq 0x2100
movq %rax, %r13
andb $-0x10, (%rax)
movq %r14, 0x8(%rax)
movq %r12, 0x10(%rax)
movq %rax, 0x120(%rbx)
movl $0x18, %edi
callq 0x2100
movq %rax, %r14
movl (%rax), %eax
andl $-0x10, %eax
incl %eax
movl %eax, (%r14)
movq -0x30(%rbp), %rax
movq %rax, 0x8(%r14)
movl $0x18, %edi
callq 0x2100
andb $-0x10, (%rax)
movq %r14, 0x8(%rax)
movq %r13, 0x10(%rax)
movq %rax, 0x120(%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x2253
xorl %r14d, %r14d
jmp 0xeb47
// File: /workspace/github_c_makefile_star2_O1/eiselekd[P]MinimalLisp/./lf1.c
// Function: lf_apply_p
v *
lf_apply_p(lfctx *lfctx) 
{
    fctx *cctx = (fctx *)lfctx; v *env = 0;
    v *fn = POP; v *args = POP; v *r = 0, *benv; int a = 0, isop = 0;
    if( (isop = ((fn->tag == FUNC) ? 0 : 1)) || fwordp(fn)) {
        benv = TOSE;
        if (FN_FUNCENVP(fn))
            benv = funcenv(fn);
        /* if (FN_ARGBINDP(fn)) */
        /*     benv = evbind(car(func(fn)), args, benv); /\* error, todo: bind eval'ed args  *\/ */
        env = benv;
        a = (FN_ARGEVALP(fn)) ? 1 : 0;
    } else {
        fprintf(stderr, "Cannot apply to "); print((ctx*)cctx, stderr, fn); fprintf(stderr, "\n"); 
    }
    PUSH(env);
    PUSH(args);
    PUSH(fn);
    PUSH(mkInt(isop));
    PUSH(mkInt(a));
    return r;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x120(%rdi), %rax
testq %rax, %rax
je 0xec57
movq 0x10(%rax), %rcx
movq %rcx, 0x120(%rbx)
movq 0x8(%rax), %rsi
jmp 0xec64
movq $0x0, 0x120(%rbx)
xorl %esi, %esi
movq 0x120(%rbx), %rax
testq %rax, %rax
je 0xec85
movq 0x10(%rax), %rcx
movq %rcx, 0x120(%rbx)
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0xec98
movq $0x0, 0x120(%rbx)
movq $0x0, -0x38(%rbp)
movl (%rsi), %ecx
movl %ecx, %r15d
andl $0xf, %r15d
cmpl $0x4, %r15d
movq %rsi, -0x40(%rbp)
je 0xedd6
movq 0x178(%rbx), %rax
testq %rax, %rax
je 0xecc1
movq 0x8(%rax), %r12
jmp 0xecc4
xorl %r12d, %r12d
testb $0x20, %cl
je 0xeccd
movq 0x10(%rsi), %r12
shrl $0x4, %ecx
andl $0x1, %ecx
movq %rcx, -0x30(%rbp)
xorl %r13d, %r13d
cmpl $0x4, %r15d
setne %r13b
movq 0x120(%rbx), %r14
movl $0x18, %edi
callq 0x2100
movq %rax, %r15
andb $-0x10, (%rax)
movq %r12, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rax, 0x120(%rbx)
movl $0x18, %edi
callq 0x2100
movq %rax, %r12
andb $-0x10, (%rax)
movq -0x38(%rbp), %rax
movq %rax, 0x8(%r12)
movq %r15, 0x10(%r12)
movq %r12, 0x120(%rbx)
movl $0x18, %edi
callq 0x2100
movq %rax, %r15
andb $-0x10, (%rax)
movq -0x40(%rbp), %rax
movq %rax, 0x8(%r15)
movq %r12, 0x10(%r15)
movq %r15, 0x120(%rbx)
movl $0x18, %edi
callq 0x2100
movq %rax, %r14
movl (%rax), %eax
andl $-0x10, %eax
incl %eax
movl %eax, (%r14)
movq %r13, 0x8(%r14)
movl $0x18, %edi
callq 0x2100
movq %rax, %r12
andb $-0x10, (%rax)
movq %r14, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %rax, 0x120(%rbx)
movl $0x18, %edi
callq 0x2100
movq %rax, %r14
movl (%rax), %eax
andl $-0x10, %eax
incl %eax
movl %eax, (%r14)
movq -0x30(%rbp), %rax
movq %rax, 0x8(%r14)
movl $0x18, %edi
callq 0x2100
andb $-0x10, (%rax)
movq %r14, 0x8(%rax)
movq %r12, 0x10(%rax)
movq %rax, 0x120(%rbx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x2277
xorl %r12d, %r12d
movq $0x0, -0x30(%rbp)
jmp 0xecd7
// File: /workspace/github_c_makefile_star2_O1/eiselekd[P]MinimalLisp/./lf1.c
// Function: lf_remap
void
lf_remap(lfctx *lfctx)
{
    struct ctx *lctx = (struct ctx *) lfctx;
    struct fctx *fctx = (struct fctx *)lfctx;
    v *le = 0, *fe; struct lf_maps *c = m;
    while(c->ln && c->fn) {
        if ((le = assq(unique(lctx,c->ln, strlen(c->ln)), lctx->env)) &&
            (fe = assq(unique(lctx,c->fn, strlen(c->fn)), fctx->env))) {
            rplacd(le,cdr(fe));
            printf("Map %s to %s (0x%p)\n", c->ln, c->fn, cdr(fe));
        } else {
            printf("Cannot map %s to %s\n", c->ln, c->fn);
        }
        c++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x4e6f(%rip), %r12      # 0x152d0
testq %r12, %r12
je 0x10557
movq %rdi, %rbx
leaq 0x4e5c(%rip), %r13      # 0x152d0
leaq 0x1015(%rip), %r14      # 0x11490
cmpq $0x0, 0x8(%r13)
je 0x10557
movq %r12, %rdi
callq 0x2060
movq %rbx, %rdi
movq %r12, %rsi
movl %eax, %edx
callq 0x36a6
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
je 0x104c0
movq 0x8(%rcx), %r15
testq %r15, %r15
je 0x104b3
movq 0x8(%r15), %rdx
jmp 0x104b5
xorl %edx, %edx
cmpq %rax, %rdx
je 0x104c3
movq 0x10(%rcx), %rcx
jmp 0x1049f
xorl %r15d, %r15d
testq %r15, %r15
je 0x10534
movq 0x8(%r13), %r12
movq %r12, %rdi
callq 0x2060
movq %rbx, %rdi
movq %r12, %rsi
movl %eax, %edx
callq 0x36a6
movq 0x148(%rbx), %rdx
testq %rdx, %rdx
je 0x10509
movq 0x8(%rdx), %rcx
testq %rcx, %rcx
je 0x104fc
movq 0x8(%rcx), %rsi
jmp 0x104fe
xorl %esi, %esi
cmpq %rax, %rsi
je 0x1050b
movq 0x10(%rdx), %rdx
jmp 0x104e8
xorl %ecx, %ecx
testq %rcx, %rcx
je 0x10534
movq 0x10(%rcx), %rax
movq %rax, 0x10(%r15)
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq 0x10(%rcx), %rcx
leaq 0xf50(%rip), %rdi       # 0x1147b
xorl %eax, %eax
callq 0x2070
jmp 0x10546
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %r14, %rdi
xorl %eax, %eax
callq 0x2070
movq 0x10(%r13), %r12
addq $0x10, %r13
testq %r12, %r12
jne 0x1047b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/soso7885[P]OPCUA_example/demo_src/server_datasource.c
// Function: readInteger
static UA_StatusCode
readInteger(void *handle, const UA_NodeId nodeid, UA_Boolean sourceTimeStamp,
            const UA_NumericRange *range, UA_DataValue *dataValue) {
    dataValue->hasValue = true;
    UA_Variant_setScalarCopy(&dataValue->value, (UA_UInt32*)handle, &UA_TYPES[UA_TYPES_INT32]);
    // we know the nodeid is a string
    UA_LOG_INFO(logger, UA_LOGCATEGORY_USERLAND, "Node read %.*s",
                nodeid.identifier.string.length, nodeid.identifier.string.data);
    UA_LOG_INFO(logger, UA_LOGCATEGORY_USERLAND, "read value %i", *(UA_UInt32*)handle);
    return UA_STATUSCODE_GOOD;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
orb $0x1, (%rcx)
leaq 0x8(%rcx), %rdi
movl $0xc8, %edx
addq 0x2b8f(%rip), %rdx      # 0x3fd8
movq %rbx, %rsi
callq 0x1070
movq 0x2c20(%rip), %r9       # 0x4078
testq %r9, %r9
je 0x147f
leaq 0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rax), %r8
leaq 0xbc0(%rip), %rdx       # 0x2030
movl $0x2, %edi
movl $0x5, %esi
xorl %eax, %eax
callq *%r9
movq 0x2bf2(%rip), %r8       # 0x4078
testq %r8, %r8
je 0x14a3
movl (%rbx), %ecx
leaq 0xbab(%rip), %rdx       # 0x203f
movl $0x2, %edi
movl $0x5, %esi
xorl %eax, %eax
callq *%r8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/soso7885[P]OPCUA_example/demo_src/server_datasource.c
// Function: writeInteger
static UA_StatusCode
writeInteger(void *handle, const UA_NodeId nodeid,
             const UA_Variant *data, const UA_NumericRange *range) {
    if(UA_Variant_isScalar(data) && data->type == &UA_TYPES[UA_TYPES_INT32] && data->data){
        *(UA_UInt32*)handle = *(UA_UInt32*)data->data;
    }
    // we know the nodeid is a string
    UA_LOG_INFO(logger, UA_LOGCATEGORY_USERLAND, "Node written %.*s",
                nodeid.identifier.string.length, nodeid.identifier.string.data);
    UA_LOG_INFO(logger, UA_LOGCATEGORY_USERLAND, "written value %i", *(UA_UInt32*)handle);
    return UA_STATUSCODE_GOOD;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x10(%rsi)
jne 0x14e1
cmpq $0x2, 0x18(%rsi)
jb 0x14e1
movl $0xc8, %eax
addq 0x2b09(%rip), %rax      # 0x3fd8
cmpq %rax, (%rsi)
jne 0x14e1
movq 0x18(%rsi), %rax
testq %rax, %rax
je 0x14e1
movl (%rax), %eax
movl %eax, (%rbx)
movq 0x2b90(%rip), %r9       # 0x4078
testq %r9, %r9
je 0x150f
leaq 0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rax), %r8
leaq 0xb4d(%rip), %rdx       # 0x204d
movl $0x2, %edi
movl $0x5, %esi
xorl %eax, %eax
callq *%r9
movq 0x2b62(%rip), %r8       # 0x4078
testq %r8, %r8
je 0x1533
movl (%rbx), %ecx
leaq 0xb3b(%rip), %rdx       # 0x205f
movl $0x2, %edi
movl $0x5, %esi
xorl %eax, %eax
callq *%r8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/giometti[P]mastering_UNIX_programming/chapter_09/scdu_mod13.c
// Function: mod_crypt
void mod_crypt(char *text, size_t n)
{
        int i, c;
        char base;

        for (i = 0; i < n; i++) {
                if ((text[i] >= 'a') && (text[i] <= 'z')) 
                        base = 'a';
                else if ((text[i] >= 'A') && (text[i] <= 'Z'))
                        base = 'A';
		else
			continue;

                c = text[i] - base;
                c = (c + 13) % 26;
                text[i] = c + base;
        }
}

// Assembly:
testq %rsi, %rsi
je 0x1061
xorl %eax, %eax
movsbl (%rdi,%rax), %edx
leal -0x61(%rdx), %r8d
movl $0x61, %ecx
cmpb $0x1a, %r8b
jb 0x1029
leal -0x41(%rdx), %r8d
movl $0x41, %ecx
cmpb $0x19, %r8b
ja 0x1059
subl %ecx, %edx
addl $0xd, %edx
movslq %edx, %rdx
imulq $0x4ec4ec4f, %rdx, %r8  # imm = 0x4EC4EC4F
movq %r8, %r9
shrq $0x3f, %r9
sarq $0x23, %r8
addl %r9d, %r8d
leal (%r8,%r8,4), %r9d
leal (%r9,%r9,4), %r9d
addl %r8d, %r9d
subl %r9d, %edx
addl %ecx, %edx
movb %dl, (%rdi,%rax)
incq %rax
cmpq %rax, %rsi
jne 0x1007
retq
// File: /workspace/github_c_makefile_star2_O1/ryuichiueda[P]glueutils/src/log2.c
// Function: usage
void usage(void){
	fputs("log2: write stderr to a file\n", stderr);
	fputs("usage: log2 <filename> <command> [args]\n", stderr);
	fputs("\nCopyright (C) 2021 Ryuichi Ueda\n", stderr);
	fputs("Released under the MIT License.\n", stderr);
	fputs("https://github.com/ryuichiueda/glueutils\n", stderr);
}

// Assembly:
pushq %rbx
movq 0x2f30(%rip), %rbx      # 0x3ff8
movq (%rbx), %rsi
leaq 0xf32(%rip), %rdi       # 0x2004
callq 0x1060
movq (%rbx), %rsi
leaq 0xf41(%rip), %rdi       # 0x2022
callq 0x1060
movq (%rbx), %rsi
leaq 0xf5b(%rip), %rdi       # 0x204b
callq 0x1060
movq (%rbx), %rsi
leaq 0xf6e(%rip), %rdi       # 0x206d
callq 0x1060
movq (%rbx), %rsi
leaq 0xf80(%rip), %rdi       # 0x208e
popq %rbx
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O1/ryuichiueda[P]glueutils/src/log2.c
// Function: tryopen
int tryopen(char *filename){
	int fd = open(filename, O_WRONLY|O_CREAT|O_TRUNC, 0600);
	if(fd < 0){
		printf("Error: %s: %s\n", filename, strerror(errno));
		exit(1);
	}

	return fd;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x241, %esi            # imm = 0x241
movl $0x180, %edx            # imm = 0x180
xorl %eax, %eax
callq 0x1070
testl %eax, %eax
js 0x126b
popq %rbx
retq
callq 0x1030
movl (%rax), %edi
callq 0x10a0
leaq 0xe45(%rip), %rdi       # 0x20c3
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1050
movl $0x1, %edi
callq 0x1090
// File: /workspace/github_c_makefile_star2_O1/ryuichiueda[P]glueutils/src/log2.c
// Function: main
int main(int argc, char * argv[])
{
	if(argc < 3){
		usage();
		exit(1);
	}

	int fd = tryopen(argv[1]);
	trydup2(fd, 2);

	return - execvp(argv[2], &argv[2]);
}

// Assembly:
pushq %rbx
cmpl $0x2, %edi
jle 0x12c7
movq %rsi, %rbx
movq 0x8(%rsi), %rdi
callq 0x1250
movl %eax, %edi
movl $0x2, %esi
callq 0x121c
movq 0x10(%rbx), %rdi
addq $0x10, %rbx
movq %rbx, %rsi
callq 0x1080
negl %eax
popq %rbx
retq
callq 0x1114
// File: /workspace/github_c_makefile_star2_O1/openshmem-org[P]openshmem-examples/c/fcollect64.c
// Function: main
int
main(void)
{
    int i;

    shmem_init();
    npes = shmem_n_pes();
    me = shmem_my_pe();

    for (i = 0; i < DST_SIZE; i++) {
        dst[i] = -1;
    }

    for (i = 0; i < SHMEM_COLLECT_SYNC_SIZE; i += 1) {
        pSync[i] = SHMEM_SYNC_VALUE;
    }

    shmem_barrier_all();

    shmem_fcollect64(dst, src, 2, 0, 0, npes, pSync);

    shmem_barrier_all();

    show_dst("AFTER");

    shmem_finalize();

    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
callq 0x10a0
callq 0x1060
movl %eax, 0x2ecb(%rip)      # 0x40a0
callq 0x1080
movl %eax, 0x2ec4(%rip)      # 0x40a4
leaq 0x2ec9(%rip), %rbx      # 0x40b0
movl $0x400, %edx            # imm = 0x400
movq %rbx, %rdi
movl $0xff, %esi
callq 0x1040
pcmpeqd %xmm0, %xmm0
movdqa %xmm0, 0x32ab(%rip)     # 0x44b0
movq $-0x1, 0x32b0(%rip) # 0x44c0
leaq 0x3299(%rip), %r14      # 0x44b0
callq 0x1090
movl 0x2e7d(%rip), %r9d      # 0x40a0
movq %r14, (%rsp)
leaq 0x2e42(%rip), %rsi      # 0x4070
movl $0x2, %edx
movq %rbx, %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x10b0
callq 0x1090
movl 0x2e59(%rip), %edx      # 0x40a4
movl 0x2e4f(%rip), %ecx      # 0x40a0
leaq 0xdb2(%rip), %rdi       # 0x200a
leaq 0xda5(%rip), %rsi       # 0x2004
xorl %eax, %eax
callq 0x1030
leaq 0xdb0(%rip), %r14       # 0x201d
xorl %r15d, %r15d
movq (%r15,%rbx), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x1030
addq $0x8, %r15
cmpq $0x400, %r15            # imm = 0x400
jne 0x1270
movl $0xa, %edi
callq 0x1050
callq 0x1070
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq