LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x73d4(%rip), %rdi      # 0xae58
leaq 0x2861(%rip), %rsi      # 0x62ec
movq %r14, %rdx
xorl %eax, %eax
callq 0x392c
testq %r14, %r14
je 0x3b8a
movq %r14, %rdi
movl $0x3a, %esi
callq 0x2100
testq %rax, %rax
je 0x3b8a
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 0x2a2e
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 0x3b75
leaq 0x7323(%rip), %r14      # 0xae50
movl (%r14), %edx
movq -0x40(%rbp), %rcx
leaq 0x731d(%rip), %rdi      # 0xae58
leaq 0x27ba(%rip), %rsi      # 0x62fc
movl %ebx, %r8d
xorl %eax, %eax
callq 0x392c
movslq (%r14), %rdi
shlq $0x5, %rdi
addq 0x5476(%rip), %rdi      # 0x8fd0
leaq -0x40(%rbp), %rsi
callq 0x2170
movslq (%r14), %rax
leaq 0x6fc3(%rip), %rcx      # 0xab30
movl %ebx, (%rcx,%rax,4)
incl %eax
movl %eax, (%r14)
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x3b8a
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 0x3bb2
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x2290
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O3/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 0x540b(%rip), %rax      # 0x8fe0
movl $0x0, (%rax)
leaq 0x5616(%rip), %rax      # 0x91f8
movl $0x2, (%rax)
leaq 0x560d(%rip), %rax      # 0x91fc
movl $0x1e61, (%rax)         # imm = 0x1E61
leaq 0x272b(%rip), %r15      # 0x6327
leaq 0x7255(%rip), %r13      # 0xae58
movl %edi, -0x2c(%rbp)
movl %r14d, %edi
movq %r12, %rsi
movq %r15, %rdx
callq 0x2090
cmpl $0x6e, %eax
jle 0x3c8e
cmpl $0x6f, %eax
je 0x3cc4
cmpl $0x72, %eax
jne 0x3c06
movq %r12, %r14
movq %r15, %r12
movq 0x5394(%rip), %rbx      # 0x8fc8
movq (%rbx), %rdx
movq %r13, %r15
movq %r13, %rdi
leaq 0x26ea(%rip), %rsi      # 0x632e
xorl %eax, %eax
callq 0x392c
movq (%rbx), %r13
movq %r13, %rdi
leaq 0x26e4(%rip), %rsi      # 0x633c
callq 0x2320
testl %eax, %eax
je 0x3cf7
movq %r13, %rdi
leaq 0x26d4(%rip), %rsi      # 0x6343
callq 0x2320
testl %eax, %eax
je 0x3d06
leaq 0x5575(%rip), %rax      # 0x91f8
movl $0x2, (%rax)
jmp 0x3d13
cmpl $0x6c, %eax
jne 0x3cec
movq 0x532e(%rip), %rbx      # 0x8fc8
movq (%rbx), %rdx
movq %r13, %rdi
leaq 0x26a3(%rip), %rsi      # 0x634a
xorl %eax, %eax
callq 0x392c
movq (%rbx), %rdi
callq 0x2360
leaq 0x553f(%rip), %rcx      # 0x91fc
movl %eax, (%rcx)
jmp 0x3c06
movq 0x52fd(%rip), %rbx      # 0x8fc8
movq (%rbx), %rdx
movq %r13, %rdi
leaq 0x2680(%rip), %rsi      # 0x6358
xorl %eax, %eax
callq 0x392c
movq (%rbx), %rdi
callq 0x3a68
jmp 0x3c06
cmpl $-0x1, %eax
jne 0x3c06
jmp 0x3d25
leaq 0x54fa(%rip), %rax      # 0x91f8
movl $0x0, (%rax)
jmp 0x3d13
leaq 0x54eb(%rip), %rax      # 0x91f8
movl $0x1, (%rax)
movq %r15, %r13
movq %r12, %r15
movq %r14, %r12
movl -0x2c(%rbp), %r14d
jmp 0x3c06
movl $0x40, %edi
callq 0x2270
movq %rax, %rbx
leaq 0x54c3(%rip), %rax      # 0x91fc
movl (%rax), %esi
movq %rbx, %rdi
callq 0x2acc
leaq 0x714e(%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_O3/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 0x4ab8
leaq 0x4b77(%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 0x6c76(%rip), %r15      # 0xae54
movl (%r15), %eax
leaq 0x6c68(%rip), %r13      # 0xae50
cltd
idivl (%r13)
movslq %edx, %rsi
shlq $0x5, %rsi
addq 0x4dd5(%rip), %rsi      # 0x8fd0
movq %r14, %rdi
callq 0x2170
movl (%r15), %ecx
movl (%r13), %esi
movl %ecx, %eax
cltd
idivl %esi
movslq %edx, %rax
leaq 0x6917(%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 0x424f
movq (%r12), %rsi
incq %rsi
callq 0x2290
movq %rbx, %rdi
callq 0x4ad6
movq %r15, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x43b4
callq 0x27cf
movl $0x0, 0xc(%rbx)
movq 0x28(%rbx), %rdi
addq $0x8, %rsp
testq %rdi, %rdi
je 0x43c8
popq %rbx
popq %rbp
jmp 0x34e8
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x448d
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq -0x20(%rbp), %r14
movq $0x0, 0x8(%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 0x4457
callq 0x2040
movl (%rax), %edx
leal -0x72(%rdx), %eax
cmpl $0x2, %eax
jae 0x4452
movl $0x1, 0x30(%rbx)
jmp 0x4485
cmpl $0x6a, %edx
jne 0x4468
movq %rbx, %rdi
callq 0x49e8
movl $0x2, 0x30(%rbx)
jmp 0x4485
leaq 0x69e9(%rip), %rdi      # 0xae58
leaq 0x1f90(%rip), %rsi      # 0x6406
xorl %eax, %eax
callq 0x392c
movq %rbx, %rdi
callq 0x4398
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4596
cmpl $0x2, %eax
jne 0x45ac
movq 0x10(%r13), %rsi
cmpq %rsi, 0x18(%r13)
je 0x457c
xorl %r12d, %r12d
movq %r13, -0x30(%rbp)
movq %r12, %rbx
shlq $0x5, %rbx
movq (%rsi,%rbx), %rax
movq %rax, -0x38(%rbp)
movq 0x8(%rsi,%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 -0x38(%rbp), %rsi
callq 0x2200
leaq 0x4ce4(%rip), %rax      # 0x91f8
cmpl $0x1, (%rax)
ja 0x4535
testl %r14d, %r14d
jle 0x4535
movl %r14d, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
xorb $-0x5b, (%r15,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0x4528
movq -0x30(%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 0x45bb
incq %r12
movq 0x10(%r13), %rsi
movq 0x18(%r13), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %r12, %rax
ja 0x44cb
addq $0x10, %r13
movq %r13, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3828
movq %r13, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4650
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4398
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4a8b
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 0x4a7b
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x19fc(%rip), %rsi      # 0x6436
leaq 0x1a35(%rip), %rdx      # 0x6476
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x2a2e
leaq 0x6404(%rip), %rdi      # 0xae58
movq %r14, %rsi
callq 0x387c
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x4a71
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2290
movq %rbx, %rdi
callq 0x4398
jmp 0x4a83
movl 0xc(%rbx), %edi
callq 0x270d
movq %rbx, %rdi
callq 0x448e
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x4aae
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2290
movq %rbx, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
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 0x4d00
movq %rdi, %rbx
leaq -0x58(%rbp), %r15
leaq 0x20(%r14), %rsi
movq %r15, %rdi
callq 0x513e
movq %r14, %rdi
callq 0x21c0
movq %rax, %r14
cmpq %r13, %rax
jne 0x4c8b
movq -0x40(%rbp), %r14
cmpq %r12, %r14
je 0x4d00
movq 0x18(%rbx), %rdx
testq %rdx, %rdx
je 0x4cf0
movl 0x20(%r14), %ecx
movq %r13, %rax
xorl %esi, %esi
cmpl %ecx, 0x20(%rdx)
setl %sil
cmovgeq %rdx, %rax
movq 0x10(%rdx,%rsi,8), %rdx
testq %rdx, %rdx
jne 0x4cc0
cmpq %r13, %rax
je 0x4cf0
cmpl 0x20(%rax), %ecx
jl 0x4cf0
movq 0x28(%rax), %rdi
testq %rdi, %rdi
je 0x4cf0
movq (%rdi), %rax
callq *0x20(%rax)
movq %r14, %rdi
callq 0x22d0
movq %rax, %r14
cmpq %r12, %rax
jne 0x4cb0
leaq -0x58(%rbp), %rdi
callq 0x4d96
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4d1a
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x4d96
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1d85(%rip), %rsi      # 0x3060
leaq 0x8(%rsp), %rbx
movl $0x20, %edx
movq %rbx, %rdi
callq 0x1980
movq %rbx, %rdi
callq 0x1d42
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 0x1d4c(%rip), %rsi      # 0x306a
leaq 0x8(%rsp), %rdi
callq 0x1d90
leaq 0x8(%rsp), %rdi
callq 0x1ffe
xorl %eax, %eax
addq $0x90, %rsp
popq %rbx
retq
jmp 0x133f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1ffe
movq %rbx, %rdi
callq 0x1190
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6008
leaq 0x8(%rsp), %rdi
callq 0x620e
xorb $0x1, %al
movzbl %al, %ebx
leaq 0x8(%rsp), %rdi
callq 0x618a
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 0x618a
jmp 0x37a2
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x4176
movq %rbx, %rdi
callq 0x3440
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3d1d
movq 0x8(%r14), %rdi
callq 0x3400
movl $0x10, %esi
movq %r14, %rdi
callq 0x32c0
movq 0x28(%rbx), %r14
testq %r14, %r14
je 0x3d3c
movq 0x8(%r14), %rdi
callq 0x3400
movl $0x10, %esi
movq %r14, %rdi
callq 0x32c0
movq 0x30(%rbx), %r14
testq %r14, %r14
je 0x3d5b
movq 0x8(%r14), %rdi
callq 0x3400
addq $0x20, %rbx
movl $0x10, %esi
movq %r14, %rdi
callq 0x32c0
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_O3/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:
testq %rsi, %rsi
je 0x4e99
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x4f4d(%rip), %r14      # 0x9c80
leaq 0x4f6e(%rip), %r12      # 0x9ca8
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x2120
testq %rax, %rax
je 0x4d72
movq %rax, %r13
movq 0x80(%rax), %rsi
movq %rbx, %rdi
callq 0x4d0c
movq 0x88(%r13), %r15
testq %r15, %r15
jne 0x4d3a
jmp 0x4e8b
leaq 0x4f07(%rip), %rsi      # 0x9c80
leaq 0x4f10(%rip), %rdx      # 0x9c90
movq %r15, %rdi
xorl %ecx, %ecx
callq 0x2120
testq %rax, %rax
movq %rbx, -0x38(%rbp)
je 0x4e0c
movq %rax, %r14
movq 0x80(%rax), %rsi
movq 0x50(%rsi), %r13
testq %r13, %r13
je 0x4dfb
leaq -0x30(%rbp), %r15
movq 0x8(%r13), %rax
movq (%rbx), %rcx
movq (%rcx,%rax,8), %r12
subq $-0x80, %r12
movq %r14, %rbx
movq 0x88(%r14), %rax
movq 0x18(%rax), %r14
movq %r12, -0x30(%rbp)
testq %r14, %r14
je 0x4de4
leaq 0x8(%r14), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x3920
movq (%r14), %r14
jmp 0x4dcb
movq (%r13), %r13
testq %r13, %r13
movq %rbx, %r14
movq -0x38(%rbp), %rbx
jne 0x4daa
movq 0x80(%r14), %rsi
movq %rbx, %rdi
callq 0x4d0c
addq $0x88, %r14
jmp 0x4e80
leaq 0x4e6d(%rip), %rsi      # 0x9c80
leaq 0x4ea6(%rip), %rdx      # 0x9cc0
movq %r15, %rdi
xorl %ecx, %ecx
callq 0x2120
testq %rax, %rax
je 0x4e8b
movq %rax, %r14
movq 0x50(%rax), %r13
testq %r13, %r13
je 0x4e7c
leaq -0x30(%rbp), %r15
movq 0x8(%r13), %rax
movq (%rbx), %rcx
movq (%rcx,%rax,8), %r12
subq $-0x80, %r12
movq %r14, %rbx
movq 0x18(%r14), %r14
movq %r12, -0x30(%rbp)
testq %r14, %r14
je 0x4e6c
leaq 0x8(%r14), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x3920
movq (%r14), %r14
jmp 0x4e53
movq (%r13), %r13
testq %r13, %r13
movq %rbx, %r14
movq -0x38(%rbp), %rbx
jne 0x4e39
subq $-0x80, %r14
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x4d0c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x49c5(%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 0x53c2
leaq -0x30(%rbp), %r12
leaq 0x8(%r13), %rsi
movq %r14, %rdi
movq %r12, %rdx
callq 0x3920
movq (%r13), %r13
testq %r13, %r13
jne 0x53aa
movq 0x88(%rbx), %rax
movq 0x18(%rax), %r13
movq %r14, -0x30(%rbp)
testq %r13, %r13
je 0x53f2
leaq -0x30(%rbp), %r12
leaq 0x8(%r13), %rsi
movq %r14, %rdi
movq %r12, %rdx
callq 0x3920
movq (%r13), %r13
testq %r13, %r13
jne 0x53da
movq 0x80(%rbx), %rax
movq 0x50(%rax), %r13
movq %r15, -0x30(%rbp)
testq %r13, %r13
je 0x5422
leaq -0x30(%rbp), %r12
leaq 0x8(%r13), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x3920
movq (%r13), %r13
testq %r13, %r13
jne 0x540a
movq 0x88(%rbx), %rax
movq 0x50(%rax), %r13
movq %r15, -0x30(%rbp)
testq %r13, %r13
je 0x5452
leaq -0x30(%rbp), %r12
leaq 0x8(%r13), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x3920
movq (%r13), %r13
testq %r13, %r13
jne 0x543a
movq 0x80(%rbx), %rcx
movb $0x1, %al
cmpb $0x0, 0x78(%rcx)
jne 0x546b
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 0x5483
jmp 0x5483
jmp 0x5483
movq %rax, %r12
movq 0x88(%rbx), %rdi
testq %rdi, %rdi
je 0x5498
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x88(%rbx)
movq 0x80(%rbx), %rdi
testq %rdi, %rdi
je 0x54b5
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x80(%rbx)
leaq 0x47a9(%rip), %rax      # 0x9c70
movq %rax, (%rbx)
movq %r15, %rdi
callq 0x347c
movq %r14, %rdi
callq 0x347c
movq %r12, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x428b(%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), %rcx
movq 0x18(%rcx), %r13
movq %r14, -0x30(%rbp)
testq %r13, %r13
je 0x5b43
leaq -0x30(%rbp), %r12
leaq 0x8(%r13), %rsi
movq %r14, %rdi
movq %r12, %rdx
callq 0x3920
movq (%r13), %r13
testq %r13, %r13
jne 0x5b24
movq 0x80(%rbx), %rcx
movq 0x88(%rbx), %rax
cmpb $0x1, 0x78(%rcx)
jne 0x5b80
movq 0x18(%rax), %r13
movq %r14, -0x30(%rbp)
testq %r13, %r13
je 0x5b80
leaq -0x30(%rbp), %r12
leaq 0x8(%r13), %rsi
movq %r14, %rdi
movq %r12, %rdx
callq 0x3920
movq (%r13), %r13
testq %r13, %r13
jne 0x5b61
movq 0x88(%rbx), %rax
movq 0x50(%rax), %r13
movq %r15, -0x30(%rbp)
testq %r13, %r13
je 0x5bb0
leaq -0x30(%rbp), %r12
leaq 0x8(%r13), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x3920
movq (%r13), %r13
testq %r13, %r13
jne 0x5b91
movq 0x88(%rbx), %rax
movq 0x80(%rbx), %rcx
cmpb $0x1, 0x78(%rax)
jne 0x5bed
movq 0x50(%rcx), %r13
movq %r15, -0x30(%rbp)
testq %r13, %r13
je 0x5bed
leaq -0x30(%rbp), %r12
leaq 0x8(%r13), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x3920
movq (%r13), %r13
testq %r13, %r13
jne 0x5bce
movq 0x80(%rbx), %rcx
cmpb $0x1, 0x78(%rcx)
jne 0x5bff
movq 0x88(%rbx), %rax
movb 0x78(%rax), %al
jmp 0x5c01
xorl %eax, %eax
movb %al, 0x78(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5c19
jmp 0x5c19
jmp 0x5c19
movq %rax, %r12
movq 0x88(%rbx), %rdi
testq %rdi, %rdi
je 0x5c2e
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x88(%rbx)
movq 0x80(%rbx), %rdi
testq %rdi, %rdi
je 0x5c4b
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x80(%rbx)
leaq 0x4013(%rip), %rax      # 0x9c70
movq %rax, (%rbx)
movq %r15, %rdi
callq 0x347c
movq %r14, %rdi
callq 0x347c
movq %r12, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O3/markondej[P]phase_correl/phase_correl.cpp
// Function: main
GrayscaleImage(std::size_t width, std::size_t height, unsigned char fill) {
        data = new unsigned char[width * height];
        memset(data, fill, sizeof(unsigned char) * width * height);
        this->width = width;
        this->height = height;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl $0x8000, %edi           # imm = 0x8000
callq 0x1030
movq %rax, %r14
movq %rax, 0x30(%rsp)
movl $0x8000, %edx           # imm = 0x8000
movq %rax, %rdi
xorl %esi, %esi
callq 0x10a0
movl $0x100, %r15d           # imm = 0x100
movq %r15, 0x20(%rsp)
movl $0x80, %r12d
movq %r12, 0x28(%rsp)
movl $0x8000, %edi           # imm = 0x8000
callq 0x1030
movq %rax, %rbx
movq %rax, 0x18(%rsp)
movl $0x8000, %edx           # imm = 0x8000
movq %rax, %rdi
movl $0xff, %esi
callq 0x10a0
movq %r15, 0x8(%rsp)
movq %r12, 0x10(%rsp)
addq $0x2010, %r14           # imm = 0x2010
movl $0x20, %eax
xorl %ecx, %ecx
cmpq $0x7f, %rax
seta %dl
leaq 0x10(%rcx), %rsi
cmpq $0x100, %rsi            # imm = 0x100
setae %sil
orb %dl, %sil
jne 0x138a
movb $-0x80, (%r14,%rcx)
incq %rcx
cmpq $0x3c, %rcx
jne 0x136a
incq %rax
addq $0x100, %r14            # imm = 0x100
cmpq $0x5c, %rax
jne 0x1368
addq $0x2808, %rbx           # imm = 0x2808
movl $0x28, %eax
xorl %ecx, %ecx
cmpq $0x7f, %rax
seta %dl
leaq 0x8(%rcx), %rsi
cmpq $0x100, %rsi            # imm = 0x100
setae %sil
orb %dl, %sil
jne 0x13d0
movb $0x10, (%rbx,%rcx)
incq %rcx
cmpq $0x3c, %rcx
jne 0x13b1
incq %rax
addq $0x100, %rbx            # imm = 0x100
cmpq $0x64, %rax
jne 0x13af
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x4(%rsp), %r14
movq %rsp, %rbx
movq %r14, %rdx
movq %rbx, %rcx
callq 0x149a
movq 0x3bc3(%rip), %r15      # 0x4fd0
leaq 0x1c54(%rip), %rsi      # 0x3068
movl $0x13, %edx
movq %r15, %rdi
callq 0x1130
movl (%r14), %esi
movq %r15, %rdi
callq 0x1170
movq %rax, %r14
leaq 0x1c46(%rip), %rsi      # 0x307c
movl $0x2, %edx
movq %rax, %rdi
callq 0x1130
movl (%rbx), %esi
movq %r14, %rdi
callq 0x1170
movq %rax, %rbx
leaq 0x1c28(%rip), %rsi      # 0x307f
movl $0x1, %edx
movq %rax, %rdi
callq 0x1130
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1110
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1040
movq %rax, %rdi
callq 0x10b0
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/markondej[P]phase_correl/phase_correl.cpp
// Function: PhaseCorrelation::ComputeNormalized(std::complex<double> const&, std::complex<double> const&, std::complex<double>&)
static void ComputeNormalized(const std::complex<double> &input1, const std::complex<double> &input2, std::complex<double> &output) {
        double a1 = (input1.imag() != 0.0) ? ((input1.real() != 0.0) ? atan(input1.imag() / input1.real()) : std::copysign(M_PI, input1.imag()) / 2.0) : 0.0;
        if (input1.real() < 0.0) {
            a1 = std::copysign(M_PI, input1.imag()) + a1;
        }

        double a2 = (input2.imag() != 0.0) ? ((input2.real() != 0.0) ? atan(input2.imag() / input2.real()) : std::copysign(M_PI, input2.imag()) / 2.0) : 0.0;
        if (input2.real() < 0.0) {
            a2 = std::copysign(M_PI, input2.imag()) + a2;
        }

        output.real(cos(a1 - a2));
        output.imag(sin(a1 - a2));
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movsd 0x8(%rdi), %xmm3
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm3
jne 0x183a
jnp 0x1864
movsd (%r15), %xmm0
ucomisd %xmm1, %xmm0
jne 0x1847
jnp 0x1873
divsd %xmm0, %xmm3
movapd %xmm3, %xmm0
callq 0x10e0
xorpd %xmm1, %xmm1
movapd %xmm0, %xmm4
movsd 0x8(%r15), %xmm3
jmp 0x1868
xorpd %xmm4, %xmm4
ucomisd (%r15), %xmm1
seta %bpl
jmp 0x1891
movapd 0x1795(%rip), %xmm4     # 0x3010
andpd %xmm3, %xmm4
orpd 0x1799(%rip), %xmm4     # 0x3020
mulsd 0x17c1(%rip), %xmm4     # 0x3050
xorl %ebp, %ebp
movsd 0x8(%r14), %xmm0
ucomisd %xmm1, %xmm0
jne 0x189f
jnp 0x18d9
movsd (%r14), %xmm1
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm1
jne 0x18b0
jnp 0x1917
divsd %xmm1, %xmm0
movapd %xmm4, (%rsp)
movapd %xmm3, 0x10(%rsp)
callq 0x10e0
movapd 0x10(%rsp), %xmm3
movapd (%rsp), %xmm4
movapd %xmm0, %xmm1
movsd 0x8(%r14), %xmm0
movsd (%r14), %xmm2
testb %bpl, %bpl
je 0x18f7
andpd 0x1725(%rip), %xmm3     # 0x3010
orpd 0x172d(%rip), %xmm3     # 0x3020
addsd %xmm3, %xmm4
xorpd %xmm3, %xmm3
ucomisd %xmm2, %xmm3
jbe 0x194c
andpd 0x1707(%rip), %xmm0     # 0x3010
orpd 0x170f(%rip), %xmm0     # 0x3020
addsd %xmm0, %xmm1
jmp 0x194c
movapd 0x16f1(%rip), %xmm1     # 0x3010
andpd %xmm1, %xmm0
movapd 0x16f5(%rip), %xmm2     # 0x3020
orpd %xmm2, %xmm0
testb %bpl, %bpl
je 0x1940
andpd %xmm1, %xmm3
orpd %xmm2, %xmm3
addsd %xmm3, %xmm4
mulsd 0x1708(%rip), %xmm0     # 0x3050
movapd %xmm0, %xmm1
subsd %xmm1, %xmm4
movapd %xmm4, (%rsp)
movapd %xmm4, %xmm0
callq 0x1190
movsd %xmm0, (%rbx)
movaps (%rsp), %xmm0
callq 0x1050
movsd %xmm0, 0x8(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/markondej[P]phase_correl/phase_correl.cpp
// Function: PhaseCorrelation::GenInputOrder(unsigned long)
static std::vector<std::size_t> GenInputOrder(std::size_t size) {
        std::size_t stride = 1;
        std::vector<std::size_t> offset;
        offset.resize(size);

        std::memset(offset.data(), 0xff, sizeof(std::size_t) * size);
        offset[0] = 0;

        for (std::size_t step = size >> 1; step > 0; step >>= 1) {
            std::size_t base = 0;
            for (std::size_t i = 0; i < size; i += step) {
                if (offset[i] != SIZE_MAX) {
                    base = offset[i];
                } else {
                    offset[i] = base + stride;
                }
            }
            stride <<= 1;
        }

        return offset;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x20f0
movq (%rbx), %rdi
leaq (,%r14,8), %rdx
movl $0xff, %esi
callq 0x10a0
movq (%rbx), %rax
movq $0x0, (%rax)
cmpq $0x2, %r14
jb 0x1fb1
movl $0x1, %ecx
movq %r14, %rdx
movq %r14, %rsi
shrq %rsi
xorl %edi, %edi
xorl %r8d, %r8d
movq (%rax,%rdi,8), %r9
cmpq $-0x1, %r9
jne 0x1f9a
leaq (%r8,%rcx), %r9
movq %r9, (%rax,%rdi,8)
movq %r8, %r9
addq %rsi, %rdi
movq %r9, %r8
cmpq %r14, %rdi
jb 0x1f85
addq %rcx, %rcx
cmpq $0x4, %rdx
movq %rsi, %rdx
jae 0x1f7d
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1fcc
callq 0x1100
movq %r14, %rdi
callq 0x1180
// File: /workspace/github_cpp_makefile_star2_O3/markondej[P]phase_correl/phase_correl.cpp
// Function: PhaseCorrelation::Sum2FFT(std::complex<double> const*, std::complex<double>*, unsigned long, bool)
static void Sum2FFT(const std::complex<double> *input, std::complex<double> *output, std::size_t size, bool inverse) {
        double dfi = (inverse ? 2.0 : -2.0) * M_PI / static_cast<double>(size << 1),
            kfi = 0.0;

        for (std::size_t k = 0; k < size; k++) {
            double cosfi = cos(kfi), sinfi = sin(kfi);
            std::complex<double> temp[] = { input[k], input[k + size] };

            output[k].real(temp[0].real() + cosfi * temp[1].real() - sinfi * temp[1].imag());
            output[k].imag(temp[0].imag() + sinfi * temp[1].real() + cosfi * temp[1].imag());
            output[k + size].real(temp[0].real() - cosfi * temp[1].real() + sinfi * temp[1].imag());
            output[k + size].imag(temp[0].imag() - sinfi * temp[1].real() - cosfi * temp[1].imag());
            kfi += dfi;
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testl %ecx, %ecx
jne 0x1ff6
movsd 0x106c(%rip), %xmm2     # 0x3060
jmp 0x1ffe
movsd 0x105a(%rip), %xmm2     # 0x3058
testq %rbx, %rbx
je 0x20e3
leaq (%rbx,%rbx), %rax
movq %rax, %xmm0
punpckldq 0x1018(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x1020(%rip), %xmm0     # 0x3040
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
divsd %xmm1, %xmm2
movq %rbx, %r12
shlq $0x4, %r12
xorpd %xmm0, %xmm0
movsd %xmm2, 0x8(%rsp)
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm0
callq 0x1190
movaps %xmm0, 0x10(%rsp)
movsd (%rsp), %xmm0
callq 0x1050
movupd (%r15), %xmm1
movapd 0x10(%rsp), %xmm6
movapd %xmm6, %xmm2
unpcklpd %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0]
movsd (%r15,%r12), %xmm3
unpcklpd %xmm3, %xmm3            # xmm3 = xmm3[0,0]
mulpd %xmm2, %xmm3
xorpd 0xf88(%rip), %xmm2      # 0x3010
movsd 0x8(%r15,%r12), %xmm4
movapd %xmm3, %xmm5
addpd %xmm1, %xmm5
unpcklpd %xmm2, %xmm0            # xmm0 = xmm0[0],xmm2[0]
shufpd $0x1, %xmm6, %xmm2      # xmm2 = xmm2[1],xmm6[0]
unpcklpd %xmm4, %xmm4            # xmm4 = xmm4[0,0]
mulpd %xmm4, %xmm2
addpd %xmm5, %xmm2
movupd %xmm2, (%r14)
movsd 0x8(%rsp), %xmm2
subpd %xmm3, %xmm1
mulpd %xmm0, %xmm4
movsd (%rsp), %xmm0
addpd %xmm1, %xmm4
movupd %xmm4, (%r14,%r12)
addsd %xmm2, %xmm0
addq $0x10, %r14
addq $0x10, %r15
decq %rbx
jne 0x2041
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/JohnWoodman[P]SHellNo/listener.cpp
// Function: listener::test()
void listener::test(){
	printf("server: waiting for connections...\n");
	sin_size = sizeof their_addr;
	new_fd = accept(sockfd, (struct sockaddr *)&their_addr, &sin_size);
	if (new_fd == -1) {
		cout<<"accepted error"<<endl;
	}
	cout<<"got connection"<<endl;
	status = 1;
	inet_ntop(their_addr.ss_family, get_in_addr((struct sockaddr *)&their_addr), s, sizeof s);
	//postExploitMenu(this);

	//close(sockfd);
	//close(new_fd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2e7c(%rip), %rdi      # 0x1715e
callq 0x55a0
leaq 0xe0(%rbx), %rdx
movl $0x80, 0xe0(%rbx)
movl 0x10(%rbx), %edi
leaq 0x60(%rbx), %r14
movq %r14, %rsi
callq 0x5130
movl %eax, 0x14(%rbx)
cmpl $-0x1, %eax
jne 0x14351
movq 0xac92(%rip), %r15      # 0x1efa8
leaq 0x2dad(%rip), %rsi      # 0x170ca
movl $0xe, %edx
movq %r15, %rdi
callq 0x5400
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x5350
movsbl %al, %esi
movq %r15, %rdi
callq 0x5040
movq %rax, %rdi
callq 0x5280
movq 0xac50(%rip), %r15      # 0x1efa8
leaq 0x2d7a(%rip), %rsi      # 0x170d9
movl $0xe, %edx
movq %r15, %rdi
callq 0x5400
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x5350
movsbl %al, %esi
movq %r15, %rdi
callq 0x5040
movq %rax, %rdi
callq 0x5280
movl $0x1, 0x184(%rbx)
movzwl 0x60(%rbx), %edi
xorl %eax, %eax
cmpl $0x2, %edi
setne %al
leaq (%r14,%rax,4), %rsi
addq $0x4, %rsi
addq $0x188, %rbx            # imm = 0x188
movq %rbx, %rdx
movl $0x2e, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x53b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/JohnWoodman[P]SHellNo/listener.cpp
// Function: listener::injectShellcode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int listener::injectShellcode(string l_path) {
	printf("Injecting Shellcode...\n");
	std::streampos filesize = 0;
	ifstream in(l_path, std::ios::binary);
	char* sendbuf = new char[1024];
	int sendbuflen = 1024;
	memset(sendbuf, '\0', sendbuflen);
	
	string cmd = "shellcode:";
	send(new_fd, cmd.c_str(), cmd.length(), 0);

	while (in.is_open()) {
		printf("File is open\n");
		in.read(sendbuf, sendbuflen);
		if (in.eof()) {
			printf("End of file\n");
			send(new_fd, sendbuf, sendbuflen, 0);
			memset(sendbuf, '\0', sendbuflen);
			in.close();
		} else {
			printf("Sending file\n");
			send(new_fd, sendbuf, sendbuflen, 0);
			memset(sendbuf, '\0', sendbuflen);
		}
	}
	printf("Finished Uploading Shellcode!\n");
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x29f2(%rip), %rdi      # 0x171f3
callq 0x55a0
leaq -0x250(%rbp), %rdi
movq %r14, %rsi
movl $0x4, %edx
callq 0x55d0
movl $0x400, %edi            # imm = 0x400
callq 0x5030
movq %rax, %r14
movl $0x400, %edx            # imm = 0x400
movq %rax, %rdi
xorl %esi, %esi
callq 0x5230
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x28fc(%rip), %rsi      # 0x17141
leaq 0x28ff(%rip), %rdx      # 0x1714b
leaq -0x48(%rbp), %rdi
callq 0x14faa
movl 0x14(%rbx), %edi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
xorl %ecx, %ecx
callq 0x51f0
leaq -0x1d8(%rbp), %r15
movq %r15, %rdi
callq 0x50c0
testb %al, %al
je 0x1492d
leaq 0x29a3(%rip), %r12      # 0x17228
leaq -0x250(%rbp), %r13
movq %r12, %rdi
callq 0x55a0
movl $0x400, %edx            # imm = 0x400
movq %r13, %rdi
movq %r14, %rsi
callq 0x5480
movq -0x250(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x230(%rbp,%rax)
jne 0x148e8
leaq 0x2975(%rip), %rdi      # 0x17235
callq 0x55a0
movl 0x14(%rbx), %edi
movl $0x400, %edx            # imm = 0x400
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x51f0
movl $0x400, %edx            # imm = 0x400
movq %r14, %rdi
xorl %esi, %esi
callq 0x5230
jmp 0x1491d
leaq 0x2953(%rip), %rdi      # 0x17242
callq 0x55a0
movl 0x14(%rbx), %edi
movl $0x400, %edx            # imm = 0x400
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x51f0
movl $0x400, %edx            # imm = 0x400
movq %r14, %rdi
xorl %esi, %esi
callq 0x5230
movq %r13, %rdi
callq 0x50b0
movq %r15, %rdi
callq 0x50c0
testb %al, %al
jne 0x1488c
leaq 0x28d6(%rip), %rdi      # 0x1720a
callq 0x55a0
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x14952
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x5370
leaq -0x250(%rbp), %rdi
callq 0x50e0
xorl %eax, %eax
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1497b
jmp 0x14976
movq %rax, %rbx
jmp 0x14997
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x14997
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x5370
leaq -0x250(%rbp), %rdi
callq 0x50e0
movq %rbx, %rdi
callq 0x5630
// File: /workspace/github_cpp_makefile_star2_O3/JohnWoodman[P]SHellNo/listener.cpp
// Function: printingThing(void*)
void 
*printingThing(void* in){
	int new_fd = *(int*)in;
	char* recvbuf = new char[2048];
	int n = 1000;
	int buflen = 2048;
	int byte_recv;
	do{
		byte_recv = recv(new_fd, recvbuf, buflen, 0);
		for(int i=0;i<byte_recv;i++){
			printf("%c",recvbuf[i]);
		}
		n--;
	}while(n>0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl (%rdi), %ebx
movl $0x800, %edi            # imm = 0x800
callq 0x5030
movq %rax, %r14
movl $0x800, %edx            # imm = 0x800
movl %ebx, %edi
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x5140
movq %rax, %r15
testl %r15d, %r15d
jle 0x149c5
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
xorl %r12d, %r12d
movsbl (%r14,%r12), %edi
callq 0x54f0
incq %r12
cmpq %r12, %r15
jne 0x149e8
jmp 0x149c5
// File: /workspace/github_cpp_makefile_star2_O3/JohnWoodman[P]SHellNo/listenerManager.cpp
// Function: listenerManager::addListener(int)
int
listenerManager::addListener(int port){
    listener* newListener = new listener(port);
    listeners.push_back(newListener);
    thread t1(&listener::test,newListener);
    t1.detach();
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %r15d
movq %rdi, %rbx
movl $0x1c0, %edi            # imm = 0x1C0
callq 0x5360
movq %rax, %r14
movq %rax, %rdi
movl %r15d, %esi
callq 0x1404e
movq %r14, -0x28(%rbp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x154a7
movq %r14, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x154b3
leaq -0x28(%rbp), %rdx
movq %rbx, %rdi
callq 0x1568c
leaq -0x11ec(%rip), %rax     # 0x142ce
leaq -0x38(%rbp), %rsi
movq %rax, (%rsi)
movq $0x0, 0x8(%rsi)
leaq -0x20(%rbp), %rbx
leaq -0x28(%rbp), %rdx
movq %rbx, %rdi
callq 0x1560a
movq %rbx, %rdi
callq 0x5620
cmpq $0x0, -0x20(%rbp)
jne 0x15504
movl $0x1, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpq $0x0, -0x20(%rbp)
jne 0x15504
movq %rax, %rbx
jmp 0x15519
callq 0x50f0
movq %rax, %rbx
movl $0x1c0, %esi            # imm = 0x1C0
movq %r14, %rdi
callq 0x5370
movq %rbx, %rdi
callq 0x5630
nop
// File: /workspace/github_cpp_makefile_star2_O3/ushitora-anqou[P]aqtfhe2/main.cpp
// Function: aqtfhe2::detail::nd_array<bool, 1000ul> (anonymous namespace)::random_bool_array<1000ul, std::random_device>(std::random_device&)
nd_array<bool, N> random_bool_array(RandomEngine& rand)
{
    nd_array<bool, N> ret;
    std::binomial_distribution<int> binary;
    for (bool& v : ret)
        v = binary(rand);
    return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x98, %rsp
leaq 0x8(%rsp), %r15
movabsq $0x3fe0000000000000, %rax # imm = 0x3FE0000000000000
movq %rdi, %r14
movq %rsi, %rbx
movl $0x1, (%r15)
movq %r15, %rdi
movq %rax, 0x8(%r15)
callq 0x512e
vxorps %xmm0, %xmm0, %xmm0
vmovhps 0x5358(%rip), %xmm0, %xmm0 # xmm0 = xmm0[0,1],mem[0,1]
xorl %r12d, %r12d
vmovups %xmm0, 0x70(%r15)
movq $0x0, 0x80(%r15)
movb $0x0, 0x88(%r15)
movq %r15, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x545c
testl %eax, %eax
setne (%r14,%r12)
incq %r12
cmpq $0x3e8, %r12            # imm = 0x3E8
jne 0x2cdc
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/ushitora-anqou[P]aqtfhe2/./aqtfhe2.hpp
// Function: aqtfhe2::secret_key<aqtfhe2::params::CGGI16> aqtfhe2::secret_key<aqtfhe2::params::CGGI16>::make<std::random_device>(std::random_device&)
static secret_key make(RandomEngine &rand)
    {
        std::binomial_distribution<uint32_t> binary;

        container_key_lvl0 key_lvl0;
        for (uint32_t &v : key_lvl0)
            v = binary(rand);

        container_key_lvl1 key_lvl1;
        for (uint32_t &v : key_lvl1)
            v = binary(rand);

        return secret_key{std::move(key_lvl0), std::move(key_lvl1)};
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1868, %rsp           # imm = 0x1868
leaq 0x8(%rsp), %r15
movabsq $0x3fe0000000000000, %rax # imm = 0x3FE0000000000000
movq %rdi, %rbx
movq %rsi, %r14
movl $0x1, (%r15)
movq %r15, %rdi
movq %rax, 0x8(%r15)
callq 0x3046
vxorps %xmm0, %xmm0, %xmm0
vmovhps 0x5250(%rip), %xmm0, %xmm0 # xmm0 = xmm0[0,1],mem[0,1]
xorl %r12d, %r12d
vmovups %xmm0, 0x70(%r15)
movq $0x0, 0x80(%r15)
movb $0x0, 0x88(%r15)
movq %r15, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x337c
movl %eax, 0x98(%rsp,%r12)
addq $0x4, %r12
cmpq $0x7d0, %r12            # imm = 0x7D0
jne 0x2de4
leaq 0x8(%rsp), %r15
xorl %r12d, %r12d
movq %r15, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x337c
movl %eax, 0x868(%rsp,%r12)
addq $0x4, %r12
cmpq $0x1000, %r12           # imm = 0x1000
jne 0x2e0f
leaq 0x98(%rsp), %rsi
movl $0x7d0, %edx            # imm = 0x7D0
movq %rbx, %rdi
callq 0x2130
movq %rbx, %rdi
addq $0x7d0, %rdi            # imm = 0x7D0
leaq 0x868(%rsp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x2130
movq %rbx, %rax
addq $0x1868, %rsp           # imm = 0x1868
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop