LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/mtgp64-fast.c
// Function: alloc_state
static int alloc_state(mtgp64_fast_t *mtgp64,
		       const mtgp64_params_fast_t *para) {
    int size = para->mexp / 64 + 1;
    int large_size;
    mtgp64_status_fast_t *st;

    int x;
    int y = size;
    for (x = 1; (x != size) && (y > 0); x <<= 1, y >>= 1);
    large_size = x;

    st = (mtgp64_status_fast_t *)malloc(sizeof(mtgp64_status_fast_t)
				     + sizeof(uint64_t) * large_size);
    if (st == NULL) {
	return -1;
    }
    mtgp64->params = *para;
    mtgp64->status = st;
    st->size = size;
    st->large_size = large_size;
    st->large_mask = large_size -1;
    return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movl (%rax), %eax
movl $0x40, %ecx
cltd
idivl %ecx
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0x8(%rsp)
movl $0x1, 0xc(%rsp)
movl 0xc(%rsp), %ecx
xorl %eax, %eax
cmpl 0x1c(%rsp), %ecx
movb %al, 0x7(%rsp)
je 0x12a0
cmpl $0x0, 0x8(%rsp)
setg %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x12aa
jmp 0x12c2
jmp 0x12ac
movl 0xc(%rsp), %eax
shll %eax
movl %eax, 0xc(%rsp)
movl 0x8(%rsp), %eax
sarl %eax
movl %eax, 0x8(%rsp)
jmp 0x1284
movl 0xc(%rsp), %eax
movl %eax, 0x18(%rsp)
movslq 0x18(%rsp), %rdi
shlq $0x3, %rdi
addq $0x10, %rdi
callq 0x10b0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x12f3
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x1347
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl $0x1b0, %edx            # imm = 0x1B0
callq 0x10a0
movq 0x10(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x1b0(%rax)
movl 0x1c(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x4(%rax)
movl 0x18(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x8(%rax)
movl 0x18(%rsp), %ecx
subl $0x1, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0xc(%rax)
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/mtgp64-fast.c
// Function: mtgp64_init_state
void mtgp64_init_state(uint64_t array[],
		      const mtgp64_params_fast_t *para, uint64_t seed) {
    int i;
    int size = para->mexp / 64 + 1;
    uint64_t hidden_seed;
    uint64_t tmp;
    hidden_seed = para->tbl[4] ^ (para->tbl[8] << 16);
    tmp = hidden_seed >> 32;
    tmp += tmp >> 16;
    tmp += tmp >> 8;
    memset(array, tmp & 0xff, sizeof(uint64_t) * size);
    array[0] = seed;
    array[1] = hidden_seed;
    for (i = 1; i < size; i++) {
	array[i] ^= UINT64_C(6364136223846793005)
	    * (array[i - 1]
	       ^ (array[i - 1] >> 62)) + i;
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x28(%rsp), %rax
movl (%rax), %eax
movl $0x40, %ecx
cltd
idivl %ecx
addl $0x1, %eax
movl %eax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x28(%rsp), %rcx
movq 0x50(%rcx), %rcx
shlq $0x10, %rcx
xorq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
shrq $0x20, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
shrq $0x10, %rax
addq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
shrq $0x8, %rax
addq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rax
andq $0xff, %rax
movslq 0x18(%rsp), %rdx
shlq $0x3, %rdx
movzbl %al, %esi
callq 0x1070
movq 0x20(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
movl $0x1, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x18(%rsp), %eax
jge 0x147b
movq 0x30(%rsp), %rax
movl 0x1c(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
movq 0x30(%rsp), %rax
movl 0x1c(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
shrq $0x3e, %rax
xorq %rax, %rdx
movabsq $0x5851f42d4c957f2d, %rax # imm = 0x5851F42D4C957F2D
imulq %rax, %rdx
movslq 0x1c(%rsp), %rax
addq %rax, %rdx
movq 0x30(%rsp), %rax
movslq 0x1c(%rsp), %rcx
xorq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x140f
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/mtgp64-fast.c
// Function: mtgp64_print_idstring
void mtgp64_print_idstring(const mtgp64_fast_t *mtgp64, FILE *fp) {
    int i;
    fprintf(fp, "mtgp64:%d:", mtgp64->params.mexp);
    for (i = 0; i < 20; i++) {
	fprintf(fp, "%02x", (unsigned int)mtgp64->params.poly_sha1[i]);
    }
    fprintf(fp, "\n");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movl (%rax), %edx
leaq 0x1927(%rip), %rsi      # 0x4018
movb $0x0, %al
callq 0x1080
movl $0x0, 0x4(%rsp)
cmpl $0x14, 0x4(%rsp)
jge 0x2739
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movslq 0x4(%rsp), %rcx
movzbl 0x198(%rax,%rcx), %edx
leaq 0x18fe(%rip), %rsi      # 0x4023
movb $0x0, %al
callq 0x1080
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x2700
movq 0x8(%rsp), %rdi
leaq 0x1903(%rip), %rsi      # 0x4048
movb $0x0, %al
callq 0x1080
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/mtgp64-fast.c
// Function: print_uint64
void print_uint64(mtgp64_fast_t *mtgp64, int count) {
    int i;
    for (i = 0; i < count; i++) {
	printf("%016"PRIx64" ", mtgp64_genrand_uint64(mtgp64));
	if (i % 3 == 2) {
	    printf("\n");
	}
    }
    printf("\n");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x27c8
movq 0x10(%rsp), %rdi
callq 0x27e0
movq %rax, %rsi
leaq 0x1895(%rip), %rdi      # 0x4028
movb $0x0, %al
callq 0x1060
movl 0x8(%rsp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
cmpl $0x2, %edx
jne 0x27b9
leaq 0x1896(%rip), %rdi      # 0x4048
movb $0x0, %al
callq 0x1060
jmp 0x27bb
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x2775
leaq 0x1879(%rip), %rdi      # 0x4048
movb $0x0, %al
callq 0x1060
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/./mtgp64-fast.h
// Function: mtgp64_genrand_uint64
inline static uint64_t mtgp64_genrand_uint64(mtgp64_fast_t *mtgp64) {
    int idx;
    uint64_t *tmp_tbl = mtgp64->params.tmp_tbl;
    uint64_t *array = mtgp64->status->array;
    int pos = mtgp64->params.pos;
    int large_size = mtgp64->status->large_size;
    int size = mtgp64->status->size;
    uint64_t large_mask = mtgp64->status->large_mask;

    mtgp64_next_state(mtgp64);
    idx = mtgp64->status->idx;
    return mtgp64_temper(tmp_tbl,
			 array[idx],
			 array[(idx + pos - 1 - size + large_size)
			       & large_mask]);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x90, %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq 0x1b0(%rax), %rax
addq $0x10, %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x30(%rsp), %rax
movq 0x1b0(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq 0x1b0(%rax), %rax
movl 0x4(%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rax
movq 0x1b0(%rax), %rax
movslq 0xc(%rax), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
callq 0x30c0
movq 0x30(%rsp), %rax
movq 0x1b0(%rax), %rax
movl (%rax), %eax
movl %eax, 0x2c(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
movq 0x18(%rsp), %rax
movl 0x2c(%rsp), %ecx
addl 0x14(%rsp), %ecx
subl $0x1, %ecx
subl 0xc(%rsp), %ecx
addl 0x10(%rsp), %ecx
movslq %ecx, %rcx
andq (%rsp), %rcx
movq (%rax,%rcx,8), %rdx
callq 0x3210
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/./mtgp64-fast.h
// Function: mtgp64_genrand_close1_open2
inline static double mtgp64_genrand_close1_open2(mtgp64_fast_t *mtgp64) {
    int idx;
    uint64_t *dbl_tmp_tbl = mtgp64->params.dbl_tmp_tbl;
    uint64_t *array = mtgp64->status->array;
    int pos = mtgp64->params.pos;
    int large_size = mtgp64->status->large_size;
    int size = mtgp64->status->size;
    uint64_t large_mask = mtgp64->status->large_mask;

    mtgp64_next_state(mtgp64);
    idx = mtgp64->status->idx;
    return mtgp64_temper_double(dbl_tmp_tbl,
				array[idx],
				array[(idx + pos - 1 - size + large_size)
				      & large_mask]);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x110, %rax            # imm = 0x110
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq 0x1b0(%rax), %rax
addq $0x10, %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x30(%rsp), %rax
movq 0x1b0(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq 0x1b0(%rax), %rax
movl 0x4(%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rax
movq 0x1b0(%rax), %rax
movslq 0xc(%rax), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
callq 0x30c0
movq 0x30(%rsp), %rax
movq 0x1b0(%rax), %rax
movl (%rax), %eax
movl %eax, 0x2c(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
movq 0x18(%rsp), %rax
movl 0x2c(%rsp), %ecx
addl 0x14(%rsp), %ecx
subl $0x1, %ecx
subl 0xc(%rsp), %ecx
addl 0x10(%rsp), %ecx
movslq %ecx, %rcx
andq (%rsp), %rcx
movq (%rax,%rcx,8), %rdx
callq 0x3380
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/mtgp64-fast.c
// Function: print_close_open
void print_close_open(mtgp64_fast_t *mtgp64, int count) {
    int i;
    for (i = 0; i < count; i++) {
	printf("%.18f ", mtgp64_genrand_close_open(mtgp64));
	if (i % 3 == 2) {
	    printf("\n");
	}
    }
    printf("\n");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x2a65
movq 0x10(%rsp), %rdi
callq 0x2a80
leaq 0x1600(%rip), %rdi      # 0x4030
movb $0x1, %al
callq 0x1060
movl 0x8(%rsp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
cmpl $0x2, %edx
jne 0x2a56
leaq 0x15f9(%rip), %rdi      # 0x4048
movb $0x0, %al
callq 0x1060
jmp 0x2a58
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x2a15
leaq 0x15dc(%rip), %rdi      # 0x4048
movb $0x0, %al
callq 0x1060
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/mtgp64-fast.c
// Function: print_open_close
void print_open_close(mtgp64_fast_t *mtgp64, int count) {
    int i;
    for (i = 0; i < count; i++) {
	printf("%.18f ", mtgp64_genrand_open_close(mtgp64));
	if (i % 3 == 2) {
	    printf("\n");
	}
    }
    printf("\n");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x2b05
movq 0x10(%rsp), %rdi
callq 0x2b20
leaq 0x1560(%rip), %rdi      # 0x4030
movb $0x1, %al
callq 0x1060
movl 0x8(%rsp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
cmpl $0x2, %edx
jne 0x2af6
leaq 0x1559(%rip), %rdi      # 0x4048
movb $0x0, %al
callq 0x1060
jmp 0x2af8
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x2ab5
leaq 0x153c(%rip), %rdi      # 0x4048
movb $0x0, %al
callq 0x1060
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/./mtgp64-fast.h
// Function: mtgp64_genrand_open_open
inline static double mtgp64_genrand_open_open(mtgp64_fast_t *mtgp64) {
    double r;
    int idx;
    uint64_t *dbl_tmp_tbl = mtgp64->params.dbl_tmp_tbl;
    uint64_t *array = mtgp64->status->array;
    int pos = mtgp64->params.pos;
    int large_size = mtgp64->status->large_size;
    int size = mtgp64->status->size;
    uint64_t large_mask = mtgp64->status->large_mask;
    mtgp64_next_state(mtgp64);
    idx = mtgp64->status->idx;
    r = mtgp64_temper_double_open(dbl_tmp_tbl,
				  array[idx],
				  array[(idx + pos - 1 - size + large_size)
					& large_mask]);
    return r - 1.0;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x110, %rax            # imm = 0x110
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rax
movq 0x1b0(%rax), %rax
addq $0x10, %rax
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x1c(%rsp)
movq 0x40(%rsp), %rax
movq 0x1b0(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, 0x18(%rsp)
movq 0x40(%rsp), %rax
movq 0x1b0(%rax), %rax
movl 0x4(%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x40(%rsp), %rax
movq 0x1b0(%rax), %rax
movslq 0xc(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
callq 0x30c0
movq 0x40(%rsp), %rax
movq 0x1b0(%rax), %rax
movl (%rax), %eax
movl %eax, 0x34(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movslq 0x34(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
movq 0x20(%rsp), %rax
movl 0x34(%rsp), %ecx
addl 0x1c(%rsp), %ecx
subl $0x1, %ecx
subl 0x14(%rsp), %ecx
addl 0x18(%rsp), %ecx
movslq %ecx, %rcx
andq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
callq 0x33f0
movsd %xmm0, 0x38(%rsp)
movsd 0x38(%rsp), %xmm0
movsd 0x1367(%rip), %xmm1     # 0x4008
subsd %xmm1, %xmm0
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/./mtgp64-fast.h
// Function: mtgp64_next_state
inline static void mtgp64_next_state(mtgp64_fast_t *mtgp64) {
    uint64_t *array = mtgp64->status->array;
    int idx;
    int pos = mtgp64->params.pos;
    int large_size = mtgp64->status->large_size;
    uint64_t large_mask = mtgp64->status->large_mask;
    int size = mtgp64->status->size;

    mtgp64->status->idx = (mtgp64->status->idx + 1) & large_mask;
    idx = mtgp64->status->idx;
    mtgp64_do_recursion(&(array[idx]),
			array[(idx - size + large_size) & large_mask],
			array[(idx - size + large_size + 1) & large_mask],
			array[(idx + pos - size + large_size) & large_mask],
			mtgp64->params.sh1,
			mtgp64->params.sh2,
			mtgp64->params.mask,
			mtgp64->params.tbl);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq 0x1b0(%rax), %rax
addq $0x10, %rax
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq 0x1b0(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, 0x2c(%rsp)
movq 0x40(%rsp), %rax
movq 0x1b0(%rax), %rax
movslq 0xc(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rax
movq 0x1b0(%rax), %rax
movl 0x4(%rax), %eax
movl %eax, 0x1c(%rsp)
movq 0x40(%rsp), %rax
movq 0x1b0(%rax), %rax
movl (%rax), %eax
addl $0x1, %eax
cltq
andq 0x20(%rsp), %rax
movl %eax, %ecx
movq 0x40(%rsp), %rax
movq 0x1b0(%rax), %rax
movl %ecx, (%rax)
movq 0x40(%rsp), %rax
movq 0x1b0(%rax), %rax
movl (%rax), %eax
movl %eax, 0x34(%rsp)
movq 0x38(%rsp), %rdi
movslq 0x34(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq 0x38(%rsp), %rax
movl 0x34(%rsp), %ecx
subl 0x1c(%rsp), %ecx
addl 0x2c(%rsp), %ecx
movslq %ecx, %rcx
andq 0x20(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
movq 0x38(%rsp), %rax
movl 0x34(%rsp), %ecx
subl 0x1c(%rsp), %ecx
addl 0x2c(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
andq 0x20(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
movq 0x38(%rsp), %rax
movl 0x34(%rsp), %ecx
addl 0x30(%rsp), %ecx
subl 0x1c(%rsp), %ecx
addl 0x2c(%rsp), %ecx
movslq %ecx, %rcx
andq 0x20(%rsp), %rcx
movq (%rax,%rcx,8), %rcx
movq 0x40(%rsp), %rax
movl 0x8(%rax), %r8d
movq 0x40(%rsp), %rax
movl 0xc(%rax), %r9d
movq 0x40(%rsp), %rax
movq 0x190(%rax), %r10
movq 0x40(%rsp), %rax
addq $0x10, %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x3270
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/./mtgp64-fast.h
// Function: mtgp64_temper
inline static uint64_t mtgp64_temper(const uint64_t tmp_tbl[16],
				     uint64_t r, uint64_t t) {
    t ^= t >> 16;
    t ^= t >> 8;
    r ^= tmp_tbl[t & 0x0f];
    return r;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x18(%rsp), %rax
shrq $0x10, %rax
xorq -0x18(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
shrq $0x8, %rax
xorq -0x18(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq -0x18(%rsp), %rcx
andq $0xf, %rcx
movq (%rax,%rcx,8), %rax
xorq -0x10(%rsp), %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/./mtgp64-fast.h
// Function: mtgp64_do_recursion
inline static void mtgp64_do_recursion(uint64_t *r, uint64_t x1,
				       uint64_t x2, uint64_t y,
				       int sh1, int sh2,
				       uint64_t mask, uint64_t tbl[16]) {
    uint64_t x;
    uint32_t xh;
    uint32_t xl;
    uint32_t yh;
    uint32_t yl;

    x = (x1 & mask) ^ x2;
    xh = (uint32_t)(x >> 32);
    xl = (uint32_t)(x & 0xffffffffU);
    yh = (uint32_t)(y >> 32);
    yl = (uint32_t)(y & 0xffffffffU);
    xh ^= xh << sh1;
    xl ^= xl << sh1;
    yh = xl ^ (yh >> sh2);
    yl = xh ^ (yl >> sh2);
    *r = ((uint64_t)yh << 32) | yl;
    *r ^= tbl[yl & 0x0f];
}

// Assembly:
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rax
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movl %r8d, -0x24(%rsp)
movl %r9d, -0x28(%rsp)
movq -0x10(%rsp), %rax
andq 0x8(%rsp), %rax
xorq -0x18(%rsp), %rax
movq %rax, -0x30(%rsp)
movq -0x30(%rsp), %rax
shrq $0x20, %rax
movl %eax, -0x34(%rsp)
movabsq $0xffffffff, %rax       # imm = 0xFFFFFFFF
andq -0x30(%rsp), %rax
movl %eax, -0x38(%rsp)
movq -0x20(%rsp), %rax
shrq $0x20, %rax
movl %eax, -0x3c(%rsp)
movabsq $0xffffffff, %rax       # imm = 0xFFFFFFFF
andq -0x20(%rsp), %rax
movl %eax, -0x40(%rsp)
movl -0x34(%rsp), %eax
movl -0x24(%rsp), %ecx
shll %cl, %eax
xorl -0x34(%rsp), %eax
movl %eax, -0x34(%rsp)
movl -0x38(%rsp), %eax
movl -0x24(%rsp), %ecx
shll %cl, %eax
xorl -0x38(%rsp), %eax
movl %eax, -0x38(%rsp)
movl -0x38(%rsp), %eax
movl -0x3c(%rsp), %edx
movl -0x28(%rsp), %ecx
shrl %cl, %edx
movl %edx, %ecx
xorl %ecx, %eax
movl %eax, -0x3c(%rsp)
movl -0x34(%rsp), %eax
movl -0x40(%rsp), %edx
movl -0x28(%rsp), %ecx
shrl %cl, %edx
movl %edx, %ecx
xorl %ecx, %eax
movl %eax, -0x40(%rsp)
movl -0x3c(%rsp), %eax
movl %eax, %ecx
shlq $0x20, %rcx
movl -0x40(%rsp), %eax
orq %rax, %rcx
movq -0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movl -0x40(%rsp), %ecx
andl $0xf, %ecx
movl %ecx, %ecx
movq (%rax,%rcx,8), %rcx
movq -0x8(%rsp), %rax
xorq (%rax), %rcx
movq %rcx, (%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/./mtgp64-fast.h
// Function: mtgp64_temper_double
inline static double mtgp64_temper_double(const uint64_t dbl_tmp_tbl[16],
					  uint64_t r, uint64_t t) {
    union {
	uint64_t u;
	double d;
    } x;
    t ^= t >> 16;
    t ^= t >> 8;
    r = r >> 12;
    x.u = r ^ dbl_tmp_tbl[t & 0x0f];
    return x.d;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x18(%rsp), %rax
shrq $0x10, %rax
xorq -0x18(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
shrq $0x8, %rax
xorq -0x18(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x10(%rsp), %rax
shrq $0xc, %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq -0x8(%rsp), %rcx
movq -0x18(%rsp), %rdx
andq $0xf, %rdx
xorq (%rcx,%rdx,8), %rax
movq %rax, -0x20(%rsp)
movsd -0x20(%rsp), %xmm0
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/./mtgp64-fast.h
// Function: mtgp64_temper_double_open
inline static double mtgp64_temper_double_open(const uint64_t dbl_tmp_tbl[16],
					       uint64_t r, uint64_t t) {
    union {
	uint64_t u;
	double d;
    } x;
    t ^= t >> 16;
    t ^= t >> 8;
    r = (r >> 12) | 1;
    x.u = r ^ dbl_tmp_tbl[t & 0x0f];
    return x.d;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x18(%rsp), %rax
shrq $0x10, %rax
xorq -0x18(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
shrq $0x8, %rax
xorq -0x18(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x10(%rsp), %rax
shrq $0xc, %rax
orq $0x1, %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq -0x8(%rsp), %rcx
movq -0x18(%rsp), %rdx
andq $0xf, %rdx
xorq (%rcx,%rdx,8), %rax
movq %rax, -0x20(%rsp)
movsd -0x20(%rsp), %xmm0
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Joy-Division[P]tools-mgs/stage-extract.c
// Function: getInfoFromFlags
char *getInfoFromFlags(unsigned int flags) {
	char *retstring = malloc(16);
	switch(flags) {
		case 'c' : RETPRINT("cache")
		case 'n' : RETPRINT("nocache")
		case 'r' : RETPRINT("resident")
		case 's' : RETPRINT("sound")
		default: {
			sprintf( retstring, "%02x", flags );
			break;
		}
	}
	return retstring;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl $0x10, %edi
callq 0x1100
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %eax
addl $-0x63, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x10, %eax
ja 0x1a3e
movq -0x18(%rbp), %rax
leaq 0x16ff(%rip), %rcx      # 0x30c8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
leaq 0x17d2(%rip), %rsi      # 0x31af
leaq 0x1778(%rip), %rdx      # 0x315c
movb $0x0, %al
callq 0x1160
jmp 0x1a53
movq -0x10(%rbp), %rdi
leaq 0x17b7(%rip), %rsi      # 0x31af
leaq 0x175b(%rip), %rdx      # 0x315a
movb $0x0, %al
callq 0x1160
jmp 0x1a53
movq -0x10(%rbp), %rdi
leaq 0x179c(%rip), %rsi      # 0x31af
leaq 0x1748(%rip), %rdx      # 0x3162
movb $0x0, %al
callq 0x1160
jmp 0x1a53
movq -0x10(%rbp), %rdi
leaq 0x1781(%rip), %rsi      # 0x31af
leaq 0x1736(%rip), %rdx      # 0x316b
movb $0x0, %al
callq 0x1160
jmp 0x1a53
movq -0x10(%rbp), %rdi
movl -0x4(%rbp), %edx
leaq 0x1725(%rip), %rsi      # 0x3171
movb $0x0, %al
callq 0x1160
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Joy-Division[P]tools-mgs/stage-extract.c
// Function: getNameFromDetails
char *getNameFromDetails(uint16_t hash, uint16_t extension, unsigned int flags, unsigned int texnum) {
	char *retstring = malloc(32);
	unsigned int result;
	if(!hash) {
		switch(flags) {
			case 0x63: RETPRINT("stg_mdl1.dar")
			case 0x6E: {
				sprintf( retstring, "%s%d.dar", "stg_tex", texnum );
				break;
			}
			case 0x72: RETPRINT("res_mdl1.dar")
		}
	}
	else {
		result = matchhash(hash, extension, stagedic, numstagedic);
		if(result != 0xFFFFFFFF) sprintf(retstring, "%s", stagedic[result].name);
		else {
			result = matchhash(hash, extension, commondic, numcommondic);
			if(result != 0xFFFFFFFF) sprintf(retstring, "%s", commondic[result].name);
			else {
				sprintf( retstring, "%04x.%c", hash, extension );
			}
		}
	}
	return retstring;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movw %di, %si
movw %si, -0x2(%rbp)
movw %ax, -0x4(%rbp)
movl %edx, -0x8(%rbp)
movl %ecx, -0xc(%rbp)
movl $0x20, %edi
callq 0x1100
movq %rax, -0x18(%rbp)
cmpw $0x0, -0x2(%rbp)
jne 0x1b09
movl -0x8(%rbp), %eax
movl %eax, -0x20(%rbp)
subl $0x63, %eax
je 0x1ab2
jmp 0x1a9e
movl -0x20(%rbp), %eax
subl $0x6e, %eax
je 0x1acd
jmp 0x1aa8
movl -0x20(%rbp), %eax
subl $0x72, %eax
je 0x1aeb
jmp 0x1b04
movq -0x18(%rbp), %rdi
leaq 0x16f2(%rip), %rsi      # 0x31af
leaq 0x16b2(%rip), %rdx      # 0x3176
movb $0x0, %al
callq 0x1160
jmp 0x1b04
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %ecx
leaq 0x16a8(%rip), %rsi      # 0x3183
leaq 0x16aa(%rip), %rdx      # 0x318c
movb $0x0, %al
callq 0x1160
jmp 0x1b04
movq -0x18(%rbp), %rdi
leaq 0x16b9(%rip), %rsi      # 0x31af
leaq 0x1697(%rip), %rdx      # 0x3194
movb $0x0, %al
callq 0x1160
jmp 0x1bc5
movzwl -0x2(%rbp), %edi
movzwl -0x4(%rbp), %esi
movq 0x35c8(%rip), %rdx      # 0x50e0
movl 0x35ce(%rip), %ecx      # 0x50ec
callq 0x1910
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
je 0x1b58
movq -0x18(%rbp), %rdi
movq 0x35a9(%rip), %rdx      # 0x50e0
movl -0x1c(%rbp), %eax
imulq $0x108, %rax, %rax      # imm = 0x108
addq %rax, %rdx
addq $0x8, %rdx
leaq 0x1660(%rip), %rsi      # 0x31af
movb $0x0, %al
callq 0x1160
jmp 0x1bc3
movzwl -0x2(%rbp), %edi
movzwl -0x4(%rbp), %esi
movq 0x3571(%rip), %rdx      # 0x50d8
movl 0x357b(%rip), %ecx      # 0x50e8
callq 0x1910
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
je 0x1ba7
movq -0x18(%rbp), %rdi
movq 0x3552(%rip), %rdx      # 0x50d8
movl -0x1c(%rbp), %eax
imulq $0x108, %rax, %rax      # imm = 0x108
addq %rax, %rdx
addq $0x8, %rdx
leaq 0x1611(%rip), %rsi      # 0x31af
movb $0x0, %al
callq 0x1160
jmp 0x1bc1
movq -0x18(%rbp), %rdi
movzwl -0x2(%rbp), %edx
movzwl -0x4(%rbp), %ecx
leaq 0x15e7(%rip), %rsi      # 0x31a1
movb $0x0, %al
callq 0x1160
jmp 0x1bc3
jmp 0x1bc5
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/Output/output.c
// Function: initDB
int initDB( char *dbfile )
{

	pthread_mutex_lock(&lock);
	while( db == NULL )
	{
		int ret = sqlite3_open( dbfile , &db );
		char *sql="create table house(id integer primary key,title char(200),city char(100), address char(100),type char(50),price char(8),infourl char(255),source char(50))";
		if ( ret != SQLITE_OK )
		{
			puts( "create database error");
			db = NULL;
			pthread_mutex_unlock(&lock);
			return -1;
		}
		ret = sqlite3_exec(db,sql,0,0,&err);
		if (ret != SQLITE_OK )
		{
			puts(sql);
			puts(err);
			pthread_mutex_unlock(&lock);
			return -1;
		}
	}
	pthread_mutex_unlock(&lock);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0xb5765(%rip), %rdi     # 0xc11a8
callq 0xb930
cmpq $0x0, 0xb5780(%rip)     # 0xc11d0
jne 0xbafc
movq -0x10(%rbp), %rdi
leaq 0xb576f(%rip), %rsi     # 0xc11d0
callq 0xb1f0
movl %eax, -0x14(%rbp)
leaq 0x95590(%rip), %rax     # 0xa1000
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0xbaa6
leaq 0x9561a(%rip), %rdi     # 0xa109b
callq 0xb160
movq $0x0, 0xb573f(%rip) # 0xc11d0
leaq 0xb5710(%rip), %rdi     # 0xc11a8
callq 0xb4d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xbb0f
movq 0xb5723(%rip), %rdi     # 0xc11d0
movq -0x20(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
leaq 0xb571c(%rip), %r8      # 0xc11d8
movq %rcx, %rdx
callq 0xb190
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0xbaf7
movq -0x20(%rbp), %rdi
callq 0xb160
movq 0xb56fb(%rip), %rdi     # 0xc11d8
callq 0xb160
leaq 0xb56bf(%rip), %rdi     # 0xc11a8
callq 0xb4d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xbb0f
jmp 0xba48
leaq 0xb56a5(%rip), %rdi     # 0xc11a8
callq 0xb4d0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/Output/output.c
// Function: saveToDB
int saveToDB( char *title,char *city, char *address, char *type, char *price, char *infourl, char *source)
{
	pthread_mutex_lock(&lock);
	char sql[2048] = { 0 };
	sprintf(sql,"insert into house(title,city,address,type,price,infourl,source) values('%s','%s','%s','%s','%s','%s','%s')",title,city,address,type,price,infourl,source);
	int ret = sqlite3_exec(db,sql,0,0,&err);
	if (ret != SQLITE_OK )
	{
		puts(sql);
		pthread_mutex_unlock(&lock);
		return -1;
	}
	pthread_mutex_unlock(&lock);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x860, %rsp            # imm = 0x860
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
leaq 0xb565a(%rip), %rdi     # 0xc11a8
callq 0xb930
leaq -0x840(%rbp), %rdi
xorl %esi, %esi
movl $0x800, %edx            # imm = 0x800
callq 0xb2b0
leaq -0x840(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
movq -0x30(%rbp), %r11
movq -0x38(%rbp), %r10
movq 0x10(%rbp), %rax
leaq 0x95521(%rip), %rsi     # 0xa10b1
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movb $0x0, %al
callq 0xb7a0
movq 0xb5624(%rip), %rdi     # 0xc11d0
leaq -0x840(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
leaq 0xb561a(%rip), %r8      # 0xc11d8
movq %rcx, %rdx
callq 0xb190
movl %eax, -0x844(%rbp)
cmpl $0x0, -0x844(%rbp)
je 0xbbf6
leaq -0x840(%rbp), %rdi
callq 0xb160
leaq 0xb55c0(%rip), %rdi     # 0xc11a8
callq 0xb4d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xbc09
leaq 0xb55ab(%rip), %rdi     # 0xc11a8
callq 0xb4d0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x860, %rsp            # imm = 0x860
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_compileoption_used
SQLITE_STDCALL sqlite3_compileoption_used(const char *zOptName){
  int i, n;

#if SQLITE_ENABLE_API_ARMOR
  if( zOptName==0 ){
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif
  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
     && sqlite3IsIdChar((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 0x99489(%rip), %rsi     # 0xa5980
movl $0x7, %edx
callq 0xb850
cmpl $0x0, %eax
jne 0xc512
movq -0x10(%rbp), %rax
addq $0x7, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc6c0
movl %eax, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x2, -0x14(%rbp)
jge 0xc582
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rcx
leaq 0xb10c6(%rip), %rax     # 0xbd600
movq (%rax,%rcx,8), %rsi
movl -0x18(%rbp), %edx
callq 0xb850
cmpl $0x0, %eax
jne 0xc575
movslq -0x14(%rbp), %rcx
leaq 0xb10aa(%rip), %rax     # 0xbd600
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movzbl (%rax,%rcx), %edi
callq 0xc700
cmpl $0x0, %eax
jne 0xc575
movl $0x1, -0x4(%rbp)
jmp 0xc589
jmp 0xc577
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xc525
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_status
SQLITE_STDCALL sqlite3_status(int op, int *pCurrent, int *pHighwater, int resetFlag){
  sqlite3_int64 iCur, iHwtr;
  int rc;
#ifdef SQLITE_ENABLE_API_ARMOR
  if( pCurrent==0 || pHighwater==0 ) return SQLITE_MISUSE_BKPT;
#endif
  rc = sqlite3_status64(op, &iCur, &iHwtr, resetFlag);
  if( rc==0 ){
    *pCurrent = (int)iCur;
    *pHighwater = (int)iHwtr;
  }
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl -0x4(%rbp), %edi
movl -0x1c(%rbp), %ecx
leaq -0x28(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0xb330
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0xc95a
movq -0x28(%rbp), %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/Output/../Persistence/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->aColName);
  sqlite3DbFree(db, p->zSql);
  sqlite3DbFree(db, p->pFree);
#ifdef SQLITE_ENABLE_STMT_SCANSTATUS
  for(i=0; i<p->nScan; i++){
    sqlite3DbFree(db, p->aScan[i].zName);
  }
  sqlite3DbFree(db, p->aScan);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdi
movq -0x10(%rbp), %rax
movswl 0x78(%rax), %esi
callq 0x352c0
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rax
movzwl 0x88(%rax), %esi
shll %esi
callq 0x352c0
movq -0x10(%rbp), %rax
movq 0x108(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xd1cf
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 0x353d0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xd260
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xd18e
movq -0x10(%rbp), %rax
movswl 0x7a(%rax), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0xd207
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0xd260
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xd1dd
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x3c(%rax), %edx
callq 0x353d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0xd260
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rsi
callq 0xd260
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0xe8(%rax), %rsi
callq 0xd260
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3MutexAlloc
SQLITE_PRIVATE sqlite3_mutex *sqlite3MutexAlloc(int id){
  if( !sqlite3GlobalConfig.bCoreMutex ){
    return 0;
  }
  assert( GLOBAL(int, mutexIsInit) );
  assert( sqlite3GlobalConfig.mutex.xMutexAlloc );
  return sqlite3GlobalConfig.mutex.xMutexAlloc(id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0xc(%rbp)
cmpl $0x0, 0xb1ec2(%rip)     # 0xbf4c4
jne 0xd60e
movq $0x0, -0x8(%rbp)
jmp 0xd61e
movq 0xb1f23(%rip), %rax     # 0xbf538
movl -0xc(%rbp), %edi
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3MutexInit
SQLITE_PRIVATE int sqlite3MutexInit(void){ 
  int rc = SQLITE_OK;
  if( !sqlite3GlobalConfig.mutex.xMutexAlloc ){
    /* If the xMutexAlloc method has not been set, then the user did not
    ** install a mutex implementation via sqlite3_config() prior to 
    ** sqlite3_initialize() being called. This block copies pointers to
    ** the default implementation into the sqlite3GlobalConfig structure.
    */
    sqlite3_mutex_methods const *pFrom;
    sqlite3_mutex_methods *pTo = &sqlite3GlobalConfig.mutex;

    if( sqlite3GlobalConfig.bCoreMutex ){
      pFrom = sqlite3DefaultMutex();
    }else{
      pFrom = sqlite3NoopMutex();
    }
    pTo->xMutexInit = pFrom->xMutexInit;
    pTo->xMutexEnd = pFrom->xMutexEnd;
    pTo->xMutexFree = pFrom->xMutexFree;
    pTo->xMutexEnter = pFrom->xMutexEnter;
    pTo->xMutexTry = pFrom->xMutexTry;
    pTo->xMutexLeave = pFrom->xMutexLeave;
    pTo->xMutexHeld = pFrom->xMutexHeld;
    pTo->xMutexNotheld = pFrom->xMutexNotheld;
    sqlite3MemoryBarrier();
    pTo->xMutexAlloc = pFrom->xMutexAlloc;
  }
  assert( sqlite3GlobalConfig.mutex.xMutexInit );
  rc = sqlite3GlobalConfig.mutex.xMutexInit();

#ifdef SQLITE_DEBUG
  GLOBAL(int, mutexIsInit) = 1;
#endif

  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
cmpq $0x0, 0xb1cf1(%rip)     # 0xbf538
jne 0xd90c
leaq 0xb1c6c(%rip), %rax     # 0xbf4c0
addq $0x68, %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, 0xb1c61(%rip)     # 0xbf4c4
je 0xd870
callq 0x21360
movq %rax, -0x10(%rbp)
jmp 0xd879
callq 0x21370
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x40(%rax)
callq 0x21380
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
callq *0xb1c16(%rip)          # 0xbf528
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_mutex_try
SQLITE_STDCALL sqlite3_mutex_try(sqlite3_mutex *p){
  int rc = SQLITE_OK;
  if( p ){
    assert( sqlite3GlobalConfig.mutex.xMutexTry );
    return sqlite3GlobalConfig.mutex.xMutexTry(p);
  }
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xd97c
movq 0xb1bdf(%rip), %rax     # 0xbf550
movq -0x10(%rbp), %rdi
callq *%rax
movl %eax, -0x4(%rbp)
jmp 0xd982
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_soft_heap_limit64
SQLITE_STDCALL sqlite3_soft_heap_limit64(sqlite3_int64 n){
  sqlite3_int64 priorLimit;
  sqlite3_int64 excess;
  sqlite3_int64 nUsed;
#ifndef SQLITE_OMIT_AUTOINIT
  int rc = sqlite3_initialize();
  if( rc ) return -1;
#endif
  sqlite3_mutex_enter(mem0.mutex);
  priorLimit = mem0.alarmThreshold;
  if( n<0 ){
    sqlite3_mutex_leave(mem0.mutex);
    return priorLimit;
  }
  mem0.alarmThreshold = n;
  nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED);
  mem0.nearlyFull = (n>0 && n<=nUsed);
  sqlite3_mutex_leave(mem0.mutex);
  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 0xb0a0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0xd9e7
movq $-0x1, -0x8(%rbp)
jmp 0xda92
movq 0xb389a(%rip), %rdi     # 0xc1288
callq 0xb550
movq 0xb3896(%rip), %rax     # 0xc1290
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jge 0xda1b
movq 0xb387c(%rip), %rdi     # 0xc1288
callq 0xb4f0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xda92
movq -0x10(%rbp), %rax
movq %rax, 0xb386a(%rip)     # 0xc1290
xorl %edi, %edi
callq 0xdaa0
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x2d(%rbp)
jle 0xda4b
movq -0x10(%rbp), %rax
cmpq -0x28(%rbp), %rax
setle %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0xb3853(%rip)     # 0xc12ac
movq 0xb3828(%rip), %rdi     # 0xc1288
callq 0xb4f0
callq 0xb560
subq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jle 0xda8a
movq -0x20(%rbp), %rax
andq $0x7fffffff, %rax       # imm = 0x7FFFFFFF
movl %eax, %edi
callq 0xb470
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_malloc
SQLITE_API void *SQLITE_STDCALL sqlite3_malloc(int n){
#ifndef SQLITE_OMIT_AUTOINIT
  if( sqlite3_initialize() ) return 0;
#endif
  return n<=0 ? 0 : sqlite3Malloc(n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
callq 0xb0a0
cmpl $0x0, %eax
je 0xdb6f
movq $0x0, -0x8(%rbp)
jmp 0xdb92
cmpl $0x0, -0xc(%rbp)
jg 0xdb7d
xorl %eax, %eax
movq %rax, -0x18(%rbp)
jmp 0xdb8a
movslq -0xc(%rbp), %rdi
callq 0xdba0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_vmprintf
SQLITE_API char *SQLITE_STDCALL sqlite3_vmprintf(const char *zFormat, va_list ap){
  char *z;
  char zBase[SQLITE_PRINT_BUF_SIZE];
  StrAccum acc;

#ifdef SQLITE_ENABLE_API_ARMOR  
  if( zFormat==0 ){
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif
#ifndef SQLITE_OMIT_AUTOINIT
  if( sqlite3_initialize() ) return 0;
#endif
  sqlite3StrAccumInit(&acc, 0, zBase, sizeof(zBase), SQLITE_MAX_LENGTH);
  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 0xb0a0
cmpl $0x0, %eax
je 0xdf67
movq $0x0, -0x8(%rbp)
jmp 0xdfb4
leaq -0x70(%rbp), %rdx
leaq -0x98(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x46, %ecx
movl $0x3b9aca00, %r8d       # imm = 0x3B9ACA00
callq 0xdfd0
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq -0x98(%rbp), %rdi
xorl %esi, %esi
callq 0xe040
leaq -0x98(%rbp), %rdi
callq 0xfdb0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3StrAccumInit
SQLITE_PRIVATE void sqlite3StrAccumInit(StrAccum *p, sqlite3 *db, char *zBase, int n, int mx){
  p->zText = p->zBase = zBase;
  p->db = db;
  p->nChar = 0;
  p->nAlloc = n;
  p->mxAlloc = mx;
  p->accError = 0;
  p->bMalloced = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x18(%rax)
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1c(%rax)
movl -0x20(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x24(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x25(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3StrAccumFinish
SQLITE_PRIVATE char *sqlite3StrAccumFinish(StrAccum *p){
  if( p->zText ){
    assert( (p->zText==p->zBase)==(p->bMalloced==0) );
    p->zText[p->nChar] = 0;
    if( p->mxAlloc>0 && p->bMalloced==0 ){
      p->zText = sqlite3DbMallocRaw(p->db, p->nChar+1 );
      if( p->zText ){
        memcpy(p->zText, p->zBase, p->nChar+1);
        p->bMalloced = 1;
      }else{
        setStrAccumError(p, 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 0xfe64
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x18(%rcx), %ecx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jbe 0xfe62
movq -0x8(%rbp), %rax
movzbl 0x25(%rax), %eax
cmpl $0x0, %eax
jne 0xfe62
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x175d0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xfe52
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
movl %eax, %eax
movl %eax, %edx
callq 0xb420
movq -0x8(%rbp), %rax
movb $0x1, 0x25(%rax)
jmp 0xfe60
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x21900
jmp 0xfe62
jmp 0xfe64
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_mprintf
SQLITE_API char *SQLITE_CDECL 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 0xfebb
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 0xb0a0
cmpl $0x0, %eax
je 0xfef6
movq $0x0, -0x8(%rbp)
jmp 0xff37
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 0xb5d0
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/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_vsnprintf
SQLITE_API char *SQLITE_STDCALL sqlite3_vsnprintf(int n, char *zBuf, const char *zFormat, va_list ap){
  StrAccum acc;
  if( n<=0 ) return zBuf;
#ifdef SQLITE_ENABLE_API_ARMOR
  if( zBuf==0 || zFormat==0 ) {
    (void)SQLITE_MISUSE_BKPT;
    if( zBuf ) zBuf[0] = 0;
    return zBuf;
  }
#endif
  sqlite3StrAccumInit(&acc, 0, zBuf, n, 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 0xff77
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xffae
movq -0x18(%rbp), %rdx
movl -0xc(%rbp), %ecx
leaq -0x50(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %r8d, %r8d
callq 0xdfd0
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
callq 0xe040
leaq -0x50(%rbp), %rdi
callq 0xfdb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_snprintf
SQLITE_API char *SQLITE_CDECL 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 0xfffb
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 0xb510
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/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: renderLogMsg
static void renderLogMsg(int iErrCode, const char *zFormat, va_list ap){
  StrAccum acc;                          /* String accumulator */
  char zMsg[SQLITE_PRINT_BUF_SIZE*3];    /* Complete log message */

  sqlite3StrAccumInit(&acc, 0, zMsg, sizeof(zMsg), 0);
  sqlite3VXPrintf(&acc, 0, zFormat, ap);
  sqlite3GlobalConfig.xLog(sqlite3GlobalConfig.pLogArg, iErrCode,
                           sqlite3StrAccumFinish(&acc));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x120(%rbp), %rdx
leaq -0x40(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xd2, %ecx
xorl %r8d, %r8d
callq 0xdfd0
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0xe040
movq 0xaf4e4(%rip), %rax     # 0xbf650
movq %rax, -0x128(%rbp)
movq 0xaf4de(%rip), %rax     # 0xbf658
movq %rax, -0x138(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x12c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xfdb0
movq -0x138(%rbp), %rdi
movl -0x12c(%rbp), %esi
movq %rax, %rdx
movq -0x128(%rbp), %rax
callq *%rax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
nopw %cs:(%rax,%rax)