LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/jkbenaim[P]psfrag/db.c
// Function: DB_FragSearch
int DB_FragSearch(sqlite3 *db, uint8_t *data, ssize_t size)
{
	int rc = SQLITE_OK;
	char pcode[6] = {0};
	get_pcode(pcode, data);
	DB_Begin(db);
	for (ssize_t i = 0; i < (size - 15); i += 16) {
		struct fragment_s *frag = (struct fragment_s *)(data + i);
		if (!isfrag(frag)) continue;
		rc = DB_AddFrag(
			db,
			pcode,
			i,
			get_frag_num(frag),
			get_entrypoint(frag),
			ntohl(frag->offset_code),
			ntohl(frag->offset_relocs),
			ntohl(frag->romsize),
			ntohl(frag->ramsize),
			get_vma(frag)
		);
		if (rc != SQLITE_OK) {
			break;
		}
	}
	DB_End(db);
	return rc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rsi, %r15
leaq 0x18(%rsp), %rax
andw $0x0, 0x4(%rax)
movq %rdi, %rbx
andl $0x0, (%rax)
movq %rax, %rdi
callq 0x9860
movq %rbx, 0x8(%rsp)
movq %rbx, %rdi
callq 0x92d9
addq $-0xf, %r14
xorl %ebp, %ebp
movq %r14, 0x20(%rsp)
movq %r15, 0x10(%rsp)
cmpq %r14, %rbp
jge 0x968d
leaq (%r15,%rbp), %r13
movq %r13, %rdi
callq 0x9701
testb %al, %al
je 0x9684
movq %r13, %rdi
callq 0x96b0
cltq
movq %rax, 0x30(%rsp)
movq %r13, %rdi
callq 0x96df
movl %eax, %eax
movq %rax, 0x28(%rsp)
movl 0x10(%r15,%rbp), %r14d
movl 0x14(%r15,%rbp), %r12d
bswapl %r14d
bswapl %r12d
movl 0x18(%r15,%rbp), %ebx
bswapl %ebx
movq 0x10(%rsp), %rax
movl 0x1c(%rax,%rbp), %r15d
bswapl %r15d
movq %r13, %rdi
callq 0x96f0
movl %eax, %eax
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
movq %rbp, %rdx
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %r8
movq %r14, %r9
movq 0x20(%rsp), %r14
pushq %rax
pushq %r15
movq 0x20(%rsp), %r15
pushq %rbx
pushq %r12
callq 0x92ff
addq $0x20, %rsp
testl %eax, %eax
jne 0x9691
addq $0x10, %rbp
jmp 0x95e4
xorl %ebx, %ebx
jmp 0x9693
movl %eax, %ebx
movq 0x8(%rsp), %rdi
callq 0x92ec
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
movl $0x242, %esi            # imm = 0x242
movl $0x180, %edx            # imm = 0x180
xorl %eax, %eax
callq 0x82a0
movl %eax, 0x10(%rbx)
testl %eax, %eax
je 0x97a7
movl %eax, %edi
callq 0x8140
movq %r15, %rdi
movq %r14, %rsi
callq 0x81e0
testl %eax, %eax
js 0x97a7
pushq $0x2
popq %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x82a0
movl %eax, 0x10(%rbx)
testl %eax, %eax
je 0x97a7
movl %eax, %ebp
pushq $0x3
popq %rdx
pushq $0x1
popq %rcx
xorl %edi, %edi
movq %r14, %rsi
movl %eax, %r8d
xorl %r9d, %r9d
callq 0x80c0
movq %rax, (%rbx)
testq %rax, %rax
je 0x97a0
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x8130
movq %r14, 0x8(%rbx)
jmp 0x97ad
movl %ebp, %edi
callq 0x8140
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %rsi
movq %r15, %rdi
callq 0x81c0
cmpl $-0x1, %eax
je 0x982e
movq 0x30(%rsp), %r14
movq %r14, 0x8(%rbx)
movzbl %bpl, %r12d
leal (%r12,%r12), %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x82a0
movl %eax, 0x10(%rbx)
testl %eax, %eax
je 0x982e
movl %eax, %ebp
pushq $0x2
popq %rcx
subl %r12d, %ecx
pushq $0x3
popq %rdx
xorl %edi, %edi
movq %r14, %rsi
movl %eax, %r8d
xorl %r9d, %r9d
callq 0x80c0
movq %rax, (%rbx)
testq %rax, %rax
jne 0x9832
movl %ebp, %edi
callq 0x8140
andq $0x0, (%rbx)
movq %rbx, %rax
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x98e5
movb 0x3b(%rsi), %al
movb %al, (%rbx)
movb 0x3c(%rsi), %al
movb %al, 0x1(%rbx)
movb 0x3d(%rsi), %al
movb %al, 0x2(%rbx)
movb 0x3e(%rsi), %al
movb %al, 0x3(%rbx)
movb 0x3f(%rsi), %al
addb $0x30, %al
movb %al, 0x4(%rbx)
movb $0x0, 0x5(%rbx)
xorl %r15d, %r15d
callq 0x8380
movq %rax, %r14
movq (%r14), %rax
cmpq $0x4, %r15
je 0x98d5
movsbq (%rbx,%r15), %r12
movb $0x5f, %cl
testb $0x8, (%rax,%r12,2)
je 0x98cc
callq 0x8370
movq (%rax), %rax
movb (%rax,%r12,4), %cl
movb %cl, (%rbx,%r15)
incq %r15
jmp 0x98a9
movsbq 0x4(%rbx), %rcx
testb $0x8, 0x1(%rax,%rcx,2)
jne 0x98e5
movb $0x5f, 0x4(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0x2482e
movq (%r15), %rax
subq 0xb8(%rbx), %rax
imulq $0xf4240, %rax, %rdx    # imm = 0xF4240
movq %rdx, (%rsp)
movq 0xf0(%r14), %rax
testq %rax, %rax
je 0xf332
movq 0xf8(%r14), %rdi
movq 0xf0(%rbx), %rsi
callq *%rax
testb $0x2, 0x68(%r14)
je 0xf350
movq 0xe8(%r14), %rsi
pushq $0x2
popq %rdi
movq %rsp, %rcx
movq %rbx, %rdx
callq *0xe0(%r14)
andq $0x0, 0xb8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
cmpb $0x0, 0x61(%rdi)
je 0xfde7
retq
cmpb $0x0, 0x62(%rdi)
jne 0xfde6
movb $0x1, 0x61(%rdi)
cmpl $0x0, 0xcc(%rdi)
jle 0xfe04
movl $0x1, 0x168(%rdi)
incl 0x170(%rdi)
movq 0x130(%rdi), %rax
testq %rax, %rax
je 0xfde6
movl $0x7, 0x18(%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/jkbenaim[P]psfrag/sqlite3.c
// Function: columnName
static const void *columnName(
  sqlite3_stmt *pStmt,     /* The statement */
  int N,                   /* Which column to get the name for */
  int useUtf16,            /* True to return the name as UTF16 */
  int useType              /* What type of name */
){
  const void *ret;
  Vdbe *p;
  int n;
  sqlite3 *db;
#ifdef SQLITE_ENABLE_API_ARMOR
  if( pStmt==0 ){
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif
  ret = 0;
  p = (Vdbe *)pStmt;
  db = p->db;
  assert( db!=0 );
  n = sqlite3_column_count(pStmt);
  if( N<n && N>=0 ){
    N += useType*n;
    sqlite3_mutex_enter(db->mutex);
    assert( db->mallocFailed==0 );
#ifndef SQLITE_OMIT_UTF16
    if( useUtf16 ){
      ret = sqlite3_value_text16((sqlite3_value*)&p->aColName[N]);
    }else
#endif
    {
      ret = sqlite3_value_text((sqlite3_value*)&p->aColName[N]);
    }
    /* A malloc may have failed inside of the _text() call. If this
    ** is the case, clear the mallocFailed flag and return NULL.
    */
    if( db->mallocFailed ){
      sqlite3OomClear(db);
      ret = 0;
    }
    sqlite3_mutex_leave(db->mutex);
  }
  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movzwl 0xc0(%rdi), %r15d
cmpl %esi, %r15d
jbe 0x10e26
movl %edx, %ebp
movq %rdi, %r14
movq (%rdi), %rbx
imull %ecx, %r15d
addl %esi, %r15d
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x10e0d
callq *0x8c503(%rip)          # 0x9d310
movl %r15d, %eax
imulq $0x38, %rax, %rdi
addq 0x98(%r14), %rdi
testl %ebp, %ebp
je 0x10e2b
callq 0xf72c
jmp 0x10e30
xorl %r14d, %r14d
jmp 0x10e53
callq 0xf623
movq %rax, %r14
cmpb $0x0, 0x61(%rbx)
je 0x10e44
movq %rbx, %rdi
callq 0x17149
xorl %r14d, %r14d
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x10e53
callq *0x8c4cd(%rip)          # 0x9d320
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jkbenaim[P]psfrag/sqlite3.c
// Function: sqlite3_blob_close
SQLITE_API int sqlite3_blob_close(sqlite3_blob *pBlob){
  Incrblob *p = (Incrblob *)pBlob;
  int rc;
  sqlite3 *db;

  if( p ){
    sqlite3_stmt *pStmt = p->pStmt;
    db = p->db;
    sqlite3_mutex_enter(db->mutex);
    sqlite3DbFree(db, p);
    sqlite3_mutex_leave(db->mutex);
    rc = sqlite3_finalize(pStmt);
  }else{
    rc = SQLITE_OK;
  }
  return rc;
}

// Assembly:
testq %rdi, %rdi
je 0x12af3
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rbx
movq 0x20(%rdi), %r15
movq 0x18(%r15), %rdi
testq %rdi, %rdi
je 0x12acc
callq *0x8a844(%rip)          # 0x9d310
movq %r15, %rdi
movq %r14, %rsi
callq 0x18e0a
movq 0x18(%r15), %rdi
testq %rdi, %rdi
je 0x12ae6
callq *0x8a83a(%rip)          # 0x9d320
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xf24e
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/jkbenaim[P]psfrag/sqlite3.c
// Function: sqlite3_set_authorizer
SQLITE_API int sqlite3_set_authorizer(
  sqlite3 *db,
  int (*xAuth)(void*,int,const char*,const char*,const char*,const char*),
  void *pArg
){
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
#endif
  sqlite3_mutex_enter(db->mutex);
  db->xAuth = (sqlite3_xauth)xAuth;
  db->pAuthArg = pArg;
  if( db->xAuth ) sqlite3ExpirePreparedStatements(db, 1);
  sqlite3_mutex_leave(db->mutex);
  return SQLITE_OK;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x12d60
callq *0x8a5b0(%rip)          # 0x9d310
movq %r14, 0x1a8(%rbx)
movq %r15, 0x1b0(%rbx)
testq %r14, %r14
je 0x12d7e
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x12d95
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x12d8d
callq *0x8a593(%rip)          # 0x9d320
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jkbenaim[P]psfrag/sqlite3.c
// Function: sqlite3_enable_load_extension
SQLITE_API int sqlite3_enable_load_extension(sqlite3 *db, int onoff){
  sqlite3_mutex_enter(db->mutex);
  if( onoff ){
    db->flags |= SQLITE_LoadExtension|SQLITE_LoadExtFunc;
  }else{
    db->flags &= ~(u64)(SQLITE_LoadExtension|SQLITE_LoadExtFunc);
  }
  sqlite3_mutex_leave(db->mutex);
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x13a3c
callq *0x898d4(%rip)          # 0x9d310
movq $-0x30001, %rax         # imm = 0xFFFCFFFF
andq 0x30(%rbx), %rax
xorl %ecx, %ecx
testl %ebp, %ebp
movl $0x30000, %edx          # imm = 0x30000
cmoveq %rcx, %rdx
orq %rax, %rdx
movq %rdx, 0x30(%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x13a6a
callq *0x898b6(%rip)          # 0x9d320
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jkbenaim[P]psfrag/sqlite3.c
// Function: sqlite3_profile
SQLITE_API void *sqlite3_profile(
  sqlite3 *db,
  void (*xProfile)(void*,const char*,sqlite_uint64),
  void *pArg
){
  void *pOld;

#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif
  sqlite3_mutex_enter(db->mutex);
  pOld = db->pProfileArg;
  db->xProfile = xProfile;
  db->pProfileArg = pArg;
  db->mTrace &= SQLITE_TRACE_NONLEGACY_MASK;
  if( db->xProfile ) db->mTrace |= SQLITE_TRACE_XPROFILE;
  sqlite3_mutex_leave(db->mutex);
  return pOld;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x16bce
callq *0x86748(%rip)          # 0x9d310
movq 0x18(%rbx), %rdi
jmp 0x16bd0
xorl %edi, %edi
movq 0xf8(%rbx), %r15
movq %r14, 0xf0(%rbx)
movq %r12, 0xf8(%rbx)
movb 0x68(%rbx), %al
andb $0xf, %al
leal -0x80(%rax), %ecx
testq %r14, %r14
movzbl %al, %eax
movzbl %cl, %ecx
cmovel %eax, %ecx
movb %cl, 0x68(%rbx)
testq %rdi, %rdi
je 0x16c07
callq *0x86719(%rip)          # 0x9d320
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testl %edx, %edx
sete %bpl
testq %r14, %r14
je 0x376cf
movq %r14, %r15
movq (%r14), %rsi
movq 0x50(%r14), %r14
movq %rbx, %rdi
callq 0x374e4
movq 0x28(%r15), %rsi
movq %rbx, %rdi
callq 0x376da
movq 0x30(%r15), %rsi
movq %rbx, %rdi
callq 0x374de
movq 0x38(%r15), %rsi
movq %rbx, %rdi
callq 0x374e4
movq 0x40(%r15), %rsi
movq %rbx, %rdi
callq 0x374de
movq 0x48(%r15), %rsi
movq %rbx, %rdi
callq 0x374e4
movq 0x60(%r15), %rsi
movq %rbx, %rdi
callq 0x374de
movq 0x78(%r15), %rsi
testq %rsi, %rsi
je 0x3769d
movq %rbx, %rdi
callq 0x37799
movq 0x68(%r15), %rsi
testq %rsi, %rsi
je 0x376ae
movq %rbx, %rdi
callq 0x377be
testb $0x1, %bpl
movl $0x0, %ebp
jne 0x37629
movq %rbx, %rdi
movq %r15, %rsi
callq 0x18e0a
xorl %ebp, %ebp
jmp 0x37629
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl 0x4(%rdi), %r15d
xorl %ebp, %ebp
btl $0x1a, %r15d
jb 0x407f3
movq %rdi, %rbx
movq 0x8(%rdi), %r14
leaq 0x3c1be(%rip), %rsi     # 0x7c974
movq %r14, %rdi
callq 0xc84a
testl %eax, %eax
je 0x407d5
leaq 0x3c1b0(%rip), %rsi     # 0x7c979
movq %r14, %rdi
callq 0xc84a
testl %eax, %eax
jne 0x407f3
movb $-0x5b, (%rbx)
xorl %eax, %eax
cmpb $0x0, 0x4(%r14)
setne %al
shll $0x1c, %eax
addl $0x10000000, %eax       # imm = 0x10000000
orl %r15d, %eax
movl %eax, 0x4(%rbx)
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
testq %rsi, %rsi
je 0x4c3c4
movq %rsi, %rdx
testq %rbx, %rbx
je 0x4c3c1
movq %rdi, %r14
movq (%rdi), %r15
movl $0x20000001, %eax       # imm = 0x20000001
movl 0x4(%rdx), %ecx
andl %eax, %ecx
cmpl $0x20000000, %ecx       # imm = 0x20000000
je 0x4c392
andl 0x4(%rbx), %eax
cmpl $0x20000000, %eax       # imm = 0x20000000
jne 0x4c3cd
movq %r14, %rdi
movq %rdx, %rsi
callq 0x4c417
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4c417
leaq 0x2fe04(%rip), %rdx     # 0x7c1b3
movq %r15, %rdi
movl $0x96, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x475c0
movq %rdx, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
pushq $0x2c
popq %rsi
movq %r14, %rdi
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x4063e
// File: /workspace/github_c_makefile_star2_O2/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:
movq %rdi, %rax
testq %rax, %rax
je 0x527eb
testb $0x10, 0x5(%rax)
je 0x527eb
movq 0x10(%rax), %rax
jmp 0x527da
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq %rdi, %rax
testq %rax, %rax
je 0x528d4
movl 0x4(%rax), %ecx
testl $0x41000, %ecx          # imm = 0x41000
je 0x528d4
btl $0x12, %ecx
jb 0x528c7
addq $0x10, %rax
jmp 0x528cf
movq 0x20(%rax), %rax
addq $0x8, %rax
movq (%rax), %rax
jmp 0x528ab
retq
// File: /workspace/github_c_makefile_star2_O2/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:
testb $0x10, 0x5(%rdi)
jne 0x52919
movzbl (%rdi), %eax
cmpl $0xab, %eax
je 0x5291f
cmpl $0x86, %eax
jne 0x52922
movq 0x20(%rdi), %rax
movq (%rax), %rdi
addq $0x8, %rdi
jmp 0x52942
addq $0x10, %rdi
jmp 0x52942
movb 0x36(%rdi), %al
cmpb $-0x53, %al
jne 0x52947
movq 0x10(%rdi), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
movswq 0x30(%rdi), %rcx
shlq $0x5, %rcx
leaq (%rax,%rcx), %rdi
addq $0x8, %rdi
movq (%rdi), %rdi
jmp 0x528f5
movzbl %al, %eax
cmpl $0xa4, %eax
je 0x52968
cmpl $0xa2, %eax
je 0x52968
cmpl $0x24, %eax
jne 0x52988
movq 0x8(%rdi), %rdi
xorl %esi, %esi
jmp 0x50e55
movq 0x40(%rdi), %rax
testq %rax, %rax
je 0x52988
movswq 0x30(%rdi), %rcx
testq %rcx, %rcx
js 0x5298c
movq 0x8(%rax), %rax
shlq $0x5, %rcx
movb 0x19(%rax,%rcx), %al
retq
movb 0x1(%rdi), %al
retq
movb $0x44, %al
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movb 0x20(%rsi), %al
pushq $0x1
popq %rbx
cmpb 0x20(%rdx), %al
jne 0x5318e
movq %rdx, %r15
movq %rsi, %r12
movb 0x21(%rsi), %al
cmpb 0x21(%rdx), %al
jne 0x5318e
movb 0x22(%r12), %al
cmpb 0x22(%r15), %al
jne 0x5318e
movb 0x24(%r12), %al
cmpb 0x24(%r15), %al
jne 0x5318e
movl %ecx, %ebp
movq %rdi, %r14
movq 0x28(%r12), %rsi
movq 0x28(%r15), %rdx
pushq $-0x1
popq %rcx
callq 0x52d65
testl %eax, %eax
jne 0x5318e
movq 0x30(%r12), %rsi
movq 0x30(%r15), %rdx
pushq $-0x1
popq %rcx
movq %r14, %rdi
callq 0x52d65
testl %eax, %eax
jne 0x5318e
movq 0x10(%r12), %rdi
movq 0x10(%r15), %rsi
pushq $-0x1
popq %rdx
callq 0x53199
testl %eax, %eax
jne 0x5318e
movq 0x18(%r12), %rdi
movq 0x18(%r15), %rsi
pushq $-0x1
popq %rdx
callq 0x53199
testl %eax, %eax
jne 0x5318e
testl %ebp, %ebp
je 0x5318c
movq 0x48(%r12), %rsi
movq 0x48(%r15), %rdx
pushq $-0x1
popq %rcx
movq %r14, %rdi
callq 0x52d65
testl %eax, %eax
jne 0x5318e
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %ebx, %ebx
movq %rdi, %rax
orq %rsi, %rax
je 0x5320f
movq %rsi, %r14
movq %rdi, %r15
testq %rsi, %rsi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
pushq $0x1
popq %rbx
jne 0x5320f
movl (%r15), %eax
cmpl (%r14), %eax
jne 0x5320f
movl %edx, %ebp
pushq $0x20
popq %rcx
pushq $-0x1
popq %r12
movslq (%r15), %rax
incq %r12
cmpq %rax, %r12
jge 0x5320d
movb (%r15,%rcx), %al
cmpb (%r14,%rcx), %al
jne 0x5320f
leaq 0x20(%rcx), %r13
movq -0x18(%r14,%rcx), %rdx
movq -0x18(%r15,%rcx), %rsi
xorl %edi, %edi
movl %ebp, %ecx
callq 0x52d65
movq %r13, %rcx
testl %eax, %eax
je 0x531d8
jmp 0x5320f
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jkbenaim[P]psfrag/sqlite3.c
// Function: sqlite3ExprListDup
SQLITE_PRIVATE ExprList *sqlite3ExprListDup(sqlite3 *db, ExprList *p, int flags){
  ExprList *pNew;
  struct ExprList_item *pItem, *pOldItem;
  int i;
  Expr *pPriorSelectCol = 0;
  assert( db!=0 );
  if( p==0 ) return 0;
  pNew = sqlite3DbMallocRawNN(db, sqlite3DbMallocSize(db, p));
  if( pNew==0 ) return 0;
  pNew->nExpr = p->nExpr;
  pItem = pNew->a;
  pOldItem = p->a;
  for(i=0; i<p->nExpr; i++, pItem++, pOldItem++){
    Expr *pOldExpr = pOldItem->pExpr;
    Expr *pNewExpr;
    pItem->pExpr = sqlite3ExprDup(db, pOldExpr, flags);
    if( pOldExpr 
     && pOldExpr->op==TK_SELECT_COLUMN
     && (pNewExpr = pItem->pExpr)!=0 
    ){
      assert( pNewExpr->iColumn==0 || i>0 );
      if( pNewExpr->iColumn==0 ){
        assert( pOldExpr->pLeft==pOldExpr->pRight );
        pPriorSelectCol = pNewExpr->pLeft = pNewExpr->pRight;
      }else{
        assert( i>0 );
        assert( pItem[-1].pExpr!=0 );
        assert( pNewExpr->iColumn==pItem[-1].pExpr->iColumn+1 );
        assert( pPriorSelectCol==pItem[-1].pExpr->pLeft );
        pNewExpr->pLeft = pPriorSelectCol;
      }
    }
    pItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
    pItem->zSpan = sqlite3DbStrDup(db, pOldItem->zSpan);
    pItem->sortFlags = pOldItem->sortFlags;
    pItem->done = 0;
    pItem->bNulls = pOldItem->bNulls;
    pItem->bSpanIsTab = pOldItem->bSpanIsTab;
    pItem->bSorterRef = pOldItem->bSorterRef;
    pItem->u = pOldItem->u;
  }
  return pNew;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, 0xc(%rsp)
testq %rsi, %rsi
je 0x5463e
movq %rsi, %r14
movq %rdi, %r15
callq 0xc0b9
movslq %eax, %rsi
movq %r15, %rdi
callq 0x18edb
xorl %ebp, %ebp
testq %rax, %rax
je 0x5463e
movq %rax, %r12
movl (%r14), %eax
movl %eax, (%r12)
pushq $0x8
popq %rbx
movq $0x0, 0x10(%rsp)
cmpl %eax, %ebp
jge 0x54641
movq (%r14,%rbx), %r13
movq %r15, %rdi
movq %r13, %rsi
movl 0xc(%rsp), %edx
callq 0x51e1e
movq %rax, (%r12,%rbx)
testq %r13, %r13
je 0x545b6
cmpb $-0x53, (%r13)
setne %cl
testq %rax, %rax
sete %dl
orb %cl, %dl
jne 0x545b6
cmpw $0x0, 0x30(%rax)
jne 0x545ad
movq 0x18(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x8(%r14,%rbx), %rsi
movq %r15, %rdi
callq 0x10982
movq %rax, 0x8(%r12,%rbx)
movq 0x10(%r14,%rbx), %rsi
movq %r15, %rdi
callq 0x10982
movq %rax, 0x10(%r12,%rbx)
movb 0x18(%r14,%rbx), %al
movb %al, 0x18(%r12,%rbx)
movb 0x19(%r12,%rbx), %al
movl %eax, %ecx
andb $-0x2, %cl
movb %cl, 0x19(%r12,%rbx)
movb 0x19(%r14,%rbx), %cl
andb $0x10, %cl
andb $-0x12, %al
orb %cl, %al
movb %al, 0x19(%r12,%rbx)
movb 0x19(%r14,%rbx), %cl
andb $0x2, %cl
andb $-0x4, %al
orb %cl, %al
movb %al, 0x19(%r12,%rbx)
movb 0x19(%r14,%rbx), %cl
andb $0x8, %cl
andb $-0xa, %al
orb %cl, %al
movb %al, 0x19(%r12,%rbx)
movl 0x1c(%r14,%rbx), %eax
movl %eax, 0x1c(%r12,%rbx)
incl %ebp
movl (%r14), %eax
addq $0x20, %rbx
jmp 0x54567
xorl %r12d, %r12d
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x54775
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0x90, %esi
callq 0x10b45
testq %rax, %rax
je 0x54775
movq %rax, %rbx
movq (%r14), %rsi
movq %r12, %rdi
callq 0x10982
movq %rax, (%rbx)
movq 0x8(%r14), %rsi
movq %r12, %rdi
callq 0x10982
movq %rax, 0x8(%rbx)
movq 0x48(%r14), %rsi
movq %r12, %rdi
xorl %edx, %edx
callq 0x51e1e
movq %rax, 0x48(%rbx)
movq 0x50(%r14), %rax
movq %rax, 0x50(%rbx)
movq 0x10(%r14), %rsi
movq %r12, %rdi
xorl %edx, %edx
callq 0x54515
movq %rax, 0x10(%rbx)
movq 0x18(%r14), %rsi
movq %r12, %rdi
xorl %edx, %edx
callq 0x54515
movq %rax, 0x18(%rbx)
movb 0x20(%r14), %al
movb %al, 0x20(%rbx)
movb 0x22(%r14), %al
movb %al, 0x22(%rbx)
movb 0x21(%r14), %al
movb %al, 0x21(%rbx)
movb 0x24(%r14), %al
movb %al, 0x24(%rbx)
movl 0x60(%r14), %eax
movl %eax, 0x60(%rbx)
movq 0x28(%r14), %rsi
movq %r12, %rdi
xorl %edx, %edx
callq 0x51e1e
movq %rax, 0x28(%rbx)
movq 0x30(%r14), %rsi
movq %r12, %rdi
xorl %edx, %edx
callq 0x51e1e
movq %rax, 0x30(%rbx)
movq %r15, 0x70(%rbx)
movb 0x23(%r14), %al
movb %al, 0x23(%rbx)
jmp 0x54777
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r12
movq (%rdi), %rax
movl $0x10000001, %ecx       # imm = 0x10000001
andl 0x30(%rax), %ecx
xorl %ebx, %ebx
cmpl $0x1, %ecx
je 0x54f6a
testb $0x2, 0xb6(%rax)
jne 0x54f6a
movq %rsi, %r15
movq %rdi, %r14
cmpb $0x0, 0xb5(%rax)
je 0x54f4d
movq 0xb8(%rax), %r13
movq (%r13), %rsi
movq %rdx, %rdi
callq 0xc834
testl %eax, %eax
jne 0x54f2e
movq 0x8(%r13), %rsi
movq %r15, %rdi
callq 0xc834
testl %eax, %eax
jne 0x54f2e
movq 0x10(%r13), %rsi
movq %r12, %rdi
callq 0xc834
testl %eax, %eax
je 0x54f6a
cmpb $0x0, 0x48364(%rip)     # 0x9d299
je 0x54f6a
leaq 0x1fb2e(%rip), %rsi     # 0x74a6c
movq %r14, %rdi
xorl %eax, %eax
callq 0x12276
pushq $0x1
popq %rbx
jmp 0x54f6a
cmpb $0x0, 0x1e(%r14)
jne 0x54f6a
leaq 0x270c1(%rip), %rsi     # 0x7c01c
pushq $0x7
popq %rdx
movq %r15, %rdi
callq 0xc87e
testl %eax, %eax
je 0x54f76
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x270a7(%rip), %rsi     # 0x7c024
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x12276
jmp 0x54f48
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0xb0, %rsp
movq %r8, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x98(%rsp)
andq $0x0, 0xa8(%rsp)
movups %xmm0, 0x88(%rsp)
movaps %xmm0, (%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x60(%rsp)
andq $0x0, 0x70(%rsp)
testq %rsi, %rsi
je 0x55058
movl $0x1, (%rsp)
movq (%rsi), %rax
movq %rax, 0x18(%rsp)
movq %rsi, 0x28(%rsp)
orl $-0x1, 0x48(%rsp)
leaq 0x78(%rsp), %rax
movq %rdi, (%rax)
movq %rsp, %rsi
movq %rsi, 0x8(%rax)
orl $0x10000, %edx          # imm = 0x10000
movl %edx, 0x28(%rax)
movq %rax, %rdi
movq %rcx, %rsi
callq 0x555d4
testl %eax, %eax
je 0x55084
pushq $0x1
popq %rax
jmp 0x5509a
testq %rbx, %rbx
je 0x55098
leaq 0x78(%rsp), %rdi
movq %rbx, %rsi
callq 0x5569f
jmp 0x5509a
xorl %eax, %eax
addq $0xb0, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movq %rdi, %r14
movq 0x28(%rsi), %r15
testq %r15, %r15
jne 0x5524b
movq %rsi, %r12
movq (%r14), %r13
movswq 0x46(%rsi), %rdi
incq %rdi
callq 0xa6c8
testq %rax, %rax
je 0x552a1
movq %rax, %r15
pushq $0x19
popq %rcx
xorl %eax, %eax
movswq 0x46(%r12), %rdx
cmpq %rdx, %rax
jge 0x5523c
movq 0x8(%r12), %rdx
movb (%rdx,%rcx), %dl
movb %dl, (%r15,%rax)
incq %rax
addq $0x20, %rcx
jmp 0x55210
cmpb $0x42, -0x1(%r15,%rax)
leaq -0x1(%rax), %rax
jge 0x55246
movb $0x0, (%r15,%rax)
testq %rax, %rax
jg 0x55230
movq %r15, 0x28(%r12)
movq %r15, %rdi
callq 0x80b0
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
je 0x55276
testl %ebx, %ebx
je 0x55284
movl %eax, (%rsp)
pushq $0x5b
popq %rsi
movq %r14, %rdi
movl %ebx, %edx
movl %eax, %ecx
xorl %r8d, %r8d
movq %r15, %r9
callq 0x4f693
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
pushq $-0x1
popq %rsi
movq %r14, %rdi
movq %r15, %rdx
movl %eax, %ecx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1258e
movq %r13, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xfde0
// File: /workspace/github_c_makefile_star2_O2/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:
movzbl (%rsi), %eax
cmpl $0xa4, %eax
je 0x57641
cmpl $0xa2, %eax
jne 0x57695
movq 0x28(%rdi), %rax
movq (%rax), %rcx
xorl %edx, %edx
movl $0x0, %edi
testq %rcx, %rcx
je 0x57656
movl (%rcx), %edi
testl %edi, %edi
movl $0x0, %r8d
cmovgl %edi, %r8d
imulq $0x70, %r8, %r8
addq $0x70, %r8
leaq 0x70(%rdx), %r9
cmpq %r9, %r8
je 0x57686
movl 0x2c(%rsi), %r10d
cmpl 0x48(%rcx,%rdx), %r10d
movq %r9, %rdx
jne 0x5766a
incl 0x8(%rax)
jmp 0x57695
testl %edi, %edi
je 0x57692
movl 0x2c(%rsi), %edx
cmpl 0x48(%rcx), %edx
jge 0x57695
incl 0xc(%rax)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
subq $0x38, %rsp
xorps %xmm0, %xmm0
leaq 0x8(%rsp), %rax
movups %xmm0, 0x18(%rax)
andq $0x0, 0x28(%rax)
movq %rdi, (%rax)
leaq 0x1c(%rip), %rcx        # 0x59745
movq %rcx, 0x8(%rax)
leaq 0x23(%rip), %rcx        # 0x59757
movq %rcx, 0x10(%rax)
movq %rax, %rdi
callq 0x52ab6
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq (%rdi), %rbx
movq (%rsi), %r15
testq %r15, %r15
je 0x59799
leaq 0x10(%r15), %r12
xorl %r13d, %r13d
movslq (%r15), %rax
cmpq %rax, %r13
jge 0x59799
movq (%r12), %rdx
testq %rdx, %rdx
je 0x59790
movq %rbx, %rdi
xorl %esi, %esi
callq 0x55464
incq %r13
addq $0x20, %r12
jmp 0x59775
movq 0x28(%r14), %r14
testq %r14, %r14
je 0x597c7
leaq 0x18(%r14), %r15
xorl %r12d, %r12d
movslq (%r14), %rax
cmpq %rax, %r12
jge 0x597c7
movq (%r15), %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x55464
incq %r12
addq $0x70, %r15
jmp 0x597a9
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %r15d
movl %esi, %r14d
movq %rdi, %rbx
callq 0x4f648
movq %rax, %r12
movq %rbx, %rdi
callq 0x528d5
movl %eax, %ebp
cmpl $0x1, %r14d
jg 0x5a689
leaq 0x2276e(%rip), %rsi     # 0x7cded
movq %rbx, %rdi
xorl %eax, %eax
callq 0x12276
movq %r12, %rdi
movl $0x88, %esi
movl %r14d, %edx
movl %ebp, %ecx
movl %r15d, %r8d
callq 0x393ef
movq 0xa0(%rbx), %rax
testq %rax, %rax
cmoveq %rbx, %rax
movb $0x1, 0x21(%rax)
movq (%rbx), %rax
movq 0x20(%rax), %rax
movslq %r15d, %rcx
shlq $0x5, %rcx
movq (%rax,%rcx), %rdx
movl %ebp, (%rsp)
leaq 0x22730(%rip), %rsi     # 0x7cdfc
leaq 0x20677(%rip), %rcx     # 0x7ad4a
movq %rbx, %rdi
movl %r14d, %r8d
movl %ebp, %r9d
xorl %eax, %eax
callq 0x552b6
testl %ebp, %ebp
je 0x5a6fe
movzbl 0x1f(%rbx), %eax
cmpq $0x7, %rax
ja 0x5a6fe
leal 0x1(%rax), %ecx
movb %cl, 0x1f(%rbx)
movl %ebp, 0xcc(%rbx,%rax,4)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %esi, %ebx
callq 0x528a8
movq %rax, %r14
pushq $0x10
popq %r15
pushq $0x1
popq %rbp
pushq $0x18
popq %r12
testq %r14, %r14
je 0x5a75a
movzbl (%r14), %eax
movq %r15, %rcx
cmpl $0x33, %eax
je 0x5a754
cmpl $0x2c, %eax
jne 0x5a75a
movq 0x10(%r14), %rdi
movl %ebx, %esi
callq 0x5a70b
movq %r12, %rcx
testl %eax, %eax
jne 0x5a789
movq (%r14,%rcx), %r14
jmp 0x5a72c
leaq 0x4e64(%rip), %rax      # 0x5f5c5
movq %rsp, %r15
movq %rax, 0x8(%r15)
movb $0x0, 0x24(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
movl %ebx, 0x28(%r15)
movq %r15, %rdi
movq %r14, %rsi
callq 0x52ab6
movzbl 0x24(%r15), %ebp
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jkbenaim[P]psfrag/sqlite3.c
// Function: exprListAppendList
static ExprList *exprListAppendList(
  Parse *pParse,          /* Parsing context */
  ExprList *pList,        /* List to which to append. Might be NULL */
  ExprList *pAppend,      /* List of values to append. Might be NULL */
  int bIntToNull
){
  if( pAppend ){
    int i;
    int nInit = pList ? pList->nExpr : 0;
    for(i=0; i<pAppend->nExpr; i++){
      Expr *pDup = sqlite3ExprDup(pParse->db, pAppend->a[i].pExpr, 0);
      if( bIntToNull && pDup && pDup->op==TK_INTEGER ){
        pDup->op = TK_NULL;
        pDup->flags &= ~(EP_IntValue|EP_IsTrue|EP_IsFalse);
      }
      pList = sqlite3ExprListAppend(pParse, pList, pDup);
      if( pList ) pList->a[nInit+i].sortFlags = pAppend->a[i].sortFlags;
    }
  }
  return pList;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rdx, %rdx
je 0x5f411
movl %ecx, %ebp
movq %rdx, %r14
movq %rdi, %r15
testq %rbx, %rbx
je 0x5f3a2
movslq (%rbx), %rax
jmp 0x5f3a4
xorl %eax, %eax
shlq $0x5, %rax
movq %rax, (%rsp)
pushq $0x20
popq %r13
xorl %r12d, %r12d
movslq (%r14), %rax
cmpq %rax, %r12
jge 0x5f411
movq (%r15), %rdi
movq -0x18(%r14,%r13), %rsi
xorl %edx, %edx
callq 0x51e1e
testl %ebp, %ebp
je 0x5f3e2
testq %rax, %rax
je 0x5f3e2
cmpb $-0x6a, (%rax)
jne 0x5f3e2
movb $0x75, (%rax)
andl $0xcffffbff, 0x4(%rax)  # imm = 0xCFFFFBFF
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x474bc
movq %rax, %rbx
testq %rax, %rax
je 0x5f408
movb (%r14,%r13), %al
movq (%rsp), %rcx
addq %rbx, %rcx
movb %al, (%r13,%rcx)
incq %r12
addq $0x20, %r13
jmp 0x5f3b3
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jkbenaim[P]psfrag/sqlite3.c
// Function: constInsert
static void constInsert(
  WhereConst *pConst,      /* The WhereConst into which we are inserting */
  Expr *pColumn,           /* The COLUMN part of the constraint */
  Expr *pValue             /* The VALUE part of the constraint */
){
  int i;
  assert( pColumn->op==TK_COLUMN );

  /* 2018-10-25 ticket [cf5ed20f]
  ** Make sure the same pColumn is not inserted more than once */
  for(i=0; i<pConst->nConst; i++){
    const Expr *pExpr = pConst->apExpr[i*2];
    assert( pExpr->op==TK_COLUMN );
    if( pExpr->iTable==pColumn->iTable
     && pExpr->iColumn==pColumn->iColumn
    ){
      return;  /* Already present.  Return without doing anything. */
    }
  }

  pConst->nConst++;
  pConst->apExpr = sqlite3DbReallocOrFree(pConst->pParse->db, pConst->apExpr,
                         pConst->nConst*2*sizeof(Expr*));
  if( pConst->apExpr==0 ){
    pConst->nConst = 0;
  }else{
    if( ExprHasProperty(pValue, EP_FixedCol) ) pValue = pValue->pLeft;
    pConst->apExpr[pConst->nConst*2-2] = pColumn;
    pConst->apExpr[pConst->nConst*2-1] = pValue;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movslq 0x8(%rdi), %rdx
xorl %eax, %eax
testl %edx, %edx
movl $0x0, %ecx
cmovgl %edx, %ecx
shlq $0x4, %rcx
cmpq %rax, %rcx
je 0x600d9
movq 0x10(%r14), %rsi
movq (%rsi,%rax), %rsi
movl 0x2c(%rsi), %edi
cmpl 0x2c(%r15), %edi
jne 0x600d3
movzwl 0x30(%rsi), %esi
cmpw 0x30(%r15), %si
je 0x60123
addq $0x10, %rax
jmp 0x600b2
incq %rdx
movl %edx, 0x8(%r14)
movq (%r14), %rax
movq 0x10(%r14), %rsi
movq (%rax), %rdi
shlq $0x4, %rdx
callq 0x26110
movq %rax, 0x10(%r14)
testq %rax, %rax
je 0x6011e
testb $0x8, 0x4(%rbx)
je 0x60106
movq 0x10(%rbx), %rbx
movslq 0x8(%r14), %rcx
shlq $0x4, %rcx
movq %r15, -0x10(%rax,%rcx)
movq 0x10(%r14), %rax
movq %rbx, -0x8(%rax,%rcx)
jmp 0x60123
andl $0x0, 0x8(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jkbenaim[P]psfrag/sqlite3.c
// Function: sqlite3IndexAffinityOk
SQLITE_PRIVATE int sqlite3IndexAffinityOk(Expr *pExpr, char idx_affinity){
  char aff = comparisonAffinity(pExpr);
  if( aff<SQLITE_AFF_TEXT ){
    return 1;
  }
  if( aff==SQLITE_AFF_TEXT ){
    return idx_affinity==SQLITE_AFF_TEXT;
  }
  return sqlite3IsNumericAffinity(idx_affinity);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
callq 0x528f5
movq 0x18(%r14), %rdi
testq %rdi, %rdi
jne 0x62ee1
testb $0x8, 0x5(%r14)
jne 0x62ed6
testb %al, %al
jne 0x62ee9
movb $0x1, %cl
jmp 0x62eff
movq 0x20(%r14), %rcx
movq (%rcx), %rcx
movq 0x8(%rcx), %rdi
movsbl %al, %esi
callq 0x5298f
movb $0x1, %cl
cmpb $0x42, %al
jl 0x62eff
jne 0x62ef9
cmpb $0x42, %bl
sete %cl
jmp 0x62eff
cmpb $0x43, %bl
setge %cl
movzbl %cl, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq