LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/huanghuide[P]SimpleNetworkTunnel/Main.cpp
// Function: ParseIpPort(char*)
void ParseIpPort(char* ipPortStr)
{
    gLog.Write("ipPortStr is %s", ipPortStr);

    if (ipPortStr != NULL)
    {
        char* pos = strchr(ipPortStr, ':');
        if (pos != NULL)
        {
            char tmp[200];
            int ipStrLen = pos - ipPortStr;

            memcpy(tmp, ipPortStr, ipStrLen);
            tmp[ipStrLen] = '\0';

            string ipAddr(tmp);            
            int port = atoi(pos + 1);

            if ((ipAddr.length() > 0) && (port > 0))
            {
                gLog.Write("gOuterDstCounter is %d, ipAddr %s, port %d", gOuterDstCounter, ipAddr.c_str(), port);
                gOuterDstIpAddrArray[gOuterDstCounter] = ipAddr;
                gOuterDstPortArray[gOuterDstCounter] = port;
                gOuterDstCounter++;
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xf0, %rsp
movq %rdi, %r14
leaq 0x738c(%rip), %rdi      # 0xae58
leaq 0x2819(%rip), %rsi      # 0x62ec
movq %r14, %rdx
xorl %eax, %eax
callq 0x3974
testq %r14, %r14
je 0x3bd2
movq %r14, %rdi
movl $0x3a, %esi
callq 0x2100
testq %rax, %rax
je 0x3bd2
movq %rax, %rbx
subl %r14d, %eax
movslq %eax, %r15
leaq -0x110(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2200
movb $0x0, -0x110(%rbp,%r15)
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
movq %r12, %rdi
callq 0x2120
leaq (%rax,%rbp), %rdx
addq $-0x110, %rdx           # imm = 0xFEF0
leaq -0x40(%rbp), %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x2a2c
incq %rbx
movq %rbx, %rdi
callq 0x2360
movl %eax, %ebx
cmpq $0x0, 0x8(%r14)
setne %al
testl %ebx, %ebx
setg %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x3bbd
leaq 0x72db(%rip), %r14      # 0xae50
movl (%r14), %edx
movq -0x40(%rbp), %rcx
leaq 0x72d5(%rip), %rdi      # 0xae58
leaq 0x2772(%rip), %rsi      # 0x62fc
movl %ebx, %r8d
xorl %eax, %eax
callq 0x3974
movslq (%r14), %rdi
shlq $0x5, %rdi
addq 0x542e(%rip), %rdi      # 0x8fd0
leaq -0x40(%rbp), %rsi
callq 0x2170
movslq (%r14), %rax
leaq 0x6f7b(%rip), %rcx      # 0xab30
movl %ebx, (%rcx,%rax,4)
incl %eax
movl %eax, (%r14)
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x3bd2
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x2290
addq $0xf0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x3bfa
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x2290
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O1/huanghuide[P]SimpleNetworkTunnel/Main.cpp
// Function: ParseParamsAndInit(int, char**)
void ParseParamsAndInit(int argc, char *argv[])
{
	int ch;
	opterr = 0;

	// Default setting
	gRoleType = SERVER;
	gInnerListenPort = BB_LISTEN_PORT;

	// Read parameters
	while ((ch = getopt(argc, argv, "r:l:o:")) != EOF)
	{
		switch (ch)
		{
		case 'r': // Role
            gLog.Write("Param (r): %s", optarg);
			if (strcmp(optarg, "client") == 0)
			{
				gRoleType = CLIENT;
			}
            else if (strcmp(optarg, "middle") == 0)
			{
				gRoleType = MIDDLE;
			}
			else
			{
				gRoleType = SERVER;
			}

			break;

		case 'l': // inner listen port
            gLog.Write("Param (l): %s", optarg);
			gInnerListenPort = atoi(optarg);
			break;

		case 'o': // outer dest IP address
            gLog.Write("Param (o): %s", optarg);
            ParseIpPort(optarg);
			break;
		}
	}

	// Init variables
	gInnerInitiator = new InnerInitiator(gInnerListenPort);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movl %edi, %r14d
movq 0x53c3(%rip), %rax      # 0x8fe0
movl $0x0, (%rax)
leaq 0x55ce(%rip), %rax      # 0x91f8
movl $0x2, (%rax)
leaq 0x55c5(%rip), %rax      # 0x91fc
movl $0x1e61, (%rax)         # imm = 0x1E61
leaq 0x26e3(%rip), %r15      # 0x6327
leaq 0x720d(%rip), %r13      # 0xae58
movl %edi, -0x2c(%rbp)
movl %r14d, %edi
movq %r12, %rsi
movq %r15, %rdx
callq 0x2090
cmpl $0x6e, %eax
jle 0x3cd6
cmpl $0x6f, %eax
je 0x3d0c
cmpl $0x72, %eax
jne 0x3c4e
movq %r12, %r14
movq %r15, %r12
movq 0x534c(%rip), %rbx      # 0x8fc8
movq (%rbx), %rdx
movq %r13, %r15
movq %r13, %rdi
leaq 0x26a2(%rip), %rsi      # 0x632e
xorl %eax, %eax
callq 0x3974
movq (%rbx), %r13
movq %r13, %rdi
leaq 0x269c(%rip), %rsi      # 0x633c
callq 0x2320
testl %eax, %eax
je 0x3d3f
movq %r13, %rdi
leaq 0x268c(%rip), %rsi      # 0x6343
callq 0x2320
testl %eax, %eax
je 0x3d4e
leaq 0x552d(%rip), %rax      # 0x91f8
movl $0x2, (%rax)
jmp 0x3d5b
cmpl $0x6c, %eax
jne 0x3d34
movq 0x52e6(%rip), %rbx      # 0x8fc8
movq (%rbx), %rdx
movq %r13, %rdi
leaq 0x265b(%rip), %rsi      # 0x634a
xorl %eax, %eax
callq 0x3974
movq (%rbx), %rdi
callq 0x2360
leaq 0x54f7(%rip), %rcx      # 0x91fc
movl %eax, (%rcx)
jmp 0x3c4e
movq 0x52b5(%rip), %rbx      # 0x8fc8
movq (%rbx), %rdx
movq %r13, %rdi
leaq 0x2638(%rip), %rsi      # 0x6358
xorl %eax, %eax
callq 0x3974
movq (%rbx), %rdi
callq 0x3ab0
jmp 0x3c4e
cmpl $-0x1, %eax
jne 0x3c4e
jmp 0x3d6d
leaq 0x54b2(%rip), %rax      # 0x91f8
movl $0x0, (%rax)
jmp 0x3d5b
leaq 0x54a3(%rip), %rax      # 0x91f8
movl $0x1, (%rax)
movq %r15, %r13
movq %r12, %r15
movq %r14, %r12
movl -0x2c(%rbp), %r14d
jmp 0x3c4e
movl $0x40, %edi
callq 0x2270
movq %rax, %rbx
leaq 0x547b(%rip), %rax      # 0x91fc
movl (%rax), %esi
movq %rbx, %rdi
callq 0x2ac8
leaq 0x7106(%rip), %rax      # 0xae98
movq %rbx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0x40, %esi
movq %rbx, %rdi
callq 0x2290
movq %r14, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O1/huanghuide[P]SimpleNetworkTunnel/OuterRunner.cpp
// Function: OuterRunner::OuterRunner(InnerRunner*)
OuterRunner::OuterRunner(InnerRunner* innerRunner) :
    Runner(OUTER_RUNNER),
    mInnerRunner(innerRunner),
    mSendStatus(INIT)
{
    mDstIpAddr = gOuterDstIpAddrArray[gOuterRunnerCounter % gOuterDstCounter];
    mDstPort = gOuterDstPortArray[gOuterRunnerCounter % gOuterDstCounter];

    gOuterRunnerCounter++;
    gOuterRunnerCounter = gOuterRunnerCounter % gOuterDstCounter;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x5, %esi
callq 0x4b4c
leaq 0x4af3(%rip), %rax      # 0x8d28
movq %rax, (%rbx)
movq %r14, 0x28(%rbx)
movl $0x0, 0x30(%rbx)
leaq 0x38(%rbx), %r14
leaq 0x48(%rbx), %r12
movq %r12, 0x38(%rbx)
movq $0x0, 0x40(%rbx)
movb $0x0, 0x48(%rbx)
leaq 0x6bf2(%rip), %r15      # 0xae54
movl (%r15), %eax
leaq 0x6be4(%rip), %r13      # 0xae50
cltd
idivl (%r13)
movslq %edx, %rsi
shlq $0x5, %rsi
addq 0x4d51(%rip), %rsi      # 0x8fd0
movq %r14, %rdi
callq 0x2170
movl (%r15), %ecx
movl (%r13), %esi
movl %ecx, %eax
cltd
idivl %esi
movslq %edx, %rax
leaq 0x6893(%rip), %rdx      # 0xab30
movl (%rdx,%rax,4), %eax
movl %eax, 0x58(%rbx)
incl %ecx
movl %ecx, %eax
cltd
idivl %esi
movl %edx, (%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq (%r14), %rdi
cmpq %r12, %rdi
je 0x42d3
movq (%r12), %rsi
incq %rsi
callq 0x2290
movq %rbx, %rdi
callq 0x4b6a
movq %r15, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O1/huanghuide[P]SimpleNetworkTunnel/OuterRunner.cpp
// Function: OuterRunner::SocketRead(int)
void OuterRunner::SocketRead(int sockFd)
{
    bool successFlag = false;
    char buf[MSG_LEN];
    int recvLen = 0;
    
    if (mSendStatus == ESTABLISHED)
    {
        while (true)
        {
            recvLen = recv(mSockFd, buf, MSG_LEN, 0);

            if (recvLen > 0)
            {
            	if ((gRoleType == MIDDLE) || (gRoleType == CLIENT))
            	{
            		for (int index = 0; index < recvLen; index++)
            		{
            			buf[index] = buf[index] ^ SIMPLE_XOR_VALUE;
            		}
            	}

                //printf("Receive from the remote server. SockFd %d, Length %d\n", mSockFd, recvLen);
                //PrintBuf(buf, recvLen);
                
                if (mInnerRunner != NULL)
                {
                    mInnerRunner->AddPendingMsg(buf, recvLen);
                }
                
                successFlag = true;

                break;
            }
            else if (recvLen == 0)
            {
                // socket is normally closed
                successFlag = false;
                
                break;
            }
            else
            {
                if ((errno == EWOULDBLOCK) || (errno == EINTR) || (errno == EINPROGRESS))
                {
                    usleep(1000);
                    continue;
                }
                else 
                {
                    gLog.Write("OuterRunner::SocketRead receive socket error! errno %d\n", errno);
                    successFlag = false;
                    
                    break;
                }
            }
        }

        if (!successFlag)
        {
            HandleError();
        }
    }  
}

// Assembly:
cmpl $0x2, 0x30(%rdi)
jne 0x4412
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x808, %rsp            # imm = 0x808
movq %rdi, %rbx
movl 0xc(%rdi), %edi
leaq -0x820(%rbp), %rsi
movl $0x800, %edx            # imm = 0x800
xorl %ecx, %ecx
callq 0x20e0
testl %eax, %eax
setg %r15b
jg 0x43c0
leaq -0x820(%rbp), %r14
testl %eax, %eax
je 0x43f7
callq 0x2040
movl (%rax), %edx
cmpl $0x4, %edx
je 0x439c
cmpl $0x73, %edx
je 0x439c
cmpl $0xb, %edx
jne 0x4413
movl $0x3e8, %edi            # imm = 0x3E8
callq 0x2330
movl 0xc(%rbx), %edi
movl $0x800, %edx            # imm = 0x800
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x20e0
testl %eax, %eax
setg %r15b
jle 0x4382
leaq 0x4e31(%rip), %rcx      # 0x91f8
cmpl $0x1, (%rcx)
ja 0x43e0
movl %eax, %ecx
xorl %edx, %edx
xorb $-0x5b, -0x820(%rbp,%rdx)
incq %rdx
cmpq %rdx, %rcx
jne 0x43d0
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x43f7
leaq -0x820(%rbp), %rsi
movl %eax, %edx
callq 0x348e
testb $0x1, %r15b
jne 0x4405
movq %rbx, %rdi
callq 0x442a
addq $0x808, %rsp            # imm = 0x808
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6a3e(%rip), %rdi      # 0xae58
leaq 0x1fad(%rip), %rsi      # 0x63ce
xorl %eax, %eax
callq 0x3974
jmp 0x43f7
// File: /workspace/github_cpp_makefile_star2_O1/huanghuide[P]SimpleNetworkTunnel/OuterRunner.cpp
// Function: OuterRunner::HandleError()
void OuterRunner::HandleError()
{
    if (mSockFd > 0)
    {
        //printf("OuterRunner Error! sockFd %d, errno %d\n", mSockFd, errno);
        CloseSockFd(mSockFd);
        mSockFd = 0;
    }
    
    if (mInnerRunner != NULL)
    {
        mInnerRunner->HandleError();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0xc(%rdi), %edi
testl %edi, %edi
jle 0x4446
callq 0x27cf
movl $0x0, 0xc(%rbx)
movq 0x28(%rbx), %rdi
addq $0x8, %rsp
testq %rdi, %rdi
je 0x445a
popq %rbx
popq %rbp
jmp 0x350c
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/huanghuide[P]SimpleNetworkTunnel/OuterRunner.cpp
// Function: OuterRunner::ProcessConnectingStatus()
void OuterRunner::ProcessConnectingStatus()
{
    if (mSockFd > 0)
    {
        struct sockaddr_in addr;
        
        bzero(&addr, sizeof(addr));
        addr.sin_family = AF_INET;
        addr.sin_port = htons(mDstPort);
        addr.sin_addr.s_addr = inet_addr(mDstIpAddr.c_str());

        int retConn = connect(mSockFd, (sockaddr*)&addr, sizeof(addr));
        
        if (retConn != 0)
        {
            if ((errno == EINPROGRESS) || (errno == EALREADY))
            {
                mSendStatus = CONNECTING;
            }
            else if (errno == EISCONN)
            {
                ProcessEstablishedStatus();
                mSendStatus = ESTABLISHED;
            }
            else
            {
                gLog.Write("OuterRunner::ProcessConnectingStatus: errno %d\n", errno);
                HandleError();                
            }
        }
        else
        {
            ProcessEstablishedStatus();
            mSendStatus = ESTABLISHED;
        }
    }
}

// Assembly:
cmpl $0x0, 0xc(%rdi)
jle 0x451e
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq -0x20(%rbp), %r14
movaps %xmm0, (%r14)
movw $0x2, (%r14)
movzwl 0x58(%rdi), %eax
rolw $0x8, %ax
movw %ax, 0x2(%r14)
movq 0x38(%rdi), %rdi
callq 0x2280
movl %eax, 0x4(%r14)
movl 0xc(%rbx), %edi
movq %r14, %rsi
movl $0x10, %edx
callq 0x2210
testl %eax, %eax
je 0x44e8
callq 0x2040
movl (%rax), %edx
leal -0x72(%rdx), %eax
cmpl $0x2, %eax
jae 0x44e3
movl $0x1, 0x30(%rbx)
jmp 0x4516
cmpl $0x6a, %edx
jne 0x44f9
movq %rbx, %rdi
callq 0x4a7c
movl $0x2, 0x30(%rbx)
jmp 0x4516
leaq 0x6958(%rip), %rdi      # 0xae58
leaq 0x1eff(%rip), %rsi      # 0x6406
xorl %eax, %eax
callq 0x3974
movq %rbx, %rdi
callq 0x442a
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/huanghuide[P]SimpleNetworkTunnel/OuterRunner.cpp
// Function: OuterRunner::SendPendingMsg()
void OuterRunner::SendPendingMsg()
{
    if (mSendStatus == INIT)
    {
        ProcessInitStatus();
    }
    else if (mSendStatus == ESTABLISHED)
    {
        for (int index = 0; index < mSendMsg.size(); index++)
        {
        	char* msgPos = ((char*)(mSendMsg[index].c_str()));
        	int msgLen = mSendMsg[index].length();

        	char* msgBuf = new char[msgLen + 1];

        	memset(msgBuf, 0, msgLen + 1);
        	memcpy(msgBuf, msgPos, msgLen);

            //printf("Sending message to the remote server. SockFd %d, msgLen %d\n", mSockFd, msgLen);
            //PrintBuf(msgBuf, msgLen);

        	if ((gRoleType == MIDDLE) || (gRoleType == CLIENT))
        	{
        		for (int index = 0; index < msgLen; index++)
        		{
        			msgBuf[index] = msgBuf[index] ^ SIMPLE_XOR_VALUE;
        		}
        	}

            int sendBytes = SockSendPacket(mSockFd, msgBuf, msgLen);
                        
            if (sendBytes != mSendMsg[index].length())
            {
            	delete [] msgBuf;
                HandleError();

                return;
            }

            delete [] msgBuf;
        }

        mSendMsg.clear();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r13
movl 0x30(%rdi), %eax
testl %eax, %eax
je 0x4619
cmpl $0x2, %eax
jne 0x463d
movq 0x10(%r13), %rax
cmpq %rax, 0x18(%r13)
setne %cl
je 0x464c
xorl %r12d, %r12d
movq %r13, -0x38(%rbp)
movb %cl, -0x29(%rbp)
movq %r12, %rbx
shlq $0x5, %rbx
movq (%rax,%rbx), %rcx
movq %rcx, -0x40(%rbp)
movq 0x8(%rax,%rbx), %r14
leal 0x1(%r14), %eax
movslq %eax, %r13
movq %r13, %rdi
callq 0x2030
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x2180
movslq %r14d, %rdx
movq %r15, %rdi
movq -0x40(%rbp), %rsi
callq 0x2200
leaq 0x4c4c(%rip), %rax      # 0x91f8
cmpl $0x1, (%rax)
ja 0x45cd
testl %r14d, %r14d
jle 0x45cd
movl %r14d, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
xorb $-0x5b, (%r15,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0x45c0
movq -0x38(%rbp), %r13
movl 0xc(%r13), %edi
movq %r15, %rsi
movl %r14d, %edx
callq 0x27fe
movslq %eax, %r14
movq 0x10(%r13), %rax
movq 0x8(%rax,%rbx), %rbx
movq %r15, %rdi
callq 0x2310
cmpq %r14, %rbx
jne 0x462f
incq %r12
movq 0x10(%r13), %rax
movq 0x18(%r13), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
cmpq %r12, %rcx
seta %cl
ja 0x4560
jmp 0x464c
movq %r13, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x46e8
movq %r13, %rdi
callq 0x442a
testb $0x1, -0x29(%rbp)
je 0x464c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq $0x10, %r13
movq (%r13), %rsi
movq %r13, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3870
// File: /workspace/github_cpp_makefile_star2_O1/huanghuide[P]SimpleNetworkTunnel/OuterRunner.cpp
// Function: OuterRunner::ProcessEstablishedStatus()
void OuterRunner::ProcessEstablishedStatus()
{
    if (mSockFd > 0)
    {
        // Set as block socket
        int flags = fcntl(mSockFd, F_GETFL, 0);
        int ret = fcntl(mSockFd, F_SETFL, flags & ~O_NONBLOCK);

        if (ret != 0)
        {
            gLog.Write("OuterRunner::ProcessEstablishedStatus: Set socket block failed!\n");
            HandleError();
        }
        else
        {        
            AddSockFdIntoSet(mSockFd);
        }

        SendPendingMsg();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl 0xc(%rdi), %edi
testl %edi, %edi
jle 0x4b1f
movl $0x3, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x2190
movl 0xc(%rbx), %edi
andl $0xfffff7ff, %eax       # imm = 0xFFFFF7FF
movl $0x4, %esi
movl %eax, %edx
xorl %eax, %eax
callq 0x2190
testl %eax, %eax
je 0x4b0f
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x1968(%rip), %rsi      # 0x6436
leaq 0x19a1(%rip), %rdx      # 0x6476
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x2a2c
leaq 0x6370(%rip), %rdi      # 0xae58
movq %r14, %rsi
callq 0x38c4
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x4b05
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2290
movq %rbx, %rdi
callq 0x442a
jmp 0x4b17
movl 0xc(%rbx), %edi
callq 0x270d
movq %rbx, %rdi
callq 0x4520
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x4b42
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2290
movq %rbx, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O1/huanghuide[P]SimpleNetworkTunnel/RunnerManager.cpp
// Function: RunnerManager::FindRunnerByFd(int)
Runner* RunnerManager::FindRunnerByFd(int sockFd)
{
    Runner* ret = NULL;
    
    map<int, Runner*>::iterator iter = mSockRunnerMap.find(sockFd);

    if ((iter != mSockRunnerMap.end()) && (iter->second != NULL))
    {
        ret = iter->second;
    }

    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x18(%rdi), %rcx
addq $0x10, %rdi
movq %rdi, %rax
testq %rcx, %rcx
je 0x4cd3
movq %rdi, %rax
xorl %edx, %edx
cmpl %esi, 0x20(%rcx)
setl %dl
cmovgeq %rcx, %rax
movq 0x10(%rcx,%rdx,8), %rcx
testq %rcx, %rcx
jne 0x4cbd
movq %rdi, %rcx
cmpq %rdi, %rax
je 0x4ce5
cmpl %esi, 0x20(%rax)
cmovgq %rdi, %rax
movq %rax, %rcx
cmpq %rdi, %rcx
je 0x4cf0
movq 0x28(%rcx), %rax
jmp 0x4cf2
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/huanghuide[P]SimpleNetworkTunnel/RunnerManager.cpp
// Function: RunnerManager::RunnerTimeout()
void RunnerManager::RunnerTimeout()
{
    //printf("RunnerTimeout: current time is %d\n", time(NULL));

    std::set<int> keySet;
    std::set<int>::iterator keySetIter;

    std::map<int, Runner*>::iterator mapIter = mSockRunnerMap.begin();
    while (mapIter != mSockRunnerMap.end())
    {
        keySet.insert(mapIter->first);
        //printf("RunnerTimeout: key is %d\n", mapIter->first);
    
        mapIter++;
    }

    keySetIter = keySet.begin();
    while (keySetIter != keySet.end())
    {
        mapIter = mSockRunnerMap.find(*keySetIter);
        if ((mapIter != mSockRunnerMap.end()) && (mapIter->second != NULL))
        {
            Runner* pRunner = mapIter->second;
            //printf("RunnerTimeout: key is %d, value is %p\n", mapIter->first, mapIter->second);
            
            pRunner->SocketTimeout();
        }
        
        keySetIter++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq -0x50(%rbp), %r12
movl $0x0, (%r12)
xorl %eax, %eax
movq %rax, 0x8(%r12)
movq %r12, 0x10(%r12)
movq %r12, 0x18(%r12)
movq %rax, 0x20(%r12)
movq 0x20(%rdi), %r14
leaq 0x10(%rdi), %r13
cmpq %r13, %r14
je 0x4d57
leaq -0x58(%rbp), %r15
leaq 0x20(%r14), %rsi
movq %r15, %rdi
callq 0x5208
movq %r14, %rdi
callq 0x21c0
movq %rax, %r14
cmpq %r13, %rax
jne 0x4d3b
movq -0x40(%rbp), %r14
cmpq %r12, %r14
je 0x4dc4
movq 0x18(%rbx), %rcx
movq %r13, %rax
testq %rcx, %rcx
je 0x4d8a
movl 0x20(%r14), %edx
movq %r13, %rax
xorl %esi, %esi
cmpl %edx, 0x20(%rcx)
setl %sil
cmovgeq %rcx, %rax
movq 0x10(%rcx,%rsi,8), %rcx
testq %rcx, %rcx
jne 0x4d73
movq %r13, %rcx
cmpq %r13, %rax
je 0x4da0
movl 0x20(%r14), %ecx
cmpl 0x20(%rax), %ecx
cmovlq %r13, %rax
movq %rax, %rcx
cmpq %r13, %rcx
je 0x4db4
movq 0x28(%rcx), %rdi
testq %rdi, %rdi
je 0x4db4
movq (%rdi), %rax
callq *0x20(%rax)
movq %r14, %rdi
callq 0x22d0
movq %rax, %r14
cmpq %r12, %rax
jne 0x4d60
leaq -0x58(%rbp), %rdi
callq 0x4e5a
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4dde
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x4e5a
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O1/onai[P]npio/example3.cc
// Function: main
int main()
{
  auto a = npio::Array("test2.npy");
  for (auto &v : a.values<float>())
    v += 10.0f;
  a.save("example3-out.npy");
}

// Assembly:
pushq %rbx
subq $0x90, %rsp
leaq 0x1d65(%rip), %rsi      # 0x3040
leaq 0x8(%rsp), %rbx
movl $0x20, %edx
movq %rbx, %rdi
callq 0x19c0
movq %rbx, %rdi
callq 0x1db0
cmpq %rdx, %rax
je 0x1317
movss 0x1d02(%rip), %xmm0     # 0x3004
movss (%rax), %xmm1
addss %xmm0, %xmm1
movss %xmm1, (%rax)
addq $0x4, %rax
cmpq %rdx, %rax
jne 0x1302
leaq 0x1d2c(%rip), %rsi      # 0x304a
leaq 0x8(%rsp), %rdi
callq 0x1dfe
leaq 0x8(%rsp), %rdi
callq 0x2072
xorl %eax, %eax
addq $0x90, %rsp
popq %rbx
retq
jmp 0x133f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2072
movq %rbx, %rdi
callq 0x1190
// File: /workspace/github_cpp_makefile_star2_O1/t0mm4rx[P]piscine_cpp/day00/ex01/nul.cpp
// Function: main
int main()
{
	Contact contacts[8];
	int current_index = 0;
	print_header();
	print_helper();
	listen_user(contacts, &current_index);
	return (0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xb10, %rsp            # imm = 0xB10
xorl %r14d, %r14d
leaq (%rsp,%r14), %rdi
addq $0x10, %rdi
callq 0x4394
addq $0x160, %r14            # imm = 0x160
cmpq $0xb00, %r14            # imm = 0xB00
jne 0x23bb
movl $0x0, 0xc(%rsp)
callq 0x247a
callq 0x28c8
leaq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x2bf8
movl $0x9a0, %ebx            # imm = 0x9A0
movq $-0x160, %r14           # imm = 0xFEA0
leaq (%rsp,%rbx), %rdi
addq $0x10, %rdi
callq 0x4490
addq %r14, %rbx
cmpq %r14, %rbx
jne 0x2405
xorl %eax, %eax
addq $0xb10, %rsp            # imm = 0xB10
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x9a0, %r14d           # imm = 0x9A0
movq $-0x160, %r15           # imm = 0xFEA0
leaq (%rsp,%r14), %rdi
addq $0x10, %rdi
callq 0x4490
addq %r15, %r14
cmpq %r15, %r14
jne 0x2439
jmp 0x2472
movq %rax, %rbx
testq %r14, %r14
je 0x2472
leaq -0x150(%rsp), %r15
leaq (%r15,%r14), %rdi
callq 0x4490
addq $-0x160, %r14           # imm = 0xFEA0
jne 0x2460
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O1/t0mm4rx[P]piscine_cpp/day00/ex01/commands.cpp
// Function: handle_command(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Contact*, int*)
void handle_command(std::string cmd, Contact contacts[8], int *index)
{
	if (to_upper(cmd) == "EXIT")
		exit(0);
	else if (to_upper(cmd) == "ADD")
		add(contacts, index);
	else if (to_upper(cmd) == "SEARCH")
		search(contacts, index);
	else if (cmd != "")
		std::cout << "Not a valid command!" << std::endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, %r15
leaq 0x88(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
addq %rsi, %rdx
leaq 0x78(%rsp), %r12
movq %r12, %rdi
callq 0x4304
leaq 0x18(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x2f15
leaq 0x23f8(%rip), %rsi      # 0x514e
movq %r13, %rdi
callq 0x2060
movl %eax, %ebp
movq (%r13), %rdi
leaq 0x28(%rsp), %rbx
cmpq %rbx, %rdi
je 0x2d7b
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x2100
movq 0x78(%rsp), %rdi
cmpq %r14, %rdi
je 0x2d95
movq 0x88(%rsp), %rsi
incq %rsi
callq 0x2100
testl %ebp, %ebp
je 0x2f0e
leaq 0x68(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x58(%rsp), %r12
movq %r12, %rdi
callq 0x4304
leaq 0x18(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x2f15
leaq 0x2319(%rip), %rsi      # 0x50ed
movq %r13, %rdi
callq 0x2060
movl %eax, %ebp
movq (%r13), %rdi
cmpq %rbx, %rdi
je 0x2df4
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x2100
movq 0x58(%rsp), %rdi
cmpq %r14, %rdi
je 0x2e0b
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x2100
testl %ebp, %ebp
je 0x2edc
leaq 0x48(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x38(%rsp), %r12
movq %r12, %rdi
callq 0x4304
leaq 0x18(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x2f15
leaq 0x22cb(%rip), %rsi      # 0x5115
movq %r13, %rdi
callq 0x2060
movl %eax, %ebp
movq (%r13), %rdi
cmpq %rbx, %rdi
je 0x2e6a
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x2100
movq 0x38(%rsp), %rdi
cmpq %r14, %rdi
je 0x2e81
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x2100
testl %ebp, %ebp
je 0x2eed
leaq 0x21cc(%rip), %rsi      # 0x5058
movq %r15, %rdi
callq 0x2060
testl %eax, %eax
je 0x2efc
movq 0x4131(%rip), %rbx      # 0x6fd0
leaq 0x2300(%rip), %rsi      # 0x51a6
movl $0x14, %edx
movq %rbx, %rdi
callq 0x2120
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20b0
jmp 0x2efc
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x2f9c
jmp 0x2efc
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x3a78
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %edi, %edi
callq 0x2130
// File: /workspace/github_cpp_makefile_star2_O1/t0mm4rx[P]piscine_cpp/day00/ex01/commands.cpp
// Function: to_upper(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string to_upper(std::string str)
{
	int str_len = str.length();

	for (int i = 0; i < str_len; i++)
		str[i] = std::toupper(str[i]);
	return str;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %r15
testl %r15d, %r15d
jle 0x2f52
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
xorl %r12d, %r12d
movq (%r14), %r13
movsbl (%r13,%r12), %edi
callq 0x2210
movb %al, (%r13,%r12)
incq %r12
cmpq %r12, %r15
jne 0x2f37
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%r14), %rdx
leaq 0x10(%r14), %rax
cmpq %rax, %rdx
je 0x2f71
movq %rdx, (%rbx)
movq (%rax), %rcx
movq %rcx, 0x10(%rbx)
jmp 0x2f77
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rbx)
movq %rax, (%r14)
movq $0x0, 0x8(%r14)
movb $0x0, 0x10(%r14)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/dustin[P]kvtest/sqlite3-test.cc
// Function: main
int main(int argc, char **args) {
    const char *env_path = getenv("SQLITE_TEST_DB");
    Sqlite3 sq(env_path ? env_path : "/tmp/test.db",
               getenv("KVSTORE_AUDITABLE"));
    TestSuite suite(&sq);
    return suite.run() ? 0 : 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
leaq 0x5908(%rip), %rdi      # 0x9004
callq 0x3320
testq %rax, %rax
leaq 0x5908(%rip), %rbx      # 0x9013
cmovneq %rax, %rbx
leaq 0x590a(%rip), %rdi      # 0x9020
callq 0x3320
movq %rax, %r14
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3a8a
leaq 0xa2e3(%rip), %rax      # 0xda18
addq $0x10, %rax
testq %r14, %r14
movq %rax, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r15)
movq $0x0, 0x30(%r15)
setne 0x19(%r15)
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x6040
leaq 0x8(%rsp), %rdi
callq 0x6242
xorb $0x1, %al
movzbl %al, %ebx
leaq 0x8(%rsp), %rdi
callq 0x61c2
leaq 0x28(%rsp), %rdi
callq 0x4176
movl %ebx, %eax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x61c2
jmp 0x37a2
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x4176
movq %rbx, %rdi
callq 0x3440
// File: /workspace/github_cpp_makefile_star2_O1/dustin[P]kvtest/sqlite-base.cc
// Function: kvtest::PreparedStatement::PreparedStatement(sqlite3*, char const*)
PreparedStatement::PreparedStatement(sqlite3 *d, const char *query) {
        db = d;
        if(sqlite3_prepare_v2(db, query, (int)strlen(query), &st, NULL)
           != SQLITE_OK) {
            throw std::runtime_error(sqlite3_errmsg(db));
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, (%rdi)
movq %rdx, %rdi
callq 0x30e0
leaq 0x8(%rbx), %rcx
movq %r15, %rdi
movq %r14, %rsi
movl %eax, %edx
xorl %r8d, %r8d
callq 0x3270
testl %eax, %eax
jne 0x37eb
popq %rbx
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x3100
movq %rax, %r14
movq (%rbx), %rdi
callq 0x3290
movq %r14, %rdi
movq %rax, %rsi
callq 0x30c0
movq 0xa7de(%rip), %rsi      # 0xdff0
movq 0xa79f(%rip), %rdx      # 0xdfb8
movq %r14, %rdi
callq 0x3410
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
movq %rbx, %rdi
callq 0x3440
// File: /workspace/github_cpp_makefile_star2_O1/dustin[P]kvtest/sqlite-base.cc
// Function: kvtest::PreparedStatement::execute()
int PreparedStatement::execute() {
        int steps_run = 0, rc = 0;
        while ((rc = sqlite3_step(st)) != SQLITE_DONE) {
            steps_run++;
            assert(steps_run < MAX_STEPS);
            if (rc == SQLITE_ROW) {
                // This is rather normal
            } else if (rc == SQLITE_BUSY) {
                std::cerr << "SQLITE_BUSY (retrying)" << std::endl;
            } else {
                const char *msg = sqlite3_errmsg(db);
                std::cerr << "sqlite error:  " << msg << std::endl;
                assert(false);
            }
        }
        return sqlite3_changes(db);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x3350
cmpl $0x65, %eax
je 0x38f2
movl $0x2710, %ebp           # imm = 0x2710
movq 0xa750(%rip), %r14      # 0xdfe8
leaq 0x57e1(%rip), %r15      # 0x9080
decl %ebp
je 0x3904
cmpl $0x64, %eax
je 0x38e4
cmpl $0x5, %eax
jne 0x3923
movl $0x16, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x32e0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3280
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3190
movq 0x8(%rbx), %rdi
callq 0x3350
cmpl $0x65, %eax
jne 0x389f
movq (%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x32d0
leaq 0x5727(%rip), %rdi      # 0x9032
leaq 0x5736(%rip), %rsi      # 0x9048
leaq 0x573e(%rip), %rcx      # 0x9057
movl $0x1d, %edx
callq 0x3160
movq (%rbx), %rdi
callq 0x3290
movq %rax, %rbx
movq 0xa6b3(%rip), %rdi      # 0xdfe8
leaq 0x575b(%rip), %rsi      # 0x9097
callq 0x32a0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x32a0
movq %rax, %rdi
callq 0x30f0
leaq 0x574c(%rip), %rdi      # 0x90a7
leaq 0x56e6(%rip), %rsi      # 0x9048
leaq 0x56ee(%rip), %rcx      # 0x9057
movl $0x25, %edx
callq 0x3160
nop
// File: /workspace/github_cpp_makefile_star2_O1/dustin[P]kvtest/sqlite-base.cc
// Function: kvtest::PreparedStatement::fetch()
bool PreparedStatement::fetch() {
        bool rv = true;
        assert(st);
        switch(sqlite3_step(st)) {
        case SQLITE_BUSY:
            throw std::runtime_error("DB was busy.");
            break;
        case SQLITE_ROW:
            break;
        case SQLITE_DONE:
            rv = false;
            break;
        default:
            throw std::runtime_error("Unhandled case.");
        }
        return rv;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x399e
callq 0x3350
movb $0x1, %cl
cmpl $0x64, %eax
je 0x3994
cmpl $0x65, %eax
jne 0x39bd
xorl %ecx, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x5cdc(%rip), %rdi      # 0x9681
leaq 0x569c(%rip), %rsi      # 0x9048
leaq 0x56fa(%rip), %rcx      # 0x90ad
movl $0x2d, %edx
callq 0x3160
movl $0x10, %edi
cmpl $0x5, %eax
jne 0x39e0
callq 0x3100
movq %rax, %rbx
leaq 0x56ff(%rip), %rsi      # 0x90d5
movq %rax, %rdi
callq 0x30c0
jmp 0x39f7
callq 0x3100
movq %rax, %rbx
leaq 0x56f3(%rip), %rsi      # 0x90e2
movq %rax, %rdi
callq 0x30c0
movq 0xa5f2(%rip), %rsi      # 0xdff0
movq 0xa5b3(%rip), %rdx      # 0xdfb8
movq %rbx, %rdi
callq 0x3410
jmp 0x3a0f
movq %rax, %r14
movq %rbx, %rdi
callq 0x31c0
movq %r14, %rdi
callq 0x3440
// File: /workspace/github_cpp_makefile_star2_O1/dustin[P]kvtest/sqlite-base.cc
// Function: kvtest::BaseSqlite3::open()
void BaseSqlite3::open() {
        if(!db) {
            if(sqlite3_open(filename, &db) !=  SQLITE_OK) {
                throw std::runtime_error("Error initializing sqlite3");
            }

            if(sqlite3_extended_result_codes(db, 1) != SQLITE_OK) {
                throw std::runtime_error("Error enabling extended RCs");
            }

            intransaction = false;
            initTables();
            initStatements();
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x8(%rdi)
je 0x3ab9
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq 0x10(%rdi), %rdi
movq %r14, %rsi
callq 0x3430
testl %eax, %eax
jne 0x3afe
movq (%r14), %rdi
movl $0x1, %esi
callq 0x3180
testl %eax, %eax
jne 0x3b1c
movb $0x0, 0x18(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x68(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x58(%rax)
movl $0x10, %edi
callq 0x3100
movq %rax, %rbx
leaq 0x55fb(%rip), %rsi      # 0x910d
movq %rax, %rdi
callq 0x30c0
jmp 0x3b38
movl $0x10, %edi
callq 0x3100
movq %rax, %rbx
leaq 0x55f8(%rip), %rsi      # 0x9128
movq %rax, %rdi
callq 0x30c0
movq 0xa4b1(%rip), %rsi      # 0xdff0
movq 0xa472(%rip), %rdx      # 0xdfb8
movq %rbx, %rdi
callq 0x3410
jmp 0x3b50
movq %rax, %r14
movq %rbx, %rdi
callq 0x31c0
movq %r14, %rdi
callq 0x3440
nop
// File: /workspace/github_cpp_makefile_star2_O1/dustin[P]kvtest/sqlite-base.cc
// Function: kvtest::BaseSqlite3::close()
void BaseSqlite3::close() {
        if(db) {
            intransaction = false;
            destroyStatements();
            sqlite3_close(db);
            db = NULL;
        }
    }

// Assembly:
cmpq $0x0, 0x8(%rdi)
je 0x3b8b
pushq %rbx
movq %rdi, %rbx
movb $0x0, 0x18(%rdi)
movq (%rdi), %rax
callq *0x60(%rax)
movq 0x8(%rbx), %rdi
callq 0x3110
movq $0x0, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/dustin[P]kvtest/sqlite-base.cc
// Function: kvtest::BaseSqlite3::reset()
void BaseSqlite3::reset() {
        if(db) {
            rollback();
            close();
            open();
            destroyTables();
            initTables();
            execute("vacuum");
        }
    }

// Assembly:
cmpq $0x0, 0x8(%rdi)
je 0x3bd1
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x50(%rax)
movq %rbx, %rdi
callq 0x3b64
movq %rbx, %rdi
callq 0x3aa6
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x70(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x68(%rax)
leaq 0x557c(%rip), %rsi      # 0x9144
movq %rbx, %rdi
popq %rbx
jmp 0x3bd2
retq
// File: /workspace/github_cpp_makefile_star2_O1/dustin[P]kvtest/sqlite-base.cc
// Function: kvtest::Sqlite3::destroyStatements()
void Sqlite3::destroyStatements() {
        delete ins_stmt;
        delete sel_stmt;
        delete del_stmt;
        ins_stmt = sel_stmt = del_stmt = NULL;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %r14
testq %r14, %r14
je 0x3d2a
movq 0x8(%r14), %rdi
callq 0x3400
movl $0x10, %esi
movq %r14, %rdi
callq 0x32c0
movq 0x28(%rbx), %r14
testq %r14, %r14
je 0x3d49
movq 0x8(%r14), %rdi
callq 0x3400
movl $0x10, %esi
movq %r14, %rdi
callq 0x32c0
movq 0x30(%rbx), %r14
testq %r14, %r14
je 0x3d68
movq 0x8(%r14), %rdi
callq 0x3400
movl $0x10, %esi
movq %r14, %rdi
callq 0x32c0
addq $0x20, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x3d86
jmp 0x3d86
movq %rax, %rdi
callq 0x4190
// File: /workspace/github_cpp_makefile_star2_O1/dustin[P]kvtest/sqlite-base.cc
// Function: kvtest::Sqlite3::destroyTables()
void Sqlite3::destroyTables() {
        execute("drop table if exists kv");
        execute("drop table if exists history");
        execute("drop trigger if exists on_audit_insert");
        execute("drop trigger if exists on_audit_delete");
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x55f2(%rip), %rsi      # 0x93d1
callq 0x3bd2
leaq 0x55fe(%rip), %rsi      # 0x93e9
movq %rbx, %rdi
callq 0x3bd2
leaq 0x560c(%rip), %rsi      # 0x9406
movq %rbx, %rdi
callq 0x3bd2
leaq 0x5624(%rip), %rsi      # 0x942d
movq %rbx, %rdi
popq %rbx
jmp 0x3bd2
// File: /workspace/github_cpp_makefile_star2_O1/dustin[P]kvtest/sqlite-base.cc
// Function: kvtest::Sqlite3::set(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char const*, kvtest::Callback<bool>&)
void Sqlite3::set(std::string &key, const char *val,
                      kvtest::Callback<bool> &cb) {
        ins_stmt->bind(1, key.c_str());
        ins_stmt->bind(2, val);
        bool rv = ins_stmt->execute() == 1;
        cb.callback(rv);
        ins_stmt->reset();
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
movq 0x20(%rdi), %rax
movq (%rsi), %r12
movq 0x8(%rax), %r13
movq %r12, %rdi
callq 0x30e0
movq %r13, %rdi
movl $0x1, %esi
movq %r12, %rdx
movl %eax, %ecx
xorl %r8d, %r8d
callq 0x3220
movq 0x20(%rbx), %rax
movq 0x8(%rax), %r12
movq %r15, %rdi
callq 0x30e0
movq %r12, %rdi
movl $0x2, %esi
movq %r15, %rdx
movl %eax, %ecx
xorl %r8d, %r8d
callq 0x3220
movq 0x20(%rbx), %rdi
callq 0x3874
cmpl $0x1, %eax
leaq 0xf(%rsp), %rsi
sete (%rsi)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq 0x20(%rbx), %rdi
callq 0x3a2c
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/dustin[P]kvtest/sqlite-base.cc
// Function: kvtest::Sqlite3::del(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, kvtest::Callback<bool>&)
void Sqlite3::del(std::string &key, kvtest::Callback<bool> &cb) {
        del_stmt->bind(1, key.c_str());
        bool rv = del_stmt->execute() == 1;
        cb.callback(rv);
        del_stmt->reset();
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movq (%rsi), %r15
movq 0x8(%rax), %r12
movq %r15, %rdi
callq 0x30e0
movq %r12, %rdi
movl $0x1, %esi
movq %r15, %rdx
movl %eax, %ecx
xorl %r8d, %r8d
callq 0x3220
movq 0x30(%rbx), %rdi
callq 0x3874
cmpl $0x1, %eax
leaq 0x7(%rsp), %rsi
sete (%rsi)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq 0x30(%rbx), %rdi
callq 0x3a2c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/ghallak[P]regex-to-dfa/src/RegexTree.cpp
// Function: RegexTree::CalcFollowPos(RegexTree::Node*)
void RegexTree::CalcFollowPos(RegexTree::Node* n) {
  if (auto node = dynamic_cast<RegexTree::UnionNode*>(n)) {
    CalcFollowPos(node->left.get());
    CalcFollowPos(node->right.get());
  } else if (auto node = dynamic_cast<RegexTree::ConcatNode*>(n)) {
    for (auto i : node->left->lastpos) {
      leaves[i]->followpos.insert(node->right->firstpos.cbegin(),
                                  node->right->firstpos.cend());
    }
    CalcFollowPos(node->left.get());
    CalcFollowPos(node->right.get());
  } else if (auto node = dynamic_cast<RegexTree::StarNode*>(n)) {
    for (auto i : node->lastpos) {
      leaves[i]->followpos.insert(node->firstpos.cbegin(),
                                  node->firstpos.cend());
    }
    CalcFollowPos(node->child.get());
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %rbx
testq %rsi, %rsi
je 0x4ef1
leaq 0x4da5(%rip), %rsi      # 0x9c80
leaq 0x4dc6(%rip), %rdx      # 0x9ca8
movq %r15, %rdi
xorl %ecx, %ecx
callq 0x2120
movq %rax, %r14
jmp 0x4ef4
xorl %r14d, %r14d
testq %r14, %r14
je 0x4f29
movq 0x80(%r14), %rsi
movq %rbx, %rdi
callq 0x4eb8
addq $0x88, %r14
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x4eb8
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testq %r15, %r15
je 0x4f4b
leaq 0x4d4b(%rip), %rsi      # 0x9c80
leaq 0x4d54(%rip), %rdx      # 0x9c90
movq %r15, %rdi
xorl %ecx, %ecx
callq 0x2120
movq %rax, %r14
jmp 0x4f4e
xorl %r14d, %r14d
testq %r14, %r14
movq %rbx, -0x38(%rbp)
je 0x4fb4
movq 0x80(%r14), %rax
movq 0x50(%rax), %r13
testq %r13, %r13
je 0x4ef9
leaq -0x30(%rbp), %r15
movq 0x8(%r13), %rax
movq (%rbx), %rcx
movq (%rcx,%rax,8), %r12
subq $-0x80, %r12
movq 0x88(%r14), %rax
movq 0x18(%rax), %rbx
movq %r12, -0x30(%rbp)
testq %rbx, %rbx
je 0x4fa2
leaq 0x8(%rbx), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x39ee
movq (%rbx), %rbx
jmp 0x4f89
movq (%r13), %r13
testq %r13, %r13
movq -0x38(%rbp), %rbx
jne 0x4f6b
jmp 0x4ef9
testq %r15, %r15
je 0x4fd6
leaq 0x4cc0(%rip), %rsi      # 0x9c80
leaq 0x4cf9(%rip), %rdx      # 0x9cc0
movq %r15, %rdi
xorl %ecx, %ecx
callq 0x2120
movq %rax, %r14
jmp 0x4fd9
xorl %r14d, %r14d
testq %r14, %r14
je 0x4f1a
movq 0x50(%r14), %r13
testq %r13, %r13
je 0x502c
leaq -0x30(%rbp), %r15
movq 0x8(%r13), %rax
movq (%rbx), %rcx
movq (%rcx,%rax,8), %r12
subq $-0x80, %r12
movq 0x18(%r14), %rbx
movq %r12, -0x30(%rbp)
testq %rbx, %rbx
je 0x501f
leaq 0x8(%rbx), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x39ee
movq (%rbx), %rbx
jmp 0x5006
movq (%r13), %r13
testq %r13, %r13
movq -0x38(%rbp), %rbx
jne 0x4fef
subq $-0x80, %r14
jmp 0x4f0f
nop
// File: /workspace/github_cpp_makefile_star2_O1/ghallak[P]regex-to-dfa/src/./RegexTree.h
// Function: RegexTree::UnionNode::UnionNode(std::unique_ptr<RegexTree::Node, std::default_delete<RegexTree::Node>>, std::unique_ptr<RegexTree::Node, std::default_delete<RegexTree::Node>>)
explicit UnionNode(std::unique_ptr<Node> l, std::unique_ptr<Node> r)
        : left(std::move(l)), right(std::move(r)) {
      firstpos.insert(left->firstpos.cbegin(), left->firstpos.cend());
      firstpos.insert(right->firstpos.cbegin(), right->firstpos.cend());

      lastpos.insert(left->lastpos.cbegin(), left->lastpos.cend());
      lastpos.insert(right->lastpos.cbegin(), right->lastpos.cend());

      nullable = left->nullable || right->nullable;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
leaq 0x38(%rdi), %rax
movq %rax, 0x8(%rdi)
movl $0x1, %eax
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movl $0x3f800000, %ecx       # imm = 0x3F800000
movl %ecx, 0x28(%rdi)
movups %xmm0, 0x30(%rdi)
leaq 0x40(%rdi), %r15
leaq 0x70(%rdi), %rdi
movq %rdi, 0x40(%rbx)
movq %rax, 0x48(%rbx)
movups %xmm0, 0x50(%rbx)
movl %ecx, 0x60(%rbx)
movups %xmm0, 0x68(%rbx)
leaq 0x481d(%rip), %rax      # 0x9d38
movq %rax, (%rbx)
movq (%rsi), %rax
movq %rax, 0x80(%rbx)
xorl %eax, %eax
movq %rax, (%rsi)
movq (%rdx), %rcx
movq %rcx, 0x88(%rbx)
movq %rax, (%rdx)
movq 0x80(%rbx), %rax
movq 0x18(%rax), %r13
movq %r14, -0x30(%rbp)
testq %r13, %r13
je 0x556a
leaq -0x30(%rbp), %r12
leaq 0x8(%r13), %rsi
movq %r14, %rdi
movq %r12, %rdx
callq 0x39ee
movq (%r13), %r13
testq %r13, %r13
jne 0x5552
movq 0x88(%rbx), %rax
movq 0x18(%rax), %r13
movq %r14, -0x30(%rbp)
testq %r13, %r13
je 0x559a
leaq -0x30(%rbp), %r12
leaq 0x8(%r13), %rsi
movq %r14, %rdi
movq %r12, %rdx
callq 0x39ee
movq (%r13), %r13
testq %r13, %r13
jne 0x5582
movq 0x80(%rbx), %rax
movq 0x50(%rax), %r13
movq %r15, -0x30(%rbp)
testq %r13, %r13
je 0x55ca
leaq -0x30(%rbp), %r12
leaq 0x8(%r13), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x39ee
movq (%r13), %r13
testq %r13, %r13
jne 0x55b2
movq 0x88(%rbx), %rax
movq 0x50(%rax), %r13
movq %r15, -0x30(%rbp)
testq %r13, %r13
je 0x55fa
leaq -0x30(%rbp), %r12
leaq 0x8(%r13), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x39ee
movq (%r13), %r13
testq %r13, %r13
jne 0x55e2
movq 0x80(%rbx), %rcx
movb $0x1, %al
cmpb $0x0, 0x78(%rcx)
jne 0x5613
movq 0x88(%rbx), %rax
movb 0x78(%rax), %al
movb %al, 0x78(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x562b
jmp 0x562b
jmp 0x562b
movq %rax, %r12
movq 0x88(%rbx), %rdi
testq %rdi, %rdi
je 0x5640
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x88(%rbx)
movq 0x80(%rbx), %rdi
testq %rdi, %rdi
je 0x565d
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x80(%rbx)
leaq 0x4601(%rip), %rax      # 0x9c70
movq %rax, (%rbx)
movq %r15, %rdi
callq 0x354c
movq %r14, %rdi
callq 0x354c
movq %r12, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O1/ghallak[P]regex-to-dfa/src/./RegexTree.h
// Function: RegexTree::ConcatNode::ConcatNode(std::unique_ptr<RegexTree::Node, std::default_delete<RegexTree::Node>>, std::unique_ptr<RegexTree::Node, std::default_delete<RegexTree::Node>>)
explicit ConcatNode(std::unique_ptr<Node> l, std::unique_ptr<Node> r)
        : left(std::move(l)), right(std::move(r)) {
      firstpos.insert(left->firstpos.cbegin(), left->firstpos.cend());
      if (left->nullable) {
        firstpos.insert(right->firstpos.cbegin(), right->firstpos.cend());
      }

      lastpos.insert(right->lastpos.cbegin(), right->lastpos.cend());
      if (right->nullable) {
        lastpos.insert(left->lastpos.cbegin(), left->lastpos.cend());
      }

      nullable = left->nullable && right->nullable;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
leaq 0x38(%rdi), %rax
movq %rax, 0x8(%rdi)
movl $0x1, %eax
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movl $0x3f800000, %ecx       # imm = 0x3F800000
movl %ecx, 0x28(%rdi)
movups %xmm0, 0x30(%rdi)
leaq 0x40(%rdi), %r15
leaq 0x70(%rdi), %rdi
movq %rdi, 0x40(%rbx)
movq %rax, 0x48(%rbx)
movups %xmm0, 0x50(%rbx)
movl %ecx, 0x60(%rbx)
movups %xmm0, 0x68(%rbx)
leaq 0x40f3(%rip), %rax      # 0x9d78
movq %rax, (%rbx)
movq (%rsi), %rax
movq %rax, 0x80(%rbx)
xorl %eax, %eax
movq %rax, (%rsi)
movq (%rdx), %rcx
movq %rcx, 0x88(%rbx)
movq %rax, (%rdx)
movq 0x80(%rbx), %rax
movq 0x18(%rax), %r13
movq %r14, -0x30(%rbp)
testq %r13, %r13
je 0x5cd4
leaq -0x30(%rbp), %r12
leaq 0x8(%r13), %rsi
movq %r14, %rdi
movq %r12, %rdx
callq 0x39ee
movq (%r13), %r13
testq %r13, %r13
jne 0x5cbc
movq 0x80(%rbx), %rax
cmpb $0x1, 0x78(%rax)
jne 0x5d11
movq 0x88(%rbx), %rax
movq 0x18(%rax), %r13
movq %r14, -0x30(%rbp)
testq %r13, %r13
je 0x5d11
leaq -0x30(%rbp), %r12
leaq 0x8(%r13), %rsi
movq %r14, %rdi
movq %r12, %rdx
callq 0x39ee
movq (%r13), %r13
testq %r13, %r13
jne 0x5cf9
movq 0x88(%rbx), %rax
movq 0x50(%rax), %r13
movq %r15, -0x30(%rbp)
testq %r13, %r13
je 0x5d41
leaq -0x30(%rbp), %r12
leaq 0x8(%r13), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x39ee
movq (%r13), %r13
testq %r13, %r13
jne 0x5d29
movq 0x88(%rbx), %rax
cmpb $0x1, 0x78(%rax)
jne 0x5d7e
movq 0x80(%rbx), %rax
movq 0x50(%rax), %r13
movq %r15, -0x30(%rbp)
testq %r13, %r13
je 0x5d7e
leaq -0x30(%rbp), %r12
leaq 0x8(%r13), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x39ee
movq (%r13), %r13
testq %r13, %r13
jne 0x5d66
movq 0x80(%rbx), %rax
cmpb $0x1, 0x78(%rax)
jne 0x5d97
movq 0x88(%rbx), %rax
movb 0x78(%rax), %al
jmp 0x5d99
xorl %eax, %eax
movb %al, 0x78(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5db1
jmp 0x5db1
jmp 0x5db1
movq %rax, %r12
movq 0x88(%rbx), %rdi
testq %rdi, %rdi
je 0x5dc6
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x88(%rbx)
movq 0x80(%rbx), %rdi
testq %rdi, %rdi
je 0x5de3
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x80(%rbx)
leaq 0x3e7b(%rip), %rax      # 0x9c70
movq %rax, (%rbx)
movq %r15, %rdi
callq 0x354c
movq %r14, %rdi
callq 0x354c
movq %r12, %rdi
callq 0x21c0