LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/unixlab[P]cloudflare-udp-ping/udpserver.c
// Function: thread_loop
static void thread_loop(void *userdata)
{
	struct state *state = userdata;

	while (1) {
		int flags = state->polling ? MSG_DONTWAIT : 0;
		int r = recvmsg(state->fd, &state->msg, flags);
		if (r <= 0 && (errno == EAGAIN || errno == EWOULDBLOCK ||
			       errno == EINTR)) {
			continue;
		}
		if (r == 0 && state->polling) {
			continue;
		}

		if (r <= 0) {
			PFATAL("recvmmsg()");
		}

		struct msghdr *msg = &state->msg;
		msg->msg_iov->iov_len = r;

		int s = sendmsg(state->fd, &state->msg, 0);
		if (s != r) {
			PFATAL("sendmmsg()");
		}
		msg->msg_iov->iov_len = MTU_SIZE;
		msg->msg_controllen = sizeof(state->pktinfo);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x28(%rdi), %r14
xorl %edx, %edx
cmpl $0x0, 0x4(%rbx)
setne %dl
shll $0x6, %edx
movl (%rbx), %edi
movq %r14, %rsi
callq 0x45f370
movq %rax, %r15
testl %r15d, %r15d
jle 0x402581
testl %r15d, %r15d
je 0x402594
testl %r15d, %r15d
jle 0x40259c
movl %r15d, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movq 0x38(%rbx), %rcx
movq %rax, 0x8(%rcx)
movl (%rbx), %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0x45f420
cmpl %r15d, %eax
jne 0x4025dc
movq 0x38(%rbx), %rax
movq $0x780, 0x8(%rax)       # imm = 0x780
movq $0x1000, 0x50(%rbx)     # imm = 0x1000
jmp 0x402522
callq 0x4059b0
movl (%rax), %eax
cmpl $0x4, %eax
je 0x402522
cmpl $0xb, %eax
je 0x402522
jmp 0x402540
cmpl $0x0, 0x4(%rbx)
jne 0x402522
jmp 0x402545
movq $0x4e77c8, %rbx         # imm = 0x4E77C8
movq (%rbx), %rcx
leaq 0xb1bdf(%rip), %rdi     # 0x4b418c
movl $0x1d, %esi
movl $0x1, %edx
callq 0x414240
movq (%rbx), %rdi
leaq 0xb1be4(%rip), %rsi     # 0x4b41aa
leaq 0xb1bf7(%rip), %rdx     # 0x4b41c4
leaq 0xb1ad5(%rip), %rcx     # 0x4b40a9
movl $0x41, %r8d
jmp 0x40261a
movq $0x4e77c8, %rbx         # imm = 0x4E77C8
movq (%rbx), %rcx
leaq 0xb1bf5(%rip), %rdi     # 0x4b41e2
movl $0x1d, %esi
movl $0x1, %edx
callq 0x414240
movq (%rbx), %rdi
leaq 0xb1ba4(%rip), %rsi     # 0x4b41aa
leaq 0xb1bb7(%rip), %rdx     # 0x4b41c4
leaq 0xb1a95(%rip), %rcx     # 0x4b40a9
movl $0x49, %r8d
xorl %eax, %eax
callq 0x40d2b0
leaq 0xb1ba8(%rip), %rdi     # 0x4b41d0
callq 0x40d590
movq (%rbx), %rsi
movl $0xa, %edi
callq 0x4164a0
movl $0x1, %edi
callq 0x40c210
// File: /workspace/github_c_makefile_star2_O1/stevenmherring[P]DNS/mutex-trie.c
// Function: new_leaf
struct trie_node * new_leaf(const char *string, size_t strlen, int32_t ip4_address) {
  struct trie_node *new_node = malloc(sizeof (struct trie_node));
  if (!new_node) {
    printf("WARNING: Node memory allocation failed.  Results may be bogus.\n");
    return NULL;
  }
  assert(strlen < 64);
  assert(strlen > 0);
  new_node->next = NULL;
  new_node->strlen = strlen;
  strncpy(new_node->key, string, strlen);
  new_node->key[strlen] = '\0';
  new_node->ip4_address = ip4_address;
  new_node->children = NULL;

  return new_node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movl $0x58, %edi
callq 0x1130
testq %rax, %rax
je 0x13a0
cmpq $0x40, %r14
jae 0x13ba
testq %r14, %r14
je 0x13d9
movq %rax, %rbx
xorl %r12d, %r12d
movq %r12, (%rax)
movl %r14d, 0x8(%rax)
movq %rax, %rdi
addq $0x18, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1050
movb $0x0, 0x18(%rbx,%r14)
movl %ebp, 0xc(%rbx)
movq %r12, 0x10(%rbx)
jmp 0x13ae
leaq 0x2031(%rip), %rdi      # 0x33d8
callq 0x1080
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1ce4(%rip), %rdi      # 0x30a5
leaq 0x1c3c(%rip), %rsi      # 0x3004
leaq 0x1c42(%rip), %rcx      # 0x3011
movl $0x27, %edx
callq 0x10c0
leaq 0x1c6b(%rip), %rdi      # 0x304b
leaq 0x1c1d(%rip), %rsi      # 0x3004
leaq 0x1c23(%rip), %rcx      # 0x3011
movl $0x28, %edx
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O1/stevenmherring[P]DNS/mutex-trie.c
// Function: squat_search
int squat_search(const char *string, size_t strlen, int32_t *ip4_address) {
  struct trie_node *found;
  int result = 0;
  // Skip strings of length 0
  if (strlen == 0)
  return result;
  found = _search(root, string, strlen);
  if (found && ip4_address)
  *ip4_address = found->ip4_address;
  result = (found != NULL);
  return result;
}

// Assembly:
pushq %rbx
movq %rdx, %rbx
movq %rsi, %rdx
testq %rsi, %rsi
je 0x1546
movq %rdi, %rsi
movq 0x4c36(%rip), %rdi      # 0x6158
callq 0x145a
testq %rax, %rax
sete %cl
testq %rbx, %rbx
sete %dl
orb %cl, %dl
jne 0x153c
movl 0xc(%rax), %ecx
movl %ecx, (%rbx)
xorl %ecx, %ecx
testq %rax, %rax
setne %cl
jmp 0x1548
xorl %ecx, %ecx
movl %ecx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/stevenmherring[P]DNS/mutex-trie.c
// Function: search
int search(const char *string, size_t strlen, int32_t *ip4_address) {
  struct trie_node *found;
  //int rv;
  int result;

  // Skip strings of length 0
  if (strlen == 0)
  return 0;
  pthread_cleanup_push(cleanup_handler,&lock);
  // obtain the lock
  //rv =
  pthread_mutex_lock(&lock);
  // assert(rv == 0);
  found = _search(root, string, strlen);

  if (found && ip4_address)
  *ip4_address = found->ip4_address;

  result = (found != NULL);

  // Return the lock
  /**** NEW ***/
  pthread_cleanup_pop(1);
  //rv = pthread_mutex_unlock(&lock);
  //assert(rv == 0);

  return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
testq %rsi, %rsi
je 0x15ce
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsp, %rdi
xorl %esi, %esi
callq 0x11d0
movq %rsp, %rdi
testl %eax, %eax
jne 0x15da
callq 0x11a0
leaq 0x4ba8(%rip), %rdi      # 0x6128
callq 0x1200
movq 0x4bcc(%rip), %rdi      # 0x6158
movq %r15, %rsi
movq %r14, %rdx
callq 0x145a
testq %rax, %rax
sete %cl
testq %rbx, %rbx
sete %dl
orb %cl, %dl
jne 0x15ac
movl 0xc(%rax), %ecx
movl %ecx, (%rbx)
xorl %ebx, %ebx
testq %rax, %rax
setne %al
movb %al, %bl
movq %rsp, %rdi
callq 0x10b0
leaq 0x4b63(%rip), %rdi      # 0x6128
callq 0x1120
movl %ebx, %eax
jmp 0x15d0
xorl %eax, %eax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x1220
// File: /workspace/github_c_makefile_star2_O1/stevenmherring[P]DNS/mutex-trie.c
// Function: delete
int delete(const char *string, size_t strlen) {
            int result = 0;
            // Skip strings of length 0
            if (strlen != 0) {
              int rv;
              // Obtain the lock
              rv = pthread_mutex_lock(&lock);
              assert(rv == 0);
              // Attempt to delete the node.
              result = (NULL != _delete(root, string, strlen));

              // if squatting is allowed and a key was deleted.
              if (allow_squatting && result) {
                rv = pthread_mutex_unlock(&lock);
                assert(rv == 0);
                printf("Thread: %lu Node deleted, broadcasting %s\n", (long) pthread_self(), string);
                rv = pthread_cond_broadcast(&cv);
                // Check to see if the broadcasr was successful
                assert(rv == 0);
              } else {
                // Unlock
                rv = pthread_mutex_unlock(&lock);
                assert(rv == 0);
              }
            }
            return result;
          }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x1e2c
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x4392(%rip), %rdi      # 0x6128
callq 0x1200
testl %eax, %eax
jne 0x1e43
movq 0x43ae(%rip), %rdi      # 0x6158
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1bcd
movq %rax, %r14
leaq 0x43d9(%rip), %rax      # 0x6198
movl (%rax), %r15d
leaq 0x435f(%rip), %rdi      # 0x6128
callq 0x1120
testq %r14, %r14
setne %bpl
je 0x1e30
testl %r15d, %r15d
je 0x1e30
testl %eax, %eax
jne 0x1e81
callq 0x1160
leaq 0x1504(%rip), %rdi      # 0x32f4
movq %rax, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x10a0
leaq 0x4364(%rip), %rdi      # 0x6168
callq 0x1070
testl %eax, %eax
je 0x1e34
leaq 0x13be(%rip), %rdi      # 0x31d2
leaq 0x11e9(%rip), %rsi      # 0x3004
leaq 0x14b1(%rip), %rcx      # 0x32d3
movl $0x1ac, %edx            # imm = 0x1AC
callq 0x10c0
xorl %ebp, %ebp
jmp 0x1e34
testl %eax, %eax
jne 0x1e62
movzbl %bpl, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1388(%rip), %rdi      # 0x31d2
leaq 0x11b3(%rip), %rsi      # 0x3004
leaq 0x147b(%rip), %rcx      # 0x32d3
movl $0x1a1, %edx            # imm = 0x1A1
callq 0x10c0
leaq 0x1369(%rip), %rdi      # 0x31d2
leaq 0x1194(%rip), %rsi      # 0x3004
leaq 0x145c(%rip), %rcx      # 0x32d3
movl $0x1b0, %edx            # imm = 0x1B0
callq 0x10c0
leaq 0x134a(%rip), %rdi      # 0x31d2
leaq 0x1175(%rip), %rsi      # 0x3004
leaq 0x143d(%rip), %rcx      # 0x32d3
movl $0x1a8, %edx            # imm = 0x1A8
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O1/stevenmherring[P]DNS/mutex-trie.c
// Function: print
void print() {
            int rv;
            // Obtain the lock
            rv = pthread_mutex_lock(&lock);
            assert(rv == 0);

            printf("Root is at %p\n", root);
            /* Do a simple depth-first search */
            if (root)
            _print(root, 0, 0);

            // Unlock
            rv = pthread_mutex_unlock(&lock);
            assert(rv == 0);
          }

// Assembly:
pushq %rax
leaq 0x4165(%rip), %rdi      # 0x6128
callq 0x1200
testl %eax, %eax
jne 0x2008
movq 0x4185(%rip), %rsi      # 0x6158
leaq 0x13ef(%rip), %rdi      # 0x33c9
xorl %eax, %eax
callq 0x10a0
movq 0x4170(%rip), %rdi      # 0x6158
testq %rdi, %rdi
je 0x1ff6
xorl %esi, %esi
xorl %edx, %edx
callq 0x1ea0
leaq 0x412b(%rip), %rdi      # 0x6128
callq 0x1120
testl %eax, %eax
jne 0x2027
popq %rax
retq
leaq 0x11c3(%rip), %rdi      # 0x31d2
leaq 0xfee(%rip), %rsi       # 0x3004
leaq 0x139f(%rip), %rcx      # 0x33bc
movl $0x1d5, %edx            # imm = 0x1D5
callq 0x10c0
leaq 0x11a4(%rip), %rdi      # 0x31d2
leaq 0xfcf(%rip), %rsi       # 0x3004
leaq 0x1380(%rip), %rcx      # 0x33bc
movl $0x1de, %edx            # imm = 0x1DE
callq 0x10c0
nop
// File: /workspace/github_c_makefile_star2_O1/MersenneTwister-Lab[P]MTGP/mtgp64-fast.c
// Function: mtgp64_init
int mtgp64_init(mtgp64_fast_t *mtgp64,
		const mtgp64_params_fast_t *para, uint64_t seed) {
    int rc;
    rc = alloc_state(mtgp64, para);
    if (rc) {
	return rc;
    }
    mtgp64->status->idx = mtgp64->status->size - 1;
    mtgp64_init_state(mtgp64->status->array, para, seed);
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x122f
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x1229
movq 0x1b0(%r15), %rdi
movl 0x4(%rdi), %eax
decl %eax
movl %eax, (%rdi)
addq $0x10, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x12bc
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
leal 0x3f(%rax), %ebp
testl %eax, %eax
cmovnsl %eax, %ebp
sarl $0x6, %ebp
incl %ebp
movl $0x1, %r12d
cmpl $0x40, %eax
jl 0x126c
movl %ebp, %eax
addl %r12d, %r12d
cmpl %ebp, %r12d
je 0x126c
movl %eax, %ecx
shrl %ecx
cmpl $0x1, %eax
movl %ecx, %eax
ja 0x1259
movslq %r12d, %rax
leaq 0x10(,%rax,8), %rdi
callq 0x10e0
testq %rax, %rax
je 0x12ae
movq %rax, %r15
movl $0x1b0, %edx            # imm = 0x1B0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10d0
movq %r15, 0x1b0(%rbx)
movl %ebp, 0x4(%r15)
movl %r12d, 0x8(%r15)
decl %r12d
movl %r12d, 0xc(%r15)
xorl %eax, %eax
jmp 0x12b3
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movl (%rsi), %r12d
leal 0x3f(%r12), %r15d
testl %r12d, %r12d
cmovnsl %r12d, %r15d
movq %rdi, %rbx
sarl $0x6, %r15d
movq 0x50(%rsi), %r13
shlq $0x10, %r13
xorq 0x30(%rsi), %r13
movq %r13, %rax
shrq $0x20, %rax
movq %r13, %rcx
shrq $0x30, %rcx
addq %rax, %rcx
movq %rcx, %rsi
shrq $0x8, %rsi
addl %ecx, %esi
movslq %r15d, %rax
leaq 0x8(,%rax,8), %rdx
callq 0x1090
movq %r14, (%rbx)
movq %r13, 0x8(%rbx)
cmpl $0x40, %r12d
jl 0x135a
incl %r15d
movq (%rbx), %rsi
movl $0x1, %eax
movabsq $0x5851f42d4c957f2d, %rcx # imm = 0x5851F42D4C957F2D
movq %rsi, %rdx
shrq $0x3e, %rdx
xorq %rsi, %rdx
imulq %rcx, %rdx
addq %rax, %rdx
xorq (%rbx,%rax,8), %rdx
movq %rdx, (%rbx,%rax,8)
incq %rax
movq %rdx, %rsi
cmpq %rax, %r15
jne 0x1339
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %edx
leaq 0x1608(%rip), %rsi      # 0x3018
movq %rbx, %rdi
xorl %eax, %eax
callq 0x10b0
leaq 0x1602(%rip), %r15      # 0x3023
xorl %r12d, %r12d
movzbl 0x198(%r14,%r12), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x10b0
incq %r12
cmpq $0x14, %r12
jne 0x1a24
movl $0xa, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x10a0
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
testl %esi, %esi
jle 0x1ba9
movl $0x2, %ebp
xorl %r13d, %r13d
movl %ebp, 0x8(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rbp
movq 0x1b0(%rbp), %rdx
movl 0x4(%rdx), %edi
movl 0x8(%rdx), %eax
movslq 0xc(%rdx), %r8
movslq (%rdx), %r9
incq %r9
andq %r8, %r9
movl 0x4(%rbp), %r10d
addl %eax, %r10d
movl %r9d, (%rdx)
movl %r9d, %ecx
subl %edi, %ecx
leal (%rcx,%rax), %esi
andl %r8d, %esi
movslq %esi, %rsi
addl %ecx, %eax
incl %eax
andl %r8d, %eax
movslq %eax, %r12
movl %r10d, %eax
subl %edi, %eax
addl %r9d, %eax
andl %r8d, %eax
cltq
movq 0x10(%rdx,%rax,8), %r11
movb 0x8(%rbp), %cl
movb 0xc(%rbp), %al
movq 0x190(%rbp), %r15
andq 0x10(%rdx,%rsi,8), %r15
xorq 0x10(%rdx,%r12,8), %r15
movq %r15, %rsi
shrq $0x20, %rsi
movq %r11, %r12
shrq $0x20, %r12
movl %esi, %ebx
shll %cl, %ebx
movl %r15d, %r14d
shll %cl, %r14d
movl %eax, %ecx
shrl %cl, %r12d
xorl %r15d, %r12d
xorl %r14d, %r12d
shrl %cl, %r11d
xorl %esi, %r11d
xorl %ebx, %r11d
shlq $0x20, %r12
leaq (%r11,%r12), %rsi
movq %rsi, 0x10(%rdx,%r9,8)
andl $0xf, %r11d
xorq 0x10(%rbp,%r11,8), %rsi
notl %edi
addl %r10d, %edi
movq %rsi, 0x10(%rdx,%r9,8)
addl %r9d, %edi
andl %r8d, %edi
movslq %edi, %rax
movq 0x10(%rdx,%rax,8), %rax
movq %rax, %rcx
shrq $0x10, %rcx
xorl %eax, %ecx
movl %ecx, %eax
shrl $0x8, %eax
xorl %ecx, %eax
andl $0xf, %eax
xorq 0x90(%rbp,%rax,8), %rsi
movl 0x8(%rsp), %ebp
movl %r13d, %eax
movl $0xaaaaaaab, %ecx       # imm = 0xAAAAAAAB
imulq %rcx, %rax
shrq $0x21, %rax
leal (%rax,%rax,2), %ebx
leaq 0x14a5(%rip), %rdi      # 0x3028
xorl %eax, %eax
callq 0x1080
addl %ebp, %ebx
jne 0x1b98
movl $0xa, %edi
callq 0x1040
incl %r13d
decl %ebp
movl 0xc(%rsp), %esi
decl %esi
jne 0x1a7e
movl $0xa, %edi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
testl %esi, %esi
jle 0x1e8d
xorl %ebp, %ebp
movl $0x2, %r12d
movl %ebp, 0x8(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rbp
movq 0x1b0(%rbp), %rdx
movl 0x4(%rdx), %esi
movl 0x8(%rdx), %eax
movslq 0xc(%rdx), %rdi
movslq (%rdx), %r8
incq %r8
andq %rdi, %r8
movl 0x4(%rbp), %r9d
addl %eax, %r9d
movl %r8d, (%rdx)
movl %r8d, %ecx
subl %esi, %ecx
leal (%rcx,%rax), %r10d
andl %edi, %r10d
movslq %r10d, %r11
addl %ecx, %eax
incl %eax
andl %edi, %eax
movslq %eax, %r13
movl %r9d, %eax
subl %esi, %eax
addl %r8d, %eax
andl %edi, %eax
cltq
movq 0x10(%rdx,%rax,8), %r10
movb 0x8(%rbp), %cl
movb 0xc(%rbp), %al
movq 0x190(%rbp), %r15
andq 0x10(%rdx,%r11,8), %r15
xorq 0x10(%rdx,%r13,8), %r15
movq %r15, %r11
shrq $0x20, %r11
movq %r10, %r13
shrq $0x20, %r13
movl %r11d, %ebx
shll %cl, %ebx
movl %r15d, %r14d
shll %cl, %r14d
movl %eax, %ecx
shrl %cl, %r13d
xorl %r15d, %r13d
xorl %r14d, %r13d
shrl %cl, %r10d
xorl %r11d, %r10d
xorl %ebx, %r10d
shlq $0x20, %r13
leaq (%r10,%r13), %rax
movq %rax, 0x10(%rdx,%r8,8)
andl $0xf, %r10d
xorq 0x10(%rbp,%r10,8), %rax
notl %esi
addl %r9d, %esi
movq %rax, 0x10(%rdx,%r8,8)
addl %r8d, %esi
andl %edi, %esi
movslq %esi, %rcx
movq 0x10(%rdx,%rcx,8), %rcx
movq %rcx, %rdx
shrq $0x10, %rdx
xorl %ecx, %edx
movl %edx, %ecx
shrl $0x8, %ecx
xorl %edx, %ecx
shrq $0xc, %rax
andl $0xf, %ecx
xorq 0x110(%rbp,%rcx,8), %rax
movl 0x8(%rsp), %ebp
movq %rax, %xmm0
movl %ebp, %eax
movl $0xaaaaaaab, %ecx       # imm = 0xAAAAAAAB
imulq %rcx, %rax
shrq $0x21, %rax
leal (%rax,%rax,2), %ebx
addsd 0x11a9(%rip), %xmm0     # 0x3008
leaq 0x11ca(%rip), %rdi      # 0x3030
movb $0x1, %al
callq 0x1080
addl %r12d, %ebx
jne 0x1e7c
movl $0xa, %edi
callq 0x1040
incl %ebp
decl %r12d
movl 0xc(%rsp), %esi
decl %esi
jne 0x1d52
movl $0xa, %edi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
testl %esi, %esi
jle 0x2007
xorl %ebp, %ebp
movl $0x2, %r12d
movl %ebp, 0x8(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rbp
movq 0x1b0(%rbp), %rdx
movl 0x4(%rdx), %esi
movl 0x8(%rdx), %eax
movslq 0xc(%rdx), %rdi
movslq (%rdx), %r8
incq %r8
andq %rdi, %r8
movl 0x4(%rbp), %r9d
addl %eax, %r9d
movl %r8d, (%rdx)
movl %r8d, %ecx
subl %esi, %ecx
leal (%rcx,%rax), %r10d
andl %edi, %r10d
movslq %r10d, %r11
addl %ecx, %eax
incl %eax
andl %edi, %eax
movslq %eax, %r13
movl %r9d, %eax
subl %esi, %eax
addl %r8d, %eax
andl %edi, %eax
cltq
movq 0x10(%rdx,%rax,8), %r10
movb 0x8(%rbp), %cl
movb 0xc(%rbp), %al
movq 0x190(%rbp), %r15
andq 0x10(%rdx,%r11,8), %r15
xorq 0x10(%rdx,%r13,8), %r15
movq %r15, %r11
shrq $0x20, %r11
movq %r10, %r13
shrq $0x20, %r13
movl %r11d, %ebx
shll %cl, %ebx
movl %r15d, %r14d
shll %cl, %r14d
movl %eax, %ecx
shrl %cl, %r13d
xorl %r15d, %r13d
xorl %r14d, %r13d
shrl %cl, %r10d
xorl %r11d, %r10d
xorl %ebx, %r10d
shlq $0x20, %r13
leaq (%r10,%r13), %rax
movq %rax, 0x10(%rdx,%r8,8)
andl $0xf, %r10d
xorq 0x10(%rbp,%r10,8), %rax
notl %esi
addl %r9d, %esi
movq %rax, 0x10(%rdx,%r8,8)
addl %r8d, %esi
andl %edi, %esi
movslq %esi, %rcx
movq 0x10(%rdx,%rcx,8), %rcx
movq %rcx, %rdx
shrq $0x10, %rdx
xorl %ecx, %edx
movl %edx, %ecx
shrl $0x8, %ecx
xorl %edx, %ecx
shrq $0xc, %rax
andl $0xf, %ecx
xorq 0x110(%rbp,%rcx,8), %rax
movl 0x8(%rsp), %ebp
movq %rax, %xmm1
movl %ebp, %eax
movl $0xaaaaaaab, %ecx       # imm = 0xAAAAAAAB
imulq %rcx, %rax
shrq $0x21, %rax
leal (%rax,%rax,2), %ebx
movsd 0x103b(%rip), %xmm0     # 0x3010
subsd %xmm1, %xmm0
leaq 0x1050(%rip), %rdi      # 0x3030
movb $0x1, %al
callq 0x1080
addl %r12d, %ebx
jne 0x1ff6
movl $0xa, %edi
callq 0x1040
incl %ebp
decl %r12d
movl 0xc(%rsp), %esi
decl %esi
jne 0x1ec8
movl $0xa, %edi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movl %edi, %ebp
movl $0x10, %edi
callq 0x1100
movq %rax, %rbx
cmpl $0x71, %ebp
jg 0x172a
cmpl $0x63, %ebp
je 0x1757
cmpl $0x6e, %ebp
jne 0x1742
movabsq $0x65686361636f6e, %rax # imm = 0x65686361636F6E
movq %rax, (%rbx)
jmp 0x1776
cmpl $0x72, %ebp
je 0x1765
cmpl $0x73, %ebp
jne 0x1742
movw $0x64, 0x4(%rbx)
movl $0x6e756f73, (%rbx)     # imm = 0x6E756F73
jmp 0x1776
leaq 0x9db(%rip), %rsi       # 0x2124
movq %rbx, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x1160
jmp 0x1776
movw $0x65, 0x4(%rbx)
movl $0x68636163, (%rbx)     # imm = 0x68636163
jmp 0x1776
movabsq $0x746e656469736572, %rax # imm = 0x746E656469736572
movq %rax, (%rbx)
movb $0x0, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r15d
movl %edi, %r12d
movl $0x20, %edi
callq 0x1100
movq %rax, %rbx
testl %r12d, %r12d
je 0x17e8
movzwl %r12w, %edx
movzwl %r15w, %ecx
movq 0x292c(%rip), %rax      # 0x40e0
movslq 0x2931(%rip), %rdi      # 0x40ec
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
testq %rdi, %rdi
jle 0x181f
leaq 0x4(%rax), %r9
xorl %r8d, %r8d
cmpl %edx, -0x4(%r9)
jne 0x17d7
cmpl %ecx, (%r9)
je 0x181c
incq %r8
addq $0x108, %r9             # imm = 0x108
cmpq %r8, %rdi
jne 0x17cc
jmp 0x181f
cmpl $0x72, %r14d
je 0x187b
cmpl $0x6e, %r14d
je 0x185f
cmpl $0x63, %r14d
jne 0x18d6
movabsq $0x7261642e316c64, %rax # imm = 0x7261642E316C64
movq %rax, 0x5(%rbx)
movabsq $0x316c646d5f677473, %rax # imm = 0x316C646D5F677473
jmp 0x1893
movl %r8d, %esi
cmpl $-0x1, %esi
jne 0x18a0
movq 0x28ad(%rip), %rax      # 0x40d8
movslq 0x28b6(%rip), %rdi      # 0x40e8
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
testq %rdi, %rdi
jle 0x189b
leaq 0x4(%rax), %r9
xorl %r8d, %r8d
cmpl %edx, -0x4(%r9)
jne 0x184e
cmpl %ecx, (%r9)
je 0x1898
incq %r8
addq $0x108, %r9             # imm = 0x108
cmpq %r8, %rdi
jne 0x1843
jmp 0x189b
leaq 0x8d0(%rip), %rsi       # 0x2136
leaq 0x8d2(%rip), %rdx       # 0x213f
movq %rbx, %rdi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x1160
jmp 0x18d6
movabsq $0x7261642e316c64, %rax # imm = 0x7261642E316C64
movq %rax, 0x5(%rbx)
movabsq $0x316c646d5f736572, %rax # imm = 0x316C646D5F736572
movq %rax, (%rbx)
jmp 0x18d6
movl %r8d, %esi
cmpl $-0x1, %esi
je 0x18c5
movl %esi, %ecx
movq %rcx, %rdx
shlq $0x8, %rdx
leaq (%rdx,%rcx,8), %rcx
leaq (%rax,%rcx), %rsi
addq $0x8, %rsi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1050
leaq 0x888(%rip), %rsi       # 0x2154
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1160
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x8a864(%rip), %rdi     # 0x94f68
callq 0xa600
leaq 0x8a880(%rip), %r15     # 0x94f90
leaq 0x6e8e9(%rip), %r12     # 0x79000
leaq 0x8a87a(%rip), %r13     # 0x94f98
xorl %ebx, %ebx
cmpq $0x0, 0x8a868(%rip)     # 0x94f90
jne 0xa789
movq %r14, %rdi
movq %r15, %rsi
callq 0xa180
testl %eax, %eax
jne 0xa76d
movq 0x8a850(%rip), %rdi     # 0x94f90
movq %r12, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r13, %r8
callq 0xa140
testl %eax, %eax
je 0xa720
leaq 0x6e8a6(%rip), %rdi     # 0x79000
callq 0xa110
movq 0x8a832(%rip), %rdi     # 0x94f98
callq 0xa110
jmp 0xa784
leaq 0x6e927(%rip), %rdi     # 0x7909b
callq 0xa110
movq $0x0, 0x8a80c(%rip) # 0x94f90
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
leaq 0x8a7d8(%rip), %rdi     # 0x94f68
callq 0xa380
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x818, %rsp            # imm = 0x818
movq %r9, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8a793(%rip), %rdi     # 0x94f68
callq 0xa600
leaq -0x840(%rbp), %r12
movl $0x800, %edx            # imm = 0x800
movq %r12, %rdi
xorl %esi, %esi
callq 0xa210
subq $0x8, %rsp
leaq 0x6e8b6(%rip), %rsi     # 0x790b1
movq %r12, %rdi
movq %rbx, %rdx
xorl %ebx, %ebx
movq %r15, %rcx
movq %r14, %r8
movq %r13, %r9
xorl %eax, %eax
pushq 0x10(%rbp)
pushq -0x30(%rbp)
pushq -0x38(%rbp)
callq 0xa4e0
addq $0x20, %rsp
movq 0x8a769(%rip), %rdi     # 0x94f90
leaq 0x8a76a(%rip), %r8      # 0x94f98
movq %r12, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xa140
testl %eax, %eax
je 0xa84f
leaq -0x840(%rbp), %rdi
callq 0xa110
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
leaq 0x8a712(%rip), %rdi     # 0x94f68
callq 0xa380
movl %ebx, %eax
addq $0x818, %rsp            # imm = 0x818
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: 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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x7226c(%rip), %rsi     # 0x7d040
movl $0x7, %edx
callq 0xa560
leaq 0x7(%r14), %rbx
testl %eax, %eax
cmovneq %r14, %rbx
testq %r14, %r14
je 0xadfc
movq %rbx, %rdi
callq 0xa190
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
jmp 0xadfe
xorl %eax, %eax
movl %eax, %r14d
xorl %r12d, %r12d
leaq 0x86895(%rip), %r13     # 0x916a0
movq (%r12,%r13), %r15
movq %rbx, %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0xa560
testl %eax, %eax
jne 0xae33
movzbl (%r15,%r14), %eax
leaq 0x6f613(%rip), %rcx     # 0x7a440
testb $0x46, (%rax,%rcx)
je 0xae41
addq $0x8, %r12
cmpq $0x8, %r12
je 0xae0b
xorl %eax, %eax
jmp 0xae46
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: 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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq -0x20(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0xa240
testl %eax, %eax
jne 0xb003
movl -0x20(%rbp), %ecx
movl %ecx, (%r14)
movl -0x18(%rbp), %ecx
movl %ecx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x68(%rsi), %rdi
movswl 0x78(%rsi), %esi
callq 0x28802
movq 0x20(%r14), %rdi
movzwl 0x88(%r14), %esi
addl %esi, %esi
callq 0x28802
movq 0x108(%r14), %r15
testq %r15, %r15
je 0xb679
movq 0x20(%r15), %r12
movq (%r15), %rsi
movl 0x8(%r15), %edx
movq %rbx, %rdi
callq 0x288a6
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb6df
movq %r12, %r15
testq %r12, %r12
jne 0xb653
movswq 0x7a(%r14), %r15
testq %r15, %r15
jle 0xb6a0
incq %r15
movq 0x70(%r14), %rax
movq -0x10(%rax,%r15,8), %rsi
movq %rbx, %rdi
callq 0xb6df
decq %r15
cmpq $0x1, %r15
jg 0xb686
movq 0x8(%r14), %rsi
movl 0x3c(%r14), %edx
movq %rbx, %rdi
callq 0x288a6
movq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0xb6df
movq 0xe0(%r14), %rsi
movq %rbx, %rdi
callq 0xb6df
movq 0xe8(%r14), %rsi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xb6df
// File: /workspace/github_c_makefile_star2_O1/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
cmpq $0x0, 0x87670(%rip)     # 0x93398
jne 0xbdf1
cmpl $0x0, 0x875ef(%rip)     # 0x93324
leaq 0x1000f(%rip), %rax     # 0x1bd4b
leaq 0xfef0(%rip), %rcx      # 0x1bc33
cmoveq %rax, %rcx
movq %rcx, 0x8763a(%rip)     # 0x93388
leaq 0xfffe(%rip), %rax      # 0x1bd53
leaq 0xfedf(%rip), %rcx      # 0x1bc3b
cmoveq %rax, %rcx
movq %rcx, 0x87629(%rip)     # 0x93390
leaq 0xfff8(%rip), %rax      # 0x1bd66
leaq 0xff91(%rip), %rcx      # 0x1bd06
cmoveq %rax, %rcx
leaq 0xffec(%rip), %rax      # 0x1bd6c
leaq 0xff9b(%rip), %rdx      # 0x1bd22
cmoveq %rax, %rdx
movq %rcx, 0x8760e(%rip)     # 0x933a0
movq %rdx, 0x8760f(%rip)     # 0x933a8
leaq 0xffd2(%rip), %rax      # 0x1bd72
leaq 0xff85(%rip), %rcx      # 0x1bd2c
cmoveq %rax, %rcx
movq %rcx, 0x875fe(%rip)     # 0x933b0
leaq 0xffc1(%rip), %rax      # 0x1bd7a
leaq 0xff81(%rip), %rcx      # 0x1bd41
cmoveq %rax, %rcx
movq %rcx, 0x875ed(%rip)     # 0x933b8
xorps %xmm0, %xmm0
movups %xmm0, 0x875eb(%rip)    # 0x933c0
mfence
leaq 0xff7c(%rip), %rax      # 0x1bd5b
leaq 0xfe5d(%rip), %rcx      # 0x1bc43
cmoveq %rax, %rcx
movq %rcx, 0x875a7(%rip)     # 0x93398
popq %rbp
jmpq *0x87590(%rip)          # 0x93388
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0xa080
movq $-0x1, %rbx
testl %eax, %eax
jne 0xbec3
movq 0x891f9(%rip), %rdi     # 0x95048
testq %rdi, %rdi
je 0xbe5a
callq *0x8754e(%rip)          # 0x933a8
movq 0x891ef(%rip), %rbx     # 0x95050
testq %r14, %r14
js 0xbeae
movq %r14, 0x891e3(%rip)     # 0x95050
setne %al
cmpq %r14, 0x89129(%rip)     # 0x94fa0
setge %cl
andb %al, %cl
movzbl %cl, %eax
movl %eax, 0x891e7(%rip)     # 0x9506c
movq 0x891bc(%rip), %rdi     # 0x95048
testq %rdi, %rdi
je 0xbe97
callq *0x87521(%rip)          # 0x933b8
movq 0x891aa(%rip), %r14     # 0x95048
testq %r14, %r14
je 0xbec3
movq %r14, %rdi
callq *0x874fc(%rip)          # 0x933a8
jmp 0xbeba
movq 0x89193(%rip), %r14     # 0x95048
testq %r14, %r14
je 0xbec3
movq %r14, %rdi
callq *0x874f5(%rip)          # 0x933b8
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0xa080
testl %eax, %eax
je 0xc395
xorl %eax, %eax
jmp 0xc3e4
leaq -0x90(%rbp), %rax
leaq -0x40(%rbp), %r15
movq %rax, 0x8(%r15)
movq %rax, 0x10(%r15)
movq $0x0, (%r15)
movabsq $0x4600000000, %rax     # imm = 0x4600000000
movq %rax, 0x18(%r15)
movl $0x3b9aca00, 0x20(%r15) # imm = 0x3B9ACA00
movw $0x0, 0x24(%r15)
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xc3ef
movq %r15, %rdi
callq 0xda95
addq $0x78, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: 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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0xdaf2
movl 0x18(%rbx), %ecx
movb $0x0, (%rax,%rcx)
cmpl $0x0, 0x20(%rbx)
je 0xdaf2
cmpb $0x0, 0x25(%rbx)
jne 0xdaf2
movq (%rbx), %rdi
movl 0x18(%rbx), %esi
incl %esi
callq 0x144ee
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0xdae7
movq 0x8(%rbx), %rsi
movl 0x18(%rbx), %edx
incl %edx
movq %rax, %rdi
callq 0xa310
movb $0x1, 0x25(%rbx)
jmp 0xdaf2
movb $0x1, 0x24(%rbx)
movl $0x0, 0x1c(%rbx)
movq 0x10(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
movq %rsi, -0xc8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %r8, -0xb0(%rbp)
movq %r9, -0xa8(%rbp)
testb %al, %al
je 0xdb59
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
callq 0xa080
testl %eax, %eax
je 0xdb66
xorl %eax, %eax
jmp 0xdb92
leaq -0xd0(%rbp), %rax
leaq -0x20(%rbp), %rsi
movq %rax, 0x10(%rsi)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%rsi)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0xa400
addq $0xc8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movq %rsi, %rax
testl %edi, %edi
jle 0xdbe8
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
leaq -0x30(%rbp), %rbx
movq %rax, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movq $0x0, (%rbx)
xorl %eax, %eax
movl %eax, 0x18(%rbx)
movl %edi, 0x1c(%rbx)
movl %eax, 0x20(%rbx)
movw $0x0, 0x24(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0xc3ef
movq %rbx, %rdi
callq 0xda95
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 $0xd0, %rsp
leaq -0xd0(%rbp), %r10
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0xdc31
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
leaq -0x20(%rbp), %rcx
movq %r10, 0x10(%rcx)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, (%rcx)
callq 0xa3a0
addq $0xd0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_stricmp
SQLITE_STDCALL sqlite3_stricmp(const char *zLeft, const char *zRight){
  register unsigned char *a, *b;
  if( zLeft==0 ){
    return zRight ? -1 : 0;
  }else if( zRight==0 ){
    return 1;
  }
  a = (unsigned char *)zLeft;
  b = (unsigned char *)zRight;
  while( *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; }
  return UpperToLower[*a] - UpperToLower[*b];
}

// Assembly:
testq %rdi, %rdi
je 0xdf33
testq %rsi, %rsi
je 0xdf3b
pushq %rbp
movq %rsp, %rbp
movb (%rdi), %al
testb %al, %al
je 0xdf1a
incq %rdi
leaq 0x6c412(%rip), %rcx     # 0x7a310
movzbl %al, %edx
movb (%rdx,%rcx), %dl
movzbl (%rsi), %r8d
cmpb (%r8,%rcx), %dl
jne 0xdf1a
incq %rsi
movb (%rdi), %al
incq %rdi
testb %al, %al
jne 0xdefe
movzbl %al, %eax
leaq 0x6c3ec(%rip), %rcx     # 0x7a310
movzbl (%rax,%rcx), %eax
movzbl (%rsi), %edx
movzbl (%rdx,%rcx), %ecx
subl %ecx, %eax
popq %rbp
retq
xorl %eax, %eax
negq %rsi
sbbl %eax, %eax
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3BtreeGetMeta
SQLITE_PRIVATE void sqlite3BtreeGetMeta(Btree *p, int idx, u32 *pMeta){
  BtShared *pBt = p->pBt;

  sqlite3BtreeEnter(p);
  assert( p->inTrans>TRANS_NONE );
  assert( SQLITE_OK==querySharedCacheTableLock(p, MASTER_ROOT, READ_LOCK) );
  assert( pBt->pPage1 );
  assert( idx>=0 && idx<=15 );

  if( idx==BTREE_DATA_VERSION ){
    *pMeta = sqlite3PagerDataVersion(pBt->pPager) + p->iDataVersion;
  }else{
    *pMeta = get4byte(&pBt->pPage1->aData[36 + idx*4]);
  }

  /* If auto-vacuum is disabled in this build and this is an auto-vacuum
  ** database, mark the database as read-only.  */
#ifdef SQLITE_OMIT_AUTOVACUUM
  if( idx==BTREE_LARGEST_ROOT_PAGE && *pMeta>0 ){
    pBt->btsFlags |= BTS_READ_ONLY;
  }
#endif

  sqlite3BtreeLeave(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
movq 0x8(%rdi), %r12
cmpb $0x0, 0x11(%rdi)
je 0xffaa
incl 0x14(%rbx)
cmpb $0x0, 0x12(%rbx)
jne 0xffaa
movq %rbx, %rdi
callq 0x25420
cmpl $0xf, %r15d
jne 0xffbf
movq (%r12), %rcx
movl 0x1c(%rbx), %eax
addl 0x84(%rcx), %eax
jmp 0xffd1
movq 0x18(%r12), %rax
movq 0x50(%rax), %rax
movslq %r15d, %rcx
movl 0x24(%rax,%rcx,4), %eax
bswapl %eax
movl %eax, (%r14)
cmpb $0x0, 0x11(%rbx)
je 0xffdf
decl 0x14(%rbx)
je 0xffe8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x254a6
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3PagerWrite
SQLITE_PRIVATE int sqlite3PagerWrite(PgHdr *pPg){
  Pager *pPager = pPg->pPager;
  assert( (pPg->flags & PGHDR_MMAP)==0 );
  assert( pPager->eState>=PAGER_WRITER_LOCKED );
  assert( assert_pager_state(pPager) );
  if( pPager->errCode ){
    return pPager->errCode;
  }else if( (pPg->flags & PGHDR_WRITEABLE)!=0 && pPager->dbSize>=pPg->pgno ){
    if( pPager->nSavepoint ) return subjournalPageIfRequired(pPg);
    return SQLITE_OK;
  }else if( pPager->sectorSize > (u32)pPager->pageSize ){
    return pagerWriteLargeSector(pPg);
  }else{
    return pager_write(pPg);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x20(%rdi), %rcx
movl 0x2c(%rcx), %eax
testl %eax, %eax
je 0x10775
popq %rbp
retq
testb $0x4, 0x2c(%rdi)
je 0x10783
movl 0x1c(%rcx), %eax
cmpl 0x28(%rdi), %eax
jae 0x1079d
movl 0xb8(%rcx), %eax
cmpl 0xbc(%rcx), %eax
jbe 0x10797
popq %rbp
jmp 0x26252
popq %rbp
jmp 0x263ed
cmpl $0x0, 0x80(%rcx)
je 0x107ac
popq %rbp
jmp 0x1f827
xorl %eax, %eax
jmp 0x10773
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3PagerSync
SQLITE_PRIVATE int sqlite3PagerSync(Pager *pPager, const char *zMaster){
  int rc = SQLITE_OK;

  if( isOpen(pPager->fd) ){
    void *pArg = (void*)zMaster;
    rc = sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_SYNC, pArg);
    if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK;
  }
  if( rc==SQLITE_OK && !pPager->noSync ){
    assert( !MEMDB );
    rc = sqlite3OsSync(pPager->fd, pPager->syncFlags);
  }
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
movq (%rdi), %rax
testq %rax, %rax
je 0x109fc
movq %rsi, %rdx
movl $0x15, %esi
callq *0x50(%rax)
movl %eax, %ecx
xorl %eax, %eax
cmpl $0xc, %ecx
cmovnel %ecx, %eax
jmp 0x109fe
xorl %eax, %eax
testl %eax, %eax
jne 0x10a0a
xorl %eax, %eax
cmpb $0x0, 0xb(%rbx)
je 0x10a11
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x48(%rbx), %rdi
movzbl 0xf(%rbx), %esi
movq (%rdi), %rax
movq 0x28(%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *%rax