LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: blackle[P]LZMA-Vizualizer/LzmaSpec.cpp
// Function: CBitTreeDecoder<3u>::Decode(CRangeDecoder*)
unsigned Decode(CRangeDecoder *rc)
  {
    unsigned m = 1;
    for (unsigned i = 0; i < NumBits; i++)
      m = (m << 1) + rc->DecodeBit(&Probs[m]);
    return m - ((unsigned)1 << NumBits);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x1, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x3, -0x18(%rbp)
jae 0x5cbf
movq -0x20(%rbp), %rsi
movl -0x14(%rbp), %eax
shll %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
shlq %rax
addq %rax, %rsi
callq 0x25c0
movl %eax, %ecx
movl -0x24(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5c86
movl -0x14(%rbp), %eax
subl $0x8, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: blackle[P]LZMA-Vizualizer/LzmaSpec.cpp
// Function: COutWindow::Create(unsigned int)
void Create(UInt32 dictSize)
  {
    Buf = new Byte[dictSize];
    Pos = 0;
    Size = dictSize;
    IsFull = false;
    TotalPos = 0;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %edi
callq 0x2030
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, 0x8(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0xc(%rax)
movb $0x0, 0x10(%rax)
movl $0x0, 0x14(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: blackle[P]LZMA-Vizualizer/LzmaSpec.cpp
// Function: ColorGradient::createDefaultHeatMapGradient()
void createDefaultHeatMapGradient()
  {
    color.clear();
    color.push_back(ColorPoint(0, 0, 0,   0.0f));      // Blue.
    color.push_back(ColorPoint(0, 0, 1,   0.2f));     // Cyan.
    color.push_back(ColorPoint(0, 1, 0,   0.5f));      // Green.
    color.push_back(ColorPoint(1, 1, 0,   0.7f));     // Yellow.
    color.push_back(ColorPoint(1, 0, 0,   0.9f));      // Red.
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x6d40
leaq -0x18(%rbp), %rdi
xorps %xmm3, %xmm3
movaps %xmm3, %xmm0
movaps %xmm3, %xmm1
movaps %xmm3, %xmm2
callq 0x6d90
movq -0x60(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x6d60
leaq -0x28(%rbp), %rdi
xorps %xmm1, %xmm1
movss 0x4c1a(%rip), %xmm2     # 0xb004
movss 0x4c2a(%rip), %xmm3     # 0xb01c
movaps %xmm1, %xmm0
callq 0x6d90
movq -0x60(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6d60
leaq -0x38(%rbp), %rdi
xorps %xmm2, %xmm2
movss 0x4bee(%rip), %xmm1     # 0xb004
movss 0x4bfa(%rip), %xmm3     # 0xb018
movaps %xmm2, %xmm0
callq 0x6d90
movq -0x60(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x6d60
leaq -0x48(%rbp), %rdi
movss 0x4bc5(%rip), %xmm1     # 0xb004
xorps %xmm2, %xmm2
movss 0x4bca(%rip), %xmm3     # 0xb014
movaps %xmm1, %xmm0
callq 0x6d90
movq -0x60(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x6d60
leaq -0x58(%rbp), %rdi
movss 0x4b99(%rip), %xmm0     # 0xb004
xorps %xmm2, %xmm2
movss 0x4b9a(%rip), %xmm3     # 0xb010
movaps %xmm2, %xmm1
callq 0x6d90
movq -0x60(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x6d60
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: blackle[P]LZMA-Vizualizer/LzmaSpec.cpp
// Function: ColorGradient::createViridisHeatMapGradient()
void createViridisHeatMapGradient()
  {
    color.clear();
    color.push_back(ColorPoint(0x44/255.f,0x02/255.f,0x55/255.f,   0.0f));
    color.push_back(ColorPoint(0x2C/255.f,0x70/255.f,0x8E/255.f,   0.33f));
    color.push_back(ColorPoint(0x3D/255.f,0xBB/255.f,0x74/255.f,   0.66f));
    color.push_back(ColorPoint(0xFA/255.f,0xE6/255.f,0x22/255.f,   1.f));
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x6d40
leaq -0x18(%rbp), %rdi
movss 0x4b87(%rip), %xmm0     # 0xb04c
movss 0x4b83(%rip), %xmm1     # 0xb050
movss 0x4b7f(%rip), %xmm2     # 0xb054
xorps %xmm3, %xmm3
callq 0x6d90
movq -0x50(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x6d60
leaq -0x28(%rbp), %rdi
movss 0x4b46(%rip), %xmm0     # 0xb03c
movss 0x4b42(%rip), %xmm1     # 0xb040
movss 0x4b3e(%rip), %xmm2     # 0xb044
movss 0x4b3a(%rip), %xmm3     # 0xb048
callq 0x6d90
movq -0x50(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6d60
leaq -0x38(%rbp), %rdi
movss 0x4b00(%rip), %xmm0     # 0xb02c
movss 0x4afc(%rip), %xmm1     # 0xb030
movss 0x4af8(%rip), %xmm2     # 0xb034
movss 0x4af4(%rip), %xmm3     # 0xb038
callq 0x6d90
movq -0x50(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x6d60
leaq -0x48(%rbp), %rdi
movss 0x4abe(%rip), %xmm0     # 0xb020
movss 0x4aba(%rip), %xmm1     # 0xb024
movss 0x4ab6(%rip), %xmm2     # 0xb028
movss 0x4a8a(%rip), %xmm3     # 0xb004
callq 0x6d90
movq -0x50(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x6d60
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: blackle[P]LZMA-Vizualizer/LzmaSpec.cpp
// Function: ColorGradient::printScale[abi:cxx11](int)
std::string printScale(int width)
  {
    std::stringstream ss;
    for (int i = 0; i < width; i++) {
      float val = (i*1.f)/width;
      float r,g,b;
      getColorAtValue(val, r,g,b);
      ss << realcolor::fg(r,g,b) << "━";
    }
    ss << realcolor::reset;
    return ss.str();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
movq %rdi, -0x200(%rbp)
movq %rdi, %rax
movq %rax, -0x1f8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1f0(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x20d0
movl $0x0, -0x1a4(%rbp)
movl -0x1a4(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x66f4
movq -0x1f0(%rbp), %rdi
cvtsi2ssl -0x1a4(%rbp), %xmm0
cvtsi2ssl -0x14(%rbp), %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0x1a8(%rbp)
movss -0x1a8(%rbp), %xmm0
leaq -0x1ac(%rbp), %rsi
leaq -0x1b0(%rbp), %rdx
leaq -0x1b4(%rbp), %rcx
callq 0x76c0
jmp 0x663b
leaq -0x190(%rbp), %rax
movq %rax, -0x208(%rbp)
movss -0x1ac(%rbp), %xmm0
movss -0x1b0(%rbp), %xmm1
movss -0x1b4(%rbp), %xmm2
leaq -0x1e8(%rbp), %rdi
callq 0x78b0
jmp 0x666f
movq -0x208(%rbp), %rdi
leaq -0x1e8(%rbp), %rsi
callq 0x2130
movq %rax, -0x210(%rbp)
jmp 0x668b
movq -0x210(%rbp), %rdi
leaq 0x4b70(%rip), %rsi      # 0xb209
callq 0x2150
jmp 0x66a0
leaq -0x1e8(%rbp), %rdi
callq 0x20c0
movl -0x1a4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1a4(%rbp)
jmp 0x65e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
jmp 0x673a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
leaq -0x1e8(%rbp), %rdi
callq 0x20c0
jmp 0x673a
leaq -0x190(%rbp), %rdi
leaq 0x30e(%rip), %rsi       # 0x6a10
callq 0x2190
jmp 0x6709
movq -0x200(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0x2140
jmp 0x671e
leaq -0x1a0(%rbp), %rdi
callq 0x20e0
movq -0x1f8(%rbp), %rax
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
leaq -0x1a0(%rbp), %rdi
callq 0x20e0
movq -0x1c0(%rbp), %rdi
callq 0x2270
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: blackle[P]LZMA-Vizualizer/LzmaSpec.cpp
// Function: ColorGradient::get[abi:cxx11](float)
std::string get(const float value)
  {
    float r,g,b;
    getColorAtValue(value, r,g,b);
    std::stringstream ss;
    ss << realcolor::bg(r,g,b) << realcolor::fg(1.f-r,1.f-g,1.f-b);
    return ss.str();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x210(%rbp)
movq %rdi, %rax
movq %rax, -0x208(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movss -0x14(%rbp), %xmm0
leaq -0x18(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
leaq -0x20(%rbp), %rcx
callq 0x76c0
leaq -0x1a8(%rbp), %rdi
callq 0x20d0
leaq -0x198(%rbp), %rax
movq %rax, -0x200(%rbp)
movss -0x18(%rbp), %xmm0
movss -0x1c(%rbp), %xmm1
movss -0x20(%rbp), %xmm2
leaq -0x1c8(%rbp), %rdi
callq 0x7d10
jmp 0x68ea
movq -0x200(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x2130
movq %rax, -0x218(%rbp)
jmp 0x6906
movss -0x18(%rbp), %xmm1
movss 0x46f1(%rip), %xmm2     # 0xb004
movaps %xmm2, %xmm0
subss %xmm1, %xmm0
movss -0x1c(%rbp), %xmm3
movaps %xmm2, %xmm1
subss %xmm3, %xmm1
movss -0x20(%rbp), %xmm3
subss %xmm3, %xmm2
leaq -0x1f8(%rbp), %rdi
callq 0x78b0
jmp 0x693d
movq -0x218(%rbp), %rdi
leaq -0x1f8(%rbp), %rsi
callq 0x2130
jmp 0x6952
leaq -0x1f8(%rbp), %rdi
callq 0x20c0
leaq -0x1c8(%rbp), %rdi
callq 0x20c0
movq -0x210(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
callq 0x2140
jmp 0x697f
leaq -0x1a8(%rbp), %rdi
callq 0x20e0
movq -0x208(%rbp), %rax
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
jmp 0x69ed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
jmp 0x69e1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
leaq -0x1f8(%rbp), %rdi
callq 0x20c0
leaq -0x1c8(%rbp), %rdi
callq 0x20c0
leaq -0x1a8(%rbp), %rdi
callq 0x20e0
movq -0x1d0(%rbp), %rdi
callq 0x2270
nopw %cs:(%rax,%rax)
nop
// File: huanghuide[P]SimpleNetworkTunnel/Common.cpp
// Function: Trim(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void Trim(string& str)
{
    string::size_type pos = str.find_last_not_of(' ');
    if(pos != string::npos)
    {
        str.erase(pos + 1);
        pos = str.find_first_not_of(' ');
        if(pos != string::npos) str.erase(0, pos);
    }
    else str.erase(str.begin(), str.end());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x20, %esi
movq $-0x1, %rdx
callq 0x3220
movq %rax, -0x10(%rbp)
cmpq $-0x1, -0x10(%rbp)
je 0x37c4
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x1, %rsi
movq $-0x1, %rdx
callq 0x30e0
movq -0x8(%rbp), %rdi
movl $0x20, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x32f0
movq %rax, -0x10(%rbp)
cmpq $-0x1, -0x10(%rbp)
je 0x37c2
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x30e0
jmp 0x3815
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
callq 0x32d0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x3e80
movq -0x8(%rbp), %rdi
callq 0x31e0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3e80
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x30c0
movq %rax, -0x38(%rbp)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: huanghuide[P]SimpleNetworkTunnel/Common.cpp
// Function: GetBBTime[abi:cxx11]()
string GetBBTime()
{
    string ret = "";
    char buf[256];
    struct tm* local;
    time_t t;

    t = time(NULL);
    local = localtime(&t);

    sprintf(buf, "%02d:%02d:%02d", local->tm_hour, local->tm_min, local->tm_sec);
    ret += buf;

    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
movq %rdi, -0x140(%rbp)
movq %rdi, %rax
movq %rax, -0x148(%rbp)
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
leaq -0xa(%rbp), %rdi
movq %rdi, -0x138(%rbp)
callq 0x34d0
movq -0x140(%rbp), %rdi
movq -0x138(%rbp), %rdx
leaq 0x7bc5(%rip), %rsi      # 0xb42e
callq 0x3ec0
jmp 0x3870
leaq -0xa(%rbp), %rdi
callq 0x3390
xorl %eax, %eax
movl %eax, -0x154(%rbp)
movl %eax, %edi
callq 0x3300
movq %rax, -0x130(%rbp)
leaq -0x130(%rbp), %rdi
callq 0x3260
movq %rax, %rcx
movl -0x154(%rbp), %eax
movq %rcx, -0x128(%rbp)
movq -0x128(%rbp), %rcx
movl 0x8(%rcx), %edx
movl (%rcx), %r8d
movl 0x4(%rcx), %ecx
leaq 0x7742(%rip), %rsi      # 0xb004
leaq -0x120(%rbp), %rdi
movq %rdi, -0x150(%rbp)
callq 0x30b0
movq -0x140(%rbp), %rdi
movq -0x150(%rbp), %rsi
callq 0x3320
jmp 0x38ea
movb $0x1, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
jne 0x3933
jmp 0x3927
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0xa(%rbp), %rdi
callq 0x3390
jmp 0x3943
movq -0x140(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x3210
jmp 0x3943
movq -0x140(%rbp), %rdi
callq 0x3210
movq -0x148(%rbp), %rax
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x34c0
nopl (%rax)
// File: huanghuide[P]SimpleNetworkTunnel/Common.cpp
// Function: DelSockFdFromSet(int)
void DelSockFdFromSet(int sockFd)
{
    if ((sockFd > 0) && (FD_ISSET(sockFd, &gReadSockFdSet)))
    {
        FD_CLR(sockFd, &gReadSockFdSet);
    }

    if ((sockFd > 0) && (FD_ISSET(sockFd, &gWriteSockFdSet)))
    {
        FD_CLR(sockFd, &gWriteSockFdSet);
    }

    while ((gMaxSockFd > 0) && (!FD_ISSET(gMaxSockFd, &gReadSockFdSet)))
    {
        gMaxSockFd--;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jle 0x3aaa
movl -0x4(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movslq %eax, %rcx
leaq 0xe50a(%rip), %rax      # 0x11f40
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movq -0x10(%rbp), %rax
movl %edx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0x3aaa
movl -0x4(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movl %edx, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
xorq $-0x1, %rax
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movq -0x18(%rbp), %rdx
movslq %eax, %rcx
leaq 0xe4a5(%rip), %rax      # 0x11f40
andq (%rax,%rcx,8), %rdx
leaq 0xe49a(%rip), %rax      # 0x11f40
movq %rdx, (%rax,%rcx,8)
cmpl $0x0, -0x4(%rbp)
jle 0x3b3d
movl -0x4(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movslq %eax, %rcx
leaq 0xe4f7(%rip), %rax      # 0x11fc0
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movl -0x4(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movq -0x20(%rbp), %rax
movl %edx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0x3b3d
movl -0x4(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movl %edx, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
xorq $-0x1, %rax
movq %rax, -0x28(%rbp)
movl -0x4(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movq -0x28(%rbp), %rdx
movslq %eax, %rcx
leaq 0xe492(%rip), %rax      # 0x11fc0
andq (%rax,%rcx,8), %rdx
leaq 0xe487(%rip), %rax      # 0x11fc0
movq %rdx, (%rax,%rcx,8)
jmp 0x3b3f
xorl %eax, %eax
cmpl $0x0, 0xe4f8(%rip)      # 0x12040
movb %al, -0x29(%rbp)
jle 0x3b9b
movl 0xe4ed(%rip), %eax      # 0x12040
movl $0x40, %ecx
cltd
idivl %ecx
movslq %eax, %rcx
leaq 0xe3db(%rip), %rax      # 0x11f40
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
movl 0xe4cd(%rip), %eax      # 0x12040
movl $0x40, %ecx
cltd
idivl %ecx
movq -0x38(%rbp), %rax
movl %edx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x3ba4
jmp 0x3bb5
movl 0xe496(%rip), %eax      # 0x12040
addl $-0x1, %eax
movl %eax, 0xe48d(%rip)      # 0x12040
jmp 0x3b3f
popq %rbp
retq
nopw (%rax,%rax)
// File: huanghuide[P]SimpleNetworkTunnel/Common.cpp
// Function: CloseSockFd(int)
void CloseSockFd(int sockFd)
{
    if (sockFd > 0)
    {
        gRunnerManager.DeleteRunner(sockFd);
        DelSockFdFromSet(sockFd);
        
        close(sockFd);        
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jle 0x3bf0
movl -0x4(%rbp), %esi
leaq 0xe325(%rip), %rdi      # 0x11f00
callq 0x80b0
movl -0x4(%rbp), %edi
callq 0x3a10
movl -0x4(%rbp), %edi
callq 0x3500
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: huanghuide[P]SimpleNetworkTunnel/Common.cpp
// Function: SockSendPacket(int, char*, int)
int SockSendPacket(int sockFd, char* buf, int bufLen)
{
    int ret = -1;

    if ((sockFd > 0) && (buf != NULL) && (bufLen > 0))
    {
        int nLeft = bufLen;        
        int nSend = 0;
        int tmpRet = 0;
        int errCount = 0;

        while (nLeft > 0)
        {
            tmpRet = send(sockFd, (buf + nSend), nLeft, 0);

            if (tmpRet < 0)
            {
                if (/*(errno == EAGAIN) || */(errno == EWOULDBLOCK) || (errno == EINTR) || (errno == EINPROGRESS))
                {
                    errCount++;
                    
                    if (errCount > 5)
                    {
                        gLog.Write("SockSendPacket: error count exceeds 2 times! errno %d\n", errno);
                        break;
                    }
                    else
                    {
                        usleep(1000);
                        continue;
                    }
                }
                else
                {
                    gLog.Write("SockSendPacket: send socket error! errno %d\n", errno);
                    break;
                }
            }
            else if (tmpRet == 0)
            {
                ret = 0;
                break;
            }
            else
            {
                errCount = 0;
                
                nLeft -= tmpRet;
                nSend += tmpRet;
                ret = nSend;
            }
        }
    }

    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
cmpl $0x0, -0x4(%rbp)
jle 0x3d30
cmpq $0x0, -0x10(%rbp)
je 0x3d30
cmpl $0x0, -0x14(%rbp)
jle 0x3d30
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
cmpl $0x0, -0x1c(%rbp)
jle 0x3d2e
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movslq -0x20(%rbp), %rax
addq %rax, %rsi
movslq -0x1c(%rbp), %rdx
xorl %ecx, %ecx
callq 0x31a0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x3cf7
callq 0x3050
cmpl $0xb, (%rax)
je 0x3c9d
callq 0x3050
cmpl $0x4, (%rax)
je 0x3c9d
callq 0x3050
cmpl $0x73, (%rax)
jne 0x3cd9
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
cmpl $0x5, -0x28(%rbp)
jle 0x3cca
callq 0x3050
movl (%rax), %edx
leaq 0xe23e(%rip), %rdi      # 0x11ef8
leaq 0x7352(%rip), %rsi      # 0xb013
movb $0x0, %al
callq 0x63c0
jmp 0x3d2e
movl $0x3e8, %edi            # imm = 0x3E8
callq 0x3470
jmp 0x3c53
callq 0x3050
movl (%rax), %edx
leaq 0xe211(%rip), %rdi      # 0x11ef8
leaq 0x735c(%rip), %rsi      # 0xb04a
movb $0x0, %al
callq 0x63c0
jmp 0x3d2e
cmpl $0x0, -0x24(%rbp)
jne 0x3d06
movl $0x0, -0x18(%rbp)
jmp 0x3d2e
movl $0x0, -0x28(%rbp)
movl -0x24(%rbp), %ecx
movl -0x1c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x24(%rbp), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x3d29
jmp 0x3c53
jmp 0x3d30
movl -0x18(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: huanghuide[P]SimpleNetworkTunnel/InnerInitiator.cpp
// Function: InnerInitiator::SocketRead(int)
void InnerInitiator::SocketRead(int sockFd)
{
    int newSockFd = accept(mSockFd, (sockaddr*)&mAddr, (socklen_t*)&mAddrLen);

    if (newSockFd > 0)
    {
        InnerRunner* pInnerRunner = new InnerRunner();
        
        if (pInnerRunner != NULL)
        {
            pInnerRunner->SetSockFd(newSockFd);
            //printf("New INNER runner socket. newSockFd %d\n", newSockFd);
        
            AddSockFdIntoSet(newSockFd);            
            gRunnerManager.AddRunner(newSockFd, pInnerRunner);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdx
movl 0xc(%rdx), %edi
movq %rdx, %rsi
addq $0x28, %rsi
addq $0x38, %rdx
callq 0x3110
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jle 0x5030
movl $0x30, %edi
callq 0x3340
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x5080
jmp 0x4fda
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x502e
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x5040
movl -0x10(%rbp), %edi
callq 0x3950
movl -0x10(%rbp), %esi
movq -0x18(%rbp), %rdx
leaq 0xcef5(%rip), %rdi      # 0x11f00
callq 0x8120
jmp 0x502e
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x30, %esi
callq 0x3360
jmp 0x5036
jmp 0x5030
addq $0x30, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x34c0
nop
// File: huanghuide[P]SimpleNetworkTunnel/InnerRunner.cpp
// Function: InnerRunner::SendPendingMsg()
void InnerRunner::SendPendingMsg()
{
    if (mSockFd > 0)
    {
        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("INNER: Send message to client. mSockFd %d, length %d\n", mSockFd, msgLen);
            //PrintBuf(msgBuf, msgLen);

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

            int sendBytes = SockSendPacket(mSockFd, msgBuf, msgLen);

            if (sendBytes <= 0)
            {
            	delete [] msgBuf;
                ClearAll();

                return;
            }

            delete [] msgBuf;
        }

        mSendMsg.clear();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, 0xc(%rax)
jle 0x535e
movl $0x0, -0xc(%rbp)
movq -0x38(%rbp), %rdi
movslq -0xc(%rbp), %rax
movq %rax, -0x40(%rbp)
addq $0x10, %rdi
callq 0x5750
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x5351
movq -0x38(%rbp), %rdi
addq $0x10, %rdi
movslq -0xc(%rbp), %rsi
callq 0x5770
movq %rax, %rdi
callq 0x3160
movq -0x38(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x10, %rdi
movslq -0xc(%rbp), %rsi
callq 0x5770
movq %rax, %rdi
callq 0x3490
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x3030
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdx
xorl %esi, %esi
callq 0x31c0
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x32a0
leaq 0xafff(%rip), %rax      # 0x102a0
cmpl $0x1, (%rax)
je 0x52b2
leaq 0xaff3(%rip), %rax      # 0x102a0
cmpl $0x2, (%rax)
jne 0x52ec
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x52ea
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
xorl $0xa5, %eax
movb %al, %dl
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x52b9
jmp 0x52ec
movq -0x38(%rbp), %rax
movl 0xc(%rax), %edi
movq -0x28(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x3c00
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
jg 0x532a
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x531f
movq -0x48(%rbp), %rdi
callq 0x3440
movq -0x38(%rbp), %rdi
callq 0x55a0
jmp 0x535e
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x5341
movq -0x50(%rbp), %rdi
callq 0x3440
jmp 0x5343
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5205
movq -0x38(%rbp), %rdi
addq $0x10, %rdi
callq 0x5790
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: huanghuide[P]SimpleNetworkTunnel/InnerRunner.cpp
// Function: InnerRunner::ClearAll()
void InnerRunner::ClearAll()
{
    //printf("Error! Clear all! SockFd %d\n", mSockFd);
    
    if (mOuterRunner != NULL)
    {
        delete mOuterRunner;
        mOuterRunner = NULL;
    }

    delete this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x28(%rax)
je 0x55e3
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x55d7
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, %rax
je 0x55f7
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: huanghuide[P]SimpleNetworkTunnel/Log.cpp
// Function: Log::Write(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Log::Write(string log)
{
    FILE* fp;

    fp = fopen(LOG_FILE, "a");

    if (fp != NULL)
    {
        time_t t;
        struct tm* local;
        char buf[2048];
        
        t = time(NULL);
        local = localtime(&t);

        sprintf(buf, "(%04d-%02d-%02d %02d:%02d:%02d) %s\n", (local->tm_year + 1900), (local->tm_mon + 1), local->tm_mday, local->tm_hour, local->tm_min, local->tm_sec, log.c_str());
        fputs(buf, fp);  

        printf(buf); // Also print to the screen

        fclose(fp);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x870, %rsp            # imm = 0x870
movq %rsi, -0x838(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x4fc5(%rip), %rdi      # 0xb266
leaq 0x4fd6(%rip), %rsi      # 0xb27e
callq 0x3400
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x63b7
xorl %eax, %eax
movl %eax, %edi
callq 0x3300
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3260
movq -0x838(%rbp), %rdi
movq %rax, -0x28(%rbp)
leaq -0x830(%rbp), %rax
movq %rax, -0x858(%rbp)
movq -0x28(%rbp), %rax
movl 0x14(%rax), %eax
addl $0x76c, %eax            # imm = 0x76C
movl %eax, -0x850(%rbp)
movq -0x28(%rbp), %rax
movl 0x10(%rax), %eax
addl $0x1, %eax
movl %eax, -0x84c(%rbp)
movq -0x28(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x848(%rbp)
movq -0x28(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x844(%rbp)
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x840(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x83c(%rbp)
callq 0x3160
movq -0x858(%rbp), %rdi
movl -0x850(%rbp), %edx
movl -0x84c(%rbp), %ecx
movl -0x848(%rbp), %r8d
movl -0x844(%rbp), %r9d
movl -0x840(%rbp), %r11d
movl -0x83c(%rbp), %r10d
leaq 0x4f05(%rip), %rsi      # 0xb280
movl %r11d, (%rsp)
movl %r10d, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movb $0x0, %al
callq 0x30b0
leaq -0x830(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x33d0
leaq -0x830(%rbp), %rdi
movb $0x0, %al
callq 0x3060
movq -0x18(%rbp), %rdi
callq 0x3330
addq $0x870, %rsp            # imm = 0x870
popq %rbp
retq
// File: huanghuide[P]SimpleNetworkTunnel/Log.cpp
// Function: Log::Write(char*, ...)
void Log::Write(char* format, ...)
{
    char buf[2048];
    va_list args;
    
    va_start(args, format);
    vsprintf(buf, format, args);
    va_end(args);

    string bufStr(buf);
    Write(bufStr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x960, %rsp            # imm = 0x960
testb %al, %al
je 0x6407
movaps %xmm0, -0x910(%rbp)
movaps %xmm1, -0x900(%rbp)
movaps %xmm2, -0x8f0(%rbp)
movaps %xmm3, -0x8e0(%rbp)
movaps %xmm4, -0x8d0(%rbp)
movaps %xmm5, -0x8c0(%rbp)
movaps %xmm6, -0x8b0(%rbp)
movaps %xmm7, -0x8a0(%rbp)
movq %r9, -0x918(%rbp)
movq %r8, -0x920(%rbp)
movq %rcx, -0x928(%rbp)
movq %rdx, -0x930(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x958(%rbp)
leaq -0x940(%rbp), %rax
movq %rax, -0x820(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x828(%rbp)
movl $0x30, -0x82c(%rbp)
movl $0x10, -0x830(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x810(%rbp), %rdi
movq %rdi, -0x950(%rbp)
leaq -0x830(%rbp), %rdx
callq 0x3190
leaq -0x851(%rbp), %rdi
movq %rdi, -0x948(%rbp)
callq 0x34d0
movq -0x950(%rbp), %rsi
movq -0x948(%rbp), %rdx
leaq -0x850(%rbp), %rdi
callq 0x3ec0
jmp 0x64b0
leaq -0x851(%rbp), %rdi
callq 0x3390
leaq -0x888(%rbp), %rdi
leaq -0x850(%rbp), %rsi
callq 0x3170
jmp 0x64d1
movq -0x958(%rbp), %rdi
leaq -0x888(%rbp), %rsi
callq 0x6280
jmp 0x64e6
leaq -0x888(%rbp), %rdi
callq 0x3210
leaq -0x850(%rbp), %rdi
callq 0x3210
addq $0x960, %rsp            # imm = 0x960
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x860(%rbp)
movl %eax, -0x864(%rbp)
leaq -0x851(%rbp), %rdi
callq 0x3390
jmp 0x6565
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x860(%rbp)
movl %eax, -0x864(%rbp)
jmp 0x6559
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x860(%rbp)
movl %eax, -0x864(%rbp)
leaq -0x888(%rbp), %rdi
callq 0x3210
leaq -0x850(%rbp), %rdi
callq 0x3210
movq -0x860(%rbp), %rdi
callq 0x34c0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdx
leaq 0xb95e(%rip), %rdi      # 0x11ef8
leaq 0x4d03(%rip), %rsi      # 0xb2a4
movb $0x0, %al
callq 0x63c0
cmpq $0x0, -0x8(%rbp)
je 0x6763
movq -0x8(%rbp), %rdi
movl $0x3a, %esi
callq 0x3140
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6761
movl -0x10(%rbp), %eax
movl -0x8(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0xe4(%rbp)
movq -0x8(%rbp), %rsi
movslq -0xe4(%rbp), %rdx
leaq -0xe0(%rbp), %rdi
movq %rdi, -0x130(%rbp)
callq 0x32a0
movslq -0xe4(%rbp), %rax
movb $0x0, -0xe0(%rbp,%rax)
leaq -0x109(%rbp), %rdi
movq %rdi, -0x128(%rbp)
callq 0x34d0
movq -0x130(%rbp), %rsi
movq -0x128(%rbp), %rdx
leaq -0x108(%rbp), %rdi
callq 0x3ec0
jmp 0x663a
leaq -0x109(%rbp), %rdi
callq 0x3390
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
callq 0x34a0
movl %eax, -0x120(%rbp)
leaq -0x108(%rbp), %rdi
callq 0x3490
cmpq $0x0, %rax
jbe 0x6755
cmpl $0x0, -0x120(%rbp)
jle 0x6755
leaq 0xb86d(%rip), %rax      # 0x11ef0
movl (%rax), %eax
movl %eax, -0x134(%rbp)
leaq -0x108(%rbp), %rdi
callq 0x3160
movl -0x134(%rbp), %edx
movq %rax, %rcx
movl -0x120(%rbp), %r8d
leaq 0xb84a(%rip), %rdi      # 0x11ef8
leaq 0x4bff(%rip), %rsi      # 0xb2b4
xorl %eax, %eax
callq 0x63c0
jmp 0x66be
leaq 0xb82b(%rip), %rax      # 0x11ef0
movslq (%rax), %rax
shlq $0x5, %rax
leaq 0x9bfd(%rip), %rdi      # 0x102d0
addq %rax, %rdi
leaq -0x108(%rbp), %rsi
callq 0x3040
jmp 0x66e4
movl -0x120(%rbp), %edx
leaq 0xb7ff(%rip), %rax      # 0x11ef0
movslq (%rax), %rcx
leaq 0xb4d5(%rip), %rax      # 0x11bd0
movl %edx, (%rax,%rcx,4)
leaq 0xb7eb(%rip), %rax      # 0x11ef0
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0xb7df(%rip), %rax      # 0x11ef0
movl %ecx, (%rax)
jmp 0x6755
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x118(%rbp)
movl %eax, -0x11c(%rbp)
leaq -0x109(%rbp), %rdi
callq 0x3390
jmp 0x676c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x118(%rbp)
movl %eax, -0x11c(%rbp)
leaq -0x108(%rbp), %rdi
callq 0x3210
jmp 0x676c
leaq -0x108(%rbp), %rdi
callq 0x3210
jmp 0x6763
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
movq -0x118(%rbp), %rdi
callq 0x34c0
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl $0x5, %esi
callq 0x7e50
movq -0x30(%rbp), %rdi
leaq 0x8c53(%rip), %rax      # 0xfd30
movq %rax, (%rdi)
movq -0x10(%rbp), %rax
movq %rax, 0x28(%rdi)
movl $0x0, 0x30(%rdi)
addq $0x38, %rdi
movq %rdi, -0x28(%rbp)
callq 0x3450
movq -0x28(%rbp), %rdi
leaq 0xaded(%rip), %rax      # 0x11ef4
movl (%rax), %eax
leaq 0xade0(%rip), %rcx      # 0x11ef0
movl (%rcx), %ecx
cltd
idivl %ecx
movslq %edx, %rax
shlq $0x5, %rax
leaq 0x91ad(%rip), %rsi      # 0x102d0
addq %rax, %rsi
callq 0x3040
jmp 0x712d
leaq 0xadc0(%rip), %rax      # 0x11ef4
movl (%rax), %eax
leaq 0xadb3(%rip), %rcx      # 0x11ef0
cltd
idivl (%rcx)
movq -0x30(%rbp), %rax
movslq %edx, %rdx
leaq 0xaa82(%rip), %rcx      # 0x11bd0
movl (%rcx,%rdx,4), %ecx
movl %ecx, 0x58(%rax)
leaq 0xad99(%rip), %rax      # 0x11ef4
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0xad8d(%rip), %rax      # 0x11ef4
movl %ecx, (%rax)
leaq 0xad84(%rip), %rax      # 0x11ef4
movl (%rax), %eax
leaq 0xad77(%rip), %rcx      # 0x11ef0
cltd
idivl (%rcx)
leaq 0xad71(%rip), %rax      # 0x11ef4
movl %edx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x3210
movq -0x30(%rbp), %rdi
callq 0x7e90
movq -0x18(%rbp), %rdi
callq 0x34c0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, 0xc(%rax)
jle 0x73e1
movq -0x10(%rbp), %rax
movl 0xc(%rax), %edi
callq 0x3bc0
movq -0x10(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x73f9
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x56c0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: huanghuide[P]SimpleNetworkTunnel/OuterRunner.cpp
// Function: OuterRunner::SocketTimeout()
void OuterRunner::SocketTimeout()
{
    //printf("SocketTimeout: mSockFd %d, mSendStatus %d\n", mSockFd, mSendStatus);
    
    if (mSendStatus == INIT)
    {
    }
    if (mSendStatus == CONNECTING)
    {
        ProcessConnectingStatus();
    }
    else
    {
        SendPendingMsg();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, 0x30(%rax)
jne 0x741c
jmp 0x741c
movq -0x10(%rbp), %rax
cmpl $0x1, 0x30(%rax)
jne 0x7431
movq -0x10(%rbp), %rdi
callq 0x7440
jmp 0x743a
movq -0x10(%rbp), %rdi
callq 0x7550
addq $0x10, %rsp
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, 0xc(%rax)
jle 0x753f
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x31c0
movq -0x28(%rbp), %rax
movw $0x2, -0x18(%rbp)
movl 0x58(%rax), %eax
movzwl %ax, %edi
callq 0x3070
movq -0x28(%rbp), %rdi
movw %ax, -0x16(%rbp)
addq $0x38, %rdi
callq 0x3160
movq %rax, %rdi
callq 0x3350
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, -0x14(%rbp)
movl 0xc(%rax), %edi
leaq -0x18(%rbp), %rsi
movl $0x10, %edx
callq 0x32b0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x7529
callq 0x3050
cmpl $0x73, (%rax)
je 0x74d3
callq 0x3050
cmpl $0x72, (%rax)
jne 0x74e0
movq -0x28(%rbp), %rax
movl $0x1, 0x30(%rax)
jmp 0x7527
callq 0x3050
cmpl $0x6a, (%rax)
jne 0x7500
movq -0x28(%rbp), %rdi
callq 0x7d40
movq -0x28(%rbp), %rax
movl $0x2, 0x30(%rax)
jmp 0x7525
callq 0x3050
movl (%rax), %edx
leaq 0xa9ea(%rip), %rdi      # 0x11ef8
leaq 0x3ea9(%rip), %rsi      # 0xb3be
movb $0x0, %al
callq 0x63c0
movq -0x28(%rbp), %rdi
callq 0x73b0
jmp 0x7527
jmp 0x753d
movq -0x28(%rbp), %rdi
callq 0x7d40
movq -0x28(%rbp), %rax
movl $0x2, 0x30(%rax)
jmp 0x753f
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpl $0x0, 0xc(%rax)
jle 0x7e36
movq -0x50(%rbp), %rax
movl 0xc(%rax), %edi
movl $0x3, %esi
xorl %edx, %edx
movb $0x0, %al
callq 0x31d0
movl %eax, %ecx
movq -0x50(%rbp), %rax
movl %ecx, -0xc(%rbp)
movl 0xc(%rax), %edi
movl -0xc(%rbp), %edx
andl $0xfffff7ff, %edx       # imm = 0xFFFFF7FF
movl $0x4, %esi
movb $0x0, %al
callq 0x31d0
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x7e21
leaq -0x31(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x34d0
movq -0x58(%rbp), %rdx
leaq 0x3635(%rip), %rsi      # 0xb3ee
leaq -0x30(%rbp), %rdi
callq 0x3ec0
jmp 0x7dc4
leaq 0xa12d(%rip), %rdi      # 0x11ef8
leaq -0x30(%rbp), %rsi
callq 0x6280
jmp 0x7dd6
leaq -0x30(%rbp), %rdi
callq 0x3210
leaq -0x31(%rbp), %rdi
callq 0x3390
movq -0x50(%rbp), %rdi
callq 0x73b0
jmp 0x7e2d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x7e16
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3210
leaq -0x31(%rbp), %rdi
callq 0x3390
jmp 0x7e3c
movq -0x50(%rbp), %rax
movl 0xc(%rax), %edi
callq 0x3950
movq -0x50(%rbp), %rdi
callq 0x7550
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x34c0
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq $0x0, -0x18(%rbp)
addq $0x8, %rdi
leaq -0xc(%rbp), %rsi
callq 0x8410
movq -0x38(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x8, %rdi
callq 0x8470
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x8440
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x29(%rbp)
jne 0x81bc
jmp 0x81d0
leaq -0x20(%rbp), %rdi
callq 0x85b0
cmpq $0x0, 0x8(%rax)
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x81d9
jmp 0x81ea
leaq -0x20(%rbp), %rdi
callq 0x85b0
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x85d0
leaq -0x40(%rbp), %rdi
callq 0x85f0
movq -0xb0(%rbp), %rdi
addq $0x8, %rdi
callq 0x8610
movq %rax, -0x48(%rbp)
movq -0xb0(%rbp), %rdi
addq $0x8, %rdi
callq 0x8470
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x8440
testb $0x1, %al
jne 0x8267
jmp 0x82ca
leaq -0x48(%rbp), %rdi
callq 0x85b0
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
callq 0x8640
movb %dl, -0xb9(%rbp)
movq %rax, -0xb8(%rbp)
jmp 0x828b
movb -0xb9(%rbp), %al
movq -0xb8(%rbp), %rcx
movq %rcx, -0x70(%rbp)
movb %al, -0x68(%rbp)
leaq -0x48(%rbp), %rdi
xorl %esi, %esi
callq 0x8690
movq %rax, -0x78(%rbp)
jmp 0x8240
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x87c0
jmp 0x8400
leaq -0x38(%rbp), %rdi
callq 0x86d0
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x8730
movq %rax, -0x88(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x8700
testb $0x1, %al
jne 0x8308
jmp 0x83ee
movq -0xb0(%rbp), %rax
addq $0x8, %rax
movq %rax, -0xd0(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x8760
movq -0xd0(%rbp), %rdi
movq %rax, %rsi
callq 0x8410
movq %rax, -0xc8(%rbp)
jmp 0x833b
movq -0xb0(%rbp), %rdi
movq -0xc8(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x48(%rbp)
addq $0x8, %rdi
callq 0x8470
movq %rax, -0x98(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x8440
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0xd1(%rbp)
jne 0x838c
jmp 0x83a3
leaq -0x48(%rbp), %rdi
callq 0x85b0
cmpq $0x0, 0x8(%rax)
setne %al
movb %al, -0xd1(%rbp)
movb -0xd1(%rbp), %al
testb $0x1, %al
jne 0x83af
jmp 0x83d7
leaq -0x48(%rbp), %rdi
callq 0x85b0
movq 0x8(%rax), %rax
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rdi
movq (%rdi), %rax
movq 0x20(%rax), %rax
callq *%rax
jmp 0x83d5
jmp 0x83d7
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0x8780
movq %rax, -0xa8(%rbp)
jmp 0x82df
leaq -0x38(%rbp), %rdi
callq 0x87c0
addq $0xe0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x34c0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movl $0x0, -0x4(%rbp)
leaq 0x2d4c(%rip), %rsi      # 0x4035
leaq -0x90(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
movl $0x20, %edx
callq 0x2c70
movq -0xe8(%rbp), %rdi
callq 0x2d20
movq %rdx, -0xe0(%rbp)
movq %rax, -0xd8(%rbp)
jmp 0x131d
movq -0xe0(%rbp), %rax
movq -0xd8(%rbp), %rcx
movq %rcx, -0xa8(%rbp)
movq %rax, -0xa0(%rbp)
leaq -0xa8(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rdi
callq 0x2da0
movq %rax, -0xf0(%rbp)
jmp 0x135c
movq -0xf0(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0x98(%rbp), %rdi
callq 0x2dc0
movq %rax, -0xf8(%rbp)
jmp 0x137f
movq -0xf8(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0xc0(%rbp), %rax
cmpq -0xc8(%rbp), %rax
je 0x13f6
movq -0xc0(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0xd0(%rbp), %rax
movss 0x2c4a(%rip), %xmm0     # 0x4004
addss (%rax), %xmm0
movss %xmm0, (%rax)
movq -0xc0(%rbp), %rax
addq $0x4, %rax
movq %rax, -0xc0(%rbp)
jmp 0x138d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x2e10
jmp 0x1423
leaq 0x2c42(%rip), %rsi      # 0x403f
leaq -0x90(%rbp), %rdi
callq 0x2de0
jmp 0x140b
leaq -0x90(%rbp), %rdi
callq 0x2e10
movl -0x4(%rbp), %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0xb0(%rbp), %rdi
callq 0x1190
nop
// File: onai[P]npio/./npio.h
// Function: npio_save(char const*, npio_Array const*)
static inline int npio_save(const char* filename, const npio_Array* array)
{
  int fd, err;
  fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
  if (fd < 0)
    return errno;
  err = npio_save_fd(fd, array);
  close(fd);
  return err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x241, %esi            # imm = 0x241
movl $0x1b6, %edx            # imm = 0x1B6
movb $0x0, %al
callq 0x1100
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x275a
callq 0x1030
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x2777
movl -0x1c(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x2780
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %edi
callq 0x11c0
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0xb80, %rsp            # imm = 0xB80
movl $0x0, -0x4(%rbp)
leaq -0xb10(%rbp), %rax
movq %rax, -0xb38(%rbp)
movq %rax, %rcx
addq $0xb00, %rcx            # imm = 0xB00
movq %rcx, -0xb30(%rbp)
movq %rax, -0xb28(%rbp)
movq -0xb28(%rbp), %rdi
movq %rdi, -0xb40(%rbp)
callq 0x45f0
jmp 0x246d
movq -0xb30(%rbp), %rcx
movq -0xb40(%rbp), %rax
addq $0x160, %rax            # imm = 0x160
cmpq %rcx, %rax
movq %rax, -0xb28(%rbp)
jne 0x2458
movl $0x0, -0xb20(%rbp)
callq 0x2600
jmp 0x249e
callq 0x2890
jmp 0x24a5
leaq -0xb10(%rbp), %rdi
leaq -0xb20(%rbp), %rsi
callq 0x2cb0
jmp 0x24ba
movl $0x0, -0x4(%rbp)
leaq -0xb10(%rbp), %rax
movq %rax, -0xb50(%rbp)
addq $0xb00, %rax            # imm = 0xB00
movq %rax, -0xb48(%rbp)
jmp 0x2573
movq -0xb38(%rbp), %rcx
movq %rax, %rsi
movq -0xb40(%rbp), %rax
movq %rsi, -0xb18(%rbp)
movl %edx, -0xb1c(%rbp)
cmpq %rax, %rcx
movq %rax, -0xb58(%rbp)
je 0x253f
movq -0xb58(%rbp), %rdi
addq $-0x160, %rdi           # imm = 0xFEA0
movq %rdi, -0xb60(%rbp)
callq 0x46b0
movq -0xb38(%rbp), %rcx
movq -0xb60(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0xb58(%rbp)
jne 0x250b
jmp 0x25e9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb18(%rbp)
movl %eax, -0xb1c(%rbp)
leaq -0xb10(%rbp), %rax
movq %rax, -0xb70(%rbp)
addq $0xb00, %rax            # imm = 0xB00
movq %rax, -0xb68(%rbp)
jmp 0x25b3
movq -0xb48(%rbp), %rdi
addq $-0x160, %rdi           # imm = 0xFEA0
movq %rdi, -0xb78(%rbp)
callq 0x46b0
movq -0xb50(%rbp), %rcx
movq -0xb78(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0xb48(%rbp)
jne 0x2573
movl -0x4(%rbp), %eax
addq $0xb80, %rsp            # imm = 0xB80
popq %rbp
retq
movq -0xb68(%rbp), %rdi
addq $-0x160, %rdi           # imm = 0xFEA0
movq %rdi, -0xb80(%rbp)
callq 0x46b0
movq -0xb70(%rbp), %rcx
movq -0xb80(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0xb68(%rbp)
jne 0x25b3
jmp 0x25e9
movq -0xb18(%rbp), %rdi
callq 0x2210
nopw %cs:(%rax,%rax)