LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]gpss/sum.c
// Function: main
int main(void)
{
	int cnt = 0;
	int npt;
	int r[NALG];
	int amax[NALG] = {0};
	int arat[NALG] = {0};
	int i;
	while (scanf("%d", &npt) == 1) {
		int best = 0;
		for (i = 0; i < NALG; i++)
			scanf("%d", &r[i]);
		for (i = 0; i < NALG; i++)
			if (best < r[i])
				best = r[i];
		for (i = 0; i < NALG; i++)
			if (r[i] == best)
				amax[i]++;
		for (i = 0; i < NALG; i++)
			arat[i] += r[i] * 10000 / best;
		cnt++;
	}
	for (i = 0; i < NALG; i++) {
		int maxrat = amax[i] * 10000 / cnt;
		int sizerat = arat[i] / cnt;
		printf("%2d.%02d %2d.%02d\n", maxrat / 100, maxrat % 100,
			sizerat / 100, sizerat % 100);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1040
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1040
leaq 0xe67(%rip), %rdi       # 0x2004
leaq -0xc(%rbp), %rsi
movb $0x0, %al
callq 0x1050
cmpl $0x1, %eax
jne 0x1299
movl $0x0, -0x48(%rbp)
movl $0x0, -0x44(%rbp)
cmpl $0x4, -0x44(%rbp)
jge 0x11ed
movslq -0x44(%rbp), %rax
leaq -0x20(%rbp), %rsi
shlq $0x2, %rax
addq %rax, %rsi
leaq 0xe29(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1050
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x11bf
movl $0x0, -0x44(%rbp)
cmpl $0x4, -0x44(%rbp)
jge 0x121f
movl -0x48(%rbp), %eax
movslq -0x44(%rbp), %rcx
cmpl -0x20(%rbp,%rcx,4), %eax
jge 0x1212
movslq -0x44(%rbp), %rax
movl -0x20(%rbp,%rax,4), %eax
movl %eax, -0x48(%rbp)
jmp 0x1214
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x11f4
movl $0x0, -0x44(%rbp)
cmpl $0x4, -0x44(%rbp)
jge 0x1255
movslq -0x44(%rbp), %rax
movl -0x20(%rbp,%rax,4), %eax
cmpl -0x48(%rbp), %eax
jne 0x1248
movslq -0x44(%rbp), %rax
movl -0x30(%rbp,%rax,4), %ecx
addl $0x1, %ecx
movl %ecx, -0x30(%rbp,%rax,4)
jmp 0x124a
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x1226
movl $0x0, -0x44(%rbp)
cmpl $0x4, -0x44(%rbp)
jge 0x128b
movslq -0x44(%rbp), %rax
imull $0x2710, -0x20(%rbp,%rax,4), %eax # imm = 0x2710
cltd
idivl -0x48(%rbp)
movl %eax, %ecx
movslq -0x44(%rbp), %rax
addl -0x40(%rbp,%rax,4), %ecx
movl %ecx, -0x40(%rbp,%rax,4)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x125c
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1196
movl $0x0, -0x44(%rbp)
cmpl $0x4, -0x44(%rbp)
jge 0x131a
movslq -0x44(%rbp), %rax
imull $0x2710, -0x30(%rbp,%rax,4), %eax # imm = 0x2710
cltd
idivl -0x8(%rbp)
movl %eax, -0x4c(%rbp)
movslq -0x44(%rbp), %rax
movl -0x40(%rbp,%rax,4), %eax
cltd
idivl -0x8(%rbp)
movl %eax, -0x50(%rbp)
movl -0x4c(%rbp), %eax
movl $0x64, %ecx
cltd
idivl %ecx
movl %eax, %esi
movl -0x4c(%rbp), %eax
movl $0x64, %ecx
cltd
idivl %ecx
movl %edx, -0x54(%rbp)
movl -0x50(%rbp), %eax
movl $0x64, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x50(%rbp), %eax
movl $0x64, %edi
cltd
idivl %edi
movl %edx, %r8d
movl -0x54(%rbp), %edx
leaq 0xcff(%rip), %rdi       # 0x2007
movb $0x0, %al
callq 0x1030
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x12a0
xorl %eax, %eax
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/chorus/chorus.c
// Function: main
int
main(int argc,char **argv)
    {
    int argIndex = 1;

    FILE *in,*out;
    RRA *h;

    argIndex = processOptions(argc,argv);

    if (argc-argIndex == 0)
        {
        in = stdin;
        out = stdout;
        }
    else if (argc-argIndex == 1)
        {
        in = OpenFile(argv[argIndex],"r");
        out = stdout;
        }
    else if (argc-argIndex == 2)
        {
        in = OpenFile(argv[argIndex],"r");
        out = OpenFile(argv[argIndex+1],"w");
        }
    else
        {
        printf("usage: chorus [<input rra file> [<output wave file>]]\n");
        exit(-1);
        }

    h = newRRAHeader();
    
    readRRAHeader(in,h,0);

    writeRRAHeader(out,h,"modifiedBy: chorus",0);

    processData(in,out,h);

    fclose(in);
    fclose(out);

    return 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x1480
movl %eax, -0x14(%rbp)
movl -0x8(%rbp), %eax
subl -0x14(%rbp), %eax
cmpl $0x0, %eax
jne 0x1378
movq 0x6c7a(%rip), %rax      # 0x7fd8
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq 0x6c64(%rip), %rax      # 0x7fd0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x1415
movl -0x8(%rbp), %eax
subl -0x14(%rbp), %eax
cmpl $0x1, %eax
jne 0x13af
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x44e8(%rip), %rsi      # 0x587e
callq 0x1fb0
movq %rax, -0x20(%rbp)
movq 0x6c2a(%rip), %rax      # 0x7fd0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x1413
movl -0x8(%rbp), %eax
subl -0x14(%rbp), %eax
cmpl $0x2, %eax
jne 0x13f9
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x44b1(%rip), %rsi      # 0x587e
callq 0x1fb0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x3d0f(%rip), %rsi      # 0x50fd
callq 0x1fb0
movq %rax, -0x28(%rbp)
jmp 0x1411
leaq 0x3cff(%rip), %rdi      # 0x50ff
movb $0x0, %al
callq 0x1090
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x11e0
jmp 0x1413
jmp 0x1415
callq 0x2490
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2990
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq 0x3cf8(%rip), %rdx      # 0x5136
xorl %eax, %eax
movl %eax, %ecx
callq 0x3930
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x17a0
movq -0x20(%rbp), %rdi
callq 0x1070
movq -0x28(%rbp), %rdi
callq 0x1070
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/chorus/chorus.c
// Function: getDatum
static double
getDatum(FILE *in,FILE *out,RRA *h,double t)
    {
    static int edge = -1;
    int ceiling;
    double result;
    
    if (t < 0) return 0;

    if (edge == -1) createRRAData(h);

    /* read in five or so samples ahead */

    ceiling = (int) (t + 0.5) + ReadAhead;

    if (ceiling >= h->samples) ceiling = h->samples - 1;

    while (edge < ceiling)
        {
        ++edge;
        h->data[0][edge] = 
            readRRAAmplitude(in,out,h->bitsPerSample,outputComment);
        }

    result = interp(h->data[0],h->samples,t);

    return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movsd %xmm0, -0x28(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x28(%rbp), %xmm0
jbe 0x1ba0
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x1c60
cmpl $-0x1, 0x65a9(%rip)     # 0x8150
jne 0x1bb2
movq -0x20(%rbp), %rdi
callq 0x2410
movsd 0x3516(%rip), %xmm0     # 0x50d0
addsd -0x28(%rbp), %xmm0
cvttsd2si %xmm0, %eax
addl 0x658b(%rip), %eax      # 0x8154
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jl 0x1be5
movq -0x20(%rbp), %rax
movl 0xc(%rax), %eax
subl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1be7
movl 0x6563(%rip), %eax      # 0x8150
cmpl -0x2c(%rbp), %eax
jge 0x1c35
movl 0x6558(%rip), %eax      # 0x8150
addl $0x1, %eax
movl %eax, 0x654f(%rip)      # 0x8150
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
movl 0x8(%rax), %edx
leaq 0x2159(%rip), %rcx      # 0x3d70
callq 0x30c0
movl %eax, %edx
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movslq 0x6520(%rip), %rcx      # 0x8150
movl %edx, (%rax,%rcx,4)
jmp 0x1be7
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movl 0xc(%rax), %esi
movsd -0x28(%rbp), %xmm0
callq 0x1c70
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/KhuramAli[P]JAM-Benchmark/Multi-producer_Multi-consumer_Lock-free_boost/code08.cpp
// Function: consumer()
void consumer(void)
{
	int value;
	while (!done) {
		while (queue.pop(value))
			++consumer_count;
	}
	while (queue.pop(value))
		++consumer_count;
}

// Assembly:
pushq %rax
leaq 0x7dc4(%rip), %rdi      # 0x90cc
callq 0x1940
xorb $-0x1, %al
testb $0x1, %al
jne 0x1315
jmp 0x133e
jmp 0x1317
leaq 0x7db2(%rip), %rdi      # 0x90d0
leaq 0x4(%rsp), %rsi
callq 0x19e0
testb $0x1, %al
jne 0x132e
jmp 0x133c
leaq 0x7d93(%rip), %rdi      # 0x90c8
callq 0x18e0
jmp 0x1317
jmp 0x1301
jmp 0x1340
leaq 0x7d89(%rip), %rdi      # 0x90d0
leaq 0x4(%rsp), %rsi
callq 0x19e0
testb $0x1, %al
jne 0x1357
jmp 0x1365
leaq 0x7d6a(%rip), %rdi      # 0x90c8
callq 0x18e0
jmp 0x1340
popq %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/lakekeyakv2/SandyBridge/KeccakP-1600-times2-SIMD128.c
// Function: KeccakP1600times2_OverwriteWithZeroes
void KeccakP1600times2_OverwriteWithZeroes(void *states, unsigned int instanceIndex, unsigned int byteCount)
{
    unsigned int sizeLeft = byteCount;
    unsigned int lanePosition = 0;
    UINT64 *statesAsLanes = states;

    while(sizeLeft >= SnP_laneLengthInBytes) {
        statesAsLanes[laneIndex(instanceIndex, lanePosition)] = 0;
        sizeLeft -= SnP_laneLengthInBytes;
        lanePosition++;
    }

    if (sizeLeft > 0) {
        memset(&statesAsLanes[laneIndex(instanceIndex, lanePosition)], 0, sizeLeft);
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl 0x18(%rsp), %eax
movl %eax, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x8, 0x14(%rsp)
jb 0x15c33
movq 0x8(%rsp), %rax
movl 0x10(%rsp), %ecx
shll %ecx
addl 0x1c(%rsp), %ecx
movl %ecx, %ecx
movq $0x0, (%rax,%rcx,8)
movl 0x14(%rsp), %eax
subl $0x8, %eax
movl %eax, 0x14(%rsp)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x15bfb
cmpl $0x0, 0x14(%rsp)
jbe 0x15c5f
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %eax
shll %eax
addl 0x1c(%rsp), %eax
movl %eax, %eax
shlq $0x3, %rax
addq %rax, %rdi
movl 0x14(%rsp), %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x5060
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/lakekeyakv2/SandyBridge/KeccakP-1600-times2-SIMD128.c
// Function: KeccakP1600times2_ExtractBytes
void KeccakP1600times2_ExtractBytes(const void *states, unsigned int instanceIndex, unsigned char *data, unsigned int offset, unsigned int length)
{
    unsigned int sizeLeft = length;
    unsigned int lanePosition = offset/SnP_laneLengthInBytes;
    unsigned int offsetInLane = offset%SnP_laneLengthInBytes;
    unsigned char *curData = data;
    const UINT64 *statesAsLanes = states;

    if ((sizeLeft > 0) && (offsetInLane != 0)) {
        unsigned int bytesInLane = SnP_laneLengthInBytes - offsetInLane;
        if (bytesInLane > sizeLeft)
            bytesInLane = sizeLeft;
        memcpy( curData, ((unsigned char *)&statesAsLanes[laneIndex(instanceIndex, lanePosition)]) + offsetInLane, bytesInLane);
        sizeLeft -= bytesInLane;
        lanePosition++;
        curData += bytesInLane;
    }

    while(sizeLeft >= SnP_laneLengthInBytes) {
        *(UINT64*)curData = statesAsLanes[laneIndex(instanceIndex, lanePosition)];
        sizeLeft -= SnP_laneLengthInBytes;
        lanePosition++;
        curData += SnP_laneLengthInBytes;
    }

    if (sizeLeft > 0) {
        memcpy( curData, &statesAsLanes[laneIndex(instanceIndex, lanePosition)], sizeLeft);
    }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq %rdx, 0x30(%rsp)
movl %ecx, 0x2c(%rsp)
movl %r8d, 0x28(%rsp)
movl 0x28(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x2c(%rsp), %eax
shrl $0x3, %eax
movl %eax, 0x20(%rsp)
movl 0x2c(%rsp), %eax
andl $0x7, %eax
movl %eax, 0x1c(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x24(%rsp)
jbe 0x15d49
cmpl $0x0, 0x1c(%rsp)
je 0x15d49
movl $0x8, %eax
subl 0x1c(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x24(%rsp), %eax
jbe 0x15cee
movl 0x24(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl 0x20(%rsp), %eax
shll %eax
addl 0x3c(%rsp), %eax
movl %eax, %eax
shlq $0x3, %rax
addq %rax, %rsi
movl 0x1c(%rsp), %eax
addq %rax, %rsi
movl 0x4(%rsp), %eax
movl %eax, %edx
callq 0x55a0
movl 0x4(%rsp), %ecx
movl 0x24(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x24(%rsp)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
movl 0x4(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
jmp 0x15d4b
cmpl $0x8, 0x24(%rsp)
jb 0x15d95
movq 0x8(%rsp), %rax
movl 0x20(%rsp), %ecx
shll %ecx
addl 0x3c(%rsp), %ecx
movl %ecx, %ecx
movq (%rax,%rcx,8), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movl 0x24(%rsp), %eax
subl $0x8, %eax
movl %eax, 0x24(%rsp)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
movq 0x10(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x10(%rsp)
jmp 0x15d4b
cmpl $0x0, 0x24(%rsp)
jbe 0x15dc4
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl 0x20(%rsp), %eax
shll %eax
addl 0x3c(%rsp), %eax
movl %eax, %eax
shlq $0x3, %rax
addq %rax, %rsi
movl 0x24(%rsp), %eax
movl %eax, %edx
callq 0x55a0
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_compileoption_used
SQLITE_API int sqlite3_compileoption_used(const char *zOptName){
  int i, n;
  if( sqlite3StrNICmp(zOptName, "SQLITE_", 7)==0 ) zOptName += 7;
  n = sqlite3Strlen30(zOptName);

  /* Since ArraySize(azCompileOpt) is normally in single digits, a
  ** linear search is adequate.  No need for a binary search. */
  for(i=0; i<ArraySize(azCompileOpt); i++){
    if( sqlite3StrNICmp(zOptName, azCompileOpt[i], n)==0
     && sqlite3CtypeMap[(unsigned char)azCompileOpt[i][n]]==0
    ){
      return 1;
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xa4db9(%rip), %rsi     # 0xadf20
movl $0x7, %edx
callq 0x9210
cmpl $0x0, %eax
jne 0x9182
movq -0x10(%rbp), %rax
addq $0x7, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x92f0
movl %eax, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x2, -0x14(%rbp)
jge 0x91fa
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rcx
leaq 0xc5b16(%rip), %rax     # 0xcecc0
movq (%rax,%rcx,8), %rsi
movl -0x18(%rbp), %edx
callq 0x9210
cmpl $0x0, %eax
jne 0x91ed
movslq -0x14(%rbp), %rcx
leaq 0xc5afa(%rip), %rax     # 0xcecc0
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0xa1865(%rip), %rax     # 0xaaa40
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x91ed
movl $0x1, -0x4(%rbp)
jmp 0x9201
jmp 0x91ef
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x9195
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_strnicmp
SQLITE_API int sqlite3_strnicmp(const char *zLeft, const char *zRight, int N){
  register unsigned char *a, *b;
  a = (unsigned char *)zLeft;
  b = (unsigned char *)zRight;
  while( N-- > 0 && *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; }
  return N<0 ? 0 : UpperToLower[*a] - UpperToLower[*b];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %ecx
movl %ecx, %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x29(%rbp)
jle 0x9285
movq -0x20(%rbp), %rax
movzbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x29(%rbp)
je 0x9285
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0xa18db(%rip), %rax     # 0xaab40
movzbl (%rax,%rcx), %eax
movq -0x28(%rbp), %rcx
movzbl (%rcx), %ecx
movl %ecx, %edx
leaq 0xa18c7(%rip), %rcx     # 0xaab40
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x928e
jmp 0x92a8
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x922f
cmpl $0x0, -0x14(%rbp)
jge 0x92b5
xorl %eax, %eax
movl %eax, -0x30(%rbp)
jmp 0x92e2
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0xa187b(%rip), %rax     # 0xaab40
movzbl (%rax,%rcx), %eax
movq -0x28(%rbp), %rcx
movzbl (%rcx), %ecx
movl %ecx, %edx
leaq 0xa1867(%rip), %rcx     # 0xaab40
movzbl (%rcx,%rdx), %ecx
subl %ecx, %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3Strlen30
SQLITE_PRIVATE int sqlite3Strlen30(const char *z){
  const char *z2 = z;
  if( z==0 ) return 0;
  while( *z2 ){ z2++; }
  return 0x3fffffff & (int)(z2 - z);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x9310
movl $0x0, -0x4(%rbp)
jmp 0x933c
jmp 0x9312
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x9329
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x9312
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_status
SQLITE_API int sqlite3_status(int op, int *pCurrent, int *pHighwater, int resetFlag){
  wsdStatInit;
  if( op<0 || op>=ArraySize(wsdStat.nowValue) ){
    return SQLITE_MISUSE_BKPT;
  }
  *pCurrent = wsdStat.nowValue[op];
  *pHighwater = wsdStat.mxValue[op];
  if( resetFlag ){
    wsdStat.mxValue[op] = wsdStat.nowValue[op];
  }
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpl $0x0, -0x8(%rbp)
jl 0x93b2
cmpl $0xa, -0x8(%rbp)
jl 0x93c1
movl $0x35d6, %edi           # imm = 0x35D6
callq 0x9420
movl %eax, -0x4(%rbp)
jmp 0x9414
movslq -0x8(%rbp), %rcx
leaq 0xc8a34(%rip), %rax     # 0xd1e00
movl (%rax,%rcx,4), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movslq -0x8(%rbp), %rcx
leaq 0xc8a20(%rip), %rax     # 0xd1e00
movl 0x28(%rax,%rcx,4), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
cmpl $0x0, -0x1c(%rbp)
je 0x940d
movslq -0x8(%rbp), %rcx
leaq 0xc8a05(%rip), %rax     # 0xd1e00
movl (%rax,%rcx,4), %edx
movslq -0x8(%rbp), %rcx
leaq 0xc89f7(%rip), %rax     # 0xd1e00
movl %edx, 0x28(%rax,%rcx,4)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3MisuseError
SQLITE_PRIVATE int sqlite3MisuseError(int lineno){
  testcase( sqlite3GlobalConfig.xLog!=0 );
  sqlite3_log(SQLITE_MISUSE, 
              "misuse at line %d of [%.10s]",
              lineno, 20+sqlite3_sourceid());
  return SQLITE_MISUSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
callq 0x17070
movl -0x8(%rbp), %edx
movq %rax, %rcx
addq $0x14, %rcx
movl $0x15, %edi
leaq 0xa8aa1(%rip), %rsi     # 0xb1eed
movb $0x0, %al
callq 0xc5f0
movl $0x15, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3BtreeEnterAll
SQLITE_PRIVATE void sqlite3BtreeEnterAll(sqlite3 *db){
  int i;
  for(i=0; i<db->nDb; i++){
    Btree *p = db->aDb[i].pBt;
    if( p ){
      p->pBt->db = p->db;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x98ed
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x98e0
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0x98e2
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x989f
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3PagerMemUsed
SQLITE_PRIVATE int sqlite3PagerMemUsed(Pager *pPager){
  int perPageSize = pPager->pageSize + pPager->nExtra + sizeof(PgHdr)
                                     + 5*sizeof(void*);
  return perPageSize*sqlite3PcachePagecount(pPager->pPCache)
           + sqlite3MallocSize(pPager)
           + pPager->pageSize;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0xbc(%rax), %eax
movq -0x8(%rbp), %rcx
movzwl 0xb0(%rcx), %ecx
addl %ecx, %eax
cltq
addq $0x48, %rax
addq $0x28, %rax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x110(%rax), %rdi
callq 0x1f6f0
movl %eax, %ecx
movl -0x14(%rbp), %eax
imull %ecx, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9990
movl %eax, %ecx
movl -0x10(%rbp), %eax
addl %ecx, %eax
movq -0x8(%rbp), %rcx
addl 0xbc(%rcx), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3DeleteTrigger
SQLITE_PRIVATE void sqlite3DeleteTrigger(sqlite3 *db, Trigger *pTrigger){
  if( pTrigger==0 ) return;
  sqlite3DeleteTriggerStep(db, pTrigger->step_list);
  sqlite3DbFree(db, pTrigger->zName);
  sqlite3DbFree(db, pTrigger->table);
  sqlite3ExprDelete(db, pTrigger->pWhen);
  sqlite3IdListDelete(db, pTrigger->pColumns);
  sqlite3DbFree(db, pTrigger);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x99c9
jmp 0x9a2a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x4c2e0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x9cd0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x9cd0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x47330
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x476c0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x9cd0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3VdbeClearObject
SQLITE_PRIVATE void sqlite3VdbeClearObject(sqlite3 *db, Vdbe *p){
  SubProgram *pSub, *pNext;
  int i;
  assert( p->db==0 || p->db==db );
  releaseMemArray(p->aVar, p->nVar);
  releaseMemArray(p->aColName, p->nResColumn*COLNAME_N);
  for(pSub=p->pProgram; pSub; pSub=pNext){
    pNext = pSub->pNext;
    vdbeFreeOpArray(db, pSub->aOp, pSub->nOp);
    sqlite3DbFree(db, pSub);
  }
  for(i=p->nzVar-1; i>=0; i--) sqlite3DbFree(db, p->azVar[i]);
  vdbeFreeOpArray(db, p->aOp, p->nOp);
  sqlite3DbFree(db, p->aLabel);
  sqlite3DbFree(db, p->aColName);
  sqlite3DbFree(db, p->zSql);
  sqlite3DbFree(db, p->pFree);
#if defined(SQLITE_ENABLE_TREE_EXPLAIN)
  sqlite3DbFree(db, p->zExplain);
  sqlite3DbFree(db, p->pExplain);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rdi
movq -0x10(%rbp), %rax
movswl 0x88(%rax), %esi
callq 0x2e430
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rax
movzwl 0x48(%rax), %esi
shll %esi
callq 0x2e430
movq -0x10(%rbp), %rax
movq 0x108(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x9c1f
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edx
callq 0x2e550
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9cd0
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x9bde
movq -0x10(%rbp), %rax
movswl 0x8a(%rax), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0x9c5d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x9cd0
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x9c30
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x34(%rax), %edx
callq 0x2e550
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
callq 0x9cd0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x9cd0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rsi
callq 0x9cd0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0xe8(%rax), %rsi
callq 0x9cd0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3DbFree
SQLITE_PRIVATE void sqlite3DbFree(sqlite3 *db, void *p){
  assert( db==0 || sqlite3_mutex_held(db->mutex) );
  if( db ){
    if( db->pnBytesFreed ){
      *db->pnBytesFreed += sqlite3DbMallocSize(db, p);
      return;
    }
    if( isLookaside(db, p) ){
      LookasideSlot *pBuf = (LookasideSlot*)p;
#if SQLITE_DEBUG
      /* Trash all content in the buffer being freed */
      memset(p, 0xaa, db->lookaside.sz);
#endif
      pBuf->pNext = db->lookaside.pFree;
      db->lookaside.pFree = pBuf;
      db->lookaside.nOut--;
      return;
    }
  }
  assert( sqlite3MemdebugHasType(p, MEMTYPE_DB) );
  assert( sqlite3MemdebugHasType(p, MEMTYPE_LOOKASIDE|MEMTYPE_HEAP) );
  assert( db!=0 || sqlite3MemdebugNoType(p, MEMTYPE_LOOKASIDE) );
  sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
  sqlite3_free(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x9d6b
movq -0x8(%rbp), %rax
cmpq $0x0, 0x328(%rax)
je 0x9d19
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1bac0
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq 0x328(%rax), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
jmp 0x9d74
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1bb20
cmpl $0x0, %eax
je 0x9d69
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x168(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x168(%rax)
movq -0x8(%rbp), %rax
movl 0x154(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x154(%rax)
jmp 0x9d74
jmp 0x9d6b
movq -0x10(%rbp), %rdi
callq 0xa420
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3PagerCacheStat
SQLITE_PRIVATE void sqlite3PagerCacheStat(Pager *pPager, int eStat, int reset, int *pnVal){

  assert( eStat==SQLITE_DBSTATUS_CACHE_HIT
       || eStat==SQLITE_DBSTATUS_CACHE_MISS
       || eStat==SQLITE_DBSTATUS_CACHE_WRITE
  );

  assert( SQLITE_DBSTATUS_CACHE_HIT+1==SQLITE_DBSTATUS_CACHE_MISS );
  assert( SQLITE_DBSTATUS_CACHE_HIT+2==SQLITE_DBSTATUS_CACHE_WRITE );
  assert( PAGER_STAT_HIT==0 && PAGER_STAT_MISS==1 && PAGER_STAT_WRITE==2 );

  *pnVal += pPager->aStat[eStat - SQLITE_DBSTATUS_CACHE_HIT];
  if( reset ){
    pPager->aStat[eStat - SQLITE_DBSTATUS_CACHE_HIT] = 0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x7, %ecx
movslq %ecx, %rcx
movl 0xf0(%rax,%rcx,4), %ecx
movq -0x18(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
cmpl $0x0, -0x10(%rbp)
je 0x9dcc
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x7, %ecx
movslq %ecx, %rcx
movl $0x0, 0xf0(%rax,%rcx,4)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_vfs_find
SQLITE_API sqlite3_vfs *sqlite3_vfs_find(const char *zVfs){
  sqlite3_vfs *pVfs = 0;
#if SQLITE_THREADSAFE
  sqlite3_mutex *mutex;
#endif
#ifndef SQLITE_OMIT_AUTOINIT
  int rc = sqlite3_initialize();
  if( rc ) return 0;
#endif
#if SQLITE_THREADSAFE
  mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
#endif
  sqlite3_mutex_enter(mutex);
  for(pVfs = vfsList; pVfs; pVfs=pVfs->pNext){
    if( zVfs==0 ) break;
    if( strcmp(zVfs, pVfs->zName)==0 ) break;
  }
  sqlite3_mutex_leave(mutex);
  return pVfs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
callq 0x9e60
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x9dfc
movq $0x0, -0x8(%rbp)
jmp 0x9e47
movq 0xc804d(%rip), %rax     # 0xd1e50
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x9e3f
cmpq $0x0, -0x10(%rbp)
jne 0x9e17
jmp 0x9e3f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x85d0
cmpl $0x0, %eax
jne 0x9e2f
jmp 0x9e3f
jmp 0x9e31
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x9e07
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_vfs_register
SQLITE_API int sqlite3_vfs_register(sqlite3_vfs *pVfs, int makeDflt){
  MUTEX_LOGIC(sqlite3_mutex *mutex;)
#ifndef SQLITE_OMIT_AUTOINIT
  int rc = sqlite3_initialize();
  if( rc ) return rc;
#endif
  MUTEX_LOGIC( mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER); )
  sqlite3_mutex_enter(mutex);
  vfsUnlink(pVfs);
  if( makeDflt || vfsList==0 ){
    pVfs->pNext = vfsList;
    vfsList = pVfs;
  }else{
    pVfs->pNext = vfsList->pNext;
    vfsList->pNext = pVfs;
  }
  assert(vfsList);
  sqlite3_mutex_leave(mutex);
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
callq 0x9e60
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0xa015
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xa073
movq -0x10(%rbp), %rdi
callq 0xa080
cmpl $0x0, -0x14(%rbp)
jne 0xa02e
cmpq $0x0, 0xc7e24(%rip)     # 0xd1e50
jne 0xa04a
movq 0xc7e1b(%rip), %rcx     # 0xd1e50
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq %rax, 0xc7e08(%rip)     # 0xd1e50
jmp 0xa06c
movq 0xc7dff(%rip), %rax     # 0xd1e50
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq 0xc7de8(%rip), %rax     # 0xd1e50
movq %rcx, 0x10(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: vfsUnlink
static void vfsUnlink(sqlite3_vfs *pVfs){
  assert( sqlite3_mutex_held(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER)) );
  if( pVfs==0 ){
    /* No-op */
  }else if( vfsList==pVfs ){
    vfsList = pVfs->pNext;
  }else if( vfsList ){
    sqlite3_vfs *p = vfsList;
    while( p->pNext && p->pNext!=pVfs ){
      p = p->pNext;
    }
    if( p->pNext==pVfs ){
      p->pNext = pVfs->pNext;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xa094
jmp 0xa124
movq 0xc7db5(%rip), %rax     # 0xd1e50
cmpq -0x8(%rbp), %rax
jne 0xa0b2
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, 0xc7da0(%rip)     # 0xd1e50
jmp 0xa122
cmpq $0x0, 0xc7d96(%rip)     # 0xd1e50
je 0xa120
movq 0xc7d8d(%rip), %rax     # 0xd1e50
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x10(%rcx)
movb %al, -0x11(%rbp)
je 0xa0e9
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x8(%rbp), %rax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0xa0f2
jmp 0xa100
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xa0c7
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0xa11e
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0xa120
jmp 0xa122
jmp 0xa124
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3MemoryAlarm
static int sqlite3MemoryAlarm(
  void(*xCallback)(void *pArg, sqlite3_int64 used,int N),
  void *pArg,
  sqlite3_int64 iThreshold
){
  int nUsed;
  sqlite3_mutex_enter(mem0.mutex);
  mem0.alarmCallback = xCallback;
  mem0.alarmArg = pArg;
  mem0.alarmThreshold = iThreshold;
  nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED);
  mem0.nearlyFull = (iThreshold>0 && iThreshold<=nUsed);
  sqlite3_mutex_leave(mem0.mutex);
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, 0xc7cb9(%rip)     # 0xd1e68
movq -0x10(%rbp), %rax
movq %rax, 0xc7cb6(%rip)     # 0xd1e70
movq -0x18(%rbp), %rax
movq %rax, 0xc7c9b(%rip)     # 0xd1e60
xorl %edi, %edi
callq 0x1b8f0
movl %eax, -0x1c(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x1d(%rbp)
jle 0xa1ec
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpq %rcx, %rax
setle %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0xc7c92(%rip)     # 0xd1e8c
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_soft_heap_limit64
SQLITE_API sqlite3_int64 sqlite3_soft_heap_limit64(sqlite3_int64 n){
  sqlite3_int64 priorLimit;
  sqlite3_int64 excess;
#ifndef SQLITE_OMIT_AUTOINIT
  int rc = sqlite3_initialize();
  if( rc ) return -1;
#endif
  sqlite3_mutex_enter(mem0.mutex);
  priorLimit = mem0.alarmThreshold;
  sqlite3_mutex_leave(mem0.mutex);
  if( n<0 ) return priorLimit;
  if( n>0 ){
    sqlite3MemoryAlarm(softHeapLimitEnforcer, 0, n);
  }else{
    sqlite3MemoryAlarm(0, 0, 0);
  }
  excess = sqlite3_memory_used() - n;
  if( excess>0 ) sqlite3_release_memory((int)(excess & 0x7fffffff));
  return priorLimit;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
callq 0x9e60
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0xa234
movq $-0x1, -0x8(%rbp)
jmp 0xa2a9
movq 0xc7c25(%rip), %rax     # 0xd1e60
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jge 0xa250
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa2a9
cmpq $0x0, -0x10(%rbp)
jle 0xa26d
movq -0x10(%rbp), %rdx
leaq 0x5e(%rip), %rdi        # 0xa2c0
xorl %eax, %eax
movl %eax, %esi
callq 0xa190
jmp 0xa27c
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rdi
movq %rdx, %rsi
callq 0xa190
callq 0xa2f0
subq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jle 0xa2a1
movq -0x20(%rbp), %rax
andq $0x7fffffff, %rax       # imm = 0x7FFFFFFF
movl %eax, %edi
callq 0xa150
movq -0x18(%rbp), %rax
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/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_memory_used
sqlite3_memory_used(void){
  int n, mx;
  sqlite3_int64 res;
  sqlite3_status(SQLITE_STATUS_MEMORY_USED, &n, &mx, 0);
  res = (sqlite3_int64)n;  /* Work around bug in Borland C. Ticket #3216 */
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
xorl %ecx, %ecx
leaq -0x4(%rbp), %rsi
leaq -0x8(%rbp), %rdx
movl %ecx, %edi
callq 0x9390
movslq -0x4(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_memory_highwater
SQLITE_API sqlite3_int64 sqlite3_memory_highwater(int resetFlag){
  int n, mx;
  sqlite3_int64 res;
  sqlite3_status(SQLITE_STATUS_MEMORY_USED, &n, &mx, resetFlag);
  res = (sqlite3_int64)mx;  /* Work around bug in Borland C. Ticket #3216 */
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %ecx
xorl %edi, %edi
leaq -0x8(%rbp), %rsi
leaq -0xc(%rbp), %rdx
callq 0x9390
movslq -0xc(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3Malloc
SQLITE_PRIVATE void *sqlite3Malloc(int n){
  void *p;
  if( n<=0               /* IMP: R-65312-04917 */ 
   || n>=0x7fffff00
  ){
    /* A memory allocation of a number of bytes which is near the maximum
    ** signed integer value might cause an integer overflow inside of the
    ** xMalloc().  Hence we limit the maximum size to 0x7fffff00, giving
    ** 255 bytes of overhead.  SQLite itself will never use anything near
    ** this amount.  The only way to reach the limit is with sqlite3_malloc() */
    p = 0;
  }else if( sqlite3GlobalConfig.bMemstat ){
    sqlite3_mutex_enter(mem0.mutex);
    mallocWithAlarm(n, &p);
    sqlite3_mutex_leave(mem0.mutex);
  }else{
    p = sqlite3GlobalConfig.m.xMalloc(n);
  }
  assert( EIGHT_BYTE_ALIGNMENT(p) );  /* IMP: R-04675-44850 */
  return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jle 0xa3da
cmpl $0x7fffff00, -0x4(%rbp) # imm = 0x7FFFFF00
jl 0xa3e4
movq $0x0, -0x10(%rbp)
jmp 0xa40d
cmpl $0x0, 0xc60a5(%rip)     # 0xd0490
je 0xa3fb
movl -0x4(%rbp), %edi
leaq -0x10(%rbp), %rsi
callq 0x1b910
jmp 0xa40b
movq 0xc60ae(%rip), %rax     # 0xd04b0
movl -0x4(%rbp), %edi
callq *%rax
movq %rax, -0x10(%rbp)
jmp 0xa40d
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_free
SQLITE_API void sqlite3_free(void *p){
  if( p==0 ) return;  /* IMP: R-49053-54554 */
  assert( sqlite3MemdebugNoType(p, MEMTYPE_DB) );
  assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
  if( sqlite3GlobalConfig.bMemstat ){
    sqlite3_mutex_enter(mem0.mutex);
    sqlite3StatusAdd(SQLITE_STATUS_MEMORY_USED, -sqlite3MallocSize(p));
    sqlite3StatusAdd(SQLITE_STATUS_MALLOC_COUNT, -1);
    sqlite3GlobalConfig.m.xFree(p);
    sqlite3_mutex_leave(mem0.mutex);
  }else{
    sqlite3GlobalConfig.m.xFree(p);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xa435
jmp 0xa47d
cmpl $0x0, 0xc6054(%rip)     # 0xd0490
je 0xa470
movq -0x8(%rbp), %rdi
callq 0x9990
xorl %esi, %esi
subl %eax, %esi
xorl %edi, %edi
callq 0xa490
movl $0x9, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xa490
movq 0xc6050(%rip), %rax     # 0xd04b8
movq -0x8(%rbp), %rdi
callq *%rax
jmp 0xa47d
movq 0xc6041(%rip), %rax     # 0xd04b8
movq -0x8(%rbp), %rdi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3StatusAdd
SQLITE_PRIVATE void sqlite3StatusAdd(int op, int N){
  wsdStatInit;
  assert( op>=0 && op<ArraySize(wsdStat.nowValue) );
  wsdStat.nowValue[op] += N;
  if( wsdStat.nowValue[op]>wsdStat.mxValue[op] ){
    wsdStat.mxValue[op] = wsdStat.nowValue[op];
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x8(%rbp), %edx
movslq -0x4(%rbp), %rcx
leaq 0xc7958(%rip), %rax     # 0xd1e00
addl (%rax,%rcx,4), %edx
leaq 0xc794e(%rip), %rax     # 0xd1e00
movl %edx, (%rax,%rcx,4)
movslq -0x4(%rbp), %rcx
leaq 0xc7940(%rip), %rax     # 0xd1e00
movl (%rax,%rcx,4), %eax
movslq -0x4(%rbp), %rdx
leaq 0xc7932(%rip), %rcx     # 0xd1e00
cmpl 0x28(%rcx,%rdx,4), %eax
jle 0xa4f1
movslq -0x4(%rbp), %rcx
leaq 0xc7921(%rip), %rax     # 0xd1e00
movl (%rax,%rcx,4), %edx
movslq -0x4(%rbp), %rcx
leaq 0xc7913(%rip), %rax     # 0xd1e00
movl %edx, 0x28(%rax,%rcx,4)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_vmprintf
SQLITE_API char *sqlite3_vmprintf(const char *zFormat, va_list ap){
  char *z;
  char zBase[SQLITE_PRINT_BUF_SIZE];
  StrAccum acc;
#ifndef SQLITE_OMIT_AUTOINIT
  if( sqlite3_initialize() ) return 0;
#endif
  sqlite3StrAccumInit(&acc, zBase, sizeof(zBase), SQLITE_MAX_LENGTH);
  acc.useMalloc = 2;
  sqlite3VXPrintf(&acc, 0, zFormat, ap);
  z = sqlite3StrAccumFinish(&acc);
  return z;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
callq 0x9e60
cmpl $0x0, %eax
je 0xa6c7
movq $0x0, -0x8(%rbp)
jmp 0xa713
leaq -0x70(%rbp), %rsi
leaq -0x98(%rbp), %rdi
movl $0x46, %edx
movl $0x3b9aca00, %ecx       # imm = 0x3B9ACA00
callq 0xa720
movb $0x2, -0x74(%rbp)
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq -0x98(%rbp), %rdi
xorl %esi, %esi
callq 0xa790
leaq -0x98(%rbp), %rdi
callq 0xc310
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3StrAccumInit
SQLITE_PRIVATE void sqlite3StrAccumInit(StrAccum *p, char *zBase, int n, int mx){
  p->zText = p->zBase = zBase;
  p->db = 0;
  p->nChar = 0;
  p->nAlloc = n;
  p->mxAlloc = mx;
  p->useMalloc = 1;
  p->accError = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x18(%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1c(%rax)
movl -0x18(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x8(%rbp), %rax
movb $0x1, 0x24(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x25(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3StrAccumFinish
SQLITE_PRIVATE char *sqlite3StrAccumFinish(StrAccum *p){
  if( p->zText ){
    p->zText[p->nChar] = 0;
    if( p->useMalloc && p->zText==p->zBase ){
      if( p->useMalloc==1 ){
        p->zText = sqlite3DbMallocRaw(p->db, p->nChar+1 );
      }else{
        p->zText = sqlite3_malloc(p->nChar+1);
      }
      if( p->zText ){
        memcpy(p->zText, p->zBase, p->nChar+1);
      }else{
        p->accError = STRACCUM_NOMEM;
      }
    }
  }
  return p->zText;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xc3eb
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x18(%rcx), %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rax
movzbl 0x24(%rax), %eax
cmpl $0x0, %eax
je 0xc3e9
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0xc3e9
movq -0x8(%rbp), %rax
movzbl 0x24(%rax), %eax
cmpl $0x1, %eax
jne 0xc396
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x18(%rax), %esi
addl $0x1, %esi
callq 0x134e0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0xc3b0
movq -0x8(%rbp), %rax
movl 0x18(%rax), %edi
addl $0x1, %edi
callq 0xa380
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xc3df
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
addl $0x1, %eax
movslq %eax, %rdx
callq 0x82f0
jmp 0xc3e7
movq -0x8(%rbp), %rax
movb $0x1, 0x25(%rax)
jmp 0xc3e9
jmp 0xc3eb
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_mprintf
SQLITE_API char *sqlite3_mprintf(const char *zFormat, ...){
  va_list ap;
  char *z;
#ifndef SQLITE_OMIT_AUTOINIT
  if( sqlite3_initialize() ) return 0;
#endif
  va_start(ap, zFormat);
  z = sqlite3_vmprintf(zFormat, ap);
  va_end(ap);
  return z;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0xc43b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rsi, -0xe8(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x9e60
cmpl $0x0, %eax
je 0xc476
movq $0x0, -0x8(%rbp)
jmp 0xc4b7
leaq -0x30(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xa6a0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rax
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_vsnprintf
SQLITE_API char *sqlite3_vsnprintf(int n, char *zBuf, const char *zFormat, va_list ap){
  StrAccum acc;
  if( n<=0 ) return zBuf;
  sqlite3StrAccumInit(&acc, zBuf, n, 0);
  acc.useMalloc = 0;
  sqlite3VXPrintf(&acc, 0, zFormat, ap);
  return sqlite3StrAccumFinish(&acc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpl $0x0, -0xc(%rbp)
jg 0xc4f7
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xc52d
movq -0x18(%rbp), %rsi
movl -0xc(%rbp), %edx
leaq -0x50(%rbp), %rdi
xorl %ecx, %ecx
callq 0xa720
movb $0x0, -0x2c(%rbp)
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
callq 0xa790
leaq -0x50(%rbp), %rdi
callq 0xc310
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_snprintf
SQLITE_API char *sqlite3_snprintf(int n, char *zBuf, const char *zFormat, ...){
  char *z;
  va_list ap;
  va_start(ap,zFormat);
  z = sqlite3_vsnprintf(n, zBuf, zFormat, ap);
  va_end(ap);
  return z;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0xc57b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0xf0(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x30, -0x3c(%rbp)
movl $0x18, -0x40(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0xc4d0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_log
SQLITE_API void sqlite3_log(int iErrCode, const char *zFormat, ...){
  va_list ap;                             /* Vararg list */
  if( sqlite3GlobalConfig.xLog ){
    va_start(ap, zFormat);
    renderLogMsg(iErrCode, zFormat, ap);
    va_end(ap);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0xc628
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, 0xc3fc5(%rip)     # 0xd0618
je 0xc68d
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0xc6a0
leaq -0x30(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)