LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jkbenaim[P]psfrag/mapfile.c
// Function: MappedFile_Create
struct MappedFile_s MappedFile_Create(char *filename, size_t size)
{
	__label__ out_error, out_ok, out_close;
	struct MappedFile_s m;

	m._fd = open(filename, O_RDWR | O_TRUNC | O_CREAT, S_IRUSR | S_IWUSR);
	if (!m._fd) goto out_error;
	close(m._fd);
	if (truncate(filename, size) < 0) goto out_error;
	m._fd = open(filename, O_RDWR);
	if (!m._fd) goto out_error;

	m.data = mmap(
		NULL,
		size,
		PROT_READ|PROT_WRITE,
		MAP_SHARED,
		m._fd,
		0
	);
	if (m.data == NULL) {
		goto out_close;
	}

	memset(m.data, 0, size);
	m.size = size;

	goto out_ok;

out_close:
	close(m._fd);
out_error:
	m.size = 0;
	m.data = NULL;
out_ok:
	return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x242, %esi            # imm = 0x242
movl $0x180, %edx            # imm = 0x180
movb $0x0, %al
callq 0x82a0
movq -0x18(%rbp), %rdi
movl %eax, 0x10(%rdi)
cmpl $0x0, 0x10(%rdi)
jne 0xa33f
jmp 0xa3e4
movq -0x18(%rbp), %rax
movl 0x10(%rax), %edi
callq 0x8140
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x81e0
cmpl $0x0, %eax
jge 0xa362
jmp 0xa3e4
movq -0x8(%rbp), %rdi
movl $0x2, %esi
movb $0x0, %al
callq 0x82a0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
cmpl $0x0, 0x10(%rax)
jne 0xa383
jmp 0xa3e4
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rsi
movl 0x10(%rax), %r8d
xorl %eax, %eax
movl %eax, %r9d
movl $0x3, %edx
movl $0x1, %ecx
movq %r9, %rdi
callq 0x80b0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, (%rax)
jne 0xa3b8
jmp 0xa3d8
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
xorl %esi, %esi
callq 0x8130
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0xa3f7
movq -0x18(%rbp), %rax
movl 0x10(%rax), %edi
callq 0x8140
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jkbenaim[P]psfrag/mapfile.c
// Function: MappedFile_Open
struct MappedFile_s MappedFile_Open(char *filename, bool writable)
{
	__label__ out_error, out_ok, out_close;
	struct MappedFile_s m;
	struct stat sb;

	if (stat(filename, &sb) == -1) {
		goto out_error;
	}
	m.size = sb.st_size;

	m._fd = open(filename, writable ? O_RDWR : O_RDONLY);
	if (!m._fd) {
		goto out_error;
	}

	m.data = mmap(
		NULL,
		sb.st_size,
		PROT_READ|PROT_WRITE,
		writable ? MAP_SHARED : MAP_PRIVATE,
		m._fd,
		0
	);
	if (m.data == NULL) {
		goto out_close;
	}

	goto out_ok;

out_close:
	close(m._fd);
out_error:
	m.data = NULL;
out_ok:
	return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0xb0(%rbp)
movb %dl, %al
movq %rdi, -0xa8(%rbp)
movq %rsi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x81c0
cmpl $-0x1, %eax
jne 0xa44e
jmp 0xa4e8
movq -0xb0(%rbp), %rax
movq -0x70(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
movb -0x9(%rbp), %cl
xorl %esi, %esi
movl $0x2, %eax
testb $0x1, %cl
cmovnel %eax, %esi
movb $0x0, %al
callq 0x82a0
movl %eax, %ecx
movq -0xb0(%rbp), %rax
movl %ecx, 0x10(%rax)
cmpl $0x0, 0x10(%rax)
jne 0xa48c
jmp 0xa4e8
movq -0xb0(%rbp), %rax
movq -0x70(%rbp), %rsi
movb -0x9(%rbp), %dil
movl $0x2, %ecx
movl $0x1, %edx
testb $0x1, %dil
cmovnel %edx, %ecx
movl 0x10(%rax), %r8d
xorl %eax, %eax
movl %eax, %r9d
movl $0x3, %edx
movq %r9, %rdi
callq 0x80b0
movq %rax, %rcx
movq -0xb0(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, (%rax)
jne 0xa4d7
jmp 0xa4d9
jmp 0xa4f6
movq -0xb0(%rbp), %rax
movl 0x10(%rax), %edi
callq 0x8140
movq -0xb0(%rbp), %rax
movq $0x0, (%rax)
movq -0xa8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jkbenaim[P]psfrag/pcode.c
// Function: get_pcode
char *get_pcode(char pcode[6], uint8_t *rom)
{
	__label__ out;
	if (!rom or !pcode) goto out;
	pcode[0] = rom[0x3b];
	pcode[1] = rom[0x3c];
	pcode[2] = rom[0x3d];
	pcode[3] = rom[0x3e];
	pcode[4] = rom[0x3f] + '0';
	pcode[5] = '\0';
	for (int i=0; i < 4; i++) {
		if (!isalnum(pcode[i]))
			pcode[i] = '_';
		else
			pcode[i] = tolower(pcode[i]);
	}

	if (!isdigit(pcode[4]))
		pcode[4] = '_';

out:
	return pcode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xa55e
cmpq $0x0, -0x8(%rbp)
jne 0xa563
jmp 0xa64a
movq -0x10(%rbp), %rax
movb 0x3b(%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movb 0x3c(%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x10(%rbp), %rax
movb 0x3d(%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x10(%rbp), %rax
movb 0x3e(%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x3(%rax)
movq -0x10(%rbp), %rax
movzbl 0x3f(%rax), %eax
addl $0x30, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x4(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x5(%rax)
movl $0x0, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0xa61f
callq 0x8360
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0xa5f4
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x5f, (%rax,%rcx)
jmp 0xa612
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x8200
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0xa614
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xa5bd
callq 0x8360
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movsbl 0x4(%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0xa648
movq -0x8(%rbp), %rax
movb $0x5f, 0x4(%rax)
jmp 0xa64a
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/jkbenaim[P]psfrag/sqlite3.c
// Function: invokeProfileCallback
static SQLITE_NOINLINE void invokeProfileCallback(sqlite3 *db, Vdbe *p){
  sqlite3_int64 iNow;
  sqlite3_int64 iElapse;
  assert( p->startTime>0 );
  assert( (db->mTrace & (SQLITE_TRACE_PROFILE|SQLITE_TRACE_XPROFILE))!=0 );
  assert( db->init.busy==0 );
  assert( p->zSql!=0 );
  sqlite3OsCurrentTimeInt64(db->pVfs, &iNow);
  iElapse = (iNow - p->startTime)*1000000;
#ifndef SQLITE_OMIT_DEPRECATED
  if( db->xProfile ){
    db->xProfile(db->pProfileArg, p->zSql, iElapse);
  }
#endif
  if( db->mTrace & SQLITE_TRACE_PROFILE ){
    db->xTrace(SQLITE_TRACE_PROFILE, db->pTraceArg, p, (void*)&iElapse);
  }
  p->startTime = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq -0x18(%rbp), %rsi
callq 0x367f0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq 0xb8(%rcx), %rax
imulq $0xf4240, %rax, %rax    # imm = 0xF4240
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0xf0(%rax)
je 0x126ef
movq -0x8(%rbp), %rax
movq 0xf0(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0xf8(%rcx), %rdi
movq -0x10(%rbp), %rcx
movq 0xf0(%rcx), %rsi
movq -0x20(%rbp), %rdx
callq *%rax
movq -0x8(%rbp), %rax
movzbl 0x68(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x12724
movq -0x8(%rbp), %rax
movq 0xe0(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0xe8(%rcx), %rsi
movq -0x10(%rbp), %rdx
movl $0x2, %edi
leaq -0x20(%rbp), %rcx
callq *%rax
movq -0x10(%rbp), %rax
movq $0x0, 0xb8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jkbenaim[P]psfrag/sqlite3.c
// Function: sqlite3VdbeIntValue
SQLITE_PRIVATE i64 sqlite3VdbeIntValue(Mem *pMem){
  int flags;
  assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
  assert( EIGHT_BYTE_ALIGNMENT(pMem) );
  flags = pMem->flags;
  if( flags & (MEM_Int|MEM_IntReal) ){
    testcase( flags & MEM_IntReal );
    return pMem->u.i;
  }else if( flags & MEM_Real ){
    return doubleToInt64(pMem->u.r);
  }else if( flags & (MEM_Str|MEM_Blob) ){
    assert( pMem->z || pMem->n==0 );
    return memIntValue(pMem);
  }else{
    return 0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x8(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
andl $0x24, %eax
cmpl $0x0, %eax
je 0x12e9f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x12edf
movl -0x14(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x12ebd
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
callq 0x3ab20
movq %rax, -0x8(%rbp)
jmp 0x12edf
movl -0x14(%rbp), %eax
andl $0x12, %eax
cmpl $0x0, %eax
je 0x12ed7
movq -0x10(%rbp), %rdi
callq 0x3ab80
movq %rax, -0x8(%rbp)
jmp 0x12edf
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jkbenaim[P]psfrag/sqlite3.c
// Function: sqlite3OomFault
SQLITE_PRIVATE void sqlite3OomFault(sqlite3 *db){
  if( db->mallocFailed==0 && db->bBenignMalloc==0 ){
    db->mallocFailed = 1;
    if( db->nVdbeExec>0 ){
      db->u1.isInterrupted = 1;
    }
    db->lookaside.bDisable++;
    if( db->pParse ){
      db->pParse->rc = SQLITE_NOMEM_BKPT;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x61(%rax), %eax
cmpl $0x0, %eax
jne 0x1401a
movq -0x8(%rbp), %rax
movzbl 0x62(%rax), %eax
cmpl $0x0, %eax
jne 0x1401a
movq -0x8(%rbp), %rax
movb $0x1, 0x61(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0xcc(%rax)
jle 0x13fe5
movq -0x8(%rbp), %rax
movl $0x1, 0x168(%rax)
movq -0x8(%rbp), %rax
movl 0x170(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x170(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x130(%rax)
je 0x14018
movq -0x8(%rbp), %rax
movq 0x130(%rax), %rax
movl $0x7, 0x18(%rax)
jmp 0x1401a
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jkbenaim[P]psfrag/sqlite3.c
// Function: vdbeMemRenderNum
static void vdbeMemRenderNum(int sz, char *zBuf, Mem *p){
  StrAccum acc;
  assert( p->flags & (MEM_Int|MEM_Real|MEM_IntReal) );
  sqlite3StrAccumInit(&acc, 0, zBuf, sz, 0);
  if( p->flags & MEM_Int ){
    sqlite3_str_appendf(&acc, "%lld", p->u.i);
  }else if( p->flags & MEM_IntReal ){
    sqlite3_str_appendf(&acc, "%!.15g", (double)p->u.i);
  }else{
    sqlite3_str_appendf(&acc, "%!.15g", p->u.r);
  }
  assert( acc.zText==zBuf && acc.mxAlloc<=0 );
  zBuf[acc.nChar] = 0; /* Fast version of sqlite3StrAccumFinish(&acc) */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdx
movl -0x4(%rbp), %ecx
leaq -0x38(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %r8d, %r8d
callq 0xe990
movq -0x18(%rbp), %rax
movzwl 0x8(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x3a245
movq -0x18(%rbp), %rax
movq (%rax), %rdx
leaq -0x38(%rbp), %rdi
leaq 0x8441e(%rip), %rsi     # 0xbe65a
movb $0x0, %al
callq 0xedb0
jmp 0x3a28e
movq -0x18(%rbp), %rax
movzwl 0x8(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x3a272
movq -0x18(%rbp), %rax
cvtsi2sdq (%rax), %xmm0
leaq -0x38(%rbp), %rdi
leaq 0x833c3(%rip), %rsi     # 0xbd62c
movb $0x1, %al
callq 0xedb0
jmp 0x3a28c
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
leaq -0x38(%rbp), %rdi
leaq 0x833a7(%rip), %rsi     # 0xbd62c
movb $0x1, %al
callq 0xedb0
jmp 0x3a28e
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
movb $0x0, (%rax,%rcx)
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jkbenaim[P]psfrag/sqlite3.c
// Function: clearSelect
static void clearSelect(sqlite3 *db, Select *p, int bFree){
  while( p ){
    Select *pPrior = p->pPrior;
    sqlite3ExprListDelete(db, p->pEList);
    sqlite3SrcListDelete(db, p->pSrc);
    sqlite3ExprDelete(db, p->pWhere);
    sqlite3ExprListDelete(db, p->pGroupBy);
    sqlite3ExprDelete(db, p->pHaving);
    sqlite3ExprListDelete(db, p->pOrderBy);
    sqlite3ExprDelete(db, p->pLimit);
#ifndef SQLITE_OMIT_WINDOWFUNC
    if( OK_IF_ALWAYS_TRUE(p->pWinDefn) ){
      sqlite3WindowListDelete(db, p->pWinDefn);
    }
    assert( p->pWin==0 );
#endif
    if( OK_IF_ALWAYS_TRUE(p->pWith) ) sqlite3WithDelete(db, p->pWith);
    if( bFree ) sqlite3DbFreeNN(db, p);
    p = pPrior;
    bFree = 1;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x575af
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x57290
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x575c0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x57260
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x57290
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
callq 0x57260
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rsi
callq 0x57290
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rsi
callq 0x57260
movq -0x10(%rbp), %rax
cmpq $0x0, 0x78(%rax)
je 0x5756c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rsi
callq 0x576f0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x68(%rax)
je 0x57588
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rsi
callq 0x57730
cmpl $0x0, -0x14(%rbp)
je 0x5759b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x211f0
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
jmp 0x574c3
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jkbenaim[P]psfrag/sqlite3.c
// Function: sqlite3ExprIdToTrueFalse
SQLITE_PRIVATE int sqlite3ExprIdToTrueFalse(Expr *pExpr){
  assert( pExpr->op==TK_ID || pExpr->op==TK_STRING );
  if( !ExprHasProperty(pExpr, EP_Quoted)
   && (sqlite3StrICmp(pExpr->u.zToken, "true")==0
       || sqlite3StrICmp(pExpr->u.zToken, "false")==0)
  ){
    pExpr->op = TK_TRUEFALSE;
    ExprSetProperty(pExpr, pExpr->u.zToken[4]==0 ? EP_IsTrue : EP_IsFalse);
    return 1;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x4000000, %eax        # imm = 0x4000000
cmpl $0x0, %eax
jne 0x63925
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x5c0f7(%rip), %rsi     # 0xbf9c3
callq 0xf180
cmpl $0x0, %eax
je 0x638ef
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x5c0e3(%rip), %rsi     # 0xbf9c8
callq 0xf180
cmpl $0x0, %eax
jne 0x63925
movq -0x10(%rbp), %rax
movb $-0x5b, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movsbl 0x4(%rax), %edx
movl $0x20000000, %ecx       # imm = 0x20000000
movl $0x10000000, %eax       # imm = 0x10000000
cmpl $0x0, %edx
cmovel %eax, %ecx
movq -0x10(%rbp), %rax
orl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x6392c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jkbenaim[P]psfrag/sqlite3.c
// Function: sqlite3ExprAnd
SQLITE_PRIVATE Expr *sqlite3ExprAnd(Parse *pParse, Expr *pLeft, Expr *pRight){
  sqlite3 *db = pParse->db;
  if( pLeft==0  ){
    return pRight;
  }else if( pRight==0 ){
    return pLeft;
  }else if( ExprAlwaysFalse(pLeft) || ExprAlwaysFalse(pRight) ){
    sqlite3ExprUnmapAndDelete(pParse, pLeft);
    sqlite3ExprUnmapAndDelete(pParse, pRight);
    return sqlite3Expr(db, TK_INTEGER, "0");
  }else{
    return sqlite3PExpr(pParse, TK_AND, pLeft, pRight);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x6d043
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6d0c9
cmpq $0x0, -0x20(%rbp)
jne 0x6d054
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6d0c9
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x20000001, %eax       # imm = 0x20000001
cmpl $0x20000000, %eax       # imm = 0x20000000
je 0x6d07a
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x20000001, %eax       # imm = 0x20000001
cmpl $0x20000000, %eax       # imm = 0x20000000
jne 0x6d0af
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6d160
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6d160
movq -0x28(%rbp), %rdi
movl $0x96, %esi
leaq 0x5215e(%rip), %rdx     # 0xbf202
callq 0x683f0
movq %rax, -0x8(%rbp)
jmp 0x6d0c9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl $0x2c, %esi
callq 0x63670
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jkbenaim[P]psfrag/sqlite3.c
// Function: sqlite3ExprSkipCollate
SQLITE_PRIVATE Expr *sqlite3ExprSkipCollate(Expr *pExpr){
  while( pExpr && ExprHasProperty(pExpr, EP_Skip) ){
    assert( pExpr->op==TK_COLLATE );
    pExpr = pExpr->pLeft;
  }   
  return pExpr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x9(%rbp)
je 0x788e9
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x1000, %eax           # imm = 0x1000
cmpl $0x0, %eax
setne %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0x788f2
jmp 0x78900
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x788c8
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jkbenaim[P]psfrag/sqlite3.c
// Function: sqlite3ExprSkipCollateAndLikely
SQLITE_PRIVATE Expr *sqlite3ExprSkipCollateAndLikely(Expr *pExpr){
  while( pExpr && ExprHasProperty(pExpr, EP_Skip|EP_Unlikely) ){
    if( ExprHasProperty(pExpr, EP_Unlikely) ){
      assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
      assert( pExpr->x.pList->nExpr>0 );
      assert( pExpr->op==TK_FUNCTION );
      pExpr = pExpr->x.pList->a[0].pExpr;
    }else{
      assert( pExpr->op==TK_COLLATE );
      pExpr = pExpr->pLeft;
    }
  }   
  return pExpr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x9(%rbp)
je 0x78ae9
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x41000, %eax          # imm = 0x41000
cmpl $0x0, %eax
setne %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0x78af2
jmp 0x78b23
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x40000, %eax          # imm = 0x40000
cmpl $0x0, %eax
je 0x78b15
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x78b21
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x78ac8
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jkbenaim[P]psfrag/sqlite3.c
// Function: sqlite3ExprAffinity
SQLITE_PRIVATE char sqlite3ExprAffinity(Expr *pExpr){
  int op;
  while( ExprHasProperty(pExpr, EP_Skip) ){
    assert( pExpr->op==TK_COLLATE );
    pExpr = pExpr->pLeft;
    assert( pExpr!=0 );
  }
  op = pExpr->op;
  if( op==TK_SELECT ){
    assert( pExpr->flags&EP_xIsSelect );
    return sqlite3ExprAffinity(pExpr->x.pSelect->pEList->a[0].pExpr);
  }
  if( op==TK_REGISTER ) op = pExpr->op2;
#ifndef SQLITE_OMIT_CAST
  if( op==TK_CAST ){
    assert( !ExprHasProperty(pExpr, EP_IntValue) );
    return sqlite3AffinityType(pExpr->u.zToken, 0);
  }
#endif
  if( (op==TK_AGG_COLUMN || op==TK_COLUMN) && pExpr->y.pTab ){
    return sqlite3TableColumnAffinity(pExpr->y.pTab, pExpr->iColumn);
  }
  if( op==TK_SELECT_COLUMN ){
    assert( pExpr->pLeft->flags&EP_xIsSelect );
    return sqlite3ExprAffinity(
        pExpr->pLeft->x.pSelect->pEList->a[pExpr->iColumn].pExpr
    );
  }
  return pExpr->affExpr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x1000, %eax           # imm = 0x1000
cmpl $0x0, %eax
je 0x78bfb
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x78bdc
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x86, -0x14(%rbp)
jne 0x78c2a
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdi
callq 0x78bd0
movb %al, -0x1(%rbp)
jmp 0x78cd4
cmpl $0xab, -0x14(%rbp)
jne 0x78c3e
movq -0x10(%rbp), %rax
movzbl 0x36(%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x24, -0x14(%rbp)
jne 0x78c5a
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x76020
movb %al, -0x1(%rbp)
jmp 0x78cd4
cmpl $0xa4, -0x14(%rbp)
je 0x78c6c
cmpl $0xa2, -0x14(%rbp)
jne 0x78c91
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x78c91
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x10(%rbp), %rax
movswl 0x30(%rax), %esi
callq 0x75c10
movb %al, -0x1(%rbp)
jmp 0x78cd4
cmpl $0xad, -0x14(%rbp)
jne 0x78cca
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
addq $0x8, %rax
movq -0x10(%rbp), %rcx
movswq 0x30(%rcx), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x78bd0
movb %al, -0x1(%rbp)
jmp 0x78cd4
movq -0x10(%rbp), %rax
movb 0x1(%rax), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jkbenaim[P]psfrag/sqlite3.c
// Function: sqlite3WindowCompare
SQLITE_PRIVATE int sqlite3WindowCompare(Parse *pParse, Window *p1, Window *p2, int bFilter){
  if( p1->eFrmType!=p2->eFrmType ) return 1;
  if( p1->eStart!=p2->eStart ) return 1;
  if( p1->eEnd!=p2->eEnd ) return 1;
  if( p1->eExclude!=p2->eExclude ) return 1;
  if( sqlite3ExprCompare(pParse, p1->pStart, p2->pStart, -1) ) return 1;
  if( sqlite3ExprCompare(pParse, p1->pEnd, p2->pEnd, -1) ) return 1;
  if( sqlite3ExprListCompare(p1->pPartition, p2->pPartition, -1) ) return 1;
  if( sqlite3ExprListCompare(p1->pOrderBy, p2->pOrderBy, -1) ) return 1;
  if( bFilter ){
    if( sqlite3ExprCompare(pParse, p1->pFilter, p2->pFilter, -1) ) return 1;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x18(%rbp), %rax
movzbl 0x20(%rax), %eax
movq -0x20(%rbp), %rcx
movzbl 0x20(%rcx), %ecx
cmpl %ecx, %eax
je 0x79af7
movl $0x1, -0x4(%rbp)
jmp 0x79c40
movq -0x18(%rbp), %rax
movzbl 0x21(%rax), %eax
movq -0x20(%rbp), %rcx
movzbl 0x21(%rcx), %ecx
cmpl %ecx, %eax
je 0x79b17
movl $0x1, -0x4(%rbp)
jmp 0x79c40
movq -0x18(%rbp), %rax
movzbl 0x22(%rax), %eax
movq -0x20(%rbp), %rcx
movzbl 0x22(%rcx), %ecx
cmpl %ecx, %eax
je 0x79b37
movl $0x1, -0x4(%rbp)
jmp 0x79c40
movq -0x18(%rbp), %rax
movzbl 0x24(%rax), %eax
movq -0x20(%rbp), %rcx
movzbl 0x24(%rcx), %ecx
cmpl %ecx, %eax
je 0x79b57
movl $0x1, -0x4(%rbp)
jmp 0x79c40
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x79550
cmpl $0x0, %eax
je 0x79b86
movl $0x1, -0x4(%rbp)
jmp 0x79c40
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x79550
cmpl $0x0, %eax
je 0x79bb5
movl $0x1, -0x4(%rbp)
jmp 0x79c40
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x79c50
cmpl $0x0, %eax
je 0x79bdd
movl $0x1, -0x4(%rbp)
jmp 0x79c40
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x79c50
cmpl $0x0, %eax
je 0x79c05
movl $0x1, -0x4(%rbp)
jmp 0x79c40
cmpl $0x0, -0x24(%rbp)
je 0x79c39
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x79550
cmpl $0x0, %eax
je 0x79c37
movl $0x1, -0x4(%rbp)
jmp 0x79c40
jmp 0x79c39
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jkbenaim[P]psfrag/sqlite3.c
// Function: sqlite3ExprListCompare
SQLITE_PRIVATE int sqlite3ExprListCompare(ExprList *pA, ExprList *pB, int iTab){
  int i;
  if( pA==0 && pB==0 ) return 0;
  if( pA==0 || pB==0 ) return 1;
  if( pA->nExpr!=pB->nExpr ) return 1;
  for(i=0; i<pA->nExpr; i++){
    Expr *pExprA = pA->a[i].pExpr;
    Expr *pExprB = pB->a[i].pExpr;
    if( pA->a[i].sortFlags!=pB->a[i].sortFlags ) return 1;
    if( sqlite3ExprCompare(0, pExprA, pExprB, iTab) ) return 1;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x79c7d
cmpq $0x0, -0x18(%rbp)
jne 0x79c7d
movl $0x0, -0x4(%rbp)
jmp 0x79d6f
cmpq $0x0, -0x10(%rbp)
je 0x79c8b
cmpq $0x0, -0x18(%rbp)
jne 0x79c97
movl $0x1, -0x4(%rbp)
jmp 0x79d6f
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
je 0x79cb1
movl $0x1, -0x4(%rbp)
jmp 0x79d6f
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x79d68
movq -0x10(%rbp), %rax
addq $0x8, %rax
movslq -0x20(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
addq $0x8, %rax
movslq -0x20(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movslq -0x20(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movzbl 0x18(%rax), %eax
movq -0x18(%rbp), %rcx
addq $0x8, %rcx
movslq -0x20(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
movzbl 0x18(%rcx), %ecx
cmpl %ecx, %eax
je 0x79d36
movl $0x1, -0x4(%rbp)
jmp 0x79d6f
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movl -0x1c(%rbp), %ecx
xorl %eax, %eax
movl %eax, %edi
callq 0x79550
cmpl $0x0, %eax
je 0x79d58
movl $0x1, -0x4(%rbp)
jmp 0x79d6f
jmp 0x79d5a
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x79cb8
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jkbenaim[P]psfrag/sqlite3.c
// Function: sqlite3WindowDup
SQLITE_PRIVATE Window *sqlite3WindowDup(sqlite3 *db, Expr *pOwner, Window *p){
  Window *pNew = 0;
  if( ALWAYS(p) ){
    pNew = sqlite3DbMallocZero(db, sizeof(Window));
    if( pNew ){
      pNew->zName = sqlite3DbStrDup(db, p->zName);
      pNew->zBase = sqlite3DbStrDup(db, p->zBase);
      pNew->pFilter = sqlite3ExprDup(db, p->pFilter, 0);
      pNew->pFunc = p->pFunc;
      pNew->pPartition = sqlite3ExprListDup(db, p->pPartition, 0);
      pNew->pOrderBy = sqlite3ExprListDup(db, p->pOrderBy, 0);
      pNew->eFrmType = p->eFrmType;
      pNew->eEnd = p->eEnd;
      pNew->eStart = p->eStart;
      pNew->eExclude = p->eExclude;
      pNew->regResult = p->regResult;
      pNew->pStart = sqlite3ExprDup(db, p->pStart, 0);
      pNew->pEnd = sqlite3ExprDup(db, p->pEnd, 0);
      pNew->pOwner = pOwner;
      pNew->bImplicitFrame = p->bImplicitFrame;
    }
  }
  return pNew;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x7bf82
movq -0x8(%rbp), %rdi
movl $0x90, %esi
callq 0x148f0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x7bf80
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x14570
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x14570
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rsi
xorl %edx, %edx
callq 0x77a40
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
xorl %edx, %edx
callq 0x7bb50
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
xorl %edx, %edx
callq 0x7bb50
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movb 0x20(%rax), %cl
movq -0x20(%rbp), %rax
movb %cl, 0x20(%rax)
movq -0x18(%rbp), %rax
movb 0x22(%rax), %cl
movq -0x20(%rbp), %rax
movb %cl, 0x22(%rax)
movq -0x18(%rbp), %rax
movb 0x21(%rax), %cl
movq -0x20(%rbp), %rax
movb %cl, 0x21(%rax)
movq -0x18(%rbp), %rax
movb 0x24(%rax), %cl
movq -0x20(%rbp), %rax
movb %cl, 0x24(%rax)
movq -0x18(%rbp), %rax
movl 0x60(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x60(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rsi
xorl %edx, %edx
callq 0x77a40
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rsi
xorl %edx, %edx
callq 0x77a40
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x70(%rax)
movq -0x18(%rbp), %rax
movb 0x23(%rax), %cl
movq -0x20(%rbp), %rax
movb %cl, 0x23(%rax)
jmp 0x7bf82
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jkbenaim[P]psfrag/sqlite3.c
// Function: sqlite3CheckObjectName
SQLITE_PRIVATE int sqlite3CheckObjectName(
  Parse *pParse,            /* Parsing context */
  const char *zName,        /* Name of the object to check */
  const char *zType,        /* Type of this object */
  const char *zTblName      /* Parent table name for triggers and indexes */
){
  sqlite3 *db = pParse->db;
  if( sqlite3WritableSchema(db) || db->init.imposterTable ){
    /* Skip these error checks for writable_schema=ON */
    return SQLITE_OK;
  }
  if( db->init.busy ){
    if( sqlite3_stricmp(zType, db->init.azInit[0])
     || sqlite3_stricmp(zName, db->init.azInit[1])
     || sqlite3_stricmp(zTblName, db->init.azInit[2])
    ){
      if( sqlite3Config.bExtraSchemaChecks ){
        sqlite3ErrorMsg(pParse, ""); /* corruptSchema() will supply the error */
        return SQLITE_ERROR;
      }
    }
  }else{
    if( pParse->nested==0 
     && 0==sqlite3StrNICmp(zName, "sqlite_", 7)
    ){
      sqlite3ErrorMsg(pParse, "object name reserved for internal use: %s",
                      zName);
      return SQLITE_ERROR;
    }
  }
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x321b0
cmpl $0x0, %eax
jne 0x7cdc7
movq -0x30(%rbp), %rax
movb 0xb6(%rax), %al
shrb %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x7cdd3
movl $0x0, -0x4(%rbp)
jmp 0x7ceb0
movq -0x30(%rbp), %rax
cmpb $0x0, 0xb5(%rax)
je 0x7ce5e
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0xb8(%rax), %rax
movq (%rax), %rsi
callq 0xf120
cmpl $0x0, %eax
jne 0x7ce36
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0xb8(%rax), %rax
movq 0x8(%rax), %rsi
callq 0xf120
cmpl $0x0, %eax
jne 0x7ce36
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0xb8(%rax), %rax
movq 0x10(%rax), %rsi
callq 0xf120
cmpl $0x0, %eax
je 0x7ce5c
cmpb $0x0, 0x5e44c(%rip)     # 0xdb289
je 0x7ce5a
movq -0x10(%rbp), %rdi
leaq 0x39c00(%rip), %rsi     # 0xb6a4a
movb $0x0, %al
callq 0x16bd0
movl $0x1, -0x4(%rbp)
jmp 0x7ceb0
jmp 0x7ce5c
jmp 0x7cea9
movq -0x10(%rbp), %rax
movzbl 0x1e(%rax), %eax
cmpl $0x0, %eax
jne 0x7cea7
movq -0x18(%rbp), %rdi
leaq 0x421f5(%rip), %rsi     # 0xbf06b
movl $0x7, %edx
callq 0xf210
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x7cea7
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x421dc(%rip), %rsi     # 0xbf073
movb $0x0, %al
callq 0x16bd0
movl $0x1, -0x4(%rbp)
jmp 0x7ceb0
jmp 0x7cea9
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jkbenaim[P]psfrag/sqlite3.c
// Function: isShadowTableName
static int isShadowTableName(sqlite3 *db, char *zName){
  char *zTail;                  /* Pointer to the last "_" in zName */
  Table *pTab;                  /* Table that zName is a shadow of */
  Module *pMod;                 /* Module for the virtual table */

  zTail = strrchr(zName, '_');
  if( zTail==0 ) return 0;
  *zTail = 0;
  pTab = sqlite3FindTable(db, zName, 0);
  *zTail = '_';
  if( pTab==0 ) return 0;
  if( !IsVirtual(pTab) ) return 0;
  pMod = (Module*)sqlite3HashFind(&db->aModule, pTab->azModuleArg[0]);
  if( pMod==0 ) return 0;
  if( pMod->pModule->iVersion<3 ) return 0;
  if( pMod->pModule->xShadowName==0 ) return 0;
  return pMod->pModule->xShadowName(zTail+1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x5f, %esi
callq 0x8100
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x7d035
movl $0x0, -0x4(%rbp)
jmp 0x7d0f7
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x1f130
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movb $0x5f, (%rax)
cmpq $0x0, -0x28(%rbp)
jne 0x7d06b
movl $0x0, -0x4(%rbp)
jmp 0x7d0f7
movq -0x28(%rbp), %rax
cmpl $0x0, 0x54(%rax)
jne 0x7d07e
movl $0x0, -0x4(%rbp)
jmp 0x7d0f7
movq -0x10(%rbp), %rdi
addq $0x1d0, %rdi            # imm = 0x1D0
movq -0x28(%rbp), %rax
movq 0x58(%rax), %rax
movq (%rax), %rsi
callq 0x56670
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x7d0ad
movl $0x0, -0x4(%rbp)
jmp 0x7d0f7
movq -0x30(%rbp), %rax
movq (%rax), %rax
cmpl $0x3, (%rax)
jge 0x7d0c2
movl $0x0, -0x4(%rbp)
jmp 0x7d0f7
movq -0x30(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0xb8(%rax)
jne 0x7d0dc
movl $0x0, -0x4(%rbp)
jmp 0x7d0f7
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq 0xb8(%rax), %rax
movq -0x20(%rbp), %rdi
addq $0x1, %rdi
callq *%rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jkbenaim[P]psfrag/sqlite3.c
// Function: sqlite3ResolveSelfReference
SQLITE_PRIVATE int sqlite3ResolveSelfReference(
  Parse *pParse,      /* Parsing context */
  Table *pTab,        /* The table being referenced, or NULL */
  int type,           /* NC_IsCheck or NC_PartIdx or NC_IdxExpr, or 0 */
  Expr *pExpr,        /* Expression to resolve.  May be NULL. */
  ExprList *pList     /* Expression list to resolve.  May be NULL. */
){
  SrcList sSrc;                   /* Fake SrcList for pParse->pNewTable */
  NameContext sNC;                /* Name context for pParse->pNewTable */
  int rc;

  assert( type==0 || pTab!=0 );
  assert( type==NC_IsCheck || type==NC_PartIdx || type==NC_IdxExpr || pTab==0 );
  memset(&sNC, 0, sizeof(sNC));
  memset(&sSrc, 0, sizeof(sSrc));
  if( pTab ){
    sSrc.nSrc = 1;
    sSrc.a[0].zName = pTab->zName;
    sSrc.a[0].pTab = pTab;
    sSrc.a[0].iCursor = -1;
  }
  sNC.pParse = pParse;
  sNC.pSrcList = &sSrc;
  sNC.ncFlags = type | NC_IsDDL;
  if( (rc = sqlite3ResolveExprNames(&sNC, pExpr))!=SQLITE_OK ) return rc;
  if( pList ) rc = sqlite3ResolveExprListNames(&sNC, pList);
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
leaq -0xe0(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x8130
leaq -0xa8(%rbp), %rdi
xorl %esi, %esi
movl $0x78, %edx
callq 0x8130
cmpq $0x0, -0x18(%rbp)
je 0x7d742
movl $0x1, -0xa8(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
movl $0xffffffff, -0x60(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movq %rax, -0xe0(%rbp)
leaq -0xa8(%rbp), %rax
movq %rax, -0xd8(%rbp)
movl -0x1c(%rbp), %eax
orl $0x10000, %eax          # imm = 0x10000
movl %eax, -0xb8(%rbp)
movq -0x28(%rbp), %rsi
leaq -0xe0(%rbp), %rdi
callq 0x7e480
movl %eax, -0xe4(%rbp)
cmpl $0x0, %eax
je 0x7d78f
movl -0xe4(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7d7b5
cmpq $0x0, -0x30(%rbp)
je 0x7d7ac
movq -0x30(%rbp), %rsi
leaq -0xe0(%rbp), %rdi
callq 0x7e5b0
movl %eax, -0xe4(%rbp)
movl -0xe4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jkbenaim[P]psfrag/sqlite3.c
// Function: sqlite3TableAffinity
SQLITE_PRIVATE void sqlite3TableAffinity(Vdbe *v, Table *pTab, int iReg){
  int i;
  char *zColAff = pTab->zColAff;
  if( zColAff==0 ){
    sqlite3 *db = sqlite3VdbeDb(v);
    zColAff = (char *)sqlite3DbMallocRaw(0, pTab->nCol+1);
    if( !zColAff ){
      sqlite3OomFault(db);
      return;
    }

    for(i=0; i<pTab->nCol; i++){
      assert( pTab->aCol[i].affinity!=0 );
      zColAff[i] = pTab->aCol[i].affinity;
    }
    do{
      zColAff[i--] = 0;
    }while( i>=0 && zColAff[i]<=SQLITE_AFF_BLOB );
    pTab->zColAff = zColAff;
  }
  assert( zColAff!=0 );
  i = sqlite3Strlen30NN(zColAff);
  if( i ){
    if( iReg ){
      sqlite3VdbeAddOp4(v, OP_Affinity, iReg, i, 0, zColAff, i);
    }else{
      sqlite3VdbeChangeP4(v, -1, zColAff, i);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x7dbc4
movq -0x8(%rbp), %rdi
callq 0x5cb60
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movswl 0x46(%rax), %eax
addl $0x1, %eax
movslq %eax, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x18870
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x7db37
movq -0x28(%rbp), %rdi
callq 0x13fa0
jmp 0x7dc1c
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
movswl 0x46(%rcx), %ecx
cmpl %ecx, %eax
jge 0x7db79
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x18(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movb 0x19(%rax), %dl
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x7db3e
jmp 0x7db7b
movq -0x20(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, %edx
addl $-0x1, %edx
movl %edx, -0x18(%rbp)
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
xorl %eax, %eax
cmpl $0x0, -0x18(%rbp)
movb %al, -0x29(%rbp)
jl 0x7dbb1
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x41, %eax
setle %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x7db7b
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rdi
callq 0x80a0
andq $0x3fffffff, %rax       # imm = 0x3FFFFFFF
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x7dc1c
cmpl $0x0, -0x14(%rbp)
je 0x7dc05
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
movq -0x20(%rbp), %r9
movl -0x18(%rbp), %eax
movl $0x5b, %esi
xorl %r8d, %r8d
movl %eax, (%rsp)
callq 0x73d90
jmp 0x7dc1a
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl -0x18(%rbp), %ecx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x17190
jmp 0x7dc1c
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jkbenaim[P]psfrag/sqlite3.c
// Function: exprSrcCount
static int exprSrcCount(Walker *pWalker, Expr *pExpr){
  /* The NEVER() on the second term is because sqlite3FunctionUsesThisSrc()
  ** is always called before sqlite3ExprAnalyzeAggregates() and so the
  ** TK_COLUMNs have not yet been converted into TK_AGG_COLUMN.  If
  ** sqlite3FunctionUsesThisSrc() is used differently in the future, the
  ** NEVER() will need to be removed. */
  if( pExpr->op==TK_COLUMN || NEVER(pExpr->op==TK_AGG_COLUMN) ){
    int i;
    struct SrcCount *p = pWalker->u.pSrcCount;
    SrcList *pSrc = p->pSrc;
    int nSrc = pSrc ? pSrc->nSrc : 0;
    for(i=0; i<nSrc; i++){
      if( pExpr->iTable==pSrc->a[i].iCursor ) break;
    }
    if( i<nSrc ){
      p->nThis++;
    }else if( nSrc==0 || pExpr->iTable<pSrc->a[0].iCursor ){
      /* In a well-formed parse tree (no name resolution errors),
      ** TK_COLUMN nodes with smaller Expr.iTable values are in an
      ** outer context.  Those are the only ones to count as "other" */
      p->nOther++;
    }
  }
  return WRC_Continue;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xa2, %eax
je 0x8120c
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xa4, %eax
jne 0x812bd
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x81235
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x30(%rbp)
jmp 0x8123c
xorl %eax, %eax
movl %eax, -0x30(%rbp)
jmp 0x8123c
movl -0x30(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x8127f
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %eax
movq -0x28(%rbp), %rcx
addq $0x8, %rcx
movslq -0x14(%rbp), %rdx
imulq $0x70, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x40(%rcx), %eax
jne 0x81272
jmp 0x8127f
jmp 0x81274
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x81249
movl -0x14(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x81296
movq -0x20(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
jmp 0x812bb
cmpl $0x0, -0x2c(%rbp)
je 0x812ac
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x48(%rcx), %eax
jge 0x812b9
movq -0x20(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
jmp 0x812bb
jmp 0x812bd
xorl %eax, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jkbenaim[P]psfrag/sqlite3.c
// Function: sqlite3RenameExprUnmap
SQLITE_PRIVATE void sqlite3RenameExprUnmap(Parse *pParse, Expr *pExpr){
  Walker sWalker;
  memset(&sWalker, 0, sizeof(Walker));
  sWalker.pParse = pParse;
  sWalker.xExprCallback = renameUnmapExprCb;
  sWalker.xSelectCallback = renameUnmapSelectCb;
  sqlite3WalkExpr(&sWalker, pExpr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x8130
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0x31(%rip), %rax        # 0x850c0
movq %rax, -0x38(%rbp)
leaq 0x66(%rip), %rax        # 0x85100
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x78f80
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jkbenaim[P]psfrag/sqlite3.c
// Function: renameUnmapSelectCb
static int renameUnmapSelectCb(Walker *pWalker, Select *p){
  Parse *pParse = pWalker->pParse;
  int i;
  if( ALWAYS(p->pEList) ){
    ExprList *pList = p->pEList;
    for(i=0; i<pList->nExpr; i++){
      if( pList->a[i].zName ){
        sqlite3RenameTokenRemap(pParse, 0, (void*)pList->a[i].zName);
      }
    }
  }
  if( ALWAYS(p->pSrc) ){  /* Every Select as a SrcList, even if it is empty */
    SrcList *pSrc = p->pSrc;
    for(i=0; i<pSrc->nSrc; i++){
      sqlite3RenameTokenRemap(pParse, 0, (void*)pSrc->a[i].zName);
    }
  }
  return WRC_Continue;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x8518f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x8518d
movq -0x28(%rbp), %rax
addq $0x8, %rax
movslq -0x1c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
je 0x85180
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
addq $0x8, %rax
movslq -0x1c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x7e140
jmp 0x85182
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x85137
jmp 0x8518f
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x851e9
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x851e7
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rax
addq $0x8, %rax
movslq -0x1c(%rbp), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x7e140
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x851ad
jmp 0x851e9
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jkbenaim[P]psfrag/sqlite3.c
// Function: destroyRootPage
static void destroyRootPage(Parse *pParse, int iTable, int iDb){
  Vdbe *v = sqlite3GetVdbe(pParse);
  int r1 = sqlite3GetTempReg(pParse);
  if( iTable<2 ) sqlite3ErrorMsg(pParse, "corrupt schema");
  sqlite3VdbeAddOp3(v, OP_Destroy, iTable, r1, iDb);
  sqlite3MayAbort(pParse);
#ifndef SQLITE_OMIT_AUTOVACUUM
  /* OP_Destroy stores an in integer r1. If this integer
  ** is non-zero, then it is the root page number of a table moved to
  ** location iTable. The following code modifies the sqlite_master table to
  ** reflect this.
  **
  ** The "#NNN" in the SQL is a special constant that means whatever value
  ** is in register NNN.  See grammar rules associated with the TK_REGISTER
  ** token for additional information.
  */
  sqlite3NestedParse(pParse, 
     "UPDATE %Q.%s SET rootpage=%d WHERE #%d AND rootpage=#%d",
     pParse->db->aDb[iDb].zDbSName, MASTER_NAME, iTable, r1, r1);
#endif
  sqlite3ReleaseTempReg(pParse, r1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x73cc0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x78b30
movl %eax, -0x1c(%rbp)
cmpl $0x2, -0xc(%rbp)
jge 0x86f03
movq -0x8(%rbp), %rdi
leaq 0x38f40(%rip), %rsi     # 0xbfe3c
movb $0x0, %al
callq 0x16bd0
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %edx
movl -0x1c(%rbp), %ecx
movl -0x10(%rbp), %r8d
movl $0x88, %esi
callq 0x5ad80
movq -0x8(%rbp), %rdi
callq 0x77f70
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rax
movslq -0x10(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rdx
movl -0xc(%rbp), %r8d
movl -0x1c(%rbp), %r9d
movl -0x1c(%rbp), %eax
leaq 0x38ef8(%rip), %rsi     # 0xbfe4b
leaq 0x36e2e(%rip), %rcx     # 0xbdd88
movl %eax, (%rsp)
movb $0x0, %al
callq 0x7de90
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x78060
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jkbenaim[P]psfrag/sqlite3.c
// Function: sqlite3ExprImpliesNonNullRow
SQLITE_PRIVATE int sqlite3ExprImpliesNonNullRow(Expr *p, int iTab){
  Walker w;
  p = sqlite3ExprSkipCollateAndLikely(p);
  while( p ){
    if( p->op==TK_NOTNULL ){
      p = p->pLeft;
    }else if( p->op==TK_AND ){
      if( sqlite3ExprImpliesNonNullRow(p->pLeft, iTab) ) return 1;
      p = p->pRight;
    }else{
      break;
    }
  }
  w.xExprCallback = impliesNotNullRow;
  w.xSelectCallback = 0;
  w.xSelectCallback2 = 0;
  w.eCode = 0;
  w.u.iCur = iTab;
  sqlite3WalkExpr(&w, p);
  return w.eCode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x78ac0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x8795b
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x33, %eax
jne 0x8791d
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x87959
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x2c, %eax
jne 0x87955
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0x14(%rbp), %esi
callq 0x878e0
cmpl $0x0, %eax
je 0x87947
movl $0x1, -0x4(%rbp)
jmp 0x87994
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x87957
jmp 0x8795b
jmp 0x87959
jmp 0x878fc
leaq 0x667e(%rip), %rax      # 0x8dfe0
movq %rax, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movb $0x0, -0x24(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x78f80
movzbl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)