LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/akw0088[P]openssl/aes_upload.cpp
// Function: rsa_encrypt(char*, unsigned char*, int, unsigned char*, unsigned int&)
int rsa_encrypt(char *public_key_filename, unsigned char *data, int data_len, unsigned char *encrypted, unsigned int &encrypted_length)
{
	unsigned char *pubkey = NULL;
	unsigned int size;

	pubkey = (unsigned char *)get_file(public_key_filename, &size);
	if (pubkey == NULL)
	{
		printf("Failed to open public key\r\n");
		return -1;
	}

	if (data_len > 245)
	{
		printf("Cannot encrypt more than 245 bytes with RSA 2048 bit key\r\n");
		delete [] pubkey;
		return -1;
	}

	RSA *rsa = createRSA(pubkey, true);
	encrypted_length = RSA_public_encrypt(data_len, data, encrypted, rsa, RSA_PKCS1_PADDING);
	if (encrypted_length == -1)
	{
		char err[130];

		ERR_load_crypto_strings();
		ERR_error_string(ERR_get_error(), err);
		printf("ERROR: %s\n", err);
		delete [] pubkey;
		return -1;
	}
	RSA_free(rsa);
	delete [] pubkey;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r8, %r14
movq %rcx, %r15
movl %edx, %r13d
movq %rsi, %r12
leaq -0x2c(%rbp), %rsi
callq 0x24c1
testq %rax, %rax
je 0x2645
movq %rax, %rbx
cmpl $0xf6, %r13d
jl 0x2653
leaq 0xb35(%rip), %rdi       # 0x3170
callq 0x22a0
jmp 0x26ca
leaq 0xb5e(%rip), %rdi       # 0x31aa
callq 0x22a0
jmp 0x26d2
movq %rbx, %rdi
movl $0x1, %esi
callq 0x2573
movl %r13d, %edi
movq %r12, %rsi
movq %r15, %rdx
movq %rax, %r15
movq %rax, %rcx
movl $0x1, %r8d
callq 0x2190
movl %eax, (%r14)
cmpl $-0x1, %eax
je 0x2696
movq %r15, %rdi
callq 0x2210
movq %rbx, %rdi
callq 0x2260
xorl %eax, %eax
jmp 0x26d7
movl $0x2, %edi
xorl %esi, %esi
callq 0x2110
callq 0x2270
leaq -0xb0(%rbp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x20c0
leaq 0x97a(%rip), %rdi       # 0x303a
movq %r14, %rsi
xorl %eax, %eax
callq 0x2050
movq %rbx, %rdi
callq 0x2260
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/akw0088[P]openssl/aes_upload.cpp
// Function: aes_encrypt(unsigned char*, unsigned char*, unsigned char*, int, unsigned char*&, unsigned int&)
int aes_encrypt(unsigned char *key, unsigned char *iv, unsigned char *data, int data_size, unsigned char *&ciphertext, unsigned int &ciphertext_len)
{
	ciphertext = (unsigned char *)malloc( (data_size / 16 + 1) * 16 );
	if (ciphertext == NULL)
	{
		perror("malloc failed");
		return -1;
	}

	printf("Using key %s iv %s\r\n", key, iv);

	ciphertext_len = encrypt(data, data_size, key, iv, ciphertext);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r12
movq %r8, %r13
movl %ecx, %r15d
movq %rdx, -0x30(%rbp)
movq %rsi, %r14
leal 0xf(%r15), %eax
testl %ecx, %ecx
cmovnsl %ecx, %eax
movq %rdi, %rbx
andl $-0x10, %eax
addl $0x10, %eax
movslq %eax, %rdi
callq 0x2280
movq %rax, (%r13)
testq %rax, %rax
je 0x282f
leaq 0x85c(%rip), %rdi       # 0x3053
movq %rbx, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2050
movq (%r13), %r8
movq -0x30(%rbp), %rdi
movl %r15d, %esi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x2701
movl %eax, (%r12)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x80f(%rip), %rdi       # 0x3045
callq 0x21c0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x2820
// File: /workspace/github_cpp_makefile_star2_O1/akw0088[P]openssl/aes_upload.cpp
// Function: main
int main(int argc, char *argv[])
{
	unsigned short port = 65535;

	if (argc < 5)
	{
		printf("Usage: aes_upload filename port key iv public_key\r\n");
		printf("Example: aes_upload file.tgz 65535 01234567890123456789012345678901 0123456789012345 id_rsa.openssl.pub\r\n");
		return 0;
	}

	port = atoi(argv[2]);
	unsigned char *key = (unsigned char *)argv[3];
	unsigned char *iv = (unsigned char *)argv[4];
	unsigned char *pubkey = (unsigned char *)argv[5];

	printf("Attempting to upload %s to client connecting on port %d\r\n", argv[1], (int)port);
	aes_file_upload(argv[1], port, key, iv, pubkey);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x4, %edi
jg 0x2c4c
leaq 0x604(%rip), %rdi       # 0x323d
callq 0x22a0
leaq 0x62b(%rip), %rdi       # 0x3270
callq 0x22a0
jmp 0x2c92
movq %rsi, %rbx
movq 0x10(%rsi), %rdi
callq 0x22b0
movq 0x8(%rbx), %rsi
movq 0x18(%rbx), %r14
movq 0x20(%rbx), %r15
movq 0x28(%rbx), %r12
movzwl %ax, %r13d
leaq 0x4c3(%rip), %rdi       # 0x3136
movl %r13d, %edx
xorl %eax, %eax
callq 0x2050
movq 0x8(%rbx), %rdi
movl %r13d, %esi
movq %r14, %rdx
movq %r15, %rcx
movq %r12, %r8
callq 0x2842
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH02_VariablesAndBasicTypes/examples/inits.cc
// Function: main
int main() {

	int v1(1024);    // direct-initialization, functional form
	int v2{1024};    // direct-initialization, list initializer form
	int v3 = 1024;   // copy-initialization
	int v4 = {1024}; // copy-initialization, list initializer form


	// alternative ways to initialize string from a character string literal
	std::string titleA = "C++ Primer, 5th Ed.";
	std::string titleB("C++ Primer, 5th Ed.");
	std::string all_nines(10, '9');  // all_nines = "9999999999"

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
leaq -0x50(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0xb1d(%rip), %rbx       # 0x2006
leaq 0xb29(%rip), %r14       # 0x2019
leaq -0x60(%rbp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1654
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq -0x40(%rbp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1654
leaq -0x70(%rbp), %rbx
movq %rbx, -0x10(%rbx)
leaq -0x80(%rbp), %rdi
movl $0xa, %esi
movl $0x39, %edx
callq 0x10a0
movq -0x80(%rbp), %rdi
cmpq %rbx, %rdi
je 0x1547
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x1080
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x155c
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x1080
movq -0x60(%rbp), %rdi
cmpq %r15, %rdi
je 0x1571
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x1080
xorl %eax, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x159d
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x1080
jmp 0x159d
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r15, %rdi
je 0x15b2
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x1080
movq %rbx, %rdi
callq 0x1100
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH12_DynamicMemory/exercises/ex12_27_30_main.cc
// Function: runQueries(std::basic_ifstream<char, std::char_traits<char>>&)
void runQueries(ifstream& infile)
{
	TextQuery tq(infile);

	while (true) {
		cout << "enter word to look for, or q to quite: ";
		string s;

		if (!(cin >> s) || s == "q")
			break;
		print(cout, tq.query(s)) << endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rsi
leaq -0xc8(%rbp), %rdi
callq 0x28a8
leaq -0x38(%rbp), %r15
movq 0x4b0e(%rip), %r14      # 0x6fc8
leaq -0x48(%rbp), %r13
leaq -0x88(%rbp), %rbx
movq %rbx, %r12
movl $0x27, %edx
movq %r14, %rdi
leaq 0x1b2d(%rip), %rsi      # 0x4004
callq 0x21d0
movq %r15, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
movb $0x0, -0x38(%rbp)
movq 0x4ae5(%rip), %rdi      # 0x6fd8
movq %r13, %rsi
callq 0x2200
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
je 0x2510
xorl %ebx, %ebx
jmp 0x25a4
movq %r13, %rdi
leaq 0x1b12(%rip), %rsi      # 0x402c
callq 0x2080
testl %eax, %eax
je 0x2509
movq %rbx, %rdi
leaq -0xc8(%rbp), %rsi
movq %r13, %rdx
callq 0x2bfc
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2f1e
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x2578
callq 0x2788
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
je 0x2586
callq 0x2788
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rax
cmpq %rax, %rdi
je 0x25a2
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x21a0
movb $0x1, %bl
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x25b9
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21a0
testb %bl, %bl
movq %r12, %rbx
jne 0x24c8
leaq -0xb8(%rbp), %rbx
movq %rbx, %rdi
callq 0x2802
movq -0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x25e1
callq 0x2788
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x260b
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x2714
jmp 0x260e
movq %rax, %rbx
jmp 0x2623
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x2623
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21a0
leaq -0xc8(%rbp), %rdi
callq 0x275e
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH12_DynamicMemory/exercises/ex12_27_30_main.cc
// Function: main
int main(int argc, char const *argv[])
{
	ifstream infile;

	// Test data CH12_DynamicMemory/examples/data/storyDataFile
	if (argc < 2 || !(infile.open(argv[1]), infile)) {
		cerr << "No input file!" << endl;
		return EXIT_FAILURE;
	}
	runQueries(infile);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rsi, %rbx
movl %edi, %r14d
leaq -0x218(%rbp), %rdi
callq 0x21c0
cmpl $0x2, %r14d
jl 0x2687
movq 0x8(%rbx), %rsi
leaq -0x218(%rbp), %rdi
movl $0x8, %edx
callq 0x20d0
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x1f8(%rbp,%rax)
je 0x26ec
movq 0x4962(%rip), %rbx      # 0x6ff0
leaq 0x1999(%rip), %rsi      # 0x402e
movl $0xe, %edx
movq %rbx, %rdi
callq 0x21d0
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq 0x4930(%rip), %rdi      # 0x6ff0
callq 0x2030
movl $0x1, %ebx
movq %rax, %rdi
callq 0x2110
leaq -0x218(%rbp), %rdi
callq 0x2060
movl %ebx, %eax
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r14
popq %rbp
retq
xorl %ebx, %ebx
leaq -0x218(%rbp), %rdi
callq 0x248c
jmp 0x26d2
movq %rax, %rbx
leaq -0x218(%rbp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH12_DynamicMemory/exercises/ex12_27_30.cc
// Function: TextQuery::clean_str(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string TextQuery::clean_str(const string& word)
{
	string ret;
	for (auto it = word.begin(); it != word.end(); ++it) {
		if (!ispunct(*it))
			ret += tolower(*it);
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
cmpq $0x0, 0x8(%rsi)
je 0x2bca
movq %rsi, %r14
movq (%rsi), %r13
movsbl (%r13), %r15d
movl %r15d, %edi
callq 0x22c0
testl %eax, %eax
jne 0x2bbb
movl %r15d, %edi
callq 0x2220
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2160
incq %r13
movq (%r14), %rax
addq 0x8(%r14), %rax
cmpq %rax, %r13
jne 0x2b97
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x2bf3
movq (%r12), %rsi
incq %rsi
callq 0x21a0
movq %r14, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH12_DynamicMemory/exercises/ex12_27_30.cc
// Function: print(std::ostream&, QueryResult const&)
ostream& print(ostream& os, const QueryResult& qr)
{
	os << qr.sought << " occurs " << qr.lines->size() << " "
		<< "time(s)" << endl;

	for (auto num : *qr.lines) {
		os << "\t(line " << num + 1 << ") "
			<< qr.file->at(num) << endl;
	}

	return os;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
callq 0x21d0
movq %rax, %r15
leaq 0x10f5(%rip), %rsi      # 0x403d
movl $0x8, %edx
movq %rax, %rdi
callq 0x21d0
movq 0x20(%r14), %rax
movq 0x28(%rax), %rsi
movq %r15, %rdi
callq 0x2100
movq %rax, %r15
leaq 0x10e8(%rip), %rsi      # 0x4057
movl $0x1, %edx
movq %rax, %rdi
callq 0x21d0
leaq 0x10c3(%rip), %rsi      # 0x4046
movl $0x7, %edx
movq %r15, %rdi
callq 0x21d0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
movq %r14, -0x30(%rbp)
movq 0x20(%r14), %r14
movq 0x18(%r14), %r15
addq $0x8, %r14
cmpq %r14, %r15
je 0x307a
movq 0x20(%r15), %r12
movl $0x7, %edx
movq %rbx, %rdi
leaq 0x106b(%rip), %rsi      # 0x404e
callq 0x21d0
leaq 0x1(%r12), %rsi
movq %rbx, %rdi
callq 0x2100
movq %rax, %r13
movl $0x2, %edx
movq %rax, %rdi
leaq 0x104f(%rip), %rsi      # 0x4056
callq 0x21d0
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rdx
subq %rax, %rdx
sarq $0x5, %rdx
cmpq %r12, %rdx
jbe 0x308c
shlq $0x5, %r12
movq (%rax,%r12), %rsi
movq 0x8(%rax,%r12), %rdx
movq %r13, %rdi
callq 0x21d0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
movq %r15, %rdi
callq 0x21e0
movq %rax, %r15
cmpq %r14, %rax
jne 0x2fd0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x101a(%rip), %rdi      # 0x40ad
movq %r12, %rsi
xorl %eax, %eax
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH12_DynamicMemory/exercises/ex12_27_30.cc
// Function: TextQuery::display_map()
void TextQuery::display_map()
{
	// auto iter = wm.cbegin();
	// auto iter_end = wm.cend();

	for (auto iter = wm.cbegin(); iter != wm.cend(); ++iter) {
		cout << "word: " << iter->first << " {";

		// auto text_locs = iter->second;
		// auto loc_iter = text_locs->cbeing()

		for (auto loc_iter = iter->second->cbegin();
			loc_iter != iter->second->cend(); ++loc_iter) {

			cout << *loc_iter << ", ";
		}

		cout << "}\n";

	}
	cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %r14
addq $0x18, %rbx
cmpq %rbx, %r14
je 0x316d
movq 0x3f01(%rip), %r15      # 0x6fc8
leaq 0xf95(%rip), %r13       # 0x4063
movl $0x6, %edx
movq %r15, %rdi
leaq 0xf7c(%rip), %rsi       # 0x4059
callq 0x21d0
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
movq %r15, %rdi
callq 0x21d0
movl $0x2, %edx
movq %rax, %rdi
leaq 0xf5f(%rip), %rsi       # 0x4060
callq 0x21d0
movq 0x40(%r14), %rax
movq 0x18(%rax), %r12
addq $0x8, %rax
cmpq %rax, %r12
je 0x3145
movq 0x20(%r12), %rsi
movq %r15, %rdi
callq 0x2100
movl $0x2, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x21d0
movq %r12, %rdi
callq 0x21e0
movq %rax, %r12
movq 0x40(%r14), %rax
jmp 0x310e
movl $0x2, %edx
movq %r15, %rdi
leaq 0xf12(%rip), %rsi       # 0x4066
callq 0x21d0
movq %r14, %rdi
callq 0x21e0
movq %rax, %r14
cmpq %rbx, %rax
jne 0x30ce
movq 0x3e54(%rip), %rbx      # 0x6fc8
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2110
nop
// File: /workspace/github_cpp_makefile_star2_O1/JianjiaoSQ[P]MyPoorWebServer/time/time_wheel_timer.cpp
// Function: time_wheel::~time_wheel()
time_wheel::~time_wheel() {
    // 遍历每一个槽，并销毁其中的定时器
    for(int i = 0; i < N; ++i) {
        tw_timer* tmp = slots[i];
        while(tmp) {
            slots[i] = tmp->next;
            delete tmp;
            tmp = slots[i];
        }
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0x8(%rbx,%r14,8), %rdi
testq %rdi, %rdi
je 0x3e3b
movq 0x18(%rdi), %rax
movq %rax, 0x8(%rbx,%r14,8)
movl $0x28, %esi
callq 0x33a0
jmp 0x3e1c
incq %r14
cmpq $0x3c, %r14
jne 0x3e1c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/JianjiaoSQ[P]MyPoorWebServer/time/time_wheel_timer.cpp
// Function: time_wheel::add_timer(tw_timer*, int)
void time_wheel::add_timer(tw_timer* timer, int timesolt) {
    if (timesolt < 0) {
        return;
    }

    int ticks = 0;
    /* 根据插入定时器的超时值计算它将在时间轮转动多少个滴答后被触发，并将
    该滴答数存于变量 ticks 中 */
    if (timesolt < SI) {
        ticks = 1;
    } else {
        ticks = timesolt / SI;
    }

    int rotation  = ticks / N; // 计算圈数
    int ts = (cur_slot + (ticks % N)) % N; // 计算待插入定时器的槽位

    timer->ratation = rotation;
    timer->time_slot = ts;

    // 插入合适的位置
    // 圈数大的放在最前面，即链表的前端
    if(!slots[ts]) {    // 头节点
        slots[ts] = timer;
    } else {    // 非头节点   
        timer->next = slots[ts];
        slots[ts]->prev = timer;
        slots[ts] = timer;
    }
}

// Assembly:
testl %edx, %edx
js 0x3eb0
cmpl $0x1, %edx
adcl $0x0, %edx
movl $0x88888889, %eax       # imm = 0x88888889
imulq %rdx, %rax
shrq $0x25, %rax
imull $0x3c, %eax, %ecx
subl %ecx, %edx
addl (%rdi), %edx
movslq %edx, %rcx
imulq $-0x77777777, %rcx, %rdx # imm = 0x88888889
shrq $0x20, %rdx
addl %ecx, %edx
movl %edx, %r8d
shrl $0x1f, %r8d
sarl $0x5, %edx
addl %r8d, %edx
imull $0x3c, %edx, %edx
subl %edx, %ecx
movl %eax, (%rsi)
movl %ecx, 0x4(%rsi)
movslq %ecx, %rax
movq 0x8(%rdi,%rax,8), %rcx
testq %rcx, %rcx
je 0x3eab
movq %rcx, 0x18(%rsi)
movq 0x8(%rdi,%rax,8), %rcx
movq %rsi, 0x20(%rcx)
movq %rsi, 0x8(%rdi,%rax,8)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/JianjiaoSQ[P]MyPoorWebServer/time/time_wheel_timer.cpp
// Function: time_wheel::del_timer(tw_timer*)
void time_wheel::del_timer(tw_timer* timer) {
    if(!timer) {
        return;
    } 
    int ts = timer->time_slot;
    // 如果是头节点
    if(slots[ts] == timer) {
        slots[ts] = slots[ts]->next;
        if(slots[ts]) {
            slots[ts]->prev = NULL;
        }
        delete timer;
    } else {
        timer->prev->next = timer->next;
        if(timer->next) {
            timer->next->prev = timer->prev;
        }
        delete timer;
    }
}

// Assembly:
testq %rsi, %rsi
je 0x3edf
movq %rsi, %rax
movslq 0x4(%rsi), %rdx
movq 0x8(%rdi,%rdx,8), %rcx
cmpq %rsi, %rcx
je 0x3ee0
movq 0x18(%rax), %rcx
movq 0x20(%rax), %rdx
movq %rcx, 0x18(%rdx)
movq 0x18(%rax), %rcx
testq %rcx, %rcx
jne 0x3ef0
jmp 0x3ef4
retq
movq 0x18(%rcx), %rcx
movq %rcx, 0x8(%rdi,%rdx,8)
testq %rcx, %rcx
je 0x3ef4
xorl %edx, %edx
movq %rdx, 0x20(%rcx)
movl $0x28, %esi
movq %rax, %rdi
jmp 0x33a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/JianjiaoSQ[P]MyPoorWebServer/time/time_wheel_timer.cpp
// Function: time_wheel::adjust_timer(tw_timer*, int)
void time_wheel::adjust_timer(tw_timer* timer,int timeslot) {
    if(!timer) {
        return;
    }
    // 先断开原位置的联系
    // 头节点
    /*
    if(timer == slots[timer->time_slot]) {
        slots[timer->time_slot] = slots[timer->time_slot]->next;
        slots[timer->time_slot]->prev = NULL;
        timer->next = NULL;
        //add_timer(timer,slots[timer->time_slot]);
    } else if(!timer->next) {  // 尾节点
        timer->prev->next = NULL;
        timer->prev = NULL;
    } else { // 中间节点
        timer->prev->next = timer->next;
        timer->next->prev = timer->prev;
        //add_timer(timer,slots[timer->time_slot]->next);
    } */
    int ts = timer->time_slot;
    // 如果是头节点
    if(slots[ts] == timer) {
        slots[ts] = slots[ts]->next;
        if(slots[ts]) {
            slots[ts]->prev = NULL;
        }
        timer->prev = NULL;
        timer->next = NULL;
    } else {
        timer->prev->next = timer->next;
        if(timer->next) {
            timer->next->prev = timer->prev;
        }
        timer->prev = NULL;
        timer->next = NULL;
    }
    // 调整新的圈数和槽位
    //timer->ratation += timeslot / SI / N;
    //timer->time_slot = (cur_slot + (timeslot / SI % N)) % N;
    
    // 添加到新的位置
    add_timer(timer,timeslot); 
}

// Assembly:
testq %rsi, %rsi
je 0x3fbc
movslq 0x4(%rsi), %rax
movq 0x8(%rdi,%rax,8), %rcx
cmpq %rsi, %rcx
je 0x3f38
leaq 0x18(%rsi), %rax
movq 0x18(%rsi), %r8
movq 0x20(%rsi), %rcx
movq %r8, 0x18(%rcx)
movq 0x18(%rsi), %r8
testq %r8, %r8
je 0x3f52
movq %rcx, 0x20(%r8)
jmp 0x3f52
movq 0x18(%rcx), %rcx
movq %rcx, 0x8(%rdi,%rax,8)
testq %rcx, %rcx
je 0x3f4e
movq $0x0, 0x20(%rcx)
leaq 0x18(%rsi), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
testl %edx, %edx
js 0x3fbc
cmpl $0x1, %edx
adcl $0x0, %edx
movl $0x88888889, %eax       # imm = 0x88888889
imulq %rdx, %rax
shrq $0x25, %rax
imull $0x3c, %eax, %ecx
subl %ecx, %edx
addl (%rdi), %edx
movslq %edx, %rcx
imulq $-0x77777777, %rcx, %rdx # imm = 0x88888889
shrq $0x20, %rdx
addl %ecx, %edx
movl %edx, %r8d
shrl $0x1f, %r8d
sarl $0x5, %edx
addl %r8d, %edx
imull $0x3c, %edx, %edx
subl %edx, %ecx
movl %eax, (%rsi)
movl %ecx, 0x4(%rsi)
movslq %ecx, %rax
movq 0x8(%rdi,%rax,8), %rcx
testq %rcx, %rcx
je 0x3fb7
movq %rcx, 0x18(%rsi)
movq 0x8(%rdi,%rax,8), %rcx
movq %rsi, 0x20(%rcx)
movq %rsi, 0x8(%rdi,%rax,8)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/JianjiaoSQ[P]MyPoorWebServer/time/time_wheel_timer.cpp
// Function: time_wheel::tick()
void time_wheel::tick() {
    tw_timer* tmp = slots[cur_slot]; // 取得时间轮上当前槽的头节点
    while(tmp) {
        // 将当前槽位上的定时器链表遍历一遍，对它们的圈数标记-1，表示新的一轮计时开始；
        if(tmp->ratation > 0) {
            tmp->ratation--;
            tmp = tmp->next;
        } else {
        // 说明定时器到期，执行定时任务，然后删除定时器
            tmp->cb_func(tmp->user_data);
            if(tmp == slots[cur_slot]) {
                slots[cur_slot] = tmp->next;
                delete tmp;
                if(slots[cur_slot]) {
                    slots[cur_slot]->prev = NULL;
                }
                tmp = slots[cur_slot];
            } else {
                tmp->prev->next = tmp->next;
                if(tmp->next) {
                    tmp->next->prev = tmp->prev;
                }
                tw_timer* tmp2 = tmp->next;
                delete tmp;
                tmp = tmp2;
            }
        }
    }
    cur_slot = ++cur_slot % N; // 更新时间轮的当前槽，以反映时间轮的转动
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq (%rdi), %rax
movq 0x8(%rdi,%rax,8), %r14
testq %r14, %r14
je 0x4057
movl (%r14), %eax
testl %eax, %eax
jle 0x3fe9
decl %eax
movl %eax, (%r14)
movq 0x18(%r14), %r15
jmp 0x404f
movq 0x10(%r14), %rdi
callq *0x8(%r14)
movslq (%rbx), %rcx
movq 0x18(%r14), %rax
cmpq 0x8(%rbx,%rcx,8), %r14
je 0x4023
movq 0x20(%r14), %rcx
movq %rax, 0x18(%rcx)
movq 0x18(%r14), %r15
testq %r15, %r15
je 0x4014
movq %rcx, 0x20(%r15)
movl $0x28, %esi
movq %r14, %rdi
callq 0x33a0
jmp 0x404f
movq %rax, 0x8(%rbx,%rcx,8)
movl $0x28, %esi
movq %r14, %rdi
callq 0x33a0
movslq (%rbx), %rax
movq 0x8(%rbx,%rax,8), %rcx
testq %rcx, %rcx
je 0x404a
movq $0x0, 0x20(%rcx)
movq 0x8(%rbx,%rax,8), %r15
movq %r15, %r14
testq %r15, %r15
jne 0x3fd7
movl (%rbx), %eax
movl %eax, %ecx
incl %ecx
movslq %ecx, %rcx
imulq $-0x77777777, %rcx, %rcx # imm = 0x88888889
shrq $0x20, %rcx
addl %eax, %ecx
incl %ecx
movl %ecx, %edx
shrl $0x1f, %edx
sarl $0x5, %ecx
addl %edx, %ecx
imull $0x3c, %ecx, %ecx
negl %ecx
addl %ecx, %eax
incl %eax
movl %eax, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/JianjiaoSQ[P]MyPoorWebServer/time/time_wheel_timer.cpp
// Function: Utils::setnonblocking(int)
int Utils::setnonblocking(int fd)
{
    int old_option = fcntl(fd, F_GETFL);
    int new_option = old_option | O_NONBLOCK;
    fcntl(fd, F_SETFL, new_option);
    return old_option;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %esi, %edi
movl $0x3, %esi
xorl %eax, %eax
callq 0x3240
movl %eax, %ebp
movl %eax, %edx
orl $0x800, %edx            # imm = 0x800
movl %ebx, %edi
movl $0x4, %esi
xorl %eax, %eax
callq 0x3240
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/JianjiaoSQ[P]MyPoorWebServer/time/time_wheel_timer.cpp
// Function: Utils::addsig(int, void (*)(int), bool)
void Utils::addsig(int sig, void(handler)(int), bool restart)
{
    struct sigaction sa;
    memset(&sa, '\0', sizeof(sa));
    sa.sa_handler = handler;
    if (restart)
        sa.sa_flags |= SA_RESTART;
    sigfillset(&sa.sa_mask);
    assert(sigaction(sig, &sa, NULL) != -1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movl %esi, %ebx
movq %rsp, %r15
movl $0x98, %edx
movq %r15, %rdi
xorl %esi, %esi
callq 0x3220
movq %r14, (%r15)
testl %ebp, %ebp
je 0x419b
orb $0x10, 0x8b(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x30f0
movq %rsp, %rsi
movl %ebx, %edi
xorl %edx, %edx
callq 0x3490
cmpl $-0x1, %eax
je 0x41c4
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4e71(%rip), %rdi      # 0x903c
leaq 0x4e8a(%rip), %rsi      # 0x905c
leaq 0x4e9d(%rip), %rcx      # 0x9076
movl $0xed, %edx
callq 0x3290
nop
// File: /workspace/github_cpp_makefile_star2_O1/JianjiaoSQ[P]MyPoorWebServer/http/http_conn.cpp
// Function: addfd(int, int, bool, int)
void addfd(int epollfd, int fd, bool one_shot, int TRIGMode)
{
    epoll_event event;  // 用于注册所感兴趣的事件和回传所发生待处理的事件
    event.data.fd = fd;

    if (1 == TRIGMode)  // events表示感兴趣的事件和被触发的事件
    /*  EPOLLIN：表示对应的文件描述符可以读；
        EPOLLET：ET的epoll工作模式；
        EPOLLHUP：表示对应的文件描述符被挂断；*/
        event.events = EPOLLIN | EPOLLET | EPOLLRDHUP;
    else
        event.events = EPOLLIN | EPOLLRDHUP;

    if (one_shot)
        event.events |= EPOLLONESHOT;
        // EPOLL_CTL_ADD注册、EPOLL_CTL_MOD修改、EPOLL_CTL_DEL删除；
    epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &event); // 用于控制某个文件描述符上的事件，可以注册事件，修改事件，删除事件。
    setnonblocking(fd);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
leaq 0x4(%rsp), %rax
movl %esi, 0x4(%rax)
xorl %esi, %esi
cmpl $0x1, %ecx
setne %sil
shll $0x1f, %esi
shll $0x1e, %edx
leal (%rsi,%rdx), %ecx
addl $0x80002001, %ecx       # imm = 0x80002001
movl %ecx, (%rax)
movl $0x1, %esi
movl %ebx, %edx
movq %rax, %rcx
callq 0x34e0
movl %ebx, %edi
movl $0x3, %esi
xorl %eax, %eax
callq 0x3240
orl $0x800, %eax            # imm = 0x800
movl %ebx, %edi
movl $0x4, %esi
movl %eax, %edx
xorl %eax, %eax
callq 0x3240
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/JianjiaoSQ[P]MyPoorWebServer/http/http_conn.cpp
// Function: http_conn::init(int, sockaddr_in const&, char*, int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void http_conn::init(int sockfd, const sockaddr_in &addr, char *root, int TRIGMode,
                     int close_log, string user, string passwd, string sqlname)
{
    m_sockfd = sockfd;
    m_address = addr;

    addfd(m_epollfd, sockfd, true, m_TRIGMode);  // m_TRIGMode ?? 传值 
    m_user_count++;

    //当浏览器出现连接重置时，可能是网站根目录出错或http响应格式出错或者访问的文件中内容完全为空
    doc_root = root;
    m_TRIGMode = TRIGMode;
    m_close_log = close_log;

    strcpy(sql_user, user.c_str());
    strcpy(sql_passwd, passwd.c_str());
    strcpy(sql_name, sqlname.c_str());

    init();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebp
movl %r8d, %r14d
movq %rcx, %r15
movq %rdi, %rbx
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
movq 0x48(%rsp), %r13
movq 0x40(%rsp), %r12
movl %esi, 0x14(%rdi)
movups (%rdx), %xmm0
movups %xmm0, 0x18(%rdi)
movl 0x8e22(%rip), %edi      # 0xd3c0
movl 0xe30(%rbx), %ecx
movl $0x1, %edx
callq 0x445d
incl 0x8e94(%rip)            # 0xd448
movq %r15, 0xdf8(%rbx)
movl %r14d, 0xe30(%rbx)
movl %ebp, 0xe34(%rbx)
leaq 0xe38(%rbx), %rdi
movq (%r12), %rsi
callq 0x3370
leaq 0xe9c(%rbx), %rdi
movq (%r13), %rsi
callq 0x3370
leaq 0xf00(%rbx), %rdi
movq (%rsp), %rax
movq (%rax), %rsi
callq 0x3370
movq $0x0, 0xdf0(%rbx)
xorl %eax, %eax
movl %eax, 0xde4(%rbx)
leaq 0x28(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movl %eax, 0x10(%rbx)
movl $0xcfd, %edx            # imm = 0xCFD
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3220
nop
// File: /workspace/github_cpp_makefile_star2_O1/JianjiaoSQ[P]MyPoorWebServer/http/http_conn.cpp
// Function: http_conn::read_once()
bool http_conn::read_once()
{
    if (m_read_idx >= READ_BUFFER_SIZE)
    {
        return false;
    }
    int bytes_read = 0;

    //LT读取数据
    if (0 == m_TRIGMode)
    {
        bytes_read = recv(m_sockfd, m_read_buf + m_read_idx, READ_BUFFER_SIZE - m_read_idx, 0);
        m_read_idx += bytes_read;

        if (bytes_read <= 0)
        {
            return false;
        }

        return true;
    }
    //ET读数据
    else
    {
        while (true)
        {
            bytes_read = recv(m_sockfd, m_read_buf + m_read_idx, READ_BUFFER_SIZE - m_read_idx, 0);
            if (bytes_read == -1)
            {
                if (errno == EAGAIN || errno == EWOULDBLOCK)
                    break;
                return false;
            }
            else if (bytes_read == 0)
            {
                return false;
            }
            m_read_idx += bytes_read;
        }
        return true;
    }
}

// Assembly:
movslq 0x828(%rdi), %rax
cmpq $0x7ff, %rax            # imm = 0x7FF
jle 0x473c
xorl %eax, %eax
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0xe30(%rdi)
je 0x477e
leaq 0x28(%rbx), %r14
movl 0x14(%rbx), %edi
movslq 0x828(%rbx), %rax
leaq (%r14,%rax), %rsi
movl $0x800, %edx            # imm = 0x800
subq %rax, %rdx
xorl %ecx, %ecx
callq 0x3100
testl %eax, %eax
je 0x47b1
cmpl $-0x1, %eax
je 0x47a4
addl %eax, 0x828(%rbx)
jmp 0x4750
movl 0x14(%rbx), %edi
leaq (%rbx,%rax), %rsi
addq $0x28, %rsi
movl $0x800, %edx            # imm = 0x800
subl %eax, %edx
xorl %ecx, %ecx
callq 0x3100
addl %eax, 0x828(%rbx)
testl %eax, %eax
setg %al
jmp 0x47b3
callq 0x3050
cmpl $0xb, (%rax)
sete %al
jmp 0x47b3
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/JianjiaoSQ[P]MyPoorWebServer/webserver.cpp
// Function: WebServer::init(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int, int, int, int, int, int)
void WebServer::init(int port, string user, string passWord, string databaseName, int log_write, 
                     int opt_linger, int trigmode, int sql_num, int thread_num, int close_log, int actor_model)
{
    m_port = port;
    m_user = user;
    m_passWord = passWord;
    m_databaseName = databaseName;
    m_sql_num = sql_num;
    m_thread_num = thread_num;
    m_log_write = log_write;
    m_OPT_LINGER = opt_linger;
    m_TRIGMode = trigmode;
    m_close_log = close_log;
    m_actormodel = actor_model;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movq %r8, %r15
movq %rcx, %r12
movq %rdi, %r14
movl 0x58(%rsp), %ebp
movl 0x50(%rsp), %r13d
movl %esi, (%rdi)
addq $0x38, %rdi
movq %rdx, %rsi
callq 0x3210
leaq 0x58(%r14), %rdi
movq %r12, %rsi
callq 0x3210
leaq 0x78(%r14), %rdi
movq %r15, %rsi
callq 0x3210
movl %r13d, 0x98(%r14)
movl %ebp, 0xa8(%r14)
movl %ebx, 0x10(%r14)
movl 0x40(%rsp), %eax
movl %eax, 0x1d570(%r14)
movl 0x48(%rsp), %eax
movl %eax, 0x1d574(%r14)
movl 0x60(%rsp), %eax
movl %eax, 0x14(%r14)
movl 0x68(%rsp), %eax
movl %eax, 0x18(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/JianjiaoSQ[P]MyPoorWebServer/webserver.cpp
// Function: WebServer::sql_pool()
void WebServer::sql_pool() {
    //初始化数据库连接池
    m_connPool = connection_pool::GetInstance();
    // MySQL的默认端口号是 3306
    m_connPool->init("localhost", m_user, m_passWord, m_databaseName, 3306, m_sql_num, m_close_log);

    //初始化数据库读取表
    users->initmysql_result(m_connPool);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
callq 0x6c4c
movq %rax, %r14
movq %rax, 0x30(%rbx)
leaq 0x78(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1f6b(%rip), %rsi      # 0x9495
leaq 0x1f6d(%rip), %rdx      # 0x949e
leaq 0x68(%rsp), %rdi
callq 0x3d6c
leaq 0x58(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x38(%rbx), %rsi
movq 0x40(%rbx), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %rdi
callq 0x3cdc
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x58(%rbx), %rsi
movq 0x60(%rbx), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x3cdc
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq 0x78(%rbx), %rsi
movq 0x80(%rbx), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x3cdc
movl 0x14(%rbx), %eax
movl 0x98(%rbx), %r10d
leaq 0x68(%rsp), %rsi
leaq 0x48(%rsp), %rdx
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %r14, %rdi
movl $0xcea, %r9d            # imm = 0xCEA
pushq %rax
pushq %r10
callq 0x6cbc
addq $0x10, %rsp
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x75e3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x33a0
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x75fa
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x33a0
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x7611
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x33a0
movq 0x68(%rsp), %rdi
cmpq %r15, %rdi
je 0x7628
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x33a0
movq 0x28(%rbx), %rdi
movq 0x30(%rbx), %rsi
callq 0x4278
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x7666
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x33a0
jmp 0x7666
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x7682
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x33a0
jmp 0x7682
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x769e
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x33a0
jmp 0x769e
movq %rax, %rbx
movq 0x68(%rsp), %rdi
cmpq %r15, %rdi
je 0x76b5
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x33a0
movq %rbx, %rdi
callq 0x35e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/JianjiaoSQ[P]MyPoorWebServer/webserver.cpp
// Function: WebServer::adjust_timer(tw_timer*)
void WebServer::adjust_timer(tw_timer* timer) {
    /* time_t cur = time(NULL);
    timer->expire = cur + 3 * TIMESLOT;
    utils.m_timer_lst.adjust_timer(timer); 
    int cur = utils.m_time_wheel.cur_slot;
    int ticks = 3*TIMESLOT / utils.m_time_wheel.SI;
    int N = utils.m_time_wheel.N;
    int ts = (cur + (ticks % N)) % N;
    timer->ratation += ticks/N;
    timer->time_slot = ts; */

    utils.m_time_wheel.adjust_timer(timer,3 * TIMESLOT); 

    LOG_INFO("%s", "adjust timer once");
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x1d588, %rdi          # imm = 0x1D588
movl $0xc, %edx
callq 0x3f02
cmpl $0x0, 0x14(%rbx)
je 0x7bd1
popq %rbx
retq
callq 0x594a
leaq 0x16eb(%rip), %rdx      # 0x92c8
leaq 0x191a(%rip), %rcx      # 0x94fe
movq %rax, %rdi
movl $0x1, %esi
xorl %eax, %eax
callq 0x64a0
callq 0x594a
movq %rax, %rdi
popq %rbx
jmp 0x68c2
nop
// File: /workspace/github_cpp_makefile_star2_O1/JianjiaoSQ[P]MyPoorWebServer/webserver.cpp
// Function: WebServer::deal_timer(tw_timer*, int)
void WebServer::deal_timer(tw_timer *timer, int sockfd) {
    timer->cb_func(&users_timer[sockfd]);
    if (timer) {
        // utils.m_timer_lst.del_timer(timer);
        utils.m_time_wheel.del_timer(timer);
    }

    LOG_INFO("close fd %d", users_timer[sockfd].sockfd);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movslq %edx, %r15
shlq $0x5, %r15
movq 0x1d580(%rdi), %rdi
addq %r15, %rdi
callq *0x8(%rsi)
testq %r14, %r14
je 0x7c35
leaq 0x1d588(%rbx), %rdi
movq %r14, %rsi
callq 0x3eb2
cmpl $0x0, 0x14(%rbx)
je 0x7c41
popq %rbx
popq %r14
popq %r15
retq
callq 0x594a
movq 0x1d580(%rbx), %rcx
movl 0x10(%rcx,%r15), %ecx
leaq 0x18b7(%rip), %rdx      # 0x9510
movq %rax, %rdi
movl $0x1, %esi
xorl %eax, %eax
callq 0x64a0
callq 0x594a
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x68c2
// File: /workspace/github_cpp_makefile_star2_O1/JianjiaoSQ[P]MyPoorWebServer/config.cpp
// Function: Config::parse_arg(int, char**)
void Config::parse_arg(int argc, char*argv[]){
    int opt;
    const char *str = "p:l:m:o:s:t:c:a:";
    while ((opt = getopt(argc, argv, str)) != -1)
    {
        switch (opt)
        {
        case 'p':
        {
            PORT = atoi(optarg);
            break;
        }
        case 'l':
        {
            LOGWrite = atoi(optarg);
            break;
        }
        case 'm':
        {
            TRIGMode = atoi(optarg);
            break;
        }
        case 'o':
        {
            OPT_LINGER = atoi(optarg);
            break;
        }
        case 's':
        {
            sql_num = atoi(optarg);
            break;
        }
        case 't':
        {
            thread_num = atoi(optarg);
            break;
        }
        case 'c':
        {
            close_log = atoi(optarg);
            break;
        }
        case 'a':
        {
            actor_model = atoi(optarg);
            break;
        }
        default:
            break;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r12
leaq 0x24(%rdi), %rax
movq %rax, 0x30(%rsp)
leaq 0x20(%rdi), %rax
movq %rax, 0x28(%rsp)
leaq 0x1c(%rdi), %rax
movq %rax, 0x20(%rsp)
leaq 0x18(%rdi), %rax
movq %rax, 0x18(%rsp)
leaq 0x14(%rdi), %rax
movq %rax, 0x10(%rsp)
leaq 0x8(%rdi), %rax
movq %rax, 0x8(%rsp)
leaq 0x4(%rdi), %rax
movq %rax, (%rsp)
leaq 0xf83(%rip), %r15       # 0x9650
leaq 0xf2c(%rip), %r13       # 0x9600
movl %ebp, %edi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x30a0
leal -0x61(%rax), %ecx
cmpl $0x13, %ecx
ja 0x8738
movslq (%r13,%rcx,4), %rax
addq %r13, %rax
movq %r12, %r14
jmpq *%rax
movq 0x30(%rsp), %r14
jmp 0x8724
movq 0x8(%rsp), %r14
jmp 0x8724
movq 0x28(%rsp), %r14
jmp 0x8724
movq (%rsp), %r14
jmp 0x8724
movq 0x20(%rsp), %r14
jmp 0x8724
movq 0x10(%rsp), %r14
jmp 0x8724
movq 0x18(%rsp), %r14
movq 0x488d(%rip), %rax      # 0xcfb8
movq (%rax), %rdi
callq 0x3550
movl %eax, (%r14)
jmp 0x86d4
cmpl $-0x1, %eax
jne 0x86d4
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jo-qzy[P]MyJson/./json.hpp
// Function: JSON::Value::asString[abi:cxx11]() const
std::string Value::asString() const {
        switch (type) {
        case JSON_NULL: return std::string("null");
        case JSON_TRUE: return std::string("true");
        case JSON_FALSE: return std::string("false");
        case JSON_STRING: return str;
        case JSON_ARRAY: return fw->write(*this);
        case JSON_OBJECT: return fw->write(*this);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rdx
movq %rdi, %rbx
movl (%rsi), %eax
leaq 0x4b63(%rip), %rcx      # 0x7004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x98(%rdx), %rsi
movq (%rsi), %rax
movq %rbx, %rdi
callq *(%rax)
jmp 0x2522
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x30(%rdx), %rsi
movq 0x38(%rdx), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x6964
jmp 0x2522
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x4bd5(%rip), %rsi      # 0x70ba
leaq 0x4bd3(%rip), %rdx      # 0x70bf
jmp 0x251a
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x4bb4(%rip), %rsi      # 0x70b0
leaq 0x4bb1(%rip), %rdx      # 0x70b4
jmp 0x251a
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x4ba2(%rip), %rsi      # 0x70b5
leaq 0x4b9f(%rip), %rdx      # 0x70b9
movq %rbx, %rdi
callq 0x69fe
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jo-qzy[P]MyJson/./json.hpp
// Function: JSON::Value::removeMember(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Value removeMember(const std::string key) {
            std::map<std::string, Value>::iterator mt = object.find(key);
            if (mt != object.end())
                object.erase(mt);
            return *this;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x68(%rsi), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x5ed4
leaq 0x70(%r14), %rcx
cmpq %rcx, %rax
je 0x2d6f
movq %r15, %rdi
movq %rax, %rsi
callq 0x5f72
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3ff0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jo-qzy[P]MyJson/./json.hpp
// Function: JSON::Value::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Value& operator[](const std::string key) {
            if (type != JSON_OBJECT)
                clear();
            type = JSON_OBJECT;
            return object[key];
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x6, (%rdi)
je 0x2dea
movq %r14, %rdi
callq 0x31de
movl $0x6, (%r14)
addq $0x68, %r14
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x5fb6
// File: /workspace/github_cpp_makefile_star2_O1/jo-qzy[P]MyJson/./json.hpp
// Function: JSON::Value::append(JSON::Value const&)
void append(const Value& value) {
            switch (type) {
            case JSON_ARRAY:
                array.push_back(value);
                break;
            case JSON_OBJECT:
                assert(value.get_type() == JSON_OBJECT);
                std::vector<std::string> names = value.getMemberNames();
                for (auto vt : names)
                    object.insert(make_pair(vt, value[vt]));
                break;
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp            # imm = 0x1D8
movq %rdi, %r14
movl (%rdi), %eax
cmpl $0x6, %eax
je 0x2ea6
cmpl $0x5, %eax
jne 0x2fb5
addq $0x50, %r14
movq %r14, %rdi
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3cb8
cmpl $0x6, (%rsi)
jne 0x2fc7
leaq -0x90(%rbp), %r15
movq %r15, %rdi
movq %rsi, -0x58(%rbp)
callq 0x304e
movq (%r15), %rbx
movq 0x8(%r15), %rax
movq %rax, -0x50(%rbp)
cmpq %rax, %rbx
je 0x2fa9
addq $0x68, %r14
leaq -0x78(%rbp), %r13
leaq -0x200(%rbp), %r15
leaq -0x158(%rbp), %r12
leaq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0x6964
leaq -0x68(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0x6964
movq %r15, %rdi
movq -0x58(%rbp), %rsi
movq %r13, %rdx
callq 0x4796
movq %r12, %rdi
leaq -0x48(%rbp), %rsi
movq %r15, %rdx
callq 0x4ab0
movq %r14, %rdi
movq %r12, %rsi
callq 0x484a
leaq -0x138(%rbp), %rdi
callq 0x2d88
movq -0x158(%rbp), %rdi
leaq -0x148(%rbp), %rax
cmpq %rax, %rdi
je 0x2f6f
callq 0x21d0
movq %r15, %rdi
callq 0x2d88
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rax
cmpq %rax, %rdi
je 0x2f89
callq 0x21d0
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x2f9b
callq 0x21d0
addq $0x20, %rbx
cmpq -0x50(%rbp), %rbx
jne 0x2eec
leaq -0x90(%rbp), %rdi
callq 0x3250
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x43ce(%rip), %rdi      # 0x739c
leaq 0x42b7(%rip), %rsi      # 0x728c
leaq 0x43e0(%rip), %rcx      # 0x73bc
movl $0x10b, %edx            # imm = 0x10B
callq 0x2140
movq %rax, %rbx
jmp 0x3039
movq %rax, %rbx
jmp 0x3027
movq %rax, %rbx
jmp 0x3015
movq %rax, %rbx
jmp 0x3009
movq %rax, %rbx
leaq -0x158(%rbp), %rdi
callq 0x481e
leaq -0x200(%rbp), %rdi
callq 0x2d88
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rax
cmpq %rax, %rdi
je 0x3027
callq 0x21d0
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x3039
callq 0x21d0
leaq -0x90(%rbp), %rdi
callq 0x3250
movq %rbx, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O1/jo-qzy[P]MyJson/./json.hpp
// Function: JSON::Value::getMemberNames[abi:cxx11]() const
std::vector<std::string> getMemberNames() const {
            assert(type == JSON_OBJECT);
            std::vector<std::string> names;
            for (auto e : object) {
                names.push_back(e.first);
            }
            return names;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
cmpl $0x6, (%rsi)
jne 0x30f6
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x80(%rsi), %r15
addq $0x70, %r14
cmpq %r14, %r15
je 0x30e1
leaq -0xe0(%rbp), %r12
leaq -0xf0(%rbp), %r13
leaq 0x20(%r15), %rsi
movq %r13, %rdi
callq 0x43da
movq %rbx, %rdi
movq %r13, %rsi
callq 0x62c6
leaq -0xd0(%rbp), %rdi
callq 0x2d88
movq -0xf0(%rbp), %rdi
cmpq %r12, %rdi
je 0x30d1
callq 0x21d0
movq %r15, %rdi
callq 0x2220
movq %rax, %r15
cmpq %r14, %rax
jne 0x309d
movq %rbx, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x41b0(%rip), %rdi      # 0x72ad
leaq 0x4188(%rip), %rsi      # 0x728c
leaq 0x42d9(%rip), %rcx      # 0x73e4
movl $0x98, %edx
callq 0x2140
movq %rax, %r14
jmp 0x3129
movq %rax, %r14
leaq -0xf0(%rbp), %rdi
callq 0x4466
movq %rbx, %rdi
callq 0x3250
movq %r14, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O1/jo-qzy[P]MyJson/./json.hpp
// Function: JSON::Value::resize(unsigned long)
void resize(size_t size) {
            assert(type == JSON_ARRAY || type == JSON_OBJECT);
            switch (type) {
            case JSON_ARRAY: array.resize(size); break;
            case JSON_OBJECT:
                if (object.size() > size) {
                    size_t delete_size = object.size() - size;
                    for (delete_size; delete_size > 0; delete_size--) {
                        auto mt = object.rbegin();
                        object.erase(mt->first);
                    }
                }
                break;
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl (%rdi), %eax
leal -0x5(%rax), %ecx
cmpl $0x2, %ecx
jae 0x31bf
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x6, %eax
je 0x3177
cmpl $0x5, %eax
jne 0x31b4
addq $0x50, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6552
leaq 0x68(%r14), %r15
movq 0x90(%r14), %rax
cmpq %rbx, %rax
jbe 0x31b4
je 0x31b4
addq $0x70, %r14
subq %rax, %rbx
movq %r14, %rdi
callq 0x2200
leaq 0x20(%rax), %rsi
movq %r15, %rdi
callq 0x67a6
movq %r15, %rdi
movq %rax, %rsi
callq 0x6858
incq %rbx
jne 0x3190
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x40d1(%rip), %rdi      # 0x7297
leaq 0x40bf(%rip), %rsi      # 0x728c
leaq 0x424d(%rip), %rcx      # 0x7421
movl $0xbd, %edx
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O1/jo-qzy[P]MyJson/./json.hpp
// Function: JSON::Value::clear()
void clear() {
            switch (type) {
            case JSON_STRING: str.clear(); break;
            case JSON_ARRAY: array.clear(); break;
            case JSON_OBJECT: object.clear(); break;
            }
            type = JSON_NULL;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x6, %eax
je 0x3238
cmpl $0x5, %eax
je 0x320e
cmpl $0x4, %eax
jne 0x3241
movq $0x0, 0x38(%rbx)
movq 0x30(%rbx), %rax
movb $0x0, (%rax)
jmp 0x3241
movq 0x50(%rbx), %r15
movq 0x58(%rbx), %r12
cmpq %r15, %r12
je 0x3241
movq %r15, %r14
movq %r14, %rdi
callq 0x2d88
addq $0xa8, %r14
cmpq %r12, %r14
jne 0x321e
movq %r15, 0x58(%rbx)
jmp 0x3241
leaq 0x68(%rbx), %rdi
callq 0x692c
movl $0x0, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jo-qzy[P]MyJson/./json.hpp
// Function: JSON::json_parser::get_parser(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, JSON::Value*)
static json_parser* get_parser(const std::string& source, Value* v){
            static json_parser singleton_parser;
            singleton_parser.set_json_source(source, v);
            // use singleton create parser
            return &singleton_parser;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movb 0x7eee(%rip), %al       # 0xb1b0
testb %al, %al
je 0x32fb
leaq 0x7eb3(%rip), %r15      # 0xb180
movq %r15, %rdi
movq %r14, %rsi
callq 0x2110
movq 0x7ea1(%rip), %rax      # 0xb180
movq %rax, 0x7eba(%rip)      # 0xb1a0
movq %rbx, 0x7ebb(%rip)      # 0xb1a8
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x22d0
jmp 0x32c6