LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/dentiny[P]HTTP-Cache-Proxy/./Parser.hpp
// Function: Parser::extractContentLength(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int extractContentLength(const std::string & header)
	{
		// start extract content length
		int res = 0;
		int idx = header.find("Content-Length");
		int N = header.length();
		bool digit_found = false;
		for(int i = idx; i < N; ++i)
		{
			char c = header[i];
			if(digit_found && isdigit(c))
			{
				res = res * 10 + (c - '0');
			}
			else if(digit_found && !isdigit(c))
			{
				break;
			}
			else if(!digit_found && isdigit(c))
			{
				digit_found = true;
				res = c - '0';
			}
		}
		return res;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
leaq 0x2c02(%rip), %rsi      # 0xd46e
xorl %ebx, %ebx
movl $0xe, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x34f0
movl 0x8(%r14), %edx
cmpl %edx, %eax
jge 0xa8e0
movslq %eax, %rcx
notl %eax
addl %edx, %eax
addq (%r14), %rcx
xorl %edx, %edx
movl $0x1, %esi
xorl %ebx, %ebx
xorl %edi, %edi
movsbl (%rcx,%rdx), %r9d
addl $-0x30, %r9d
testb $0x1, %dil
je 0xa8bc
movb $0x1, %r8b
cmpl $0x9, %r9d
ja 0xa8ce
leal (%rbx,%rbx,4), %r8d
leal (%r9,%r8,2), %ebx
jmp 0xa8cb
cmpl $0xa, %r9d
movzbl %dil, %edi
cmovbl %esi, %edi
cmovbl %r9d, %ebx
xorl %r8d, %r8d
testb %r8b, %r8b
jne 0xa8e0
movq %rdx, %r8
incq %r8
cmpl %edx, %eax
movq %r8, %rdx
jne 0xa89a
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/dentiny[P]HTTP-Cache-Proxy/./Response.hpp
// Function: Response::Response(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<std::vector<char, std::allocator<char>>, std::allocator<std::vector<char, std::allocator<char>>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Response(const std::string _url, std::vector<std::vector<char>> buffer, const std::string h) : 
		status_code { -1 },
		url { _url },
		header { h },
		content { buffer },
		no_store { false }, // default can be stored in the cache
		no_cache { false }, // default can be cached in the cache(need to check e-tag)
		has_expiration { false }, // has expiration calculation machanism
		cur_time { time(NULL) },
		expiration_time { 0 },
		last_modified { 0 }
		{}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r13
movq %rdx, %r15
movq %rdi, %rbx
movl $0xffffffff, (%rdi)     # imm = 0xFFFFFFFF
leaq 0x18(%rdi), %rax
movq %rax, 0x10(%rsp)
movq %rax, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
leaq 0x28(%rdi), %r14
leaq 0x38(%rdi), %rax
movq %rax, 0x8(%rsp)
movq %rax, 0x28(%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x3d22
leaq 0x48(%rbx), %r12
leaq 0x58(%rbx), %rbp
movq %rbp, 0x48(%rbx)
movq (%r13), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x3d22
leaq 0x68(%rbx), %rdi
movq %r15, %rsi
callq 0x8ac2
leaq 0xb0(%rbx), %rax
movq %rax, 0x80(%rbx)
movq $0x1, 0x88(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x90(%rbx)
movl $0x3f800000, 0xa0(%rbx) # imm = 0x3F800000
movups %xmm0, 0xa8(%rbx)
movl $0x0, 0xb7(%rbx)
xorl %edi, %edi
callq 0x32f0
movq %rax, 0xc0(%rbx)
leaq 0xe8(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0xc8(%rbx)
movq %rax, 0xd8(%rbx)
movq $0x0, 0xe0(%rbx)
movb $0x0, 0xe8(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq (%r12), %rdi
cmpq %rbp, %rdi
je 0xaa13
movq (%rbp), %rsi
incq %rsi
callq 0x3340
jmp 0xaa13
movq %rax, %r15
movq (%r14), %rdi
cmpq 0x8(%rsp), %rdi
je 0xaa32
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x3340
jmp 0xaa32
movq %rax, %r15
movq 0x8(%rbx), %rdi
cmpq 0x10(%rsp), %rdi
je 0xaa4d
movq 0x10(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x3340
movq %r15, %rdi
callq 0x3510
nop
// File: /workspace/github_cpp_makefile_star2_O1/dentiny[P]HTTP-Cache-Proxy/./Parser.hpp
// Function: Parser::parseResponse(Response&)
void parseResponse(Response & response)
	{
		extractFirstLine(response);
		extractKV(response);
		extractAttri(response);	
		calcExpiration(response);
		extractLastModified(response);
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xabb2
movq %r14, %rdi
movq %rbx, %rsi
callq 0xad3c
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb0c6
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb2d4
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb4b0
// File: /workspace/github_cpp_makefile_star2_O1/dentiny[P]HTTP-Cache-Proxy/./LRUCache.hpp
// Function: LRUCache::put(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Response const&)
void put(const std::string & url, const Response & response) 
    {
        std::unique_lock<std::mutex> lck(mtx1);
        if(existsUrl(url))
        {
            cache.remove(url);
            kv[url] = response;
        }
        else
        {
            if(sz == capacity)
            {
                const std::string & url = cache.front(); cache.pop_front();
                kv.erase(url);
            }
            else
            {
                ++sz;
            }
            kv.insert(std::make_pair(url, response));
        }
        cache.push_back(url);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x783a(%rip), %rax      # 0x122f0
movq %rsp, %r12
movq %rax, (%r12)
movb $0x0, 0x8(%r12)
movq %r12, %rdi
callq 0x723e
movb $0x1, 0x8(%r12)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x72a2
testb %al, %al
je 0xab05
leaq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x85f2
leaq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0x8686
movq %rax, %rdi
movq %r15, %rsi
callq 0xbaac
jmp 0xab57
movl (%rbx), %eax
cmpl 0x4(%rbx), %eax
jne 0xab2b
leaq 0x8(%rbx), %rdi
movq 0x8(%rbx), %rsi
leaq 0x10(%rsi), %r12
callq 0xc1ea
leaq 0x20(%rbx), %rdi
movq %r12, %rsi
callq 0xc220
jmp 0xab2f
incl %eax
movl %eax, (%rbx)
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xc4be
leaq 0x20(%rbx), %rdi
leaq 0x10(%rsp), %rsi
callq 0xc32c
leaq 0x10(%rsp), %rdi
callq 0xbb78
leaq 0x8(%rbx), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x8e02
movq %rax, %rdi
movq %r15, %rsi
callq 0x3050
incq 0x18(%rbx)
movq %rsp, %rdi
callq 0x7228
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xab9f
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xbb78
jmp 0xaba2
jmp 0xab9f
movq %rax, %rbx
movq %rsp, %rdi
callq 0x7228
movq %rbx, %rdi
callq 0x3510
// File: /workspace/github_cpp_makefile_star2_O1/dentiny[P]HTTP-Cache-Proxy/./Parser.hpp
// Function: Parser::extractFirstLine(Response&)
void extractFirstLine(Response & response)
	{
		// first line
		const std::string header = response.header;
		for(char c : header)
		{
			if(c == '\r')
			{
				break;
			}
			else
			{
				response.first_line += c;
			}
		}

		// status code
		// eg: first line: HTTP/1.1 200 OK
		const std::string & first_line = response.first_line;
		int idx1 = first_line.find_first_of(' ');
		int idx2 = first_line.find_last_of(' ');
		response.status_code = std::stoi(first_line.substr(idx1, idx2 - idx1)); // [idx1, idx2)
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x48(%rsi), %rsi
movq 0x50(%rbx), %rdx
addq %rsi, %rdx
movq %rsp, %r14
movq %r14, %rdi
callq 0x3d22
movq 0x8(%r14), %r15
testq %r15, %r15
je 0xac10
movq (%rsp), %r12
leaq 0x8(%rbx), %r14
xorl %ebp, %ebp
movb (%r12,%rbp), %al
cmpb $0xd, %al
je 0xac10
movsbl %al, %esi
movq %r14, %rdi
callq 0x32c0
incq %rbp
cmpq %rbp, %r15
jne 0xabf5
leaq 0x8(%rbx), %r14
movq %r14, %rdi
movl $0x20, %esi
xorl %edx, %edx
callq 0x33e0
movq %rax, %r15
movq %r14, %rdi
movl $0x20, %esi
movq $-0x1, %rdx
callq 0x3570
movslq %r15d, %rdx
subl %edx, %eax
movslq %eax, %rcx
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x3360
movq 0x20(%rsp), %r15
callq 0x3040
movq %rax, %r14
movl (%rax), %ebp
movl $0x0, (%rax)
leaq 0x40(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
movl $0xa, %edx
callq 0x3400
cmpq %r15, (%r12)
je 0xacd8
movslq %eax, %rcx
cmpq %rax, %rcx
jne 0xace4
movl (%r14), %ecx
cmpl $0x22, %ecx
je 0xace4
testl %ecx, %ecx
jne 0xac96
movl %ebp, (%r14)
movl %eax, (%rbx)
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xacb3
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3340
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0xacc9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3340
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2851(%rip), %rdi      # 0xd530
callq 0x3200
leaq 0x2845(%rip), %rdi      # 0xd530
callq 0x3420
jmp 0xad1b
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0xacfe
movl %ebp, (%r14)
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xad1e
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3340
jmp 0xad1e
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0xad34
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3340
movq %rbx, %rdi
callq 0x3510
// File: /workspace/github_cpp_makefile_star2_O1/dentiny[P]HTTP-Cache-Proxy/./Parser.hpp
// Function: Parser::extractAttri(Response&)
void extractAttri(Response & response)
	{
		std::unordered_map<std::string, std::string> & kv = response.kv; 

		// no-store and no-cache attribute
		if(kv.find("Cache-Control") != kv.end())
		{
			std::string cache_control = kv["Cache-Control"];
			if(cache_control.find("no-store") != -1)
			{
				response.no_store = true;
			}
			if(cache_control.find("no-cache") != -1)
			{
				response.no_cache = true;
			}
		}

		// e-tag
		if(kv.find("ETag") != kv.end())
		{
			response.etag = kv["ETag"];
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2402(%rip), %rsi      # 0xd4e7
leaq 0x2408(%rip), %rdx      # 0xd4f4
leaq 0x8(%rsp), %rdi
callq 0x3c86
leaq 0x80(%rbx), %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0xba72
movq %rax, %r15
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xb124
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3340
testq %r15, %r15
je 0xb1ea
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x23aa(%rip), %rsi      # 0xd4e7
leaq 0x23b0(%rip), %rdx      # 0xd4f4
leaq 0x28(%rsp), %rdi
callq 0x3c86
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0xc512
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
callq 0x3d22
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0xb189
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3340
leaq 0x23aa(%rip), %rsi      # 0xd53a
leaq 0x8(%rsp), %rdi
movl $0x8, %ecx
xorl %edx, %edx
callq 0x34f0
cmpq $-0x1, %rax
je 0xb1ae
movb $0x1, 0xb8(%rbx)
leaq 0x238e(%rip), %rsi      # 0xd543
leaq 0x8(%rsp), %rdi
movl $0x8, %ecx
xorl %edx, %edx
callq 0x34f0
cmpq $-0x1, %rax
je 0xb1d3
movb $0x1, 0xb9(%rbx)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xb1ea
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3340
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x2353(%rip), %rsi      # 0xd54c
leaq 0x2350(%rip), %rdx      # 0xd550
callq 0x3c86
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0xba72
movq %rax, %r15
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xb22c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3340
testq %r15, %r15
je 0xb282
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x230c(%rip), %rsi      # 0xd54c
leaq 0x2309(%rip), %rdx      # 0xd550
callq 0x3c86
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0xc512
addq $0xd8, %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x31e0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xb282
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3340
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xb298
jmp 0xb298
jmp 0xb29d
jmp 0xb298
jmp 0xb29d
movq %rax, %rbx
jmp 0xb2cb
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xb2cb
movq 0x18(%rsp), %rsi
jmp 0xb2c3
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0xb2cb
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3340
movq %rbx, %rdi
callq 0x3510
nop
// File: /workspace/github_cpp_makefile_star2_O1/dentiny[P]HTTP-Cache-Proxy/./Parser.hpp
// Function: Parser::calcExpiration(Response&)
void calcExpiration(Response & response)
	{
		std::unordered_map<std::string, std::string> & kv = response.kv;
		const time_t & response_time = response.cur_time;

		// get fressness time
		int fressness_time = 0;
		if(kv.find("Cache-Control") != kv.end())
		{
			const std::string & cache_control = kv["Cache-Control"];
			int idx = cache_control.find("max-age");
			if(idx != -1)
			{
				// eg: max-age=1234567
				std::string max_age_s = cache_control.substr(idx + 8);
				fressness_time = std::stoi(max_age_s);
			}
		}

		response.expiration_time = response.cur_time + fressness_time;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
leaq 0x20(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x21f2(%rip), %rsi      # 0xd4e7
leaq 0x21f8(%rip), %rdx      # 0xd4f4
leaq 0x10(%rsp), %rdi
callq 0x3c86
leaq 0x80(%rbx), %r14
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0xba72
movq %rax, %r15
movq 0x10(%rsp), %rdi
cmpq %rbp, %rdi
je 0xb334
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3340
testq %r15, %r15
je 0xb42b
leaq 0x10(%rsp), %rdi
movq %rbp, (%rdi)
leaq 0x219b(%rip), %rsi      # 0xd4e7
leaq 0x21a1(%rip), %rdx      # 0xd4f4
callq 0x3c86
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0xc512
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %rbp, %rdi
je 0xb37f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3340
leaq 0x21cb(%rip), %rsi      # 0xd551
xorl %r15d, %r15d
movl $0x7, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x34f0
cmpl $-0x1, %eax
je 0xb42e
addl $0x8, %eax
movslq %eax, %rdx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq $-0x1, %rcx
callq 0x3360
movq (%r15), %r12
callq 0x3040
movq %rax, %r14
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movl $0x0, (%r14)
leaq 0x30(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
movl $0xa, %edx
callq 0x3400
cmpq %r12, (%r13)
je 0xb44b
movq %rax, %r15
movslq %r15d, %rax
cmpq %r15, %rax
jne 0xb457
movl (%r14), %eax
cmpl $0x22, %eax
je 0xb457
testl %eax, %eax
jne 0xb40f
movl 0xc(%rsp), %eax
movl %eax, (%r14)
movq 0x10(%rsp), %rdi
cmpq %rbp, %rdi
je 0xb426
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3340
movslq %r15d, %r15
jmp 0xb42e
xorl %r15d, %r15d
addq 0xc0(%rbx), %r15
movq %r15, 0xc8(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x20de(%rip), %rdi      # 0xd530
callq 0x3200
leaq 0x20d2(%rip), %rdi      # 0xd530
callq 0x3420
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0xb473
movl 0xc(%rsp), %eax
movl %eax, (%r14)
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x35bb
jmp 0xb4a7
jmp 0xb488
jmp 0xb4a4
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %rbp, %rdi
je 0xb4a7
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3340
jmp 0xb4a7
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3510
nop
// File: /workspace/github_cpp_makefile_star2_O1/dentiny[P]HTTP-Cache-Proxy/./Parser.hpp
// Function: Parser::extractLastModified(Response&)
void extractLastModified(Response & response)
	{
		std::unordered_map<std::string, std::string> & kv = response.kv;
		if(kv.find("Last-Modified") != kv.end())
		{
			const char * time = kv["Last-Modified"].c_str();
			struct tm tm;
			memset(&tm, 0, sizeof(struct tm));
			strptime(time, "%a, %d %b %Y %H:%M:%S %z", &tm);
			response.last_modified = mktime(&tm);
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1e6c(%rip), %rsi      # 0xd33b
leaq 0x1e72(%rip), %rdx      # 0xd348
movq %rsp, %rdi
callq 0x3c86
leaq 0x80(%rbx), %r14
movq %rsp, %rsi
movq %r14, %rdi
callq 0xba72
movq %rax, %r15
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xb509
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3340
testq %r15, %r15
je 0xb588
movq %rsp, %rdi
movq %r12, (%rdi)
leaq 0x1e20(%rip), %rsi      # 0xd33b
leaq 0x1e26(%rip), %rdx      # 0xd348
callq 0x3c86
movq %rsp, %rsi
movq %r14, %rdi
callq 0xc512
movq (%rax), %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xb54b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3340
xorps %xmm0, %xmm0
movq %rsp, %r15
movaps %xmm0, 0x20(%r15)
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
movq $0x0, 0x30(%r15)
leaq 0x1feb(%rip), %rsi      # 0xd559
movq %r14, %rdi
movq %r15, %rdx
callq 0x3060
movq %r15, %rdi
callq 0x3210
movq %rax, 0xd0(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xb598
jmp 0xb5b3
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xb5b6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3340
jmp 0xb5b6
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3510
// File: /workspace/github_cpp_makefile_star2_O1/dentiny[P]HTTP-Cache-Proxy/./Response.hpp
// Function: Response::operator=(Response const&)
Response & operator=(const Response & rhs)
	{
		if(this != &rhs)
		{
			status_code = rhs.status_code;
			first_line = rhs.first_line;
			url = rhs.url;
			header = rhs.header;
			content = rhs.content;
			kv = rhs.kv;
			no_store = rhs.no_store;
			no_cache = rhs.no_cache;
			has_expiration = rhs.has_expiration;
			cur_time = rhs.cur_time;
			expiration_time = rhs.expiration_time;
			last_modified = rhs.last_modified;
			etag = rhs.etag;
		}
		return *this;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0xbb6c
movq %rsi, %r14
movl (%rsi), %eax
movl %eax, (%rbx)
addq $0x8, %rsi
leaq 0x8(%rbx), %rdi
callq 0x31e0
leaq 0x28(%r14), %rsi
leaq 0x28(%rbx), %rdi
callq 0x31e0
leaq 0x48(%r14), %rsi
leaq 0x48(%rbx), %rdi
callq 0x31e0
leaq 0x68(%r14), %rsi
leaq 0x68(%rbx), %rdi
callq 0xbc14
movl $0x80, %esi
leaq (%rbx,%rsi), %rdi
addq %r14, %rsi
callq 0xbe82
movb 0xb8(%r14), %al
movb %al, 0xb8(%rbx)
movb 0xb9(%r14), %al
movb %al, 0xb9(%rbx)
movb 0xba(%r14), %al
movb %al, 0xba(%rbx)
movq 0xc0(%r14), %rax
movq %rax, 0xc0(%rbx)
movq 0xc8(%r14), %rax
movq %rax, 0xc8(%rbx)
movq 0xd0(%r14), %rax
movq %rax, 0xd0(%rbx)
movl $0xd8, %edi
addq %rdi, %r14
addq %rbx, %rdi
movq %r14, %rsi
callq 0x31e0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/dentiny[P]HTTP-Cache-Proxy/Proxy.cpp
// Function: Proxy::getResponseHeader(int, std::vector<char, std::allocator<char>>&)
int getResponseHeader(int server_fd, std::vector<char> & buffer)
	{
		int len = recv(server_fd, &buffer.data()[0], BUFFER_SIZE, 0);
	    if(len == -1)
	    {
	    	throw ProxyException("Receive header error");
	    }
	    buffer[len] = '\0';
	    return len;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movl %esi, %edi
movq (%rdx), %rsi
movl $0x10000, %edx          # imm = 0x10000
xorl %ecx, %ecx
callq 0x3100
cmpl $-0x1, %eax
je 0xcb24
movslq %eax, %rcx
movq (%rbx), %rdx
movb $0x0, (%rdx,%rcx)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %edi
callq 0x31a0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xa6c(%rip), %rsi       # 0xd5ad
leaq 0xa79(%rip), %rdx       # 0xd5c1
leaq 0x8(%rsp), %rdi
callq 0x3c86
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x6aa8
xorl %ebp, %ebp
leaq 0x519d(%rip), %rsi      # 0x11d08
leaq -0x6080(%rip), %rdx     # 0x6af2
movq %rbx, %rdi
callq 0x34e0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xcb9c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3340
jmp 0xcb9c
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0xcba9
movq %rbx, %rdi
callq 0x3250
movq %r14, %rdi
callq 0x3510
nop
// File: /workspace/github_cpp_makefile_star2_O1/derekzwy[P]an-optimal-tcam-encoding-algorithm-for-packet-classification/cps-tss.cc
// Function: parseargs(int, char**)
void parseargs(int argc, char *argv[]) {
    int	c;
    while ((c = getopt(argc, argv, "r:")) != -1) {
        switch (c) {
            case 'r':
                fpr = fopen(optarg, "r");
                break;
            default:
                break;
        }
    }

    
    if(fpr == NULL){
        printf("can't open ruleset file\n");
        exit(-1);
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
leaq 0x4bb9(%rip), %r15      # 0x7020
movq 0x7b5a(%rip), %r13      # 0x9fc8
leaq 0x4dad(%rip), %r12      # 0x7222
movl %r14d, %edi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2060
cmpl $0x72, %eax
je 0x248f
cmpl $-0x1, %eax
jne 0x2475
jmp 0x24a4
movq (%r13), %rdi
movq %r12, %rsi
callq 0x21a0
movq %rax, 0x7cb6(%rip)      # 0xa158
jmp 0x2475
cmpq $0x0, 0x7cac(%rip)      # 0xa158
je 0x24bd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4bcf(%rip), %rdi      # 0x7093
callq 0x2200
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O1/derekzwy[P]an-optimal-tcam-encoding-algorithm-for-packet-classification/cps-tss.cc
// Function: print_bitstring(std::vector<pc_rule*, std::allocator<pc_rule*>>&)
void print_bitstring(vector<pc_rule*> &pc) 
{
    array<char, MAX_BITS> bitstring;
    int old_priority;
    for(auto rule = pc.begin(); rule != pc.end(); rule ++) {
        if((*rule)->priority != old_priority) {
            old_priority = (*rule)->priority;
            cout<<endl;
            cout<<(*rule)->priority<<endl;
        }
        bitstring = bitstring_from_rule(*rule);
        for_each(bitstring.begin(), bitstring.begin() + 32, [](char c){cout<<c<<" ";});
        cout<<endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq (%rdi), %rbx
movq %rdi, -0x38(%rbp)
cmpq 0x8(%rdi), %rbx
je 0x2b3f
movq 0x7588(%rip), %r15      # 0x9fd8
leaq -0x29(%rbp), %r12
leaq 0x45f2(%rip), %r13      # 0x704d
movq (%rbx), %rax
movl (%rax), %eax
cmpl -0x30(%rbp), %eax
je 0x2ac6
movl %eax, -0x30(%rbp)
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
movq (%rbx), %rax
movl (%rax), %esi
movq %r15, %rdi
callq 0x2230
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
movq (%rbx), %rsi
leaq -0x58(%rbp), %rdi
callq 0x28e2
xorl %r14d, %r14d
movb -0x58(%rbp,%r14), %al
movb %al, -0x29(%rbp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2190
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x2190
incq %r14
cmpq $0x20, %r14
jne 0x2ad5
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
addq $0x8, %rbx
movq -0x38(%rbp), %rax
cmpq 0x8(%rax), %rbx
jne 0x2a5b
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/derekzwy[P]an-optimal-tcam-encoding-algorithm-for-packet-classification/cps-tss.cc
// Function: get_tuple(std::array<char, 32ul>&)
array<int, MAXDIMENSIONS> get_tuple(array<char, MAX_BITS> &bitstring) 
{
    array<int, MAXDIMENSIONS> field_prefixlen;
    field_prefixlen.fill(0);
    int start_pos[MAXDIMENSIONS] = {0, 32, 64, 80, 96}; 
    int bits[MAXDIMENSIONS] = {32,32,16,16,8};
    for(int i = 0; i < MAXDIMENSIONS; i++) {    
        int spos = start_pos[i];
        for(int j = spos; j < spos + bits[i]; j++) {
            if(bitstring[j] != '*') {
                field_prefixlen[i]++;
            }
        }

    }
    return move(field_prefixlen);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x20(%rbp)
movl $0x0, -0x10(%rbp)
xorl %ecx, %ecx
leaq 0x4564(%rip), %rdx      # 0x70d0
leaq 0x453d(%rip), %rdi      # 0x70b0
movslq (%rdx,%rcx,4), %r8
movslq (%rdi,%rcx,4), %r9
addq %r9, %r8
cmpb $0x2a, (%rsi,%r9)
je 0x2b89
incl -0x20(%rbp,%rcx,4)
incq %r9
cmpq %r8, %r9
jl 0x2b7e
incq %rcx
cmpq $0x5, %rcx
jne 0x2b73
movl -0x10(%rbp), %ecx
movl %ecx, 0x10(%rax)
movaps -0x20(%rbp), %xmm0
movups %xmm0, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/derekzwy[P]an-optimal-tcam-encoding-algorithm-for-packet-classification/cps-tss.cc
// Function: main
int main(int argc, char *argv[])
{

    vector<pc_rule> pc_orig;
    vector<pc_rule> pc_prefix;
    vector<pc_rule*> pc;

    parseargs(argc, argv);
    loadrules(fpr, pc_orig);

    vector<pc_rule*> pc_r = remove_redund_pkg(pc_orig, pc_prefix);
    cout<<"load "<<pc_r.size()<<" rules"<<endl;

    //freopen ("tuple.txt","w",stdout);
    tuples_num(pc_r);
    freopen ("prefix.txt","w",stdout);
    print_bitstring(pc_r);
    fclose(stdout);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
xorps %xmm0, %xmm0
leaq -0x60(%rbp), %rbx
movaps %xmm0, (%rbx)
xorl %eax, %eax
movq %rax, 0x10(%rbx)
movq %rax, -0x30(%rbp)
movaps %xmm0, -0x40(%rbp)
callq 0x244c
movq 0x7580(%rip), %rdi      # 0xa158
movq %rbx, %rsi
callq 0x33b5
leaq -0x28(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x24d3
movq 0x73e0(%rip), %rdi      # 0x9fd8
leaq 0x4460(%rip), %rsi      # 0x705f
movl $0x5, %edx
callq 0x2190
movq -0x28(%rbp), %rbx
movq -0x20(%rbp), %rsi
subq %rbx, %rsi
sarq $0x3, %rsi
movq 0x73b9(%rip), %rdi      # 0x9fd8
callq 0x20c0
movq %rax, %r14
leaq 0x4437(%rip), %rsi      # 0x7065
movl $0x6, %edx
movq %rax, %rdi
callq 0x2190
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
leaq -0x28(%rbp), %rdi
callq 0x270a
movq 0x7346(%rip), %r14      # 0x9fb8
movq (%r14), %rdx
leaq 0x43f0(%rip), %rdi      # 0x706c
leaq 0x43f4(%rip), %rsi      # 0x7077
callq 0x2180
leaq -0x28(%rbp), %rdi
callq 0x2a27
movq (%r14), %rdi
callq 0x2150
testq %rbx, %rbx
je 0x2ca6
movq %rbx, %rdi
callq 0x2130
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x2cb4
callq 0x2130
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
je 0x2cc2
callq 0x2130
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x2ccf
movq %rax, %rbx
jmp 0x2ce5
movq %rax, %rbx
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x2ce5
callq 0x2130
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x2cf3
callq 0x2130
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
je 0x2d01
callq 0x2130
movq %rbx, %rdi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O1/derekzwy[P]an-optimal-tcam-encoding-algorithm-for-packet-classification/rulesutils.cc
// Function: init_boundary(rule_boundary&)
void init_boundary(rule_boundary & rb)
{
    rb.field[0].low = 0;
    rb.field[0].high = 0xFFFFFFFF;
    rb.field[1].low = 0;
    rb.field[1].high = 0xFFFFFFFF;
    rb.field[2].low = 0;
    rb.field[2].high = 0xFFFF;
    rb.field[3].low = 0;
    rb.field[3].high = 0xFFFF;
    rb.field[4].low = 0;
    rb.field[4].high = 0xFF;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movq %rax, (%rdi)
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movq %rcx, 0x8(%rdi)
movq %rax, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movl $0xffff, %ecx           # imm = 0xFFFF
movq %rcx, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movq %rcx, 0x38(%rdi)
movq %rax, 0x40(%rdi)
movq $0xff, 0x48(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/derekzwy[P]an-optimal-tcam-encoding-algorithm-for-packet-classification/rulesutils.cc
// Function: CheckIPBounds(range)
int CheckIPBounds(range fld)
{
    if (fld.low > 0xFFFFFFFF)
    {
        printf("Error: IPRange is buggy!(%llu)\n",fld.low);
        return 1;
    }
    if (fld.high > 0xFFFFFFFF)
    {
        printf("Error: IPRange is buggy!(%llu)\n",fld.high);
        return 1;
    }
    if (fld.low > fld.high)
    {
        printf("Error: IPRange is buggy!(%llu - %llu)\n",fld.low,fld.high);
        return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rsi, %rdx
movq %rdi, %rsi
movq %rdi, %rax
shrq $0x20, %rax
je 0x3299
leaq 0x3e61(%rip), %rdi      # 0x70f8
jmp 0x32ac
movq %rdx, %rax
shrq $0x20, %rax
je 0x32ba
leaq 0x3e4f(%rip), %rdi      # 0x70f8
movq %rdx, %rsi
xorl %eax, %eax
callq 0x2040
movl $0x1, %eax
popq %rbp
retq
xorl %eax, %eax
cmpq %rdx, %rsi
jbe 0x32b8
leaq 0x3e50(%rip), %rdi      # 0x7118
xorl %eax, %eax
callq 0x2040
jmp 0x32b3
// File: /workspace/github_cpp_makefile_star2_O1/derekzwy[P]an-optimal-tcam-encoding-algorithm-for-packet-classification/rulesutils.cc
// Function: IP2Range(unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, pc_rule*, int)
void IP2Range(unsigned ip1,unsigned ip2,unsigned ip3,unsigned ip4,unsigned iplen,pc_rule *rule,int index)
{
    unsigned tmp;
    unsigned Lo,Hi;

    if(iplen == 0){
        Lo = 0;
        Hi = 0xFFFFFFFF;

    }else if(iplen > 0 && iplen <= 8) {
        tmp = ip1 << 24;
        tmp &= (0xffffffff << (32-iplen));

        Lo = tmp;
        Hi = Lo + (1<<(32-iplen)) - 1;
    }else if(iplen > 8 && iplen <= 16){
        tmp =  ip1 << 24; 
        tmp += ip2 << 16;
        tmp &= (0xffffffff << (32-iplen));

        Lo = tmp;
        Hi = Lo + (1<<(32-iplen)) - 1;
    }else if(iplen > 16 && iplen <= 24){
        tmp = ip1 << 24; 
        tmp += ip2 << 16; 
        tmp += ip3 << 8; 
        tmp &= (0xffffffff << (32-iplen));

        Lo = tmp;
        Hi = Lo + (1<<(32-iplen)) - 1;
    }else if(iplen > 24 && iplen <= 32){
        tmp = ip1 << 24; 
        tmp += ip2 << 16; 
        tmp += ip3 << 8; 
        tmp += ip4;
        tmp &= (0xffffffff << (32-iplen));

        Lo = tmp;
        Hi = Lo + (1<<(32-iplen)) - 1;
    }else{
        printf("Error: Src IP length exceeds 32\n");
        exit(1);
    }

    rule->field[index].low  = Lo;
    rule->field[index].high = Hi;

    if (CheckIPBounds(rule->field[index]))
    {
        printf("Error: IP2Range bounds check for %d failed\n",index);
        exit(1);
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testl %r8d, %r8d
je 0x32fa
cmpl $0x8, %r8d
ja 0x3303
negb %r8b
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %r8d, %ecx
shll %cl, %eax
shll $0x18, %edi
andl %eax, %edi
notl %eax
addl %edi, %eax
jmp 0x3365
xorl %edi, %edi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x3365
cmpl $0x10, %r8d
ja 0x3328
shll $0x18, %edi
shll $0x10, %esi
addl %edi, %esi
negb %r8b
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %r8d, %ecx
shll %cl, %eax
andl %eax, %esi
notl %eax
addl %esi, %eax
movl %esi, %edi
jmp 0x3365
cmpl $0x18, %r8d
ja 0x333b
shll $0x18, %edi
shll $0x10, %esi
addl %edi, %esi
shll $0x8, %edx
jmp 0x334e
cmpl $0x20, %r8d
ja 0x33a7
shll $0x18, %edi
shll $0x10, %esi
addl %edi, %esi
shll $0x8, %edx
addl %ecx, %edx
addl %esi, %edx
negb %r8b
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %r8d, %ecx
shll %cl, %eax
andl %eax, %edx
notl %eax
addl %edx, %eax
movl %edx, %edi
movl 0x10(%rbp), %ebx
movl %edi, %edi
movslq %ebx, %rcx
shlq $0x4, %rcx
movq %rdi, 0x8(%r9,%rcx)
movl %eax, %esi
movq %rsi, 0x10(%r9,%rcx)
callq 0x327d
testl %eax, %eax
jne 0x338d
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x3dab(%rip), %rdi      # 0x713f
movl %ebx, %esi
xorl %eax, %eax
callq 0x2040
movl $0x1, %edi
callq 0x21b0
leaq 0x3e42(%rip), %rdi      # 0x71f0
callq 0x2200
jmp 0x339d
// File: /workspace/github_cpp_makefile_star2_O1/derekzwy[P]an-optimal-tcam-encoding-algorithm-for-packet-classification/rulesutils.cc
// Function: is_equal(pc_rule, pc_rule, rule_boundary)
bool is_equal(pc_rule rule1, pc_rule rule2, rule_boundary boundary)
{
    int count = 0;
    range r1, r2;
    for (int i = 0;i < MAXDIMENSIONS;i++)
    {

        r1 = range_in_boundary_1D(rule1.field[i], boundary.field[i]);

        r2 = range_in_boundary_1D(rule2.field[i], boundary.field[i]);

        if (r1.low <= r2.low && r1.high >= r2.high)

        {
            count++;
        }
    }

    if (count == MAXDIMENSIONS)
        return true;
    else
        return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
leaq 0x120(%rbp), %rcx
leaq 0x98(%rbp), %rdx
leaq 0x10(%rbp), %rsi
xorl %edi, %edi
movq (%rcx,%rax), %r8
movq 0x8(%rcx,%rax), %r9
movq 0x8(%rdx,%rax), %r10
cmpq %r8, %r10
cmovaq %r10, %r8
movq 0x10(%rdx,%rax), %r10
cmpq %r9, %r10
cmovbq %r10, %r9
cmpq %r8, 0x8(%rsi,%rax)
setbe %r8b
cmpq %r9, 0x10(%rsi,%rax)
setae %r9b
andb %r8b, %r9b
movzbl %r9b, %r8d
addl %r8d, %edi
addq $0x10, %rax
cmpq $0x50, %rax
jne 0x36e0
cmpl $0x5, %edi
sete %al
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/derekzwy[P]an-optimal-tcam-encoding-algorithm-for-packet-classification/rulesutils.cc
// Function: check_cmpl(prefix*)
bool check_cmpl(struct prefix *pf) 
{
    int rangelen = 0;
    if(pf->nvalid != 1) {
        for(size_t i = 0; i < pf->nvalid; i ++) {
            rangelen += (int)pow(2, 16 - pf->length[i]);
        }
        for(size_t i = 0; i < pf->ninvalid; i ++) {
            rangelen += (int)pow(2, 16 - pf->cmpllength[i]);
        }
    }
    else {
        rangelen = (int)pow(2, 16 - pf->length[0]);
    }
    if(rangelen == (int)pow(2, 16 - pf->fpf_len)) {
        return true;
    }
    else {
        cout<<pf->nvalid<<endl;
        cout<<rangelen<<" "<<pf->fpf_len<<" "<<(int)pow(2, 16 - pf->fpf_len)<<endl;
        return false;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
cmpl $0x1, 0x108(%rdi)
jne 0x4574
movl $0x10, %eax
subl 0x40(%r14), %eax
cvtsi2sd %rax, %xmm0
callq 0x2120
cvttsd2si %xmm0, %ebx
jmp 0x45ef
cmpl $0x0, 0x108(%r14)
je 0x45b1
xorl %r15d, %r15d
xorl %ebx, %ebx
movl $0x10, %eax
subl 0x40(%r14,%r15,4), %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
callq 0x2120
cvttsd2si %xmm0, %eax
addl %eax, %ebx
incq %r15
movl 0x108(%r14), %eax
cmpq %rax, %r15
jb 0x4583
jmp 0x45b3
xorl %ebx, %ebx
cmpl $0x0, 0x10c(%r14)
je 0x45ef
xorl %r15d, %r15d
movl $0x10, %eax
subl 0xc0(%r14,%r15,4), %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
callq 0x2120
cvttsd2si %xmm0, %eax
addl %eax, %ebx
incq %r15
movl 0x10c(%r14), %eax
cmpq %rax, %r15
jb 0x45c0
movl $0x10, %r13d
movl $0x10, %eax
subl 0x104(%r14), %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
callq 0x2120
cvttsd2si %xmm0, %eax
cmpl %eax, %ebx
je 0x46f0
movl 0x108(%r14), %esi
movq 0x59b0(%rip), %r15      # 0x9fd8
movq %r15, %rdi
movl %eax, -0x2c(%rbp)
callq 0x20c0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
movq %r15, %rdi
movl %ebx, %esi
callq 0x2230
movq %rax, %r15
leaq 0x29dc(%rip), %r12      # 0x704d
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2190
movl 0x104(%r14), %esi
movq %r15, %rdi
callq 0x20c0
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2190
subl 0x104(%r14), %r13d
xorps %xmm0, %xmm0
cvtsi2sd %r13, %xmm0
callq 0x2120
cvttsd2si %xmm0, %esi
movq %r15, %rdi
callq 0x2230
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
movl -0x2c(%rbp), %eax
cmpl %eax, %ebx
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/derekzwy[P]an-optimal-tcam-encoding-algorithm-for-packet-classification/rtrie.cc
// Function: rt_insert(rnode*, rg, pc_rule*)
void rt_insert(rnode *n, rg r, pc_rule* index)
{
    if(r.high >= n->b.high && r.low <= n->b.low) {
        n->rlist.push_back(index);
        return;
    }

    uint32_t m = (n->b.high -  n->b.low + 1ULL)/2 + n->b.low - 1;

    if(r.low <= m) {
        if(!n->left) {
            n->left = new rnode(rg(n->b.low, m));
        }

        rt_insert(n->left, r, index);
    }

    if(r.high > m) {
        if(!n->right) {
            n->right = new rnode(rg(m+1, n->b.high)); 
        }
        rt_insert(n->right, r, index);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, -0x40(%rbp)
movl 0x4(%rsi), %ecx
movl 0x4(%rdi), %r12d
cmpl %r12d, %ecx
jb 0x5ac6
movl (%r14), %eax
cmpl (%rbx), %eax
jbe 0x5b94
movl (%rbx), %eax
subl %eax, %r12d
incq %r12
shrq %r12
movq %rax, -0x38(%rbp)
leal (%rax,%r12), %r13d
decl %r13d
movl (%r14), %r15d
cmpl %r13d, %r15d
ja 0x5b37
cmpq $0x0, 0x28(%rbx)
jne 0x5b24
movl $0x30, %edi
movq %rdx, -0x48(%rbp)
movl %ecx, -0x2c(%rbp)
callq 0x2160
movq -0x48(%rbp), %rdx
movq -0x38(%rbp), %rcx
movl %ecx, (%rax)
movl -0x2c(%rbp), %ecx
movl %r13d, 0x4(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
movq $0x0, 0x28(%rax)
movq %rax, 0x28(%rbx)
movq 0x28(%rbx), %rdi
leaq -0x58(%rbp), %rsi
movl %r15d, (%rsi)
movl %ecx, 0x4(%rsi)
callq 0x5a94
movl 0x4(%r14), %r15d
cmpl %r13d, %r15d
jbe 0x5bb8
cmpq $0x0, 0x20(%rbx)
jne 0x5b78
movq -0x38(%rbp), %r13
addl %r12d, %r13d
movl $0x30, %edi
callq 0x2160
movl 0x4(%rbx), %ecx
movl %r13d, (%rax)
movl %ecx, 0x4(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x8(%rax)
movq $0x0, 0x28(%rax)
movq %rax, 0x20(%rbx)
movq 0x20(%rbx), %rdi
movl (%r14), %eax
leaq -0x50(%rbp), %rsi
movl %eax, (%rsi)
movl %r15d, 0x4(%rsi)
movq -0x40(%rbp), %rdx
callq 0x5a94
jmp 0x5bb8
movq 0x10(%rbx), %rsi
cmpq 0x18(%rbx), %rsi
je 0x5ba8
movq %rdx, (%rsi)
addq $0x8, 0x10(%rbx)
jmp 0x5bb8
addq $0x8, %rbx
leaq -0x40(%rbp), %rdx
movq %rbx, %rdi
callq 0x59be
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/derekzwy[P]an-optimal-tcam-encoding-algorithm-for-packet-classification/rtrie.cc
// Function: rt_destory(rnode*)
void rt_destory(rnode *n)
{
    if(!n)
        return;

    if(n->right){
        rt_destory(n->right);
        n->right = NULL;
    }

    if(n->left){
        rt_destory(n->left);
        n->left = NULL;
    }

    n->rlist.clear();
    delete n;
}

// Assembly:
testq %rdi, %rdi
je 0x5c27
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x5beb
callq 0x5bc7
movq $0x0, 0x20(%rbx)
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x5c01
callq 0x5bc7
movq $0x0, 0x28(%rbx)
movq 0x8(%rbx), %rdi
cmpq %rdi, 0x10(%rbx)
je 0x5c0f
movq %rdi, 0x10(%rbx)
testq %rdi, %rdi
je 0x5c19
callq 0x2130
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2130
retq
// File: /workspace/github_cpp_makefile_star2_O1/suhasjains[P]AMR-Solver/src/amrsolver.cpp
// Function: amrsolver::set_field()
void set_field() {

	myOctree::create_list_of_leaf_nodes();

    	for (std::list<Octree*>::iterator it = myOctree::leaf_nodes.begin(), end = myOctree::leaf_nodes.end(); it != end; ++it) {

   		Field* field = (*it)->get_block_data()->scalarfields[1];
   		VecField* location = (*it)->get_block_data()->mesh;
	
		for(int i=0;i<field->Nx;i++) {
                	for(int j=0;j<field->Ny;j++) {
                        	for(int k=0;k<field->Nz;k++) {
				
					double x = location->x[i][j][k];
					double y = location->y[i][j][k];
					double z = location->z[i][j][k];
 					
					if((*it)->get_block_data()->flag[i][j][k]==myOctree::DOMAIN) 
						field->val[i][j][k] = 1.0;		
					//if(x*x + y*y >= 3.0)	{field->val[i][j][k] = 100.0; }		
                        	}
                	}
        	}

    	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x2f28
leaq 0x1276e(%rip), %rax     # 0x15220
movq (%rax), %r14
cmpq %rax, %r14
je 0x2b67
movq 0x10(%r14), %rdi
callq 0x4064
movq 0x10(%rax), %rax
movq 0x8(%rax), %r12
movq 0x10(%r14), %rdi
callq 0x4064
cmpl $0x0, (%r12)
jle 0x2b57
xorl %r13d, %r13d
cmpl $0x0, 0x4(%r12)
jle 0x2b4b
xorl %ebx, %ebx
cmpl $0x0, 0x8(%r12)
jle 0x2b3e
xorl %r15d, %r15d
movq 0x10(%r14), %rdi
callq 0x4064
movq 0x88(%rax), %rax
movq (%rax,%r13,8), %rax
movq (%rax,%rbx,8), %rax
cmpl $0x7, (%rax,%r15,4)
jne 0x2b31
movq 0x10(%r12), %rax
movq (%rax,%r13,8), %rax
movq (%rax,%rbx,8), %rax
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, (%rax,%r15,8)
incq %r15
movslq 0x8(%r12), %rax
cmpq %rax, %r15
jl 0x2af7
incq %rbx
movslq 0x4(%r12), %rax
cmpq %rax, %rbx
jl 0x2aec
incq %r13
movslq (%r12), %rax
cmpq %rax, %r13
jl 0x2ae2
movq (%r14), %r14
cmpq 0x1244f(%rip), %r14     # 0x14fb0
jne 0x2abe
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/suhasjains[P]AMR-Solver/src/octreegrid.cpp
// Function: myOctree::create_list_of_leaf_nodes()
void create_list_of_leaf_nodes() {

	leaf_nodes.clear();

	for (std::list<Octree*>::iterator i = nodes.begin(), end = nodes.end(); i != end; ++i) {
		if((*i)->isLeafNode()) 
			leaf_nodes.push_back(*i);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x122e7(%rip), %rdi     # 0x15220
callq 0x38e2
movq 0x122c3(%rip), %r14     # 0x15208
leaq 0x122bc(%rip), %r15     # 0x15208
cmpq %r15, %r14
je 0x2f91
leaq 0x122c8(%rip), %rbx     # 0x15220
movq 0x10(%r14), %rdi
callq 0x4040
testb %al, %al
je 0x2f89
movl $0x18, %edi
callq 0x21f0
movq 0x10(%r14), %rcx
movq %rcx, 0x10(%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2060
incq 0x122a7(%rip)           # 0x15230
movq (%r14), %r14
cmpq %r15, %r14
jne 0x2f58
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/suhasjains[P]AMR-Solver/src/octreegrid.cpp
// Function: myOctree::create_list_of_root_nodes()
void create_list_of_root_nodes() {

	root_nodes.clear();

	for (std::list<Octree*>::iterator i = nodes.begin(), end = nodes.end(); i != end; ++i) {
		if((*i)->isRootNode()) 
			root_nodes.push_back(*i);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x1228b(%rip), %rdi     # 0x15238
callq 0x38e2
movq 0x1224f(%rip), %r14     # 0x15208
leaq 0x12248(%rip), %r15     # 0x15208
cmpq %r15, %r14
je 0x3005
leaq 0x1226c(%rip), %rbx     # 0x15238
movq 0x10(%r14), %rdi
callq 0x4052
testb %al, %al
je 0x2ffd
movl $0x18, %edi
callq 0x21f0
movq 0x10(%r14), %rcx
movq %rcx, 0x10(%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2060
incq 0x1224b(%rip)           # 0x15248
movq (%r14), %r14
cmpq %r15, %r14
jne 0x2fcc
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/suhasjains[P]AMR-Solver/src/octreegrid.cpp
// Function: myOctree::create_lists_of_level_nodes()
void create_lists_of_level_nodes() {

	//clearing all lists
	for (unsigned level=0; level <= max_level; level++) {
		level_nodes[level].clear();
	}
	

	//pushing nodes to respective lists	
	for (std::list<Octree*>::iterator j = nodes.begin(), end = nodes.end(); j != end; ++j) {
                int level = (*j)->get_level();
		level_nodes[level].push_back(*j);
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %ebx, %ebx
leaq 0x1222c(%rip), %r14     # 0x15250
leaq 0x125e9(%rip), %r15     # 0x15614
movl %ebx, %eax
leaq (%rax,%rax,2), %rax
leaq (%r14,%rax,8), %rdi
callq 0x38e2
incl %ebx
cmpl (%r15), %ebx
jbe 0x302b
movq 0x121c0(%rip), %r15     # 0x15208
leaq 0x121b9(%rip), %r12     # 0x15208
cmpq %r12, %r15
je 0x308d
movq 0x10(%r15), %rdi
callq 0x40ba
cltq
leaq (%rax,%rax,2), %rax
leaq (%r14,%rax,8), %rbx
movl $0x18, %edi
callq 0x21f0
movq 0x10(%r15), %rcx
movq %rcx, 0x10(%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2060
incq 0x10(%rbx)
movq (%r15), %r15
jmp 0x304f
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/suhasjains[P]AMR-Solver/src/octreegrid.cpp
// Function: myOctree::create_lists_of_multilevel_nodes()
void create_lists_of_multilevel_nodes() {

	//clearing all lists
	for (unsigned level=0; level <= max_level; level++) {
		multilevel_nodes[level].clear();
	}

	//pushing nodes to respective lists	
	for (unsigned level=0; level <= max_level; level++) {
		for (std::list<Octree*>::iterator j = nodes.begin(), end = nodes.end(); j != end; ++j) {
                	if(((*j)->get_level()<level && (*j)->isLeafNode())||((*j)->get_level()==level)) { 
				multilevel_nodes[level].push_back(*j);
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %ebx, %ebx
leaq 0x12383(%rip), %r14     # 0x15430
leaq 0x12560(%rip), %r15     # 0x15614
movl %ebx, %eax
leaq (%rax,%rax,2), %rax
leaq (%r14,%rax,8), %rdi
callq 0x38e2
incl %ebx
cmpl (%r15), %ebx
jbe 0x30b4
xorl %r12d, %r12d
leaq 0x12134(%rip), %r13     # 0x15208
movq 0x1212d(%rip), %r14     # 0x15208
cmpq %r13, %r14
je 0x3144
movl %r12d, %eax
leaq (%rax,%rax,2), %rax
leaq 0x12342(%rip), %rcx     # 0x15430
leaq (%rcx,%rax,8), %rbx
movq 0x10(%r14), %rdi
callq 0x40ba
cmpl %r12d, %eax
jae 0x310d
movq 0x10(%r14), %rdi
callq 0x4040
testb %al, %al
jne 0x311b
movq 0x10(%r14), %rdi
callq 0x40ba
cmpl %r12d, %eax
jne 0x313c
movl $0x18, %edi
callq 0x21f0
movq 0x10(%r14), %rcx
movq %rcx, 0x10(%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2060
incq 0x10(%rbx)
movq (%r14), %r14
cmpq %r13, %r14
jne 0x30f2
incl %r12d
cmpl (%r15), %r12d
jbe 0x30d4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/suhasjains[P]AMR-Solver/src/octreegrid.cpp
// Function: myOctree::create_node(int, double, double, double, double, double, double, int, myOctree::node_boundary_flags**)
void create_node(int blocknumber, double xmin, double xmax, double ymin, double ymax, double zmin, double zmax, int level, NodeBc **bc) {

	//memory allocation to new node
	Octree r(xmin,xmax,ymin,ymax,zmin,zmax,level);
	nodes.pop_back();
	Octree* root = new Octree(r);

	//boundaries are assigned to this root node
//	root->east_bc = east_bc;
//	root->west_bc = west_bc;
//	root->north_bc = north_bc;
//	root->south_bc = south_bc;
//	root->top_bc = top_bc;
//	root->bottom_bc = bottom_bc;

	for(int i=0;i<3;i++) {
		for(int j=0;j<2;j++) {
			root->bc[i][j] = bc[i][j];
		}
	}

	root->number = blocknumber;
		
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xf8, %rsp
movq %rdx, %rbx
movl %edi, %r14d
leaq -0x110(%rbp), %rdi
callq 0x4ade
movq 0x1208c(%rip), %r15     # 0x15210
decq 0x1208d(%rip)           # 0x15218
movq %r15, %rdi
callq 0x2310
movl $0x18, %esi
movq %r15, %rdi
callq 0x2200
movl $0xf8, %edi
callq 0x21f0
movq %rax, %r15
leaq -0x110(%rbp), %rsi
movq %rax, %rdi
callq 0x4916
movq %r15, %rax
addq $0x38, %rax
xorl %ecx, %ecx
movq (%rbx,%rcx,8), %rdx
xorl %esi, %esi
movl (%rdx,%rsi,4), %edi
movl %edi, (%rax,%rsi,4)
incq %rsi
cmpq $0x1, %rsi
je 0x31cb
incq %rcx
addq $0x8, %rax
cmpq $0x3, %rcx
jne 0x31c5
movl %r14d, 0x98(%r15)
leaq -0x110(%rbp), %rdi
callq 0x48e2
addq $0xf8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0xf8, %esi
movq %r15, %rdi
callq 0x2200
jmp 0x321d
movq %rax, %rbx
leaq -0x110(%rbp), %rdi
callq 0x48e2
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/suhasjains[P]AMR-Solver/src/octreegrid.cpp
// Function: myOctree::exchange_ghost_values_of_level(int)
void exchange_ghost_values_of_level(int level) {

	for(int l = 0; l<scalar_fields.size() ; l++) {
		amrsolver::exchange_ghost_val(level, scalar_fields[l]);
	}
	
	for(int l = 0; l<vector_fields.size() ; l++) {
		amrsolver::exchange_ghost_val(level, vector_fields[l]);
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edi, %ebx
leaq 0x11f03(%rip), %rcx     # 0x15628
movq (%rcx), %rax
cmpq %rax, 0x8(%rcx)
je 0x3797
movl $0x8, %r13d
leaq -0x58(%rbp), %r15
xorl %r12d, %r12d
leaq -0x68(%rbp), %r14
movq %r15, -0x68(%rbp)
movq -0x8(%rax,%r13), %rsi
movq (%rax,%r13), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x391e
movl %ebx, %edi
movq %r14, %rsi
callq 0x7394
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
je 0x3776
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2200
incq %r12
leaq 0x11ea8(%rip), %rcx     # 0x15628
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
addq $0x20, %r13
cmpq %r12, %rcx
ja 0x373f
leaq 0x11ea2(%rip), %rcx     # 0x15640
movq (%rcx), %rax
cmpq %rax, 0x8(%rcx)
je 0x3810
movl $0x8, %r13d
leaq -0x38(%rbp), %r15
xorl %r12d, %r12d
leaq -0x48(%rbp), %r14
movq %r15, -0x48(%rbp)
movq -0x8(%rax,%r13), %rsi
movq (%rax,%r13), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x391e
movl %ebx, %edi
movq %r14, %rsi
callq 0x7394
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x37ef
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2200
incq %r12
leaq 0x11e47(%rip), %rcx     # 0x15640
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
addq $0x20, %r13
cmpq %r12, %rcx
ja 0x37b8
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
jmp 0x382f
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
je 0x383f
movq (%r15), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2340