LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: WbtLm[P]mempool/./mempool.cpp
// Function: mpnsp::memPool::~memPool()
mpnsp::memPool::~memPool()
{
    for(int i=0;i<MaxNodeNum;i++)
    {
        if(nodeArr[i])
        {
            free(nodeArr[i]->memory);
            free(nodeArr[i]->ptrArr);
            free(nodeArr[i]);
        }
    }
    free(nodeArr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x7f, -0xc(%rbp)
jge 0x1917
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x190a
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rdi
callq 0x1110
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x20(%rax), %rdi
callq 0x1110
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1110
jmp 0x190c
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x18ab
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x1110
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: WbtLm[P]mempool/./mempool.cpp
// Function: mpnsp::memPool::memPoolInit()
void mpnsp::memPool::memPoolInit()
{
    int s=sizeof(memNode*)*(MaxNodeNum+1);
    nodeArr=(memNode**)malloc(s);
    if(__builtin_expect(nodeArr==NULL,0))
    {
        myErrorOperate("memPool.nodeArr.create fail",__LINE__,0);
        return;
    }
    memset(nodeArr,0,s);
    //初始化头结点
    memNode *node=(memNode*)malloc(sizeof(memNode));
    if(__builtin_expect(node==NULL,0))
    {
        myErrorOperate("memPool.create head node fail",0);
        return;
    }
    nodeArr[0]=node;
    node->used=0;
    node->deleted=0;
    node->memory=NULL;
    node->head=NULL;
    node->size=0;
    node->ptrArr=NULL;
    node->fptr=0;
    node->nptr=MaxNodeNum+1;
    node->top=-1;
        //创建第一个节点

    int ret=createNewNode(maxNumInNode);
    if(ret<0)
    {
        myErrorOperate("memPool.createNewNode.fail",__LINE__,1);
    }
    topPtr=ret<<OffsetBits;//指向新开辟的node
    status=1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x400, -0xc(%rbp)      # imm = 0x400
movslq -0xc(%rbp), %rdi
callq 0x1130
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
cmpq $0x0, 0x20(%rax)
jne 0x197e
leaq 0x373b(%rip), %rdi      # 0x50a8
movl $0x77, %esi
xorl %edx, %edx
callq 0x13a0
jmp 0x1a6b
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rdi
movslq -0xc(%rbp), %rdx
xorl %esi, %esi
callq 0x1080
movl $0x38, %edi
callq 0x1130
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x19be
leaq 0x3717(%rip), %rdi      # 0x50c4
xorl %esi, %esi
movl $0x1, %edx
callq 0x13a0
jmp 0x1a6b
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rcx
movq 0x20(%rdi), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x18(%rbp), %rax
movb $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x18(%rbp), %rax
movl $0x80, 0x2c(%rax)
movq -0x18(%rbp), %rax
movl $0xffffffff, 0x28(%rax) # imm = 0xFFFFFFFF
movl 0x1c(%rdi), %esi
callq 0x1630
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x1a56
leaq 0x369b(%rip), %rdi      # 0x50e2
movl $0x91, %esi
movl $0x1, %edx
callq 0x13a0
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
shll $0x15, %ecx
movslq %ecx, %rcx
movq %rcx, 0x8(%rax)
movb $0x1, 0x28(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: WbtLm[P]mempool/./mempool.cpp
// Function: mpnsp::memPool::memPool(int, int)
mpnsp::memPool::memPool(int nodeSize,int initNum/*=InitNumInNode*/)
{
    status=0;
    unitSize=nodeSize;
    topPtr=-1;
    nodeNum=0;
    deletedNum=0;
    maxNumInNode=initNum;
    MaxAllocNum=MaxAllocMem/nodeSize;
    if(MaxAllocMem<16)
    {
        myErrorOperate("memPool.MaxAllocMem is too small.",__LINE__,1); //开发阶段就很容易找到的错误
        return;
    }
    if(maxNumInNode>MaxAllocNum)
    {
        maxNumInNode=MaxAllocNum;
    }
    memPoolInit();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq $0x0, 0x20(%rcx)
movb $0x0, 0x28(%rcx)
movl -0xc(%rbp), %eax
movl %eax, (%rcx)
movq $-0x1, 0x8(%rcx)
movl $0x0, 0x10(%rcx)
movl $0x0, 0x14(%rcx)
movl -0x10(%rbp), %eax
movl %eax, 0x1c(%rcx)
movl $0x8000000, %eax        # imm = 0x8000000
cltd
idivl -0xc(%rbp)
movl %eax, 0x18(%rcx)
movl 0x1c(%rcx), %eax
cmpl 0x18(%rcx), %eax
jbe 0x1ae5
movq -0x18(%rbp), %rax
movl 0x18(%rax), %ecx
movl %ecx, 0x1c(%rax)
movq -0x18(%rbp), %rdi
callq 0x1930
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: WbtLm[P]mempool/./mempool.cpp
// Function: mpnsp::do_createMemPool(int, int, std::map<int, mpnsp::memPool*, std::less<int>, std::allocator<std::pair<int const, mpnsp::memPool*>>>&)
int mpnsp::do_createMemPool(int nodeSize,int initNum,std::map<int,memPool*>&memPoolMap)//初始个数
{
 //   cout<<"do_create.初始化内存池:"<<"size="<<nodeSize<<endl;
    if(memPoolMap.count(nodeSize))//不允许重复建立
    {
        myErrorOperate("不允许重复建立",__LINE__,1);
        return 1;
    }
    memPool *pool=new memPool(nodeSize,initNum);
    memPoolMap[nodeSize]=pool;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x4(%rbp), %rsi
callq 0x26b0
cmpq $0x0, %rax
je 0x20e6
leaq 0x30af(%rip), %rdi      # 0x517b
movl $0x152, %esi            # imm = 0x152
movl $0x1, %edx
callq 0x13a0
movl $0x1, %eax
addq $0x40, %rsp
popq %rbp
retq
movl $0x30, %edi
callq 0x10d0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movl -0x4(%rbp), %esi
movl -0x8(%rbp), %edx
callq 0x1a80
jmp 0x2107
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x4(%rbp), %rsi
callq 0x2710
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
ud2
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x30, %esi
callq 0x10e0
movq -0x20(%rbp), %rdi
callq 0x1190
// File: WbtLm[P]mempool/example_memtest.cpp
// Function: main
int main()
{
    node *p[100000];
    int n=1e4;
    int tid=0;//表示第几个线程，而不是单纯的tid。mempool中的map数组会创建PTHREADNUM个map。
    for(int i=0;i<n;i++)
        p[i]=allocNode<node>(tid);
    memPoolMap[tid][sizeof(node)]->debug();
    for(int i=0;i<n;i++)
        freeNode(p[i],tid);
    memPoolMap[tid][sizeof(node)]->debug();
    for(int i=0;i<n;i++)
        p[i]=allocNode<node>(tid);
    memPoolMap[tid][sizeof(node)]->debug();
    for(int i=0;i<n;i++)
        freeNode(p[i],tid);
    memPoolMap[tid][sizeof(node)]->debug();
    cout<<"end"<<endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc3540, %rsp          # imm = 0xC3540
movl $0x0, -0x4(%rbp)
movl $0x2710, -0xc3514(%rbp) # imm = 0x2710
movl $0x0, -0xc3518(%rbp)
movl $0x0, -0xc351c(%rbp)
movl -0xc351c(%rbp), %eax
cmpl -0xc3514(%rbp), %eax
jge 0x241c
movl -0xc3518(%rbp), %edi
callq 0x27f0
movq %rax, %rcx
movslq -0xc351c(%rbp), %rax
movq %rcx, -0xc3510(%rbp,%rax,8)
movl -0xc351c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc351c(%rbp)
jmp 0x23e0
movslq -0xc3518(%rbp), %rax
leaq 0x5ce6(%rip), %rdi      # 0x8110
imulq $0x30, %rax, %rax
addq %rax, %rdi
movl $0x40, -0xc3520(%rbp)
leaq -0xc3520(%rbp), %rsi
callq 0x2880
movq (%rax), %rdi
callq 0x2150
movl $0x0, -0xc3524(%rbp)
movl -0xc3524(%rbp), %eax
cmpl -0xc3514(%rbp), %eax
jge 0x2492
movslq -0xc3524(%rbp), %rax
movq -0xc3510(%rbp,%rax,8), %rdi
movl -0xc3518(%rbp), %esi
callq 0x2960
movl -0xc3524(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc3524(%rbp)
jmp 0x2459
movslq -0xc3518(%rbp), %rax
leaq 0x5c70(%rip), %rdi      # 0x8110
imulq $0x30, %rax, %rax
addq %rax, %rdi
movl $0x40, -0xc3528(%rbp)
leaq -0xc3528(%rbp), %rsi
callq 0x2880
movq (%rax), %rdi
callq 0x2150
movl $0x0, -0xc352c(%rbp)
movl -0xc352c(%rbp), %eax
cmpl -0xc3514(%rbp), %eax
jge 0x250b
movl -0xc3518(%rbp), %edi
callq 0x27f0
movq %rax, %rcx
movslq -0xc352c(%rbp), %rax
movq %rcx, -0xc3510(%rbp,%rax,8)
movl -0xc352c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc352c(%rbp)
jmp 0x24cf
movslq -0xc3518(%rbp), %rax
leaq 0x5bf7(%rip), %rdi      # 0x8110
imulq $0x30, %rax, %rax
addq %rax, %rdi
movl $0x40, -0xc3530(%rbp)
leaq -0xc3530(%rbp), %rsi
callq 0x2880
movq (%rax), %rdi
callq 0x2150
movl $0x0, -0xc3534(%rbp)
movl -0xc3534(%rbp), %eax
cmpl -0xc3514(%rbp), %eax
jge 0x2581
movslq -0xc3534(%rbp), %rax
movq -0xc3510(%rbp,%rax,8), %rdi
movl -0xc3518(%rbp), %esi
callq 0x2960
movl -0xc3534(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc3534(%rbp)
jmp 0x2548
movslq -0xc3518(%rbp), %rax
leaq 0x5b81(%rip), %rdi      # 0x8110
imulq $0x30, %rax, %rax
addq %rax, %rdi
movl $0x40, -0xc3538(%rbp)
leaq -0xc3538(%rbp), %rsi
callq 0x2880
movq (%rax), %rdi
callq 0x2150
movq 0x5a1d(%rip), %rdi      # 0x7fd8
leaq 0x2c2b(%rip), %rsi      # 0x51ed
callq 0x10c0
movq %rax, %rdi
movq 0x59f7(%rip), %rsi      # 0x7fc8
callq 0x1100
movl -0x4(%rbp), %eax
addq $0xc3540, %rsp          # imm = 0xC3540
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: WbtLm[P]mempool/./mempool.cpp
// Function: node* allocNode<node>(int)
T* allocNode(int tid)
{
    #ifndef MEMPOOLOFF
    using namespace mpnsp;
    if(__builtin_expect(!memPoolMap[tid].count(sizeof(T)),0))
    {
        createMemPool<T>(tid);
    }
    memPool &pool=*memPoolMap[tid][sizeof(T)];
    return (T*)pool.allocMemFromPool();
    #else
    return malloc(sizeof(T));
    #endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movslq -0x4(%rbp), %rax
leaq 0x590a(%rip), %rdi      # 0x8110
imulq $0x30, %rax, %rax
addq %rax, %rdi
movl $0x40, -0x8(%rbp)
leaq -0x8(%rbp), %rsi
callq 0x26b0
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x282c
jmp 0x2839
movl -0x4(%rbp), %edi
movl $0x2, %esi
callq 0x4030
movslq -0x4(%rbp), %rax
leaq 0x58cc(%rip), %rdi      # 0x8110
imulq $0x30, %rax, %rax
addq %rax, %rdi
movl $0x40, -0x14(%rbp)
leaq -0x14(%rbp), %rsi
callq 0x2880
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1b00
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: WbtLm[P]mempool/./mempool.cpp
// Function: void freeNode<node>(node*, int)
void freeNode(T* p,int tid)
{
    using namespace mpnsp;
    if(memPoolMap[tid].count(sizeof(T)))
    {
        memPool *pool=memPoolMap[tid][sizeof(T)];
        pool->freeMemToPool(p);
        if(memPoolMap[tid].count(sizeof(T))==0)
        {
            myErrorOperate("free.err",__LINE__);
        }
    }
    else
        free(p);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movslq -0xc(%rbp), %rax
leaq 0x5796(%rip), %rdi      # 0x8110
imulq $0x30, %rax, %rax
addq %rax, %rdi
movl $0x40, -0x10(%rbp)
leaq -0x10(%rbp), %rsi
callq 0x26b0
cmpq $0x0, %rax
je 0x2a0d
movslq -0xc(%rbp), %rax
leaq 0x576e(%rip), %rdi      # 0x8110
imulq $0x30, %rax, %rax
addq %rax, %rdi
movl $0x40, -0x1c(%rbp)
leaq -0x1c(%rbp), %rsi
callq 0x2880
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x1e90
movslq -0xc(%rbp), %rax
leaq 0x5738(%rip), %rdi      # 0x8110
imulq $0x30, %rax, %rax
addq %rax, %rdi
movl $0x40, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x26b0
cmpq $0x0, %rax
jne 0x2a0b
leaq 0x27f5(%rip), %rdi      # 0x51f1
movl $0x145, %esi            # imm = 0x145
movl $0x1, %edx
callq 0x13a0
jmp 0x2a16
movq -0x8(%rbp), %rdi
callq 0x1110
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Czxck001[P]algorithms/src/mom.cc
// Function: auto medianOfGroup<int>(std::vector<int, std::allocator<int>>::iterator, std::vector<int, std::allocator<int>>::iterator)
auto medianOfGroup(VIter<T> l, VIter<T> r) {
  // brutally get the median of a group A
  auto medLoc = l + GROUPSIZE / 2;
  for (auto i = l; i != medLoc + 1; ++i) {
    auto min = i;
    for (auto j = i + 1; j != r; ++j) {
      if (*min > *j) {
        min = j;
      }
    }
    std::iter_swap(min, i);
  }
  return *medLoc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x2320
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x2320
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2a20
testb $0x1, %al
jne 0x24c2
jmp 0x2550
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x2320
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x2a20
testb $0x1, %al
jne 0x24ef
jmp 0x2525
leaq -0x30(%rbp), %rdi
callq 0x23e0
movl (%rax), %eax
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x23e0
movq %rax, %rcx
movl -0x4c(%rbp), %eax
cmpl (%rcx), %eax
jle 0x2518
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x251a
leaq -0x38(%rbp), %rdi
callq 0x2a60
jmp 0x24dc
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x2a80
leaq -0x20(%rbp), %rdi
callq 0x2a60
jmp 0x249a
leaq -0x18(%rbp), %rdi
callq 0x23e0
movl (%rax), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: Czxck001[P]algorithms/src/mom.cc
// Function: auto partition<int>(std::vector<int, std::allocator<int>>::iterator, std::vector<int, std::allocator<int>>::iterator, int)
auto partition(VIter<T> l, VIter<T> r, T P) {
  auto p = l;
  while (*p != P) ++p;  // find the pivot index
  assert(p != r);

  std::iter_swap(p, r - 1);  // move pivot to the end

  auto s = l;  // first not-smaller element
  for (auto i = l; i != r - 1; ++i) {
    if (*i < P) {
      std::iter_swap(i, s++);
    }
  }
  std::iter_swap(s, r - 1);
  return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x23e0
movl (%rax), %eax
cmpl -0x1c(%rbp), %eax
je 0x25c6
leaq -0x28(%rbp), %rdi
callq 0x2a60
jmp 0x25ab
leaq -0x28(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x2a20
testb $0x1, %al
jne 0x25d9
jmp 0x25db
jmp 0x25fa
leaq 0xac9(%rip), %rdi       # 0x30ab
leaq 0xa86(%rip), %rsi       # 0x306f
movl $0x26, %edx
leaq 0xabd(%rip), %rcx       # 0x30b2
callq 0x1070
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x23a0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x2a80
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x23a0
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x2a20
testb $0x1, %al
jne 0x2656
jmp 0x2697
leaq -0x48(%rbp), %rdi
callq 0x23e0
movl (%rax), %eax
cmpl -0x1c(%rbp), %eax
jge 0x268a
movq -0x48(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0x2af0
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x2a80
jmp 0x268c
leaq -0x48(%rbp), %rdi
callq 0x2a60
jmp 0x2631
movq -0x40(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x23a0
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x2a80
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
// File: fuzzythecat[P]SBK-Interpreter/sbk.cpp
// Function: main
int main(int argc, char *argv[])
{	
	char *text, *code;
	bool fin_flag = false;
	vector<int> operation_container; 

	if(argc < 2)
	{
		fprintf(stderr, "[Usage] %s <sbk file>\n", argv[0]);
		return 1;
	}

	text = LoadFile(argv[1]);
	code = TruncateFile(text, &fin_flag); 

	CheckForError(fin_flag);

	StoreOperation(operation_container, code);

	ExecuteOperaions(operation_container, 0);
	
	free(text);
	free(code);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x21(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2c30
cmpl $0x2, -0x8(%rbp)
jge 0x24fb
movq 0x5b08(%rip), %rax      # 0x7fd8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0x2b2f(%rip), %rsi      # 0x5010
movb $0x0, %al
callq 0x21d0
movl $0x1, -0x4(%rbp)
movl $0x1, -0x44(%rbp)
jmp 0x2594
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x25b0
movq %rax, -0x60(%rbp)
jmp 0x250e
movq -0x60(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x21(%rbp), %rsi
callq 0x26c0
movq %rax, -0x68(%rbp)
jmp 0x2529
movq -0x68(%rbp), %rax
movq %rax, -0x20(%rbp)
movzbl -0x21(%rbp), %edi
andl $0x1, %edi
callq 0x28c0
jmp 0x253f
movq -0x20(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x2900
jmp 0x254e
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0x2970
jmp 0x255b
movq -0x18(%rbp), %rdi
callq 0x2190
movq -0x20(%rbp), %rdi
callq 0x2190
movl $0x0, -0x4(%rbp)
movl $0x1, -0x44(%rbp)
jmp 0x2594
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2c50
jmp 0x25a6
leaq -0x40(%rbp), %rdi
callq 0x2c50
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x2250
nop
// File: fuzzythecat[P]SBK-Interpreter/sbk.cpp
// Function: LoadFile(char const*)
char* LoadFile(char const *path)
{
	FILE *fp;
	char *file;
	int size;

	fp = fopen (path ,"rb");
	if(!fp) perror(path),exit(1);

	fseek(fp, 0L, SEEK_END);
	size = ftell(fp);
	rewind(fp);

	file = (char*)calloc(1, size+1);
	if(!file)
	{
		fclose(fp); 
		fputs("Failed to allocate memory", stderr); 
		exit(1);
	}

	if(fread(file, size, 1, fp) != 1)
	{
		fclose(fp); 
		free(file); 
		fputs("Failed to read the entire file", stderr); 
		exit(1);
	}
	fclose(fp);

	return file;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x2a60(%rip), %rsi      # 0x5027
callq 0x2180
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x25ea
movq -0x8(%rbp), %rdi
callq 0x2100
movl $0x1, %edi
callq 0x21a0
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x2150
movq -0x10(%rbp), %rdi
callq 0x2030
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2050
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
movl $0x1, %edi
callq 0x20e0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2658
movq -0x10(%rbp), %rdi
callq 0x2120
movq 0x5999(%rip), %rax      # 0x7fd8
movq (%rax), %rsi
leaq 0x29e1(%rip), %rdi      # 0x502a
callq 0x2160
movl $0x1, %edi
callq 0x21a0
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
movq -0x10(%rbp), %rcx
movl $0x1, %edx
callq 0x21f0
cmpq $0x1, %rax
je 0x26a6
movq -0x10(%rbp), %rdi
callq 0x2120
movq -0x18(%rbp), %rdi
callq 0x2190
movq 0x594b(%rip), %rax      # 0x7fd8
movq (%rax), %rsi
leaq 0x29ad(%rip), %rdi      # 0x5044
callq 0x2160
movl $0x1, %edi
callq 0x21a0
movq -0x10(%rbp), %rdi
callq 0x2120
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: fuzzythecat[P]SBK-Interpreter/sbk.cpp
// Function: StoreOperation(std::vector<int, std::allocator<int>>&, char*)
void StoreOperation(vector<int>& operation_container, char *code)
{
	char *binary = strtok(code, "|");
	while(binary != NULL)
	{
		operation_container.push_back(BinaryToDecimal(binary));
		binary = strtok(NULL, "|");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x2752(%rip), %rsi      # 0x506d
callq 0x2210
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2962
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x29e0
movq -0x28(%rbp), %rdi
movl %eax, -0x1c(%rbp)
leaq -0x1c(%rbp), %rsi
callq 0x2cb0
xorl %eax, %eax
movl %eax, %edi
leaq 0x2716(%rip), %rsi      # 0x506d
callq 0x2210
movq %rax, -0x18(%rbp)
jmp 0x2924
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: fuzzythecat[P]SBK-Interpreter/sbk.cpp
// Function: BinaryToDecimal(char const*)
int BinaryToDecimal(char const *binary)
{
	int dec = 0, digit = strlen(binary);
	for(int i = 0; i < digit; ++i)
		dec += (int)pow(2.0, digit - i-1) * (binary[i] - '0');
	return dec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2090
movl %eax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x2a4b
movl -0x10(%rbp), %edi
subl -0x14(%rbp), %edi
subl $0x1, %edi
movsd 0x25e9(%rip), %xmm0     # 0x5008
callq 0x2ce0
cvttsd2si %xmm0, %eax
movq -0x8(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
subl $0x30, %ecx
imull %ecx, %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2a06
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: fuzzythecat[P]SBK-Interpreter/sbk.cpp
// Function: RunOperation(int, std::vector<int, std::allocator<int>>&, int)
void RunOperation(int operation, vector<int>& operation_container, int operation_idx)
{
	if(operation <= 5 && operation >= 0)
		OperationTable[operation]();
	else if(operation == BEGIN_WHILE)
		BeginDoWhile(operation_container, operation_idx);
	else if(operation == END_WHILE)
		EndDoWhile(operation_container, operation_idx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x5, -0x4(%rbp)
jg 0x2a8e
cmpl $0x0, -0x4(%rbp)
jl 0x2a8e
movslq -0x4(%rbp), %rcx
leaq 0x56c7(%rip), %rax      # 0x8150
callq *(%rax,%rcx,8)
jmp 0x2ab8
cmpl $0x6, -0x4(%rbp)
jne 0x2aa2
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x2b20
jmp 0x2ab6
cmpl $0x7, -0x4(%rbp)
jne 0x2ab4
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x2b50
jmp 0x2ab6
jmp 0x2ab8
addq $0x20, %rsp
popq %rbp
retq
nop
// File: fuzzythecat[P]SBK-Interpreter/sbk.cpp
// Function: EndDoWhile(std::vector<int, std::allocator<int>>&, int)
void EndDoWhile(vector<int>& operation_container, int operation_idx)
{	
	if(loop_stack.empty())
	{
		fputs("No matching { for }\n", stderr);
		exit(1);
	}	
	if(*(c_ptr) != 0)
		LoopOperations(operation_container, loop_stack.top(), operation_idx);
	else
		loop_stack.pop();	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0xf988a(%rip), %rdi     # 0xfc3f0
callq 0x2d80
testb $0x1, %al
jne 0x2b71
jmp 0x2b91
movq 0x5460(%rip), %rax      # 0x7fd8
movq (%rax), %rsi
leaq 0x2518(%rip), %rdi      # 0x509a
callq 0x2160
movl $0x1, %edi
callq 0x21a0
movq 0x55a8(%rip), %rax      # 0x8140
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x2bc4
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0xf9841(%rip), %rdi     # 0xfc3f0
callq 0x2da0
movq -0x18(%rbp), %rdi
movl (%rax), %esi
movl -0xc(%rbp), %edx
callq 0x2ac0
jmp 0x2bd0
leaq 0xf9825(%rip), %rdi     # 0xfc3f0
callq 0x2dc0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: grogers0[P]dots_and_boxes/Solver.cpp
// Function: main
int main(int argc, char **argv)
{
    std::string solver = argv[0];

    while (true) {
        Board board = read_board(stdin);
        board.set_move_decider(solver);
        Edge m = board.decide_move();
        m.print(stdout);
        fflush(stdout);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xa8(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x2320
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x3350
jmp 0x8aa0
leaq -0x31(%rbp), %rdi
callq 0x21f0
jmp 0x8aab
movq 0x5516(%rip), %rax      # 0xdfc8
movq (%rax), %rsi
leaq -0x90(%rbp), %rdi
callq 0x4d50
jmp 0x8ac3
leaq -0x90(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2cd0
jmp 0x8ad5
leaq -0x90(%rbp), %rdi
callq 0x8b80
movl %eax, -0xac(%rbp)
jmp 0x8ae9
movl -0xac(%rbp), %eax
movw %ax, -0x94(%rbp)
movq 0x54b3(%rip), %rax      # 0xdfb0
movq (%rax), %rsi
leaq -0x94(%rbp), %rdi
callq 0x4310
jmp 0x8b0e
movq 0x549b(%rip), %rax      # 0xdfb0
movq (%rax), %rdi
callq 0x2220
jmp 0x8b1f
leaq -0x90(%rbp), %rdi
callq 0x4f10
jmp 0x8aa9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x21f0
jmp 0x8b76
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x8b6d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x4f10
leaq -0x30(%rbp), %rdi
callq 0x2100
movq -0x40(%rbp), %rdi
callq 0x2310
nop
// File: jp-myk[P]WAVUtil/src/SimpleWAV/WAV.cpp
// Function: WAV::WAV(WAV const&)
WAV::WAV(const WAV& other){
  //init();
  this->createHeader(other.getChannels(), other.getSampleRate(), other.getBit());
    if(this->setData(other.getData(), other.getDataSize())!=0){
      printLOG("copy constructor error.");
      exit(-1);
    }
}

// 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)
movq -0x10(%rbp), %rdi
callq 0x38a0
movw %ax, -0x26(%rbp)
movq -0x10(%rbp), %rdi
callq 0x38c0
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0x38e0
movw -0x26(%rbp), %cx
movl -0x24(%rbp), %edx
movq -0x20(%rbp), %rdi
movzwl %cx, %esi
movzwl %ax, %ecx
callq 0x24c0
movq -0x10(%rbp), %rdi
callq 0x2720
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3900
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl %eax, %edx
callq 0x2570
cmpl $0x0, %eax
je 0x24ac
leaq 0x3b83(%rip), %rdi      # 0x6004
leaq 0x3b89(%rip), %rsi      # 0x6011
leaq 0x3b98(%rip), %rdx      # 0x6027
movl $0x7, %ecx
leaq 0x3b90(%rip), %r8       # 0x602b
movb $0x0, %al
callq 0x2030
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2150
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jp-myk[P]WAVUtil/src/SimpleWAV/WAV.cpp
// Function: WAV::createHeader(unsigned short, unsigned int, unsigned short)
void WAV::createHeader(unsigned short channels, unsigned int samplerate, unsigned short bit){
  memcpy(_riffID, "RIFF", 4);
  memcpy(_wavID, "WAVE", 4);
  memcpy(_fmtID, "fmt ", 4);
  _fmtSize=16;
  _format=1;
  _channels=channels;
  _sampleRate=samplerate;
  _bit=bit;
  _bytePerSec=samplerate*channels*(bit/8);
  _blockSize=(_bit/8)*channels;
  memcpy(_dataID, "data", 4);
  //size
  //dataSize
  //WAVData
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %cx, %ax
movw %si, %cx
movq %rdi, -0x8(%rbp)
movw %cx, -0xa(%rbp)
movl %edx, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x3ba0(%rip), %ecx      # 0x6087
movl %ecx, (%rax)
movl 0x3b9d(%rip), %ecx      # 0x608c
movl %ecx, 0x8(%rax)
movl 0x3b99(%rip), %ecx      # 0x6091
movl %ecx, 0xc(%rax)
movl $0x10, 0x10(%rax)
movw $0x1, 0x14(%rax)
movw -0xa(%rbp), %cx
movw %cx, 0x16(%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x18(%rax)
movw -0x12(%rbp), %cx
movw %cx, 0x22(%rax)
movl -0x10(%rbp), %ecx
movzwl -0xa(%rbp), %eax
imull %eax, %ecx
movzwl -0x12(%rbp), %eax
movl $0x8, %esi
cltd
idivl %esi
movl %eax, %edx
movq -0x20(%rbp), %rax
imull %edx, %ecx
movl %ecx, 0x1c(%rax)
movzwl 0x22(%rax), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x20(%rbp), %rax
movzwl -0xa(%rbp), %edx
imull %edx, %ecx
movw %cx, 0x20(%rax)
movl 0x3b33(%rip), %ecx      # 0x6096
movl %ecx, 0x24(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: jp-myk[P]WAVUtil/src/SimpleWAV/WAV.cpp
// Function: WAV::getData() const
const void* WAV::getData()const{
  if(_channels==1){
    if(_bit==8){
      return (void*)_monoral8;
    }else if(_bit==16){
      return (void*)_monoral16;
      
    }else{
      return (void*)NULL;
    }
  }else   if(_channels==2){
    if(_bit==8){
      return (void*)_stereo8;
      
    }else if(_bit==16){
      return (void*)_stereo16;
    }else{
      return (void*)NULL;
    }
  }else{
    return (void*)NULL;
  }
  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movzwl 0x16(%rax), %eax
cmpl $0x1, %eax
jne 0x2779
movq -0x18(%rbp), %rax
movzwl 0x22(%rax), %eax
cmpl $0x8, %eax
jne 0x2754
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x27ce
movq -0x18(%rbp), %rax
movzwl 0x22(%rax), %eax
cmpl $0x10, %eax
jne 0x276f
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x27ce
movq $0x0, -0x8(%rbp)
jmp 0x27ce
movq -0x18(%rbp), %rax
movzwl 0x16(%rax), %eax
cmpl $0x2, %eax
jne 0x27c6
movq -0x18(%rbp), %rax
movzwl 0x22(%rax), %eax
cmpl $0x8, %eax
jne 0x27a1
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x27ce
movq -0x18(%rbp), %rax
movzwl 0x22(%rax), %eax
cmpl $0x10, %eax
jne 0x27bc
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x27ce
movq $0x0, -0x8(%rbp)
jmp 0x27ce
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jp-myk[P]WAVUtil/src/SimpleWAV/WAV.cpp
// Function: WAV::operator=(WAV const&)
WAV& WAV::operator=( const WAV& other ){
  if (this != &other) {
    this->createHeader(other.getChannels(), other.getSampleRate(), other.getBit());
    if(this->setData(other.getData(), other.getDataSize())!=0){
      printLOG("copy operator error.");
      exit(-1);
    }
  }
  return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq -0x10(%rbp), %rax
je 0x2898
movq -0x10(%rbp), %rdi
callq 0x38a0
movw %ax, -0x26(%rbp)
movq -0x10(%rbp), %rdi
callq 0x38c0
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0x38e0
movw -0x26(%rbp), %cx
movl -0x24(%rbp), %edx
movq -0x18(%rbp), %rdi
movzwl %cx, %esi
movzwl %ax, %ecx
callq 0x24c0
movq -0x10(%rbp), %rdi
callq 0x2720
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3900
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl %eax, %edx
callq 0x2570
cmpl $0x0, %eax
je 0x2896
leaq 0x3799(%rip), %rdi      # 0x6004
leaq 0x379f(%rip), %rsi      # 0x6011
leaq 0x37ca(%rip), %rdx      # 0x6043
movl $0xf, %ecx
leaq 0x37c8(%rip), %r8       # 0x604d
movb $0x0, %al
callq 0x2030
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2150
jmp 0x2898
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jp-myk[P]WAVUtil/src/SimpleWAV/WAV.cpp
// Function: WAV::freeWAVData()
int WAV::freeWAVData(){
  try{
    if(_monoral8!=(Monoral8*)NULL){ 
      std::cout << "free monoral8" << std::endl;
      free(_monoral8);
    }
    if(_monoral16!=(Monoral16*)NULL){
      free(_monoral16);
    }
    if(_stereo8!=(Stereo8*)NULL){
      free(_stereo8);
    }
    if(_stereo16!=(Stereo16*)NULL){
      free(_stereo16);
    }
  }catch(const char* e){
    printLOG("free error");
    printf("%s\n", e);
    exit(-1);
  }
  //_dataSize=0;
  //_sampleCount=0;
  _monoral8=(Monoral8*)NULL;
  _monoral16=(Monoral16*)NULL;
  _stereo8=(Stereo8*)NULL;
  _stereo16=(Stereo16*)NULL;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x38(%rax)
je 0x297a
movq 0x66fa(%rip), %rdi      # 0x8fd0
leaq 0x3785(%rip), %rsi      # 0x6062
callq 0x2100
movq %rax, -0x30(%rbp)
jmp 0x28e8
movq -0x30(%rbp), %rdi
movq 0x66cd(%rip), %rsi      # 0x8fc0
callq 0x2130
jmp 0x28fa
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x2140
jmp 0x297a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x2a03
movq -0x10(%rbp), %rdi
callq 0x2090
movq %rax, -0x20(%rbp)
leaq 0x36cb(%rip), %rdi      # 0x6004
leaq 0x36d1(%rip), %rsi      # 0x6011
leaq 0x3729(%rip), %rdx      # 0x6070
leaq 0x372e(%rip), %r8       # 0x607c
xorl %eax, %eax
movl $0x25, %ecx
callq 0x2030
jmp 0x295c
movq -0x20(%rbp), %rsi
leaq 0x36a6(%rip), %rdi      # 0x600d
xorl %eax, %eax
callq 0x2030
jmp 0x2970
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2150
movq -0x28(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x2992
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x2140
movq -0x28(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x29aa
movq -0x28(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x2140
movq -0x28(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x29c2
movq -0x28(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x2140
jmp 0x29d7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x21e0
jmp 0x2a03
movq -0x28(%rbp), %rax
movq $0x0, 0x38(%rax)
movq $0x0, 0x40(%rax)
movq $0x0, 0x48(%rax)
movq $0x0, 0x50(%rax)
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x2210
nopl (%rax)
// File: jp-myk[P]WAVUtil/src/SimpleWAV/WAVUtil.cpp
// Function: SimpleWAV::split_wav(float, WAV&)
std::vector<WAV> split_wav(float timespan_sec, WAV& wav){
  std::vector<WAV> retval;
  float dataLen_sec = (float)wav.getSampleCount()/wav.getSampleRate();
  if(timespan_sec>=dataLen_sec){
    printf("set time span[%.3f] is longer than data[%.3f]", timespan_sec,dataLen_sec);
    exit(-1);
  }
  int wav_num=(int)dataLen_sec/timespan_sec+1;
  retval.reserve(wav_num);
  
  // last splitted wav is adjusted by left time.
  float startTime=0.0;
  int n=0;
  //char outfname[100];
  while(startTime<dataLen_sec){
    float endTime=startTime+timespan_sec;
    WAV trimwav;
    trim_wav(startTime, endTime, wav, trimwav);
    retval.push_back(trimwav);
    startTime+=timespan_sec;
    n++;
  }
  return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xb0(%rbp)
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x42d0
movq -0x18(%rbp), %rdi
callq 0x42b0
movl %eax, -0x9c(%rbp)
jmp 0x3bc3
movl -0x9c(%rbp), %eax
movl %eax, %eax
cvtsi2ss %rax, %xmm0
movss %xmm0, -0xb8(%rbp)
movq -0x18(%rbp), %rdi
callq 0x38c0
movl %eax, -0xb4(%rbp)
jmp 0x3be9
movss -0xb8(%rbp), %xmm0
movl -0xb4(%rbp), %eax
movl %eax, %eax
cvtsi2ss %rax, %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0x20(%rbp)
movss -0xc(%rbp), %xmm0
ucomiss -0x20(%rbp), %xmm0
jb 0x3c4f
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movss -0x20(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
leaq 0x25aa(%rip), %rdi      # 0x61d5
movb $0x2, %al
callq 0x2030
jmp 0x3c34
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2150
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x3d66
movq -0xb0(%rbp), %rdi
movss -0x20(%rbp), %xmm0
cvttps2dq %xmm0, %xmm0
cvtdq2ps %xmm0, %xmm0
movss -0xc(%rbp), %xmm1
divss %xmm1, %xmm0
movss 0x2539(%rip), %xmm1     # 0x61ac
addss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movl %eax, -0x30(%rbp)
movslq -0x30(%rbp), %rsi
callq 0x42f0
jmp 0x3c89
xorps %xmm0, %xmm0
movss %xmm0, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movss -0x34(%rbp), %xmm1
movss -0x20(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x3d40
movss -0x34(%rbp), %xmm0
movss -0xc(%rbp), %xmm1
addss %xmm1, %xmm0
movss %xmm0, -0x3c(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x4410
jmp 0x3ccc
movss -0x34(%rbp), %xmm0
movss -0x3c(%rbp), %xmm1
movq -0x18(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x3920
jmp 0x3ce8
movq -0xb0(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x4460
jmp 0x3cfd
movss -0xc(%rbp), %xmm0
addss -0x34(%rbp), %xmm0
movss %xmm0, -0x34(%rbp)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x44d0
jmp 0x3c98
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x44d0
jmp 0x3d66
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x3d56
movq -0xb0(%rbp), %rdi
callq 0x4500
movq -0xa8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0xb0(%rbp), %rdi
callq 0x4500
movq -0x28(%rbp), %rdi
callq 0x2210
nopl (%rax,%rax)
// File: jp-myk[P]WAVUtil/src/SimpleWAV/WAV.h
// Function: WAV::WAV()
WAV(){
    init();
    _monoral8=(Monoral8*)NULL;
    _monoral16=(Monoral16*)NULL;
    _stereo8=(Stereo8*)NULL;
    _stereo16=(Stereo16*)NULL;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x4610
movq -0x10(%rbp), %rax
movq $0x0, 0x38(%rax)
movq $0x0, 0x40(%rax)
movq $0x0, 0x48(%rax)
movq $0x0, 0x50(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: jp-myk[P]WAVUtil/src/SimpleWAV/WAV.h
// Function: WAV::init()
void init(){
    _size=0;
    _fmtSize=16;
    _format=1;
    _channels=2;
    _sampleRate=44100;
    _bytePerSec=32000;
    _blockSize=2;
    _bit=16;
    _dataSize=0;
    _sampleCount=0;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movl $0x10, 0x10(%rax)
movw $0x1, 0x14(%rax)
movw $0x2, 0x16(%rax)
movl $0xac44, 0x18(%rax)     # imm = 0xAC44
movl $0x7d00, 0x1c(%rax)     # imm = 0x7D00
movw $0x2, 0x20(%rax)
movw $0x10, 0x22(%rax)
movl $0x0, 0x28(%rax)
movq $0x0, 0x30(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: jp-myk[P]WAVUtil/src/wav_cat.cpp
// Function: main
int main(int argc, char *argv[]){
  if(argc<2){
    std::cout << argv[0] << " FILENAME" << std::endl;
    exit(0);
  }
  const char* wavFName=argv[1];
  WAV wav;
  int res=0;
  res=wav.Read(wavFName);
  if(res!=0){
    std::cout << "error open WAVFILE:" << wavFName << std::endl;
    exit(-1);
  }
  SimpleWAV::cat_wav(wav);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0x5317
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq 0x3ce3(%rip), %rdi      # 0x8fd0
callq 0x2100
movq %rax, %rdi
leaq 0x1021(%rip), %rsi      # 0x631d
callq 0x2100
movq %rax, %rdi
movq 0x3cb5(%rip), %rsi      # 0x8fc0
callq 0x2130
xorl %edi, %edi
callq 0x2150
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
leaq -0x70(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x4410
movq -0x90(%rbp), %rdi
movl $0x0, -0x74(%rbp)
movq -0x18(%rbp), %rsi
callq 0x2e70
movl %eax, -0x88(%rbp)
jmp 0x5352
movl -0x88(%rbp), %eax
movl %eax, -0x74(%rbp)
cmpl $0x0, -0x74(%rbp)
je 0x53cf
movq 0x3c68(%rip), %rdi      # 0x8fd0
leaq 0xfb8(%rip), %rsi       # 0x6327
callq 0x2100
movq %rax, -0x98(%rbp)
jmp 0x537d
movq -0x98(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2100
movq %rax, -0xa0(%rbp)
jmp 0x5396
movq -0xa0(%rbp), %rdi
movq 0x3c1c(%rip), %rsi      # 0x8fc0
callq 0x2130
jmp 0x53ab
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2150
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x44d0
jmp 0x53f6
leaq -0x70(%rbp), %rdi
callq 0x3ff0
jmp 0x53da
movl $0x0, -0x4(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x44d0
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x2210
// File: jixinqi[P]lazurite/./src/main.cpp
// Function: main
int main()
{
    lazurite::http::server http_server;
    http_server.add_route("/", hello_page);
    http_server.add_route("/raw_msg", raw_msg);
    http_server.run();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
leaq -0x10(%rbp), %rdi
callq 0x1e390
leaq -0x31(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x66b0
movq -0xb8(%rbp), %rdx
leaq 0x23798(%rip), %rsi     # 0x2b05a
leaq -0x30(%rbp), %rdi
callq 0x6540
jmp 0x78cd
leaq -0x154(%rip), %rsi      # 0x7780
leaq -0x68(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x8240
movq -0xc0(%rbp), %rdx
leaq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1e3b0
jmp 0x78fa
leaq -0x68(%rbp), %rdi
callq 0x82d0
leaq -0x30(%rbp), %rdi
callq 0x67a8
leaq -0x31(%rbp), %rdi
callq 0x6420
leaq -0x89(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x66b0
movq -0xc8(%rbp), %rdx
leaq 0x23726(%rip), %rsi     # 0x2b05c
leaq -0x88(%rbp), %rdi
callq 0x6540
jmp 0x7944
leaq -0x12b(%rip), %rsi      # 0x7820
leaq -0xb0(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x8240
movq -0xd0(%rbp), %rdx
leaq -0x10(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x1e3b0
jmp 0x7977
leaq -0xb0(%rbp), %rdi
callq 0x82d0
leaq -0x88(%rbp), %rdi
callq 0x67a8
leaq -0x89(%rbp), %rdi
callq 0x6420
leaq -0x10(%rbp), %rdi
callq 0x1e460
jmp 0x79a6
leaq -0x10(%rbp), %rdi
callq 0x82f0
xorl %eax, %eax
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x79e6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x82d0
leaq -0x30(%rbp), %rdi
callq 0x67a8
leaq -0x31(%rbp), %rdi
callq 0x6420
jmp 0x7a3d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x7a23
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x82d0
leaq -0x88(%rbp), %rdi
callq 0x67a8
leaq -0x89(%rbp), %rdi
callq 0x6420
jmp 0x7a3d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x82f0
movq -0x40(%rbp), %rdi
callq 0x6680
nop
// File: jixinqi[P]lazurite/./src/lazurite_core/http_listen.cpp
// Function: lazurite::http::listen::do_accept()
void lazurite::http::listen::do_accept()
{
    acceptor.async_accept(
        socket,
        [this](boost::system::error_code ec)
        {
            if (!ec)
            {
                std::make_shared<session>(io_service_ptr, route_ptr,std::move(socket))->start();
            }
            do_accept();
        }
    );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rdi
addq $0x30, %rdi
movq %rax, %rsi
addq $0x80, %rsi
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0xb680
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jixinqi[P]lazurite/./src/lazurite_core/http_session.cpp
// Function: lazurite::http::session::do_read()
void lazurite::http::session::do_read()
{
    auto self(shared_from_this());
    socket.async_read_some(
        boost::asio::buffer(buffer),
        [this, self](boost::system::error_code ec, std::size_t length)
        {
            if (ec)
            {
                return;
            }

            _request_parser.append_msg(buffer,length);

            if (!_request_parser.do_parse())
            {
                return;
            }

            if (!_request_parser.msg_end())
            {
                do_read();
            }
            else
            {
                do_write();
            }
        }
    );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x60(%rbp)
leaq -0x18(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x23c50
movq -0x60(%rbp), %rdi
movq %rdi, %rax
addq $0x30, %rax
movq %rax, -0x58(%rbp)
subq $-0x80, %rdi
callq 0x23c80
movq -0x68(%rbp), %rsi
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x23cc0
movq -0x58(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x21250
jmp 0x2120c
leaq -0x40(%rbp), %rdi
callq 0x212a0
leaq -0x18(%rbp), %rdi
callq 0x1bd20
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x212a0
leaq -0x18(%rbp), %rdi
callq 0x1bd20
movq -0x48(%rbp), %rdi
callq 0x6680
nopl (%rax,%rax)
// File: jixinqi[P]lazurite/./src/lazurite_core/http_session.cpp
// Function: lazurite::http::session::do_write()
void lazurite::http::session::do_write()
{
    auto self(shared_from_this());
    route_ptr->run_handle(_request_parser.get_request(),_response_build.get_response());
    http_response_msg = _response_build.complete_msg();
    boost::asio::async_write(
        socket,
        boost::asio::buffer(http_response_msg, http_response_msg.length()),
        [this, self](boost::system::error_code ec, std::size_t /*length*/)
        {
            if (ec)
            {
                return;
            }
        }
    );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x88(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x23c50
movq -0x88(%rbp), %rdi
addq $0x20, %rdi
callq 0x1e700
movq -0x88(%rbp), %rdi
movq %rax, -0x80(%rbp)
addq $0x10a0, %rdi           # imm = 0x10A0
callq 0x26890
movq %rax, -0x78(%rbp)
jmp 0x21310
movq -0x88(%rbp), %rdi
addq $0x11c8, %rdi           # imm = 0x11C8
callq 0x25360
movq %rax, -0x90(%rbp)
jmp 0x2132c
movq -0x90(%rbp), %rdx
movq -0x78(%rbp), %rsi
movq -0x80(%rbp), %rdi
callq 0x28840
jmp 0x21342
movq -0x88(%rbp), %rsi
addq $0x11c8, %rsi           # imm = 0x11C8
leaq -0x48(%rbp), %rdi
callq 0x25070
jmp 0x2135b
movq -0x88(%rbp), %rdi
addq $0x1080, %rdi           # imm = 0x1080
movq %rdi, -0xa0(%rbp)
leaq -0x48(%rbp), %rsi
movq %rsi, -0xa8(%rbp)
callq 0x64a0
movq -0xa8(%rbp), %rdi
callq 0x67a8
movq -0xa0(%rbp), %rdi
movq -0x88(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x98(%rbp)
callq 0x65d0
movq -0xa0(%rbp), %rdi
movq %rax, %rsi
callq 0x23cf0
movq %rax, %rcx
movq -0x88(%rbp), %rax
movq %rcx, -0x58(%rbp)
movq %rdx, -0x50(%rbp)
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x23cc0
movq -0x98(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq -0x58(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0x21450
jmp 0x213f6
leaq -0x70(%rbp), %rdi
callq 0x214b0
leaq -0x18(%rbp), %rdi
callq 0x1bd20
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x21434
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x214b0
leaq -0x18(%rbp), %rdi
callq 0x1bd20
movq -0x20(%rbp), %rdi
callq 0x6680
nopw %cs:(%rax,%rax)
// File: jixinqi[P]lazurite/./src/lazurite_core/http_response.cpp
// Function: lazurite::http::response::error_msg_body()
void lazurite::http::response::error_msg_body()
{
    _msg_body.clear();
    _msg_body.append(std::to_string(_status_code))
             .append(" ")
             .append(_phrase);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
addq $0x28, %rdi
movq %rdi, -0x50(%rbp)
callq 0x6500
movq -0x58(%rbp), %rax
movzwl (%rax), %esi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x25400
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x6760
movq %rax, -0x40(%rbp)
jmp 0x25018
movq -0x40(%rbp), %rdi
leaq 0x705d(%rip), %rsi      # 0x2c080
callq 0x6730
movq %rax, -0x60(%rbp)
jmp 0x2502e
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
addq $0x8, %rsi
callq 0x6760
jmp 0x25041
leaq -0x28(%rbp), %rdi
callq 0x67a8
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x67a8
movq -0x30(%rbp), %rdi
callq 0x6680
nop
// File: jixinqi[P]lazurite/./src/lazurite_core/http_request.cpp
// Function: lazurite::http::request_parser::append_msg(std::array<unsigned char, 4096ul> const&, unsigned long const&)
void lazurite::http::request_parser::append_msg(const http_msg_buffer &_http_msg_buffer, const std::size_t &_length)
{
    std::string msg;
    for (std::size_t i = 0; i != _length; i++)
    {
        msg.push_back(_http_msg_buffer.at(i));
    }
    _request.append_raw_msg(msg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x6570
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
je 0x25d96
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x26a00
movq %rax, -0x60(%rbp)
jmp 0x25d5d
movq -0x60(%rbp), %rax
movsbl (%rax), %esi
leaq -0x38(%rbp), %rdi
callq 0x6380
jmp 0x25d6f
jmp 0x25d71
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x25d3d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x67a8
jmp 0x25db4
movq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x25910
jmp 0x25da5
leaq -0x38(%rbp), %rdi
callq 0x67a8
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x6680
nopl (%rax)