LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/wjmelements[P]evm/tst/dio.c
// Function: test_applyConfig_construct
void test_applyConfig_construct() {
    evmInit();

    const char config[] = "["
        "{"
            "\"address\":\"0x80d9b122dc3a16fdc41f96cf010ffe7e38d227c3\","
            "\"construct\":\"tst/in/quine.evm\","
            "\"code\":\"0x383d3d39383df3\""
        "}"
    "]";
    applyConfig(config);

    uint64_t gas = 0x521b;
    address_t from;
    val_t val;
    val[0] = 0;
    val[1] = 0;
    val[2] = 0;
    address_t to = AddressFromHex42("0x80d9b122dc3a16fdc41f96cf010ffe7e38d227c3");
    data_t input;
    input.size = 0;

    result_t result = txCall(from, gas, to, val, input, NULL);
    op_t expected[] = {
        0x38, 0x3d, 0x3d, 0x39, 0x38, 0x3d, 0xf3
    };
    assert(result.returnData.size == sizeof(expected));
    assert(memcmp(expected, result.returnData.content, result.returnData.size) == 0);
    assert(result.gasRemaining == 0);

    evmFinalize();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
xorl %eax, %eax
callq 0x66f5
leaq 0x9a7d(%rip), %rsi      # 0xd180
pushq $0x74
popq %rcx
leaq 0xb0(%rsp), %rax
movq %rax, %rdi
rep  movsb (%rsi), %es:(%rdi)
movq %rax, %rdi
callq 0x39a8
leaq 0x4c(%rsp), %rbx
andq $0x0, (%rbx)
andl $0x0, 0x8(%rbx)
leaq 0x58(%rsp), %r14
movq %r14, %rdi
callq 0x346c
movl 0x10(%r14), %eax
movl %eax, 0x28(%rsp)
movups (%r14), %xmm0
movups %xmm0, 0x18(%rsp)
movl 0x48(%rsp), %eax
movl %eax, 0x10(%rsp)
movups 0x38(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x70(%rsp), %r14
movl $0x521b, %esi           # imm = 0x521B
movq %r14, %rdi
movq %rbx, %rdx
xorl %ecx, %ecx
xorl %r9d, %r9d
callq 0x6d9d
cmpq $0x7, (%r14)
jne 0x37ac
movq 0x78(%rsp), %rsi
leaq 0x9f0d(%rip), %rdi      # 0xd690
pushq $0x7
popq %rdx
callq 0x31c0
testl %eax, %eax
jne 0x37cb
cmpq $0x0, 0xa0(%rsp)
jne 0x37ea
xorl %eax, %eax
callq 0x6a10
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r14
retq
leaq 0x9d07(%rip), %rdi      # 0xd4ba
leaq 0x9d2b(%rip), %rsi      # 0xd4e5
leaq 0x9ded(%rip), %rcx      # 0xd5ae
movl $0x8c, %edx
callq 0x30e0
leaq 0x9d3a(%rip), %rdi      # 0xd50c
leaq 0x9d0c(%rip), %rsi      # 0xd4e5
leaq 0x9dce(%rip), %rcx      # 0xd5ae
movl $0x8d, %edx
callq 0x30e0
leaq 0x9d64(%rip), %rdi      # 0xd555
leaq 0x9ced(%rip), %rsi      # 0xd4e5
leaq 0x9daf(%rip), %rcx      # 0xd5ae
movl $0x8e, %edx
callq 0x30e0
// File: /workspace/github_c_makefile_star2_O2/wjmelements[P]evm/tst/dio.c
// Function: main
int main() {
    dioInit("bin/evm");

    test_applyConfig_code();
    test_applyConfig_storage();
    test_applyConfig_balance();
    test_applyConfig_construct();

    close(2);
    test_applyConfig_tests();
    return 0;
}

// Assembly:
pushq %rax
leaq 0x9cba(%rip), %rdi      # 0xd5ee
callq 0x39a0
callq 0x335c
callq 0x34c5
callq 0x35da
callq 0x36eb
pushq $0x2
popq %rdi
callq 0x3120
callq 0x3809
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/ramirezsebas[P]TP-LISTINGS/./src/capitulo_4/4.6/critical-section.c
// Function: process_transaction
void* process_transaction(void* thread_args){
	struct transaction tr = *((struct transaction*)thread_args);

	int old_cancel_state;

	if(account_balances[tr.from_acct] < tr.dollars)
		return (void*)1;

	/* Begin critical section */

	pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &old_cancel_state);

	/* Move the money */

	account_balances[tr.to_acct] += tr.dollars;
	account_balances[tr.from_acct] -= tr.dollars;

	/* End critical section */

	pthread_setcancelstate(old_cancel_state, NULL);

	return (void*)0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movslq (%rdi), %r14
movss 0x8(%rdi), %xmm0
leaq 0x2eb6(%rip), %r15      # 0x4060
ucomiss (%r15,%r14,4), %xmm0
jbe 0x11b6
pushq $0x1
popq %rbx
jmp 0x11fe
movslq 0x4(%rdi), %r12
pushq $0x1
popq %rdi
leaq -0x28(%rbp), %rbx
movq %rbx, %rsi
movss %xmm0, -0x24(%rbp)
callq 0x1040
movss (%r15,%r12,4), %xmm0
movss -0x24(%rbp), %xmm1
addss %xmm1, %xmm0
movss %xmm0, (%r15,%r12,4)
movss (%r15,%r14,4), %xmm0
subss %xmm1, %xmm0
movss %xmm0, (%r15,%r14,4)
movl (%rbx), %edi
xorl %ebx, %ebx
xorl %esi, %esi
callq 0x1040
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ramirezsebas[P]TP-LISTINGS/./src/capitulo_4/4.6/critical-section.c
// Function: main
int main(){

	struct transaction transactions[] = {	{0, 1, 250.65},
											{7, 6, 150.25},
											{2, 9, 350.67},
											{5, 3, 150.77},
											{4, 1, 250.00}};

	int i;

	pthread_t threads_id[num_transactions];

	printf("Account balances before transactions\n");

	for(i = 0; i < num_accounts; ++i)
		printf("%d: %.2f\n", i, account_balances[i]);

	for(i = 0; i < num_transactions; ++i)
		pthread_create(&threads_id[i], NULL, &process_transaction, &transactions[i]);

	/* To demonstrate that threads are uncancelable */
	for(i = 0; i < num_transactions; ++i)
		pthread_cancel(threads_id[i]);

	for(i = 0; i < num_transactions; ++i)
		pthread_join(threads_id[i], NULL);

	printf("\nAccount balances before transactions\n");

	for(i = 0; i < num_accounts; ++i)
		printf("%d: %.2f\n", i, account_balances[i]);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rsp, %r15
movups 0xe25(%rip), %xmm0      # 0x204c
movups %xmm0, -0x34(%rbp)
movaps 0xe0e(%rip), %xmm0      # 0x2040
movaps %xmm0, -0x40(%rbp)
movaps 0xdf3(%rip), %xmm0      # 0x2030
movaps %xmm0, -0x50(%rbp)
movaps 0xdd8(%rip), %xmm0      # 0x2020
movaps %xmm0, -0x60(%rbp)
leaq 0xe14(%rip), %rdi       # 0x2067
callq 0x1030
leaq 0x2e01(%rip), %r12      # 0x4060
xorl %ebx, %ebx
leaq 0xdf4(%rip), %r14       # 0x205c
cmpq $0xa, %rbx
je 0x1289
cvtss2sd (%r12), %xmm0
movq %r14, %rdi
movl %ebx, %esi
movb $0x1, %al
callq 0x1050
incq %rbx
addq $0x4, %r12
jmp 0x1268
leaq -0x90(%rbp), %rbx
xorl %r12d, %r12d
leaq -0x10e(%rip), %r14      # 0x118c
cmpq $0x3c, %r12
je 0x12bf
leaq (%r12,%rbp), %rcx
addq $-0x60, %rcx
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x1060
addq $0xc, %r12
addq $0x8, %rbx
jmp 0x129a
xorl %ebx, %ebx
cmpq $0x5, %rbx
je 0x12d9
movq -0x90(%rbp,%rbx,8), %rdi
callq 0x1080
incq %rbx
jmp 0x12c1
xorl %ebx, %ebx
cmpq $0x5, %rbx
je 0x12f5
movq -0x90(%rbp,%rbx,8), %rdi
xorl %esi, %esi
callq 0x1070
incq %rbx
jmp 0x12db
leaq 0xd6a(%rip), %rdi       # 0x2066
callq 0x1030
leaq 0x2d58(%rip), %r12      # 0x4060
xorl %ebx, %ebx
leaq 0xd4b(%rip), %r14       # 0x205c
cmpq $0xa, %rbx
je 0x1332
cvtss2sd (%r12), %xmm0
movq %r14, %rdi
movl %ebx, %esi
movb $0x1, %al
callq 0x1050
incq %rbx
addq $0x4, %r12
jmp 0x1311
movq %r15, %rsp
xorl %eax, %eax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/giometti[P]mastering_UNIX_programming/chapter_09/limits.c
// Function: res_n2v
int res_n2v(char *n)
{
	int i;
	for (i = 0; i < 7; i++)
		if (strcmp(rlimit_n[i], n) == 0)
			break;
	if (i >= 7)
		return -1;
	return rlimit_v[i];
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x2ec2(%rip), %r12      # 0x4090
xorl %r15d, %r15d
pushq $-0x1
popq %rbx
cmpq $0x1c, %r15
je 0x11ff
movq (%r12), %rdi
movq %r14, %rsi
callq 0x1050
testl %eax, %eax
je 0x11f4
addq $0x4, %r15
addq $0x8, %r12
jmp 0x11d4
leaq 0x2e75(%rip), %rax      # 0x4070
movl (%r15,%rax), %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/giometti[P]mastering_UNIX_programming/chapter_09/limits.c
// Function: main
int main(int argc, char *argv[])
{
	int resource;
	struct rlimit rlim;
	bool do_set = false;
	int ret;

	/* Check the command line */
	if (!(argc == 2 || argc == 4)) {
		fprintf(stderr,
			"usage: %s <resource> "
				"[<soft-limit> <hard-limit>]\n",
			argv[0]);
		fprintf(stderr,
			"where <resource> can be: ");
		for (resource = 0; resource < 7; resource++)
			fprintf(stderr, "%s ", rlimit_n[resource]);
		fprintf(stderr, "\n");
		return -1;
	}
	resource = res_n2v(argv[1]);
	if (resource < 0) {
		fprintf(stderr, "invallid resource %s", argv[1]);
		return -1;

	}
	if (argc == 4) {
		rlim.rlim_cur = atoi(argv[2]);
		rlim.rlim_max = atoi(argv[3]);
		do_set = true;
	}

	if (do_set) {
		/* Try to set the new resource's values */
		ret = setrlimit(resource, &rlim);
		if (ret) {
			perror("setrlimit");
			return -1;
		}
	}

	/* Read the resource's values in order to print them */	
	ret = getrlimit(resource, &rlim);
	if (ret) {
		perror("getrlimit");
		return -1;
	}
	printf("limits for %s are soft=%lld; hard=%lld\n", argv[1],
		(long long) rlim.rlim_cur, (long long) rlim.rlim_max);

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movl %edi, %r14d
cmpl $0x2, %edi
je 0x122e
cmpl $0x4, %r14d
jne 0x12db
movq 0x8(%rbx), %r15
movq %r15, %rdi
callq 0x11bc
testl %eax, %eax
js 0x12b2
movl %eax, %ebp
cmpl $0x4, %r14d
jne 0x1278
movq 0x10(%rbx), %rdi
callq 0x1090
cltq
movq %rsp, %r14
movq %rax, (%r14)
movq 0x18(%rbx), %rdi
callq 0x1090
cltq
movq %rax, 0x8(%r14)
movl %ebp, %edi
movq %r14, %rsi
callq 0x1070
testl %eax, %eax
jne 0x1346
movq %rsp, %rsi
movl %ebp, %edi
callq 0x10b0
testl %eax, %eax
jne 0x12d2
movq 0x8(%rbx), %rsi
movq (%rsp), %rdx
movq 0x8(%rsp), %rcx
leaq 0xe38(%rip), %rdi       # 0x20d2
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x1030
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x2d3f(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xde6(%rip), %rsi       # 0x20a9
movq %r15, %rdx
xorl %eax, %eax
callq 0x1060
jmp 0x1352
leaq 0xdef(%rip), %rdi       # 0x20c8
jmp 0x134d
movq 0x2d16(%rip), %r14      # 0x3ff8
movq (%r14), %rdi
movq (%rbx), %rdx
leaq 0xd6a(%rip), %rsi       # 0x2059
xorl %eax, %eax
callq 0x1060
movq (%r14), %rcx
leaq 0xd8b(%rip), %rdi       # 0x208b
pushq $0x19
popq %rsi
pushq $0x1
popq %rdx
callq 0x10a0
leaq 0x2d7e(%rip), %r15      # 0x4090
leaq 0xd8c(%rip), %rbx       # 0x20a5
xorl %r12d, %r12d
movq (%r14), %rsi
cmpq $0x38, %r12
je 0x133c
movq (%r12,%r15), %rdx
movq %rsi, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1060
addq $0x8, %r12
jmp 0x131c
pushq $0xa
popq %rdi
callq 0x1040
jmp 0x1352
leaq 0xd71(%rip), %rdi       # 0x20be
callq 0x1080
pushq $-0x1
popq %rbx
jmp 0x12a3
// File: /workspace/github_c_makefile_star2_O2/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 0x45eef0
movq %rax, %r15
testl %r15d, %r15d
jle 0x401a99
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 0x45efa0
cmpl %r15d, %eax
jne 0x401aed
movq 0x38(%rbx), %rax
movq $0x780, 0x8(%rax)       # imm = 0x780
movq $0x1000, 0x50(%rbx)     # imm = 0x1000
jmp 0x401a44
callq 0x405550
movl (%rax), %eax
cmpl $0x4, %eax
je 0x401a44
cmpl $0xb, %eax
je 0x401a44
testl %r15d, %r15d
jne 0x401ab5
cmpl $0x0, 0x4(%rbx)
jne 0x401a44
movq $0x4e67c8, %rbx         # imm = 0x4E67C8
movq (%rbx), %rcx
leaq 0xb16c6(%rip), %rdi     # 0x4b318c
pushq $0x1d
popq %rsi
pushq $0x1
popq %rdx
callq 0x413de0
movq (%rbx), %rdi
leaq 0xb16cf(%rip), %rsi     # 0x4b31aa
leaq 0xb16e2(%rip), %rdx     # 0x4b31c4
leaq 0xb15c0(%rip), %rcx     # 0x4b30a9
pushq $0x41
jmp 0x401b23
movq $0x4e67c8, %rbx         # imm = 0x4E67C8
movq (%rbx), %rcx
leaq 0xb16e4(%rip), %rdi     # 0x4b31e2
pushq $0x1d
popq %rsi
pushq $0x1
popq %rdx
callq 0x413de0
movq (%rbx), %rdi
leaq 0xb1697(%rip), %rsi     # 0x4b31aa
leaq 0xb16aa(%rip), %rdx     # 0x4b31c4
leaq 0xb1588(%rip), %rcx     # 0x4b30a9
pushq $0x49
popq %r8
xorl %eax, %eax
callq 0x40ce50
leaq 0xb169d(%rip), %rdi     # 0x4b31d0
callq 0x40d130
movq (%rbx), %rsi
pushq $0xa
popq %rdi
callq 0x416040
pushq $0x1
popq %rdi
callq 0x40bdb0
nop
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
pushq $0x58
popq %rdi
callq 0x1130
movq %rax, %rbx
testq %rax, %rax
je 0x136c
cmpq $0x40, %r14
jae 0x1386
testq %r14, %r14
je 0x139f
andq $0x0, (%rbx)
movl %r14d, 0x8(%rbx)
movq %rbx, %rdi
addq $0x18, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1050
movb $0x0, 0x18(%rbx,%r14)
movl %ebp, 0xc(%rbx)
andq $0x0, 0x10(%rbx)
jmp 0x1378
leaq 0x2065(%rip), %rdi      # 0x33d8
callq 0x1080
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1d18(%rip), %rdi      # 0x30a5
leaq 0x1c70(%rip), %rsi      # 0x3004
leaq 0x1c76(%rip), %rcx      # 0x3011
pushq $0x27
jmp 0x13b6
leaq 0x1ca5(%rip), %rdi      # 0x304b
leaq 0x1c57(%rip), %rsi      # 0x3004
leaq 0x1c5d(%rip), %rcx      # 0x3011
pushq $0x28
popq %rdx
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O2/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 0x14fd
movq %rdi, %rsi
movq 0x4c7f(%rip), %rdi      # 0x6158
callq 0x1419
testq %rax, %rax
sete %cl
testq %rbx, %rbx
sete %dl
orb %cl, %dl
jne 0x14f3
movl 0xc(%rax), %ecx
movl %ecx, (%rbx)
xorl %ecx, %ecx
testq %rax, %rax
setne %cl
jmp 0x14ff
xorl %ecx, %ecx
movl %ecx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1585
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsp, %rdi
xorl %esi, %esi
callq 0x11d0
testl %eax, %eax
jne 0x1591
movq %rsp, %rdi
callq 0x11a0
leaq 0x4bf1(%rip), %rdi      # 0x6128
callq 0x1200
movq 0x4c15(%rip), %rdi      # 0x6158
movq %r15, %rsi
movq %r14, %rdx
callq 0x1419
testq %rax, %rax
sete %cl
testq %rbx, %rbx
sete %dl
orb %cl, %dl
jne 0x1563
movl 0xc(%rax), %ecx
movl %ecx, (%rbx)
xorl %ebx, %ebx
testq %rax, %rax
setne %al
movb %al, %bl
movq %rsp, %rdi
callq 0x10b0
leaq 0x4bac(%rip), %rdi      # 0x6128
callq 0x1120
movl %ebx, %eax
jmp 0x1587
xorl %eax, %eax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x130c
movq %rsp, %rdi
callq 0x1140
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
testq %rsi, %rsi
je 0x1dfa
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x43c3(%rip), %rdi      # 0x6128
callq 0x1200
testl %eax, %eax
jne 0x1e0a
movq 0x43df(%rip), %rdi      # 0x6158
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1ba2
movq %rax, %r14
leaq 0x440a(%rip), %rax      # 0x6198
movl (%rax), %ebp
leaq 0x4391(%rip), %rdi      # 0x6128
callq 0x1120
testq %r14, %r14
setne %cl
je 0x1dfe
testl %ebp, %ebp
je 0x1dfe
testl %eax, %eax
jne 0x1e48
callq 0x1160
leaq 0x1538(%rip), %rdi      # 0x32f4
movq %rax, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x10a0
leaq 0x4398(%rip), %rdi      # 0x6168
callq 0x1070
movb $0x1, %cl
testl %eax, %eax
je 0x1e02
leaq 0x13f0(%rip), %rdi      # 0x31d2
leaq 0x121b(%rip), %rsi      # 0x3004
leaq 0x14e3(%rip), %rcx      # 0x32d3
movl $0x1ac, %edx            # imm = 0x1AC
callq 0x10c0
xorl %ecx, %ecx
jmp 0x1e02
testl %eax, %eax
jne 0x1e29
movzbl %cl, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x13c1(%rip), %rdi      # 0x31d2
leaq 0x11ec(%rip), %rsi      # 0x3004
leaq 0x14b4(%rip), %rcx      # 0x32d3
movl $0x1a1, %edx            # imm = 0x1A1
callq 0x10c0
leaq 0x13a2(%rip), %rdi      # 0x31d2
leaq 0x11cd(%rip), %rsi      # 0x3004
leaq 0x1495(%rip), %rcx      # 0x32d3
movl $0x1b0, %edx            # imm = 0x1B0
callq 0x10c0
leaq 0x1383(%rip), %rdi      # 0x31d2
leaq 0x11ae(%rip), %rsi      # 0x3004
leaq 0x1476(%rip), %rcx      # 0x32d3
movl $0x1a8, %edx            # imm = 0x1A8
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O2/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 0x419f(%rip), %rdi      # 0x6128
callq 0x1200
testl %eax, %eax
jne 0x1fce
movq 0x41bf(%rip), %rsi      # 0x6158
leaq 0x1429(%rip), %rdi      # 0x33c9
xorl %eax, %eax
callq 0x10a0
movq 0x41aa(%rip), %rdi      # 0x6158
testq %rdi, %rdi
je 0x1fbc
xorl %esi, %esi
xorl %edx, %edx
callq 0x1e67
leaq 0x4165(%rip), %rdi      # 0x6128
callq 0x1120
testl %eax, %eax
jne 0x1fed
popq %rax
retq
leaq 0x11fd(%rip), %rdi      # 0x31d2
leaq 0x1028(%rip), %rsi      # 0x3004
leaq 0x13d9(%rip), %rcx      # 0x33bc
movl $0x1d5, %edx            # imm = 0x1D5
callq 0x10c0
leaq 0x11de(%rip), %rdi      # 0x31d2
leaq 0x1009(%rip), %rsi      # 0x3004
leaq 0x13ba(%rip), %rcx      # 0x33bc
movl $0x1de, %edx            # imm = 0x1DE
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O2/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 0x122d
testl %eax, %eax
je 0x1208
pushq $-0x1
popq %rax
jmp 0x1227
movq 0x1b0(%r15), %rdi
movl 0x4(%rdi), %eax
decl %eax
movl %eax, (%rdi)
addq $0x10, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x12ab
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x40
popq %rcx
cltd
idivl %ecx
movl %eax, %ebp
incl %ebp
pushq $0x1
popq %r12
movl %ebp, %eax
cmpl %ebp, %r12d
je 0x125d
testl %eax, %eax
jle 0x125d
addl %r12d, %r12d
shrl %eax
jmp 0x124d
movslq %r12d, %rax
leaq 0x10(,%rax,8), %rdi
callq 0x10e0
testq %rax, %rax
je 0x129f
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 0x12a2
pushq $-0x1
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movl (%rsi), %eax
pushq $0x40
popq %rcx
cltd
idivl %ecx
movq 0x50(%rsi), %r12
shlq $0x10, %r12
xorq 0x30(%rsi), %r12
movq %rdi, %rbx
movq %r12, %rcx
shrq $0x20, %rcx
movq %r12, %rdx
shrq $0x30, %rdx
addq %rcx, %rdx
movq %rdx, %rsi
shrq $0x8, %rsi
addl %edx, %esi
movslq %eax, %r15
leaq 0x8(,%r15,8), %rdx
callq 0x1090
movq %r14, (%rbx)
movq %r12, 0x8(%rbx)
pushq $0x1
popq %rax
movabsq $0x5851f42d4c957f2d, %rcx # imm = 0x5851F42D4C957F2D
cmpq %r15, %rax
jg 0x132f
movq -0x8(%rbx,%rax,8), %rdx
movq %rdx, %rsi
shrq $0x3e, %rsi
xorq %rdx, %rsi
imulq %rcx, %rsi
addq %rax, %rsi
xorq %rsi, (%rbx,%rax,8)
incq %rax
jmp 0x130b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x16a8(%rip), %rsi      # 0x3018
movq %rbx, %rdi
xorl %eax, %eax
callq 0x10b0
pushq $-0x14
popq %r12
leaq 0x169e(%rip), %r15      # 0x3023
testq %r12, %r12
je 0x19a5
movzbl 0x1ac(%r14,%r12), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x10b0
incq %r12
jmp 0x1985
pushq $0xa
popq %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x10a0
// File: /workspace/github_c_makefile_star2_O2/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
movl %esi, %ebx
movq %rdi, 0x10(%rsp)
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %ebx
pushq $0x2
popq %rcx
xorl %edi, %edi
movq 0x10(%rsp), %r14
movl %edi, %eax
xorl %edx, %edx
pushq $0x3
popq %rsi
divl %esi
subl $0x1, %ebx
jb 0x1a90
movl %edi, 0xc(%rsp)
leal (%rax,%rax,2), %r15d
addl %ecx, %r15d
movq 0x1b0(%r14), %rbp
movl 0x4(%rbp), %r13d
movl 0x8(%rbp), %r12d
movl 0xc(%rbp), %eax
movl %eax, 0x4(%rsp)
addl 0x4(%r14), %r12d
movq %r14, %rdi
movl %ecx, 0x8(%rsp)
callq 0x1fe1
movq 0x1b0(%r14), %rax
movslq (%rax), %rax
notl %r13d
addl %r12d, %r13d
addl %eax, %r13d
andl 0x4(%rsp), %r13d
movslq %r13d, %rcx
movq 0x10(%rbp,%rcx,8), %rcx
movq %rcx, %rdx
shrq $0x10, %rdx
xorl %ecx, %edx
movl %edx, %ecx
shrl $0x8, %ecx
xorl %edx, %ecx
andl $0xf, %ecx
movq 0x90(%r14,%rcx,8), %rsi
xorq 0x10(%rbp,%rax,8), %rsi
leaq 0x15bd(%rip), %rdi      # 0x3028
xorl %eax, %eax
callq 0x1080
testl %r15d, %r15d
jne 0x1a7f
pushq $0xa
popq %rdi
callq 0x1040
movl 0xc(%rsp), %edi
incl %edi
movl 0x8(%rsp), %ecx
decl %ecx
jmp 0x19e1
pushq $0xa
popq %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x1b0(%rdi), %r14
movl 0x4(%r14), %ebp
movl 0x8(%r14), %r15d
movl 0xc(%r14), %r12d
addl 0x4(%rdi), %r15d
callq 0x1fe1
movq 0x1b0(%rbx), %rax
movslq (%rax), %rax
movq 0x10(%r14,%rax,8), %rcx
notl %ebp
addl %r15d, %ebp
addl %eax, %ebp
andl %r12d, %ebp
movslq %ebp, %rax
movq 0x10(%r14,%rax,8), %rax
movq %rax, %rdx
shrq $0x10, %rdx
xorl %eax, %edx
movl %edx, %eax
shrl $0x8, %eax
xorl %edx, %eax
shrq $0xc, %rcx
andl $0xf, %eax
xorq 0x110(%rbx,%rax,8), %rcx
movq %rcx, %xmm0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %ebp, %ebp
testl %esi, %esi
cmovlel %ebp, %ebx
pushq $0x2
popq %r13
leaq 0x1481(%rip), %r15      # 0x3030
movl %ebp, %eax
xorl %edx, %edx
pushq $0x3
popq %rcx
divl %ecx
subl $0x1, %ebx
jb 0x1bf2
leal (%rax,%rax,2), %r12d
addl %r13d, %r12d
movq %r14, %rdi
callq 0x1b18
addsd 0x1434(%rip), %xmm0     # 0x3008
movq %r15, %rdi
movb $0x1, %al
callq 0x1080
testl %r12d, %r12d
jne 0x1beb
pushq $0xa
popq %rdi
callq 0x1040
incl %ebp
decl %r13d
jmp 0x1baf
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %ebp, %ebp
testl %esi, %esi
cmovlel %ebp, %ebx
pushq $0x2
popq %r13
leaq 0x1406(%rip), %r15      # 0x3030
movl %ebp, %eax
xorl %edx, %edx
pushq $0x3
popq %rcx
divl %ecx
subl $0x1, %ebx
jb 0x1c75
leal (%rax,%rax,2), %r12d
addl %r13d, %r12d
movq %r14, %rdi
callq 0x1b18
movsd 0x13c1(%rip), %xmm1     # 0x3010
subsd %xmm0, %xmm1
movq %r15, %rdi
movapd %xmm1, %xmm0
movb $0x1, %al
callq 0x1080
testl %r12d, %r12d
jne 0x1c6e
pushq $0xa
popq %rdi
callq 0x1040
incl %ebp
decl %r13d
jmp 0x1c2a
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %rbx
movq 0x1b0(%rdi), %rdx
movl 0x4(%rdx), %ecx
movl 0x8(%rdx), %r8d
movslq 0xc(%rdx), %rax
movslq (%rdx), %rsi
incq %rsi
andq %rax, %rsi
movl 0x4(%rdi), %r9d
addl %r8d, %r9d
movl %esi, (%rdx)
movl %esi, %r10d
subl %ecx, %r10d
leal (%r10,%r8), %r11d
andl %eax, %r11d
movslq %r11d, %r11
addl %r10d, %r8d
incl %r8d
andl %eax, %r8d
movslq %r8d, %r10
subl %ecx, %r9d
addl %esi, %r9d
andl %eax, %r9d
movslq %r9d, %rax
movq 0x10(%rdx,%rax,8), %r8
movb 0x8(%rdi), %cl
movb 0xc(%rdi), %al
movq 0x190(%rdi), %r9
andq 0x10(%rdx,%r11,8), %r9
xorq 0x10(%rdx,%r10,8), %r9
movq %r9, %r10
shrq $0x20, %r10
movq %r8, %r11
shrq $0x20, %r11
movl %r10d, %ebx
shll %cl, %ebx
movl %r9d, %ebp
shll %cl, %ebp
movl %eax, %ecx
shrl %cl, %r11d
xorl %r9d, %r11d
xorl %ebp, %r11d
shrl %cl, %r8d
xorl %r10d, %r8d
xorl %ebx, %r8d
shlq $0x20, %r11
leaq (%r8,%r11), %rax
movq %rax, 0x10(%rdx,%rsi,8)
andl $0xf, %r8d
xorq 0x10(%rdi,%r8,8), %rax
movq %rax, 0x10(%rdx,%rsi,8)
popq %rbx
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x10
popq %rdi
callq 0x1100
movq %rax, %rbx
cmpl $0x73, %ebp
je 0x16f9
cmpl $0x6e, %ebp
je 0x16d7
cmpl $0x72, %ebp
je 0x16e6
cmpl $0x63, %ebp
jne 0x1707
movw $0x65, 0x4(%rbx)
movl $0x68636163, (%rbx)     # imm = 0x68636163
jmp 0x171a
movabsq $0x65686361636f6e, %rax # imm = 0x65686361636F6E
movq %rax, (%rbx)
jmp 0x171a
movabsq $0x746e656469736572, %rax # imm = 0x746E656469736572
movq %rax, (%rbx)
movb $0x0, 0x8(%rbx)
jmp 0x171a
movw $0x64, 0x4(%rbx)
movl $0x6e756f73, (%rbx)     # imm = 0x6E756F73
jmp 0x171a
leaq 0xa16(%rip), %rsi       # 0x2124
movq %rbx, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x1160
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x20
popq %rdi
callq 0x1100
movq %rax, %rbx
testl %r12d, %r12d
je 0x17b2
movzwl %r12w, %ebp
movzwl %r15w, %r14d
movq 0x298a(%rip), %r15      # 0x40e0
movl 0x2990(%rip), %ecx      # 0x40ec
movl %ebp, %edi
movl %r14d, %esi
movq %r15, %rdx
callq 0x1677
cmpl $-0x1, %eax
jne 0x1791
movq 0x2963(%rip), %r15      # 0x40d8
movl 0x296d(%rip), %ecx      # 0x40e8
movl %ebp, %edi
movl %r14d, %esi
movq %r15, %rdx
callq 0x1677
cmpl $-0x1, %eax
je 0x1817
movl %eax, %eax
imulq $0x108, %rax, %rax      # imm = 0x108
leaq (%r15,%rax), %rsi
addq $0x8, %rsi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1050
cmpl $0x72, %r14d
je 0x17fa
cmpl $0x6e, %r14d
je 0x17de
cmpl $0x63, %r14d
jne 0x182d
movabsq $0x7261642e316c64, %rax # imm = 0x7261642E316C64
movq %rax, 0x5(%rbx)
movabsq $0x316c646d5f677473, %rax # imm = 0x316C646D5F677473
jmp 0x1812
leaq 0x951(%rip), %rsi       # 0x2136
leaq 0x953(%rip), %rdx       # 0x213f
movq %rbx, %rdi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x1160
jmp 0x182d
movabsq $0x7261642e316c64, %rax # imm = 0x7261642E316C64
movq %rax, 0x5(%rbx)
movabsq $0x316c646d5f736572, %rax # imm = 0x316C646D5F736572
movq %rax, (%rbx)
jmp 0x182d
leaq 0x936(%rip), %rsi       # 0x2154
movq %rbx, %rdi
movl %ebp, %edx
movl %r14d, %ecx
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_O2/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 0x7a754(%rip), %rdi     # 0x85068
callq 0xa800
leaq 0x7a770(%rip), %r15     # 0x85090
leaq 0x5d6d9(%rip), %r12     # 0x68000
leaq 0x7a76a(%rip), %r13     # 0x85098
xorl %ebx, %ebx
cmpq $0x0, 0x7a758(%rip)     # 0x85090
jne 0xa994
movq %r14, %rdi
movq %r15, %rsi
callq 0xa1a0
testl %eax, %eax
jne 0xa97d
movq 0x7a740(%rip), %rdi     # 0x85090
movq %r12, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r13, %r8
callq 0xa150
testl %eax, %eax
je 0xa930
leaq 0x5d696(%rip), %rdi     # 0x68000
callq 0xa120
movq 0x7a722(%rip), %rdi     # 0x85098
callq 0xa120
jmp 0xa991
leaq 0x5d717(%rip), %rdi     # 0x6809b
callq 0xa120
andq $0x0, 0x7a6ff(%rip)     # 0x85090
pushq $-0x1
popq %rbx
leaq 0x7a6cd(%rip), %rdi     # 0x85068
callq 0xa440
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7a688(%rip), %rdi     # 0x85068
callq 0xa800
leaq -0x840(%rbp), %r12
movl $0x800, %edx            # imm = 0x800
movq %r12, %rdi
xorl %esi, %esi
callq 0xa270
subq $0x8, %rsp
leaq 0x5d6ab(%rip), %rsi     # 0x680b1
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 0xa690
addq $0x20, %rsp
movq 0x7a65e(%rip), %rdi     # 0x85090
leaq 0x7a65f(%rip), %r8      # 0x85098
movq %r12, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xa150
testl %eax, %eax
je 0xaa58
leaq -0x840(%rbp), %rdi
callq 0xa120
pushq $-0x1
popq %rbx
leaq 0x7a609(%rip), %rdi     # 0x85068
callq 0xa440
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_O2/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 0x61094(%rip), %rsi     # 0x6c040
pushq $0x7
popq %rdx
callq 0xa730
leaq 0x7(%r14), %rbx
testl %eax, %eax
cmovneq %r14, %rbx
movq %rbx, %rdi
callq 0xb080
movl %eax, %r15d
leaq 0x766c0(%rip), %r13     # 0x81690
xorl %r14d, %r14d
cmpq $0x10, %r14
je 0xb007
movq (%r14,%r13), %r12
movq %rbx, %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0xa730
testl %eax, %eax
jne 0xb001
movzbl (%r12,%r15), %eax
leaq 0x5e445(%rip), %rcx     # 0x69440
testb $0x46, (%rax,%rcx)
je 0xb00b
addq $0x8, %r14
jmp 0xafd3
xorl %eax, %eax
jmp 0xb00e
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_status64
SQLITE_STDCALL sqlite3_status64(
  int op,
  sqlite3_int64 *pCurrent,
  sqlite3_int64 *pHighwater,
  int resetFlag
){
  sqlite3_mutex *pMutex;
  wsdStatInit;
  if( op<0 || op>=ArraySize(wsdStat.nowValue) ){
    return SQLITE_MISUSE_BKPT;
  }
#ifdef SQLITE_ENABLE_API_ARMOR
  if( pCurrent==0 || pHighwater==0 ) return SQLITE_MISUSE_BKPT;
#endif
  pMutex = statMutex[op] ? sqlite3Pcache1Mutex() : sqlite3MallocMutex();
  sqlite3_mutex_enter(pMutex);
  *pCurrent = wsdStat.nowValue[op];
  *pHighwater = wsdStat.mxValue[op];
  if( resetFlag ){
    wsdStat.mxValue[op] = wsdStat.nowValue[op];
  }
  sqlite3_mutex_leave(pMutex);
  (void)pMutex;  /* Prevent warning when SQLITE_THREADSAFE=0 */
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0xa, %edi
jb 0xb0d6
movl $0x3f72, %edi           # imm = 0x3F72
callq 0xb14d
pushq $0x15
popq %rbx
jmp 0xb13c
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %r13d
movl $0x379, %eax            # imm = 0x379
btq %rdi, %rax
leaq 0x7a4c7(%rip), %rax     # 0x855b8
leaq 0x7a050(%rip), %rcx     # 0x85148
cmovaeq %rax, %rcx
movq (%rcx), %r12
testq %r12, %r12
je 0xb10d
movq %r12, %rdi
callq *0x7839b(%rip)          # 0x834a8
leaq 0x79f8c(%rip), %rax     # 0x850a0
movq (%rax,%r13,8), %rcx
movq %rcx, (%r15)
movq 0x50(%rax,%r13,8), %rdx
movq %rdx, (%r14)
testl %ebx, %ebx
je 0xb12c
movq %rcx, 0x50(%rax,%r13,8)
xorl %ebx, %ebx
testq %r12, %r12
je 0xb13c
movq %r12, %rdi
callq *0x7837c(%rip)          # 0x834b8
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa2c0
testl %eax, %eax
jne 0xb1bf
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_O2/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 0x24b54
movq 0x20(%r14), %rdi
movzwl 0x88(%r14), %esi
addl %esi, %esi
callq 0x24b54
movq 0x108(%r14), %r15
testq %r15, %r15
je 0xb7f4
movq 0x20(%r15), %r12
movq (%r15), %rsi
movl 0x8(%r15), %edx
movq %rbx, %rdi
callq 0x24bf4
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb856
movq %r12, %r15
jmp 0xb7cc
movswq 0x7a(%r14), %rax
movl %eax, %r15d
testl %r15d, %r15d
jle 0xb817
movq 0x70(%r14), %rax
movq -0x8(%rax,%r15,8), %rsi
decq %r15
movq %rbx, %rdi
callq 0xb856
jmp 0xb7fc
movq 0x8(%r14), %rsi
movl 0x3c(%r14), %edx
movq %rbx, %rdi
callq 0x24bf4
movq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0xb856
movq 0xe0(%r14), %rsi
movq %rbx, %rdi
callq 0xb856
movq 0xe8(%r14), %rsi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xb856
// File: /workspace/github_c_makefile_star2_O2/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, 0x77574(%rip)     # 0x83498
jne 0xbfed
cmpl $0x0, 0x774f3(%rip)     # 0x83424
leaq 0xdb42(%rip), %rax      # 0x19a7a
leaq 0xda56(%rip), %rcx      # 0x19995
cmoveq %rax, %rcx
movq %rcx, 0x7753e(%rip)     # 0x83488
leaq 0xdb31(%rip), %rax      # 0x19a82
leaq 0xda45(%rip), %rcx      # 0x1999d
cmoveq %rax, %rcx
movq %rcx, 0x7752d(%rip)     # 0x83490
leaq 0xdb30(%rip), %rax      # 0x19a9a
leaq 0xdac4(%rip), %rcx      # 0x19a35
cmoveq %rax, %rcx
leaq 0xdb24(%rip), %rax      # 0x19aa0
leaq 0xdace(%rip), %rdx      # 0x19a51
cmoveq %rax, %rdx
movq %rcx, 0x77512(%rip)     # 0x834a0
movq %rdx, 0x77513(%rip)     # 0x834a8
leaq 0xdb0a(%rip), %rax      # 0x19aa6
leaq 0xdab8(%rip), %rcx      # 0x19a5b
cmoveq %rax, %rcx
movq %rcx, 0x77502(%rip)     # 0x834b0
leaq 0xdaf9(%rip), %rax      # 0x19aae
leaq 0xdab4(%rip), %rcx      # 0x19a70
cmoveq %rax, %rcx
movq %rcx, 0x774f1(%rip)     # 0x834b8
xorps %xmm0, %xmm0
movups %xmm0, 0x774ef(%rip)    # 0x834c0
mfence
leaq 0xdaaf(%rip), %rax      # 0x19a8a
leaq 0xd9c3(%rip), %rcx      # 0x199a5
cmoveq %rax, %rcx
movq %rcx, 0x774ab(%rip)     # 0x83498
popq %rbp
jmpq *0x77494(%rip)          # 0x83488
// File: /workspace/github_c_makefile_star2_O2/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
testl %eax, %eax
je 0xc042
pushq $-0x1
popq %rbx
jmp 0xc0aa
movq 0x790ff(%rip), %rdi     # 0x85148
testq %rdi, %rdi
je 0xc054
callq *0x77454(%rip)          # 0x834a8
movq 0x790f5(%rip), %rbx     # 0x85150
testq %r14, %r14
js 0xc098
movq %r14, 0x790e9(%rip)     # 0x85150
setne %al
cmpq %r14, 0x7902f(%rip)     # 0x850a0
setge %cl
andb %al, %cl
movzbl %cl, %eax
movl %eax, 0x790ed(%rip)     # 0x8516c
movq 0x790c2(%rip), %rdi     # 0x85148
testq %rdi, %rdi
je 0xc091
callq *0x77427(%rip)          # 0x834b8
callq 0xa4a0
jmp 0xc0aa
movq 0x790a9(%rip), %rdi     # 0x85148
testq %rdi, %rdi
je 0xc0aa
callq *0x7740e(%rip)          # 0x834b8
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq