LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/WbtLm[P]mempool/./mempool.cpp
// Function: mpnsp::memPool::debug()
void mpnsp::memPool::debug()
    {
        #include<iostream>
        using namespace std;
        cout<<"maxNumInNode="<<maxNumInNode<<endl;
        cout<<"AutoCleanSize="<<AutoCleanSize<<endl;
        cout<<"topPrt=";
        printf("%x\n",topPtr);
        for(int i=0;i<=MaxNodeNum;i++)
        {
            cout<<"["<<i<<"]"<<"deleted=";
            if(nodeArr[i]==NULL)
            {
                cout<<"NULL"<<endl;
            }
            else
            {
                cout<<nodeArr[i]->deleted<<" ";
                printf("%p\t",nodeArr[i]->head);
                cout<<"fptr="<<nodeArr[i]->fptr<<" nptr="<<nodeArr[i]->nptr;
                cout<<" used/size="<<nodeArr[i]->used<<"/"<<nodeArr[i]->size<<endl;
            }
        }
        return;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x35f4(%rip), %r14      # 0x4fd8
leaq 0x161d(%rip), %rsi      # 0x3008
movq %r14, %rdi
callq 0x10e0
movl 0x1c(%rbx), %esi
movq %rax, %rdi
callq 0x10a0
movq %rax, %rdi
callq 0x1080
leaq 0x1609(%rip), %rsi      # 0x3016
movq %r14, %rdi
callq 0x10e0
movl 0x1c(%rbx), %esi
shrl $0x4, %esi
movq %rax, %rdi
callq 0x10a0
movq %rax, %rdi
callq 0x1080
leaq 0x15f3(%rip), %rsi      # 0x3025
movq %r14, %rdi
callq 0x10e0
movq 0x8(%rbx), %rsi
leaq 0x15e8(%rip), %rdi      # 0x302d
xorl %eax, %eax
callq 0x1030
leaq 0x15e0(%rip), %r12      # 0x3033
leaq 0x15db(%rip), %r13      # 0x3035
xorl %r15d, %r15d
cmpq $0x80, %r15
je 0x1b89
movq %r14, %rdi
leaq 0x15bd(%rip), %rsi      # 0x3031
callq 0x10e0
movq %rax, %rdi
movl %r15d, %esi
callq 0x1190
movq %rax, %rdi
movq %r12, %rsi
callq 0x10e0
movq %rax, %rdi
movq %r13, %rsi
callq 0x10e0
movq 0x20(%rbx), %rax
movq (%rax,%r15,8), %rax
testq %rax, %rax
je 0x1b6a
movzbl 0x10(%rax), %esi
movq %r14, %rdi
callq 0x1180
movq %rax, %rdi
leaq 0x1582(%rip), %rsi      # 0x3043
callq 0x10e0
movq 0x20(%rbx), %rax
movq (%rax,%r15,8), %rax
movq 0x8(%rax), %rsi
leaq 0x156c(%rip), %rdi      # 0x3045
xorl %eax, %eax
callq 0x1030
movq %r14, %rdi
leaq 0x155f(%rip), %rsi      # 0x3049
callq 0x10e0
movq 0x20(%rbx), %rcx
movq (%rcx,%r15,8), %rcx
movl 0x30(%rcx), %esi
movq %rax, %rdi
callq 0x10a0
movq %rax, %rdi
leaq 0x1543(%rip), %rsi      # 0x304f
callq 0x10e0
movq 0x20(%rbx), %rcx
movq (%rcx,%r15,8), %rcx
movl 0x2c(%rcx), %esi
movq %rax, %rdi
callq 0x10a0
movq %r14, %rdi
leaq 0x1528(%rip), %rsi      # 0x3056
callq 0x10e0
movq 0x20(%rbx), %rcx
movq (%rcx,%r15,8), %rcx
movl 0x18(%rcx), %esi
movq %rax, %rdi
callq 0x10a0
movq %rax, %rdi
leaq 0x1512(%rip), %rsi      # 0x3062
callq 0x10e0
movq 0x20(%rbx), %rcx
movq (%rcx,%r15,8), %rcx
movl 0x14(%rcx), %esi
movq %rax, %rdi
callq 0x10a0
jmp 0x1b79
movq %r14, %rdi
leaq 0x14ca(%rip), %rsi      # 0x303e
callq 0x10e0
movq %rax, %rdi
callq 0x1080
incq %r15
jmp 0x1a5d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
subq $0xc3508, %rsp          # imm = 0xC3508
xorl %ebx, %ebx
cmpq $0x2710, %rbx           # imm = 0x2710
je 0x1bc3
xorl %edi, %edi
callq 0x1d35
movq %rax, -0xc3510(%rbp,%rbx,8)
incq %rbx
jmp 0x1ba6
leaq -0xc(%rbp), %rsi
movl $0x40, (%rsi)
leaq 0x353c(%rip), %rdi      # 0x5110
callq 0x1d9c
movq (%rax), %rdi
callq 0x19cc
xorl %ebx, %ebx
cmpq $0x2710, %rbx           # imm = 0x2710
je 0x1c00
movq -0xc3510(%rbp,%rbx,8), %rdi
xorl %esi, %esi
callq 0x1ded
incq %rbx
jmp 0x1be3
leaq -0xc(%rbp), %rsi
movl $0x40, (%rsi)
leaq 0x34ff(%rip), %rdi      # 0x5110
callq 0x1d9c
movq (%rax), %rdi
callq 0x19cc
xorl %ebx, %ebx
cmpq $0x2710, %rbx           # imm = 0x2710
je 0x1c3d
xorl %edi, %edi
callq 0x1d35
movq %rax, -0xc3510(%rbp,%rbx,8)
incq %rbx
jmp 0x1c20
leaq -0xc(%rbp), %rsi
movl $0x40, (%rsi)
leaq 0x34c2(%rip), %rdi      # 0x5110
callq 0x1d9c
movq (%rax), %rdi
callq 0x19cc
xorl %ebx, %ebx
cmpq $0x2710, %rbx           # imm = 0x2710
je 0x1c7a
movq -0xc3510(%rbp,%rbx,8), %rdi
xorl %esi, %esi
callq 0x1ded
incq %rbx
jmp 0x1c5d
leaq -0xc(%rbp), %rsi
movl $0x40, (%rsi)
leaq 0x3485(%rip), %rdi      # 0x5110
callq 0x1d9c
movq (%rax), %rdi
callq 0x19cc
movq 0x3339(%rip), %rdi      # 0x4fd8
leaq 0x13be(%rip), %rsi      # 0x3064
callq 0x10e0
movq %rax, %rdi
callq 0x1080
xorl %eax, %eax
addq $0xc3508, %rsp          # imm = 0xC3508
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edi, %r14d
movslq %edi, %rax
imulq $0x30, %rax, %rax
leaq 0x33bf(%rip), %rbx      # 0x5110
addq %rax, %rbx
leaq -0x18(%rbp), %rsi
movl $0x40, (%rsi)
movq %rbx, %rdi
callq 0x1cc0
testq %rax, %rax
je 0x1d8e
leaq -0x14(%rbp), %rsi
movl $0x40, (%rsi)
movq %rbx, %rdi
callq 0x1d9c
movq (%rax), %rdi
callq 0x1720
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x2
popq %rsi
movl %r14d, %edi
callq 0x21e7
jmp 0x1d6b
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movslq %esi, %rax
imulq $0x30, %rax, %rax
leaq 0x3305(%rip), %rbx      # 0x5110
addq %rax, %rbx
leaq -0x24(%rbp), %rsi
movl $0x40, (%rsi)
movq %rbx, %rdi
callq 0x1cc0
testq %rax, %rax
je 0x1e66
pushq $0x40
popq %r15
leaq -0x20(%rbp), %rsi
movl %r15d, (%rsi)
movq %rbx, %rdi
callq 0x1d9c
movq (%rax), %rdi
movq %r14, %rsi
callq 0x188e
leaq -0x1c(%rbp), %rsi
movl %r15d, (%rsi)
movq %rbx, %rdi
callq 0x1cc0
testq %rax, %rax
jne 0x1e6e
pushq $0x1
popq %rdx
movl $0x145, %esi            # imm = 0x145
callq 0x135c
jmp 0x1e6e
movq %r14, %rdi
callq 0x1120
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Czxck001[P]algorithms/src/mom.cc
// Function: int protoSelect<int>(std::vector<int, std::allocator<int>>::iterator, std::vector<int, std::allocator<int>>::iterator, int)
T protoSelect(VIter<T> l, VIter<T> r, int k) {
  assert(l + k < r);

  auto G = (r - l) / GROUPSIZE;
  if (l == r - 1 && k == 0 || G == 0) {
    return *(l + k);
  }

  auto M = std::vector<T>(G);
  for (auto g = 0; g < G; g++) {
    M[g] = medianOfGroup<T>(l + g * GROUPSIZE,
                            l + (g + 1) * GROUPSIZE);
  }  // O(n)

  auto P = protoSelect<T>(M.begin(), M.end(), G / 2);  // T(n / 5)

  auto s = partition<T>(l, r, P);  // O(n)

  if (l + k == s) {
    return *s;
  } else if (l + k < s) {
    return protoSelect<T>(l, s, k);
  } else {  // l + k > s
    return protoSelect<T>(s + 1, r, l + k - s - 1);
  }  // T(7n / 10)

  // T(n) = T(n / 5) + T(7n / 10) + O(n) = O(n)
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r12
movslq %edx, %rax
leaq (%rdi,%rax,4), %rdi
cmpq %rsi, %rdi
jae 0x14c3
movq %rsi, %r13
subq %r12, %r13
sarq $0x2, %r13
leaq -0x4(%rsi), %rax
cmpq %r12, %rax
sete %al
testl %edx, %edx
sete %cl
andb %al, %cl
leaq 0x4(%r13), %rax
cmpq $0x9, %rax
setb %al
orb %cl, %al
cmpb $0x1, %al
jne 0x13f3
movl (%rdi), %ebx
jmp 0x14b2
movl %edx, -0x30(%rbp)
movq %rdi, -0x38(%rbp)
movq %rsi, -0x40(%rbp)
pushq $0x5
popq %rcx
movq %r13, %rax
cqto
idivq %rcx
movq %rax, %r15
leaq -0x58(%rbp), %rdi
leaq -0x29(%rbp), %rdx
movq %rax, %rsi
callq 0x160a
xorl %ebx, %ebx
testq %r15, %r15
cmovleq %rbx, %r15
movq %r12, %rdi
cmpq %rbx, %r15
je 0x1448
leaq 0x14(%rdi), %r14
movq %r14, %rsi
callq 0x165b
movq -0x58(%rbp), %rcx
movl %eax, (%rcx,%rbx,4)
incq %rbx
movq %r14, %rdi
jmp 0x1428
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
pushq $0xa
popq %rcx
movq %r13, %rax
cqto
idivq %rcx
movl %eax, %edx
callq 0x139c
movq %r12, %rdi
movq -0x40(%rbp), %rbx
movq %rbx, %rsi
movl %eax, %edx
callq 0x16a5
movq -0x38(%rbp), %rdx
subq %rax, %rdx
je 0x148e
jae 0x1492
movq %r12, %rdi
movq %rax, %rsi
movl -0x30(%rbp), %edx
callq 0x139c
jmp 0x14a7
movl (%rax), %ebx
jmp 0x14a9
addq $0x4, %rax
shrq $0x2, %rdx
decl %edx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x139c
movl %eax, %ebx
leaq -0x58(%rbp), %rdi
callq 0x1556
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb9b(%rip), %rdi       # 0x2065
leaq 0xb9e(%rip), %rsi       # 0x206f
leaq 0xba2(%rip), %rcx       # 0x207a
pushq $0x36
popq %rdx
callq 0x1080
jmp 0x14e6
jmp 0x14e6
jmp 0x14e6
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x1556
movq %rbx, %rdi
callq 0x1100
// File: /workspace/github_cpp_makefile_star2_O2/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
xorl %eax, %eax
cmpq $0xc, %rax
je 0x16a0
leaq (%rdi,%rax), %rcx
leaq (%rdi,%rax), %rdx
addq $0x4, %rdx
addq $0x4, %rax
movq %rcx, %r8
movl (%r8), %r9d
cmpq %rsi, %rdx
je 0x1696
movq %rdx, %r10
cmpl (%rdx), %r9d
jg 0x168d
movq %r8, %r10
addq $0x4, %rdx
movq %r10, %r8
jmp 0x167a
movl (%rcx), %edx
movl %edx, (%r8)
movl %r9d, (%rcx)
jmp 0x1661
movl 0x8(%rdi), %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq -0x4(%rdi), %rcx
movq %rcx, %rax
addq $0x4, %rcx
cmpl %edx, 0x4(%rax)
jne 0x16ad
cmpq %rsi, %rcx
je 0x16f9
leaq -0x4(%rsi), %rax
movl -0x4(%rsi), %r8d
movl %r8d, (%rcx)
movl %edx, -0x4(%rsi)
movq %rdi, %rcx
cmpq %rax, %rcx
je 0x16ec
movl (%rcx), %esi
cmpl %edx, %esi
jge 0x16e6
movl (%rdi), %r8d
movl %r8d, (%rcx)
movl %esi, (%rdi)
addq $0x4, %rdi
addq $0x4, %rcx
jmp 0x16cf
movl (%rdi), %ecx
movl (%rax), %edx
movl %edx, (%rdi)
movl %ecx, (%rax)
movq %rdi, %rax
popq %rbp
retq
leaq 0x9ab(%rip), %rdi       # 0x20ab
leaq 0x968(%rip), %rsi       # 0x206f
leaq 0x9a4(%rip), %rcx       # 0x20b2
pushq $0x26
popq %rdx
callq 0x1080
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH03_StringsVectorsAndArrays/examples/cctype.cc
// Function: main
int main()
{
	string s("Hello World!!!");
	// punct_cnt has the same type that s.size returns
	decltype(s.size()) punct_cnt = 0; 
	
	// count the number of punctuation characters in s
	for (auto c : s)         // for every char in s
		if (ispunct(c))      // if the character is punctuation
			++punct_cnt;     // increment the punctuation counter
	
	cout << punct_cnt 
	     << " punctuation characters in " << s << endl;
	
	// convert s to uppercase
	string orig = s;
	for (auto &c : s)   // for every char in s (note: c is a reference)
		// c is a reference, so this assignment changes the char in s
		c = toupper(c);
	cout << s << endl;
	
	// convert first word in s to uppercase
	s = orig;  // restore s to original case
	decltype(s.size()) index = 0;

	// process characters in s until we run out of characters 
	// or we hit a whitespace
	while (index != s.size() && !isspace(s[index])) {

	    // s[index] returns a reference so we can change 
		// the underlying character
		s[index] = toupper(s[index]);

		// increment the index to look at the next character 
		// on the next iteration
		++index; 
	}
	cout << s << endl;
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
leaq 0xda2(%rip), %rsi       # 0x2004
leaq -0x40(%rbp), %rbx
leaq -0x60(%rbp), %rdx
movq %rbx, %rdi
callq 0x1040
movq (%rbx), %r14
movq 0x8(%rbx), %r15
xorl %r12d, %r12d
xorl %ebx, %ebx
cmpq %r12, %r15
je 0x1299
movsbl (%r14,%r12), %edi
callq 0x1100
cmpl $0x1, %eax
sbbq $-0x1, %rbx
incq %r12
jmp 0x127e
movq 0x2d38(%rip), %rdi      # 0x3fd8
movq %rbx, %rsi
callq 0x1080
leaq 0xd64(%rip), %rsi       # 0x2013
movq %rax, %rdi
callq 0x10b0
leaq -0x40(%rbp), %rsi
movq %rax, %rdi
callq 0x10a0
movq %rax, %rdi
callq 0x1060
leaq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x10c0
movq -0x40(%rbp), %rbx
movq -0x38(%rbp), %r14
xorl %r15d, %r15d
cmpq %r15, %r14
je 0x12fb
movsbl (%rbx,%r15), %edi
callq 0x10f0
movb %al, (%rbx,%r15)
incq %r15
jmp 0x12e3
movq 0x2cd6(%rip), %rdi      # 0x3fd8
leaq -0x40(%rbp), %rsi
callq 0x10a0
movq %rax, %rdi
callq 0x1060
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x1070
xorl %r14d, %r14d
cmpq -0x38(%rbp), %r14
je 0x134d
movq -0x40(%rbp), %r15
movsbl (%r15,%r14), %ebx
movl %ebx, %edi
callq 0x1030
testl %eax, %eax
jne 0x134d
movl %ebx, %edi
callq 0x10f0
movb %al, (%r15,%r14)
incq %r14
jmp 0x1323
movq 0x2c84(%rip), %rdi      # 0x3fd8
leaq -0x40(%rbp), %rsi
callq 0x10a0
movq %rax, %rdi
callq 0x1060
leaq -0x60(%rbp), %rdi
callq 0x1050
leaq -0x40(%rbp), %rdi
callq 0x1050
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1398
jmp 0x138a
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x1050
jmp 0x139b
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x1050
movq %rbx, %rdi
callq 0x10e0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq (%rsi), %rsi
leaq 0x10(%rsp), %r14
leaq 0x30(%rsp), %r15
movq %r14, %rdi
movq %r15, %rdx
callq 0x29fc
leaq 0x40(%rsp), %rbx
movq 0x3f5e(%rip), %r13      # 0x7fc8
movq 0x3f3f(%rip), %rbp      # 0x7fb0
leaq 0xc(%rsp), %r12
movq (%r13), %rsi
movq %r15, %rdi
callq 0x32c9
movq %r15, %rdi
movq %r14, %rsi
callq 0x279e
movq %r15, %rdi
callq 0x40de
movw %ax, 0xc(%rsp)
movq (%rbp), %rsi
movq %r12, %rdi
callq 0x2cc8
movq (%rbp), %rdi
callq 0x2180
movq %rbx, %rdi
callq 0x2ac4
jmp 0x4076
jmp 0x40c0
movq %rax, %r14
jmp 0x40cb
movq %rax, %r14
movq %rbx, %rdi
callq 0x2ac4
leaq 0x10(%rsp), %rdi
callq 0x2090
movq %r14, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movzwl 0x16(%rsi), %esi
movl 0x18(%rbx), %edx
movzwl 0x22(%rbx), %ecx
callq 0x2406
movq %rbx, %rdi
callq 0x24ec
movl 0x28(%rbx), %edx
movq %r14, %rdi
movq %rax, %rsi
callq 0x244e
testl %eax, %eax
jne 0x23d8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1c25(%rip), %rdi      # 0x4004
leaq 0x1c2b(%rip), %rsi      # 0x4011
leaq 0x1c3a(%rip), %rdx      # 0x4027
leaq 0x1c37(%rip), %r8       # 0x402b
pushq $0x7
popq %rcx
xorl %eax, %eax
callq 0x2030
pushq $-0x1
popq %rdi
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O2/jp-myk[P]WAVUtil/src/SimpleWAV/WAV.cpp
// Function: WAV::setData(void const*, unsigned int)
int WAV::setData(const void *data, unsigned int dataSize){
  //freeWAVData(); // 初期化
  _dataSize=dataSize;
  _size=_dataSize+36;
  //モノラルならサンプル数を、ステレオなら左右１サンプルずつの組の数
  _sampleCount=_dataSize / (_channels*(_bit/8));
  _monoral8=(Monoral8*)NULL;
  _monoral16=(Monoral16*)NULL;
  _stereo8=(Stereo8*)NULL;
  _stereo16=(Stereo16*)NULL;
  try{
    if(_channels==1){
      if(_bit==8){
	_monoral8=(Monoral8*)malloc(dataSize);
	memcpy((void*)_monoral8, data, dataSize);
	//_monoral8=(Monoral8*)data;
      }else if(_bit==16){
	_monoral16=(Monoral16*)malloc(dataSize);
	memcpy((void*)_monoral16, data, dataSize);
	//_monoral16=(Monoral16*)data;
      }else{
	return -1;
      }
    }else   if(_channels==2){
      // ToDO LR insert data
      if(_bit==8){
	_stereo8=(Stereo8*)malloc(dataSize);
	memcpy((void*)_stereo8, data, dataSize);
	//_stereo8=(Stereo8*)data;
	
      }else if(_bit==16){
	_stereo16=(Stereo16*)malloc(dataSize);
	memcpy((void*)_stereo16, data, dataSize);
	//_stereo16=(Stereo16*)data;
      }else{
	return -1;
      }
    }else{
      return -1;
    }
  }catch(const char* e){
    std::cout << "malloc error" << std::endl;
    exit(-1);
  }

  return 0;

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ecx
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, 0x28(%rdi)
leal 0x24(%rcx), %eax
movl %eax, 0x4(%rdi)
movzwl 0x16(%rdi), %edi
movzwl 0x22(%r14), %esi
movl %esi, %r8d
shrl $0x3, %r8d
imull %edi, %r8d
movl %edx, %eax
xorl %edx, %edx
divl %r8d
movq %rax, 0x30(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%r14)
movups %xmm0, 0x48(%r14)
pushq $-0x1
popq %rax
cmpl $0x2, %edi
je 0x24ad
cmpl $0x1, %edi
jne 0x24e5
cmpl $0x8, %esi
je 0x24bd
cmpl $0x10, %esi
jne 0x24e5
addq $0x40, %r14
jmp 0x24c7
cmpl $0x8, %esi
je 0x24c3
cmpl $0x10, %esi
jne 0x24e5
addq $0x50, %r14
jmp 0x24c7
addq $0x38, %r14
jmp 0x24c7
addq $0x48, %r14
movl %ecx, %r15d
movq %r15, %rdi
callq 0x2170
movq %rax, (%r14)
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x20e0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movzwl 0x16(%rdi), %eax
cmpl $0x2, %eax
je 0x250d
cmpl $0x1, %eax
jne 0x2520
movzwl 0x22(%rdi), %eax
cmpl $0x10, %eax
je 0x2523
cmpl $0x8, %eax
jne 0x2520
movq 0x38(%rdi), %rax
retq
movzwl 0x22(%rdi), %eax
cmpl $0x10, %eax
je 0x2528
cmpl $0x8, %eax
jne 0x2520
movq 0x48(%rdi), %rax
retq
xorl %eax, %eax
retq
movq 0x40(%rdi), %rax
retq
movq 0x50(%rdi), %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x256d
movq %rsi, %r14
movzwl 0x16(%rsi), %esi
movl 0x18(%r14), %edx
movzwl 0x22(%r14), %ecx
movq %rbx, %rdi
callq 0x2406
movq %r14, %rdi
callq 0x24ec
movl 0x28(%r14), %edx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x244e
testl %eax, %eax
jne 0x2578
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1a85(%rip), %rdi      # 0x4004
leaq 0x1a8b(%rip), %rsi      # 0x4011
leaq 0x1ab6(%rip), %rdx      # 0x4043
leaq 0x1ab9(%rip), %r8       # 0x404d
pushq $0xf
popq %rcx
xorl %eax, %eax
callq 0x2030
pushq $-0x1
popq %rdi
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x38(%rdi), %r14
cmpq $0x0, 0x38(%rdi)
je 0x25db
movq 0x3a11(%rip), %rdi      # 0x5fd0
leaq 0x1a9c(%rip), %rsi      # 0x4062
callq 0x2100
movq %rax, %rdi
callq 0x20a0
movq (%r14), %rdi
callq 0x2130
movq 0x40(%rbx), %rdi
callq 0x2130
movq 0x48(%rbx), %rdi
callq 0x2130
movq 0x50(%rbx), %rdi
callq 0x2130
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movups %xmm0, (%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x2090
movq %rax, %rbx
leaq 0x19e6(%rip), %rdi      # 0x4004
leaq 0x19ec(%rip), %rsi      # 0x4011
leaq 0x1a44(%rip), %rdx      # 0x4070
leaq 0x1a49(%rip), %r8       # 0x407c
pushq $0x25
popq %rcx
xorl %eax, %eax
callq 0x2030
movq %rbx, %rdi
callq 0x21c0
pushq $-0x1
popq %rdi
callq 0x2140
nop
// File: /workspace/github_cpp_makefile_star2_O2/jp-myk[P]WAVUtil/src/SimpleWAV/WAV.cpp
// Function: WAV::dumpHeader()
void WAV::dumpHeader(){
  printf("riffID\t%c%c%c%c\n",_riffID[0],_riffID[1],_riffID[2],_riffID[3]);
  std::cout << "size\t" << _size   << std::endl;
  printf("wavID\t%c%c%c%c\n",_wavID[0],_wavID[1],_wavID[2],_wavID[3]);
  printf("fmtID\t%c%c%c%c\n",_fmtID[0],_fmtID[1],_fmtID[2],_fmtID[3]);
  std::cout << "fmtSize\t" << _fmtSize << std::endl;
  std::cout << "format\t" << _format << std::endl;
  std::cout << "channels\t" << _channels << std::endl;
  std::cout << "sampleRate\t" << _sampleRate << std::endl;
  std::cout << "bytePerSec\t" << _bytePerSec << std::endl;
  std::cout << "blockSize\t" << _blockSize << std::endl;
  std::cout << "bitID\t" << _bit << std::endl;
  printf("dataID\t%c%c%c%c\n",_dataID[0],_dataID[1],_dataID[2],_dataID[3]);
  std::cout << "dataSize\t" << _dataSize << std::endl;

}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movsbl (%rdi), %esi
movsbl 0x1(%rdi), %edx
movsbl 0x2(%rdi), %ecx
movsbl 0x3(%rdi), %r8d
leaq 0x1600(%rip), %rdi      # 0x40fe
xorl %eax, %eax
callq 0x2030
movq 0x34c4(%rip), %r14      # 0x5fd0
leaq 0x15fc(%rip), %rsi      # 0x410f
movq %r14, %rdi
callq 0x2100
movl 0x4(%rbx), %esi
movq %rax, %rdi
callq 0x20c0
movq %rax, %rdi
callq 0x20a0
movsbl 0x8(%rbx), %esi
movsbl 0x9(%rbx), %edx
movsbl 0xa(%rbx), %ecx
movsbl 0xb(%rbx), %r8d
leaq 0x15cf(%rip), %rdi      # 0x4115
xorl %eax, %eax
callq 0x2030
movsbl 0xc(%rbx), %esi
movsbl 0xd(%rbx), %edx
movsbl 0xe(%rbx), %ecx
movsbl 0xf(%rbx), %r8d
leaq 0x15c0(%rip), %rdi      # 0x4125
xorl %eax, %eax
callq 0x2030
leaq 0x15c2(%rip), %rsi      # 0x4135
movq %r14, %rdi
callq 0x2100
movl 0x10(%rbx), %esi
movq %rax, %rdi
callq 0x20c0
movq %rax, %rdi
callq 0x20a0
leaq 0x15a9(%rip), %rsi      # 0x413e
movq %r14, %rdi
callq 0x2100
movzwl 0x14(%rbx), %esi
movq %rax, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x20a0
leaq 0x158e(%rip), %rsi      # 0x4146
movq %r14, %rdi
callq 0x2100
movzwl 0x16(%rbx), %esi
movq %rax, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x20a0
leaq 0x1575(%rip), %rsi      # 0x4150
movq %r14, %rdi
callq 0x2100
movl 0x18(%rbx), %esi
movq %rax, %rdi
callq 0x20c0
movq %rax, %rdi
callq 0x20a0
leaq 0x155f(%rip), %rsi      # 0x415c
movq %r14, %rdi
callq 0x2100
movl 0x1c(%rbx), %esi
movq %rax, %rdi
callq 0x20c0
movq %rax, %rdi
callq 0x20a0
leaq 0x1549(%rip), %rsi      # 0x4168
movq %r14, %rdi
callq 0x2100
movzwl 0x20(%rbx), %esi
movq %rax, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x20a0
leaq 0x1531(%rip), %rsi      # 0x4173
movq %r14, %rdi
callq 0x2100
movzwl 0x22(%rbx), %esi
movq %rax, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x20a0
movsbl 0x24(%rbx), %esi
movsbl 0x25(%rbx), %edx
movsbl 0x26(%rbx), %ecx
movsbl 0x27(%rbx), %r8d
leaq 0x1504(%rip), %rdi      # 0x417a
xorl %eax, %eax
callq 0x2030
leaq 0x1507(%rip), %rsi      # 0x418b
movq %r14, %rdi
callq 0x2100
movl 0x28(%rbx), %esi
movq %rax, %rdi
callq 0x20c0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x20a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/jp-myk[P]WAVUtil/src/SimpleWAV/WAVUtil.cpp
// Function: SimpleWAV::trim_wav(float, float, WAV&, WAV&)
int trim_wav(float startTime_sec, float endTime_sec, WAV& wav, WAV& outwav){
  int datasize=0;
  void* data;
  int res=0;
  unsigned int startSamplePos= startTime_sec*wav.getSampleRate();
  unsigned int endSamplePos  = endTime_sec*wav.getSampleRate();
  if(endSamplePos>wav.getSampleCount()){
    endSamplePos=wav.getSampleCount();
    endTime_sec=(float)endSamplePos/wav.getSampleRate();
  }
  printf("trim %.5f - %.5f [sec] / %.5f [sec]\n", startTime_sec, endTime_sec, (float)wav.getSampleCount()/wav.getSampleRate());
  
  unsigned int startBytePos  = startSamplePos*wav.getChannels()*wav.getBit()/8;
  unsigned int endBytePos  =  endSamplePos*wav.getChannels()*wav.getBit()/8;

  outwav.createHeader(wav.getChannels(), wav.getSampleRate(), wav.getBit());
  datasize=endBytePos-startBytePos;
  data=(void*)malloc(endBytePos-startBytePos);
  memcpy(data, (char*)wav.getData()+startBytePos, datasize);
  res=outwav.setData(data, datasize);
  free(data);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x18(%rdi), %eax
movl 0x30(%rdi), %ecx
cvtsi2ss %rax, %xmm2
movaps %xmm2, %xmm3
mulss %xmm1, %xmm3
cvttss2si %xmm3, %r13
cvtsi2ss %rcx, %xmm3
divss %xmm2, %xmm3
movaps %xmm3, %xmm4
cmpl %r13d, %ecx
cmovbl %ecx, %r13d
jb 0x2ce6
movaps %xmm1, %xmm4
mulss %xmm0, %xmm2
cvttss2si %xmm2, %r15
cvtss2sd %xmm0, %xmm0
cvtss2sd %xmm4, %xmm1
cvtss2sd %xmm3, %xmm2
leaq 0x149a(%rip), %rdi      # 0x419c
movb $0x3, %al
callq 0x2030
movzwl 0x16(%r14), %esi
movzwl 0x22(%r14), %ecx
movl %ecx, %r12d
imull %esi, %r12d
imull %r12d, %r15d
shrl $0x3, %r15d
imull %r13d, %r12d
shrl $0x3, %r12d
movl 0x18(%r14), %edx
movq %rbx, %rdi
callq 0x2406
subl %r15d, %r12d
movq %r12, %rdi
callq 0x2170
movq %rax, %r13
movq %r14, %rdi
callq 0x24ec
addq %rax, %r15
movslq %r12d, %r14
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x20e0
movq %rbx, %rdi
movq %r13, %rsi
movl %r14d, %edx
callq 0x244e
movq %r13, %rdi
callq 0x2130
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x58, %rsp
cmpl $0x1, %edi
jle 0x3620
movq 0x8(%rsi), %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x3234
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2802
testl %eax, %eax
jne 0x364d
movq %rsp, %rdi
callq 0x2fde
movq %rsp, %rdi
callq 0x3276
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq (%rsi), %rsi
movq 0x29a6(%rip), %rdi      # 0x5fd0
callq 0x2100
leaq 0xcd3(%rip), %rsi       # 0x4309
movq %rax, %rdi
callq 0x2100
movq %rax, %rdi
callq 0x20a0
xorl %edi, %edi
callq 0x2140
movq 0x297c(%rip), %rdi      # 0x5fd0
leaq 0xcb8(%rip), %rsi       # 0x4313
callq 0x2100
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2100
movq %rax, %rdi
callq 0x20a0
pushq $-0x1
popq %rdi
callq 0x2140
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3276
movq %rbx, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x98, %rsp
leaq 0x8(%rsp), %rdi
callq 0xd410
leaq 0xa24d(%rip), %rsi      # 0x11045
leaq 0x38(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x61a0
leaq 0x78(%rsp), %rdx
andq $0x0, 0x8(%rdx)
leaq -0xdc(%rip), %rax       # 0x6d3c
movq %rax, (%rdx)
leaq 0x682(%rip), %rbx       # 0x74a4
movq %rbx, 0x18(%rdx)
leaq 0x683(%rip), %r14       # 0x74b0
movq %r14, 0x10(%rdx)
leaq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xd416
leaq 0x78(%rsp), %rdi
callq 0x7108
leaq 0x38(%rsp), %rdi
callq 0x6668
leaq 0xa1ec(%rip), %rsi      # 0x11047
leaq 0x18(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x61a0
leaq 0x58(%rsp), %rdx
andq $0x0, 0x8(%rdx)
leaq -0xea(%rip), %rax       # 0x6d91
movq %rax, (%rdx)
movq %rbx, 0x18(%rdx)
movq %r14, 0x10(%rdx)
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xd416
leaq 0x58(%rsp), %rdi
callq 0x7108
leaq 0x18(%rsp), %rdi
callq 0x6668
leaq 0x8(%rsp), %rdi
callq 0xd48c
leaq 0x10(%rsp), %rdi
callq 0x73fa
xorl %eax, %eax
addq $0x98, %rsp
popq %rbx
popq %r14
retq
jmp 0x6efb
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x7108
leaq 0x18(%rsp), %rdi
jmp 0x6ef4
jmp 0x6efb
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x7108
leaq 0x38(%rsp), %rdi
callq 0x6668
jmp 0x6efe
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x73fa
movq %rbx, %rdi
callq 0x6550
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %r14
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xee5c
leaq 0x18(%rsp), %rdi
movq %r14, -0x8(%rdi)
movq %rbx, %rsi
callq 0xee48
movq 0x30(%r14), %rbx
leaq 0x10(%rsp), %rsi
movq %rsi, 0x28(%rsp)
movl $0xa0, %edi
xorl %eax, %eax
callq 0xc5e4
movq %rax, %r15
movq %rax, 0x30(%rsp)
movl 0x38(%r14), %eax
movb 0x3c(%r14), %cl
andq $0x0, (%r15)
leaq 0x26a(%rip), %rdx       # 0xe402
movq %rdx, 0x8(%r15)
andl $0x0, 0x10(%r15)
leaq 0x80(%r14), %rdx
movups 0x30(%rbx), %xmm0
movups %xmm0, 0x18(%r15)
andq $0x0, 0x28(%r15)
leaq 0xd33(%rip), %rsi       # 0xeef0
movq %rsi, 0x30(%r15)
movl %eax, 0x38(%r15)
movb %cl, 0x3c(%r15)
movq %rdx, 0x40(%r15)
movq $0x1000, 0x48(%r15)     # imm = 0x1000
andl $0x0, 0x50(%r15)
leaq 0x50(%r14), %rsi
movaps 0x10(%rsp), %xmm0
movups %xmm0, 0x58(%r15)
movq 0x20(%rsp), %rax
andq $0x0, 0x20(%rsp)
movq %rax, 0x68(%r15)
andq $0x0, 0x18(%rsp)
addq $0x38, %r14
addq $0x28, %rbx
movq %r15, %rdi
addq $0x70, %rdi
callq 0xcffc
movq %r15, 0x38(%rsp)
andl $0x0, (%rsp)
pushq $0x1
popq %r9
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %r15, %rcx
xorl %r8d, %r8d
callq 0xd09e
leaq 0x30(%rsp), %rax
leaq 0x20(%rsp), %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
leaq 0x28(%rsp), %rdi
callq 0xe3f2
movq %rbx, %rdi
callq 0x73fa
leaq 0x48(%rsp), %rdi
callq 0x73fa
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xe3f2
jmp 0xe279
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x73fa
leaq 0x48(%rsp), %rdi
callq 0x73fa
movq %rbx, %rdi
callq 0x6550
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
movq %rsp, %rdi
movq %rbx, %rsi
callq 0xee5c
movq 0x20(%rbx), %r15
leaq 0x10a0(%rbx), %rdi
callq 0xfd98
movq %rax, %r12
leaq 0x11c8(%rbx), %r14
movq %r14, %rdi
callq 0xf3ea
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x10546
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
callq 0xf244
leaq 0x1080(%rbx), %rdi
leaq 0x40(%rsp), %r14
movq %r14, %rsi
callq 0x63e0
movq %r14, %rdi
callq 0x6668
leaq 0x30(%rbx), %r12
movq 0x1088(%rbx), %r15
movq %r15, %r13
testq %r15, %r15
je 0xe327
movq 0x1080(%rbx), %r13
leaq 0x18(%rsp), %r14
movq %rbx, -0x8(%r14)
movq %rsp, %rsi
movq %r14, %rdi
callq 0xee48
leaq 0x78(%rsp), %rbx
movq %r12, -0x38(%rbx)
movq %r13, -0x30(%rbx)
movq %r15, -0x28(%rbx)
andq $0x0, -0x20(%rbx)
andl $0x0, -0x18(%rbx)
movaps -0x8(%r14), %xmm0
movups %xmm0, -0x10(%rbx)
leaq 0x20(%rsp), %r14
movq (%r14), %rax
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, -0x8(%r14)
leaq 0x30(%rsp), %r15
andl $0x0, (%r15)
movb $0x0, 0x4(%r15)
callq 0x725a
movq %rax, 0x8(%r15)
leaq 0x40(%rsp), %rdi
pushq $0x1
popq %rcx
movq %r15, %rsi
xorl %edx, %edx
callq 0xe7ec
movq %rbx, %rdi
callq 0x73fa
movq %r14, %rdi
callq 0x73fa
leaq 0x8(%rsp), %rdi
callq 0x73fa
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r15
movq %rbx, %rdi
callq 0x73fa
movq %r14, %rdi
callq 0x73fa
jmp 0xe3df
jmp 0xe3dc
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x73fa
movq %r15, %rdi
callq 0x6550
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
andq $0x0, 0x30(%rdi)
leaq 0x28(%rdi), %r14
movq 0x28(%rdi), %rax
movb $0x0, (%rax)
movzwl (%rdi), %esi
movq %rsp, %r15
movq %r15, %rdi
callq 0xf3ee
movq %r14, %rdi
movq %r15, %rsi
callq 0x6630
leaq 0x2e34(%rip), %rsi      # 0x1203c
movq %rax, %rdi
callq 0x65f0
addq $0x8, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x6630
movq %rsp, %rdi
callq 0x6668
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6668
movq %rbx, %rdi
callq 0x6550
// File: /workspace/github_cpp_makefile_star2_O2/jixinqi[P]lazurite/./src/lazurite_core/http_response.cpp
// Function: lazurite::http::response_build::complete_msg[abi:cxx11]()
std::string lazurite::http::response_build::complete_msg()
{
    std::string result;
    result.append("HTTP/1.1 ")
          .append(std::to_string(_response.status_code()))
          .append(" ")
          .append(_response.phrase())
          .append("\r\n");
    result.append("Connection: close\r\n");
    result.append("Server: lazurite/0.1\r\n");
    result.append("Content-Type: text/plain\r\n");
    result.append("Content-Length: ").append(std::to_string(_response.msg_body().length())).append("\r\n");
    result.append("\r\n");
    result.append(_response.msg_body());
    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x2dca(%rip), %rsi      # 0x12034
callq 0x65f0
movq %rax, %r15
movzwl (%r14), %esi
movq %rsp, %rdi
callq 0xf3ee
movq %rsp, %rsi
movq %r15, %rdi
callq 0x6630
leaq 0x2dac(%rip), %rsi      # 0x1203c
movq %rax, %rdi
callq 0x65f0
movq %rax, %r15
leaq 0x8(%r14), %rsi
leaq 0x20(%rsp), %rdi
callq 0x6460
leaq 0x20(%rsp), %rsi
movq %r15, %rdi
callq 0x6630
leaq 0x2f7e(%rip), %rsi      # 0x1223b
movq %rax, %rdi
callq 0x65f0
leaq 0x20(%rsp), %rdi
callq 0x6668
movq %rsp, %rdi
callq 0x6668
leaq 0x2d60(%rip), %rsi      # 0x1203e
movq %rbx, %rdi
callq 0x65f0
leaq 0x2d65(%rip), %rsi      # 0x12052
movq %rbx, %rdi
callq 0x65f0
leaq 0x2d6d(%rip), %rsi      # 0x12069
movq %rbx, %rdi
callq 0x65f0
leaq 0x2d79(%rip), %rsi      # 0x12084
movq %rbx, %rdi
callq 0x65f0
movq %rax, %r15
addq $0x28, %r14
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x6460
movq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0xf447
movq %rsp, %rsi
movq %r15, %rdi
callq 0x6630
leaq 0x2ef5(%rip), %rsi      # 0x1223b
movq %rax, %rdi
callq 0x65f0
movq %rsp, %rdi
callq 0x6668
leaq 0x20(%rsp), %rdi
callq 0x6668
leaq 0x2ed4(%rip), %rsi      # 0x1223b
movq %rbx, %rdi
callq 0x65f0
movq %rsp, %rdi
movq %r14, %rsi
callq 0x6460
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x6630
movq %rsp, %rdi
callq 0x6668
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xf3ca
jmp 0xf3d7
movq %rax, %r14
jmp 0xf3b4
jmp 0xf3d7
jmp 0xf3ca
jmp 0xf3d7
movq %rax, %r14
movq %rsp, %rdi
callq 0x6668
leaq 0x20(%rsp), %rdi
jmp 0xf3d0
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x6668
jmp 0xf3cd
movq %rax, %r14
movq %rsp, %rdi
callq 0x6668
jmp 0xf3da
movq %rax, %r14
movq %rbx, %rdi
callq 0x6668
movq %r14, %rdi
callq 0x6550
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rdi, %rbx
movb $0x0, (%rax)
xorl %r12d, %r12d
movq %rsp, %r13
cmpq (%r14), %r12
je 0xf769
movq %r15, %rdi
movq %r12, %rsi
callq 0xfdd2
movsbl (%rax), %esi
movq %r13, %rdi
callq 0x62e0
incq %r12
jmp 0xf749
addq $0x18, %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x6630
movq %rsp, %rdi
callq 0x6668
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xf790
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6668
movq %rbx, %rdi
callq 0x6550
nop
// File: /workspace/github_cpp_makefile_star2_O2/jixinqi[P]lazurite/./src/lazurite_core/http_request.cpp
// Function: lazurite::http::request_parser::do_parse()
bool lazurite::http::request_parser::do_parse()
{
    if (_request.first_line_end_index() == 0)
    {
        if (!parser_first_line())
        {
            return false;
        }
    }
    if (_request.first_line_end_index() != 0 && _request.header_end_index() == 0)
    {
        if (!parser_header())
        {
            return false;
        }
    }
    if (_request.header_end_index() != 0 && _request.body_end_index() == 0)
    {
        if (!parser_body())
        {
            return false;
        }
    }
    return true;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0xf7b9
movq 0x8(%rbx), %rax
testq %rax, %rax
jne 0xf7ea
jmp 0xf7da
movq %rbx, %rdi
callq 0xf80a
testb %al, %al
je 0xf806
cmpq $0x0, (%rbx)
setne %cl
movq 0x8(%rbx), %rax
testq %rax, %rax
sete %dl
testb %dl, %cl
je 0xf7ea
movq %rbx, %rdi
callq 0xfa44
testb %al, %al
je 0xf806
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0xf802
cmpq $0x0, 0x10(%rbx)
jne 0xf802
movq %rbx, %rdi
callq 0xfd2c
testb %al, %al
je 0xf806
movb $0x1, %al
jmp 0xf808
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/jixinqi[P]lazurite/./src/lazurite_core/http_request.cpp
// Function: lazurite::http::request_parser::parser_body()
bool lazurite::http::request_parser::parser_body()
{
    if (_request.request_method() == "GET")
    {
        _request.body_end_index(_request.raw_msg().length());
        return true;
    }
    else
    {
        return false;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x38(%rdi), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x6460
leaq 0x24f3(%rip), %rsi      # 0x12240
movq %r14, %rdi
callq 0xfe65
movl %eax, %ebp
movq %r14, %rdi
callq 0x6668
testb %bpl, %bpl
je 0xfd83
leaq 0x18(%rbx), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x6460
movq 0x8(%r14), %rax
movq %rax, 0x10(%rbx)
movq %r14, %rdi
callq 0x6668
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jixinqi[P]lazurite/./src/lazurite_core/http_route.cpp
// Function: lazurite::http::route::run_handle(lazurite::http::request&, lazurite::http::response&)
void lazurite::http::route::run_handle(request &_request, response &_response)
{
    std::string path = _request.request_uri();
    auto it = route_table.find(path);
    if (it == route_table.end())
    {
        _response.status_code(404);
        _response.phrase("Not Found");
        _response.error_msg_body();
    }
    else
    {
        route_table[path](_request, _response);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0xf6ac
movq %r15, %rdi
movq %r12, %rsi
callq 0x10908
leaq 0x8(%r15), %rcx
cmpq %rcx, %rax
je 0x10598
leaq 0x28(%rsp), %rsi
movq %r15, %rdi
callq 0x1064c
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x106b2
jmp 0x105da
movq %rbx, %rdi
movl $0x194, %esi            # imm = 0x194
callq 0xf18c
leaq 0x1d30(%rip), %rsi      # 0x122dc
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x61a0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xf190
leaq 0x8(%rsp), %rdi
callq 0x6668
movq %rbx, %rdi
callq 0xf1cc
leaq 0x28(%rsp), %rdi
callq 0x6668
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6668
jmp 0x10604
jmp 0x10601
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x6668
movq %rbx, %rdi
callq 0x6550
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH11_AssociativeContainers/examples/unorderedWordCount.cc
// Function: main
int main()
{
	// count occurrences, but the words won't be in alphabetical order
	unordered_map<string, size_t> word_count;
	string word;
	while (cin >> word)
		++word_count[word]; // fetch and increment the counter for word

	for (const auto& w : word_count) // for each element in the map
		// print the results
		cout <<  w.first << " occurs " << w.second
			 << ((w.second > 1) ? " times" : " time") << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
leaq -0x50(%rbp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
leaq -0x70(%rbp), %r12
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
movl $0x3f800000, 0x10(%r12) # imm = 0x3F800000
movups %xmm0, 0x18(%r12)
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x2c21(%rip), %rbx      # 0x3fe0
leaq -0x48(%rbp), %r14
leaq -0x80(%rbp), %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1130
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x13f0
movq %r15, %rdi
movq %r14, %rsi
callq 0x186a
incq (%rax)
jmp 0x13c7
movq 0x2bd9(%rip), %rbx      # 0x3fd0
leaq 0xc06(%rip), %r14       # 0x2004
leaq 0xc08(%rip), %r15       # 0x200d
leaq 0xc08(%rip), %r13       # 0x2014
movq (%r12), %r12
testq %r12, %r12
je 0x1459
leaq 0x8(%r12), %rsi
movq %rbx, %rdi
callq 0x10f0
movq %rax, %rdi
movq %r14, %rsi
callq 0x1100
movq 0x28(%r12), %rsi
movq %rax, %rdi
callq 0x10b0
cmpq $0x2, 0x28(%r12)
movq %r13, %rsi
cmovaeq %r15, %rsi
movq %rax, %rdi
callq 0x1100
movq %rax, %rdi
callq 0x1090
jmp 0x140c
leaq -0x48(%rbp), %rdi
callq 0x1080
leaq -0x80(%rbp), %rdi
callq 0x15c2
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x147e
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x1080
leaq -0x80(%rbp), %rdi
callq 0x15c2
movq %rbx, %rdi
callq 0x1190
// File: /workspace/github_cpp_makefile_star2_O2/qinguoyi[P]TinyWebServer/main.cpp
// Function: main
int main(int argc, char *argv[])
{
    //需要修改的数据库信息,登录名,密码,库名
    string user = "root";
    string passwd = "root";
    string databasename = "qgydb";

    //命令行解析
    Config config;
    config.parse_arg(argc, argv);

    WebServer server;

    //初始化
    server.init(config.PORT, user, passwd, databasename, config.LOGWrite, 
                config.OPT_LINGER, config.TRIGMode,  config.sql_num,  config.thread_num, 
                config.close_log, config.actor_model);
    

    //日志
    server.log_write();

    //数据库
    server.sql_pool();

    //线程池
    server.thread_pool();

    //触发模式
    server.trig_mode();

    //监听
    server.eventListen();

    //运行
    server.eventLoop();

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1d690, %rsp          # imm = 0x1D690
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x4ad6(%rip), %r14      # 0x847d
leaq 0xd0(%rsp), %rdi
leaq 0xf0(%rsp), %rdx
movq %r14, %rsi
callq 0x3bd4
leaq 0xb0(%rsp), %rdi
leaq 0xf0(%rsp), %rdx
movq %r14, %rsi
callq 0x3bd4
leaq 0x4626(%rip), %rsi      # 0x8004
leaq 0x90(%rsp), %rdi
leaq 0xf0(%rsp), %rdx
callq 0x3bd4
leaq 0x8(%rsp), %rdi
callq 0x7e94
leaq 0x8(%rsp), %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x7eb2
leaq 0xf0(%rsp), %rdi
callq 0x6af4
movl 0x8(%rsp), %ebx
leaq 0x70(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
callq 0x3520
leaq 0x50(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x3520
leaq 0x30(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x3520
movl 0x1c(%rsp), %eax
movl 0xc(%rsp), %r9d
movl 0x10(%rsp), %r10d
movl 0x20(%rsp), %r11d
movl 0x24(%rsp), %r14d
movl 0x28(%rsp), %r15d
movl 0x2c(%rsp), %r12d
leaq 0xf0(%rsp), %rdi
leaq 0x70(%rsp), %rdx
leaq 0x50(%rsp), %rcx
leaq 0x30(%rsp), %r8
movl %ebx, %esi
pushq %r12
pushq %r15
pushq %r14
pushq %r11
pushq %r10
pushq %rax
callq 0x6d2e
addq $0x30, %rsp
leaq 0x30(%rsp), %rdi
callq 0x3190
leaq 0x50(%rsp), %rdi
callq 0x3190
leaq 0x70(%rsp), %rdi
callq 0x3190
leaq 0xf0(%rsp), %rdi
callq 0x6dea
leaq 0xf0(%rsp), %rdi
callq 0x6e32
leaq 0xf0(%rsp), %rdi
callq 0x6f3e
leaq 0xf0(%rsp), %rdi
callq 0x6dbc
leaq 0xf0(%rsp), %rdi
callq 0x6f96
leaq 0xf0(%rsp), %rdi
callq 0x7816
leaq 0xf0(%rsp), %rdi
callq 0x6c48
leaq 0x90(%rsp), %rdi
callq 0x3190
leaq 0xb0(%rsp), %rdi
callq 0x3190
leaq 0xd0(%rsp), %rdi
callq 0x3190
xorl %eax, %eax
addq $0x1d690, %rsp          # imm = 0x1D690
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3190
jmp 0x3b66
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x3190
jmp 0x3b75
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x3190
jmp 0x3b97
jmp 0x3b85
jmp 0x3b85
movq %rax, %rbx
jmp 0x3ba4
movq %rax, %rbx
jmp 0x3bb1
movq %rax, %rbx
jmp 0x3bbe
movq %rax, %rbx
leaq 0xf0(%rsp), %rdi
callq 0x6c48
leaq 0x90(%rsp), %rdi
callq 0x3190
leaq 0xb0(%rsp), %rdi
callq 0x3190
leaq 0xd0(%rsp), %rdi
callq 0x3190
movq %rbx, %rdi
callq 0x3630
nop