LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/sun98[P]Mini-DFS/filetree.cpp
// Function: FileTree::list(TreeNode*, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::pair<int, int>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::pair<int, int>>>>&)
void FileTree::list(TreeNode *node, std::map<std::string, std::pair<int, int>> &meta)
{
    static int chunkSize = 2 * 1024 * 1024;
    if (node)
    {
        std::cout << meta[node->value_].first << "\t" << (int)ceil(1.0 * meta[node->value_].second / chunkSize) << "\t\t" << node->value_ << std::endl;
        // std::cout << node->value_ << "\t" << std::endl;
        list(node->firstSon, meta);
        list(node->nextSibling, meta);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x3ba8(%rip), %r12      # 0x8138
testq %r14, %r14
je 0x4623
movq %rbx, %rdi
movq %r14, %rsi
callq 0x46a4
movl (%rax), %esi
movq 0x7a13(%rip), %rdi      # 0xbfc0
callq 0x3450
movq %rax, %rdi
leaq 0x3b7d(%rip), %rsi      # 0x8139
callq 0x3280
movq %rax, %r13
movq %rbx, %rdi
movq %r14, %rsi
callq 0x46a4
cvtsi2sdl 0x4(%rax), %xmm0
mulsd 0x3b54(%rip), %xmm0     # 0x8130
callq 0x3080
cvttsd2si %xmm0, %esi
movq %r13, %rdi
callq 0x3450
movq %rax, %rdi
movq %r12, %rsi
callq 0x3280
movq %rax, %rdi
movq %r14, %rsi
callq 0x3250
movq %rax, %rdi
callq 0x3180
movq 0x30(%r14), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x4572
movq 0x38(%r14), %r14
jmp 0x4590
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/sun98[P]Mini-DFS/md5.cpp
// Function: split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const&)
std::vector<std::string> split(const std::string &s, const char &delim)
{
  std::stringstream ss(s);
  std::vector<std::string> res;
  std::string str;
  while (std::getline(ss, str, delim))
    if (!str.empty())
      res.push_back(str);
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdx, %r14
movq %rdi, %rbx
leaq -0x1c8(%rbp), %r15
pushq $0x18
popq %rdx
movq %r15, %rdi
callq 0x33e0
andq $0x0, 0x10(%rbx)
leaq -0x30(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movb $0x0, (%rax)
leaq -0x40(%rbp), %r12
movsbl (%r14), %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x34a0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x4c1e
cmpq $0x0, -0x38(%rbp)
je 0x4bed
movq %rbx, %rdi
movq %r12, %rsi
callq 0x565e
jmp 0x4bed
leaq -0x40(%rbp), %rdi
callq 0x3150
leaq -0x1c8(%rbp), %rdi
callq 0x31e0
movq %rbx, %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x3150
movq %rbx, %rdi
callq 0x466c
leaq -0x1c8(%rbp), %rdi
callq 0x31e0
movq %r14, %rdi
callq 0x3480
// File: /workspace/github_cpp_makefile_star2_O2/sun98[P]Mini-DFS/md5.cpp
// Function: MD5::update(unsigned char const*, unsigned long)
MD5 &MD5::update(const unsigned char *input, size_t inputLen)
{
  // compute number of bytes mod 64
  size_t index = (uint32_t)((lo >> 3) & 0x3F);

  // update the message length
  if ((lo += ((uint32_t)inputLen << 3)) < ((uint32_t)inputLen << 3))
    hi++;
  hi += ((uint32_t)inputLen >> 29);

  size_t partLen = 64 - index;

  // update the states using the new message
  size_t i;
  if (inputLen >= partLen)
  {
    memcpy(&buffer[index], input, partLen);
    transform(buffer);

    for (i = partLen; i + BLOCK_SIZE <= inputLen; i += BLOCK_SIZE)
    {
      transform(&input[i]);
    }

    index = 0;
  }
  else
  {
    i = 0;
  }

  // buffer the remainder
  memcpy(&buffer[index], &input[i], inputLen - i);

  return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movl 0x60(%rdi), %eax
movl %eax, %edi
shrl $0x3, %edi
andl $0x3f, %edi
leal (,%rdx,8), %ecx
shrl $0x1d, %edx
addl %eax, %ecx
movl %ecx, 0x60(%rbx)
adcl %edx, 0x64(%rbx)
movq %rsi, %r12
pushq $0x40
popq %r15
subq %rdi, %r15
cmpq %r14, %r15
jbe 0x4ce7
xorl %r15d, %r15d
jmp 0x4d1e
addq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x3210
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x4d44
leaq 0x40(%r15), %r13
cmpq %r14, %r13
ja 0x4d1c
addq %r12, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4d44
movq %r13, %r15
jmp 0x4d00
xorl %edi, %edi
addq %rbx, %rdi
addq %r15, %r12
subq %r15, %r14
movq %r12, %rsi
movq %r14, %rdx
callq 0x3210
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/sun98[P]Mini-DFS/md5.cpp
// Function: MD5::finalize()
MD5 &MD5::finalize()
{
  static uint8_t PADDING[64] = {0};
  PADDING[0] = 0x80;

  if (!finalized)
  {
    // save the length
    uint8_t bits[8];
    memcpy(bits, &lo, 4);
    memcpy(bits + 4, &hi, 4);

    // pad the 1 bit and zeroes
    size_t index = (uint32_t)((lo >> 3) & 0x3f);
    size_t padLen = (index < 56) ? (56 - index) : (120 - index);
    update(PADDING, padLen);

    // append length
    update(bits, 8);

    // store the state
    memcpy(digest, state, 16);

    // wipe out sensitive data
    memset(buffer, 0, sizeof buffer);
    hi = lo = 0;

    finalized = true;
  }

  return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movb $-0x80, 0x6db3(%rip)    # 0xc2b0
cmpb $0x0, 0x68(%rdi)
jne 0x556c
movl 0x60(%rbx), %eax
leaq -0x18(%rbp), %r14
movl %eax, (%r14)
movl 0x64(%rbx), %ecx
movl %ecx, 0x4(%r14)
shrl $0x3, %eax
andl $0x3f, %eax
xorl %edx, %edx
cmpl $0x38, %eax
setae %dl
shll $0x6, %edx
orq $0x38, %rdx
subq %rax, %rdx
leaq 0x6d7d(%rip), %rsi      # 0xc2b0
movq %rbx, %rdi
callq 0x4ca2
pushq $0x8
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4ca2
movups 0x50(%rbx), %xmm0
movups %xmm0, 0x40(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x30(%rbx)
andq $0x0, 0x60(%rbx)
movb $0x1, 0x68(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/sun98[P]Mini-DFS/md5.cpp
// Function: MD5::toString[abi:cxx11]() const
string MD5::toString() const
{
  if (!finalized)
    return string("");

  char result[33] = {0};
  for (int i = 0; i < 16; ++i)
    sprintf(result + i * 2, "%02x", digest[i]);

  return string(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpb $0x0, 0x68(%rsi)
je 0x55d6
movq %rsi, %r14
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %r15
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
movb $0x0, 0x20(%r15)
leaq 0x2b9f(%rip), %r12      # 0x8150
xorl %r13d, %r13d
cmpq $0x10, %r13
je 0x55e3
movzbl 0x40(%r14,%r13), %edx
movq %r15, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x3090
incq %r13
addq $0x2, %r15
jmp 0x55b4
leaq 0x2b5d(%rip), %rsi      # 0x813a
leaq -0x50(%rbp), %rdx
jmp 0x55eb
leaq -0x50(%rbp), %rsi
leaq -0x29(%rbp), %rdx
movq %rbx, %rdi
callq 0x3110
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/sun98[P]Mini-DFS/md5.cpp
// Function: md5(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string md5(const string str)
{
  MD5 md5 = MD5();
  md5.update(str.c_str(), str.size());
  md5.finalize();
  return md5.toString();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
leaq -0x7c(%rbp), %r14
andq $0x0, 0x60(%r14)
movaps 0x2b1d(%rip), %xmm0     # 0x8140
movups %xmm0, 0x50(%r14)
movb $0x0, 0x68(%r14)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x4ca2
movq %r14, %rdi
callq 0x54e8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5578
movq %rbx, %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/sun98[P]Mini-DFS/namenode.cpp
// Function: NameServer::parse_cmd[abi:cxx11]()
std::vector<std::string> NameServer::parse_cmd()
{
    std::cout << "Mini-DFS> ";
    std::string cmd, tmp;
    std::getline(std::cin, cmd);
    std::vector<std::string> parameters;
    std::stringstream ss(cmd);
    while (ss >> tmp)
        parameters.push_back(tmp);
    return parameters;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rdi, %rbx
movq 0x6230(%rip), %rdi      # 0xbfc0
leaq 0x2479(%rip), %rsi      # 0x8210
callq 0x3280
leaq -0x28(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
leaq -0x48(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
movq 0x6215(%rip), %rdi      # 0xbfd8
leaq -0x38(%rbp), %rsi
callq 0x30a0
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
leaq -0x1e0(%rbp), %rdi
leaq -0x38(%rbp), %rsi
pushq $0x18
popq %rdx
callq 0x33e0
leaq -0x1e0(%rbp), %r14
leaq -0x58(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x3300
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x5e1b
movq %rbx, %rdi
movq %r15, %rsi
callq 0x565e
jmp 0x5df5
leaq -0x1e0(%rbp), %rdi
callq 0x31e0
leaq -0x58(%rbp), %rdi
callq 0x3150
leaq -0x38(%rbp), %rdi
callq 0x3150
movq %rbx, %rax
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x5e63
movq %rax, %r14
jmp 0x5e6b
movq %rax, %r14
leaq -0x1e0(%rbp), %rdi
callq 0x31e0
movq %rbx, %rdi
callq 0x466c
leaq -0x58(%rbp), %rdi
callq 0x3150
leaq -0x38(%rbp), %rdi
callq 0x3150
movq %r14, %rdi
callq 0x3480
nop
// File: /workspace/github_cpp_makefile_star2_O2/sun98[P]Mini-DFS/./md5.h
// Function: std::vector<int, std::allocator<int>> argsort<double>(std::vector<double, std::allocator<double>> const&)
std::vector<int> argsort(const std::vector<T> &vec)
{
    std::vector<int> idx;
    for (int i = 0; i < vec.size(); ++i)
        idx.push_back(i);
    sort(idx.begin(), idx.end(), [&vec](int id1, int id2) { return vec[id1] < vec[id2]; });
    return idx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %eax, %eax
leaq -0x1c(%rbp), %r15
movl %eax, -0x1c(%rbp)
cltq
movq 0x8(%r14), %rcx
subq (%r14), %rcx
sarq $0x3, %rcx
cmpq %rax, %rcx
jbe 0x6a94
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6eb6
movl -0x1c(%rbp), %eax
incl %eax
jmp 0x6a6d
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
movq %r14, %rdx
callq 0x702e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6ab3
movq %rax, %r14
movq %rbx, %rdi
callq 0x6d0e
movq %r14, %rdi
callq 0x3480
// File: /workspace/github_cpp_makefile_star2_O2/eschwabe[P]interview-practice/src/printlastlines.cpp
// Function: PrintLastLines(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
void PrintLastLines(const string& filename, const int K) {
    if(K <= 0) {
        return;
    }
    ifstream filestream(filename);
    string tmp;
    vector<off_t> offsets;
    offsets.push_back(0);
    while(getline(filestream, tmp)) {
        offsets.push_back(filestream.tellg());
    }
    size_t start_line = (static_cast<size_t>(K) < offsets.size()) ? (offsets.size() - static_cast<size_t>(K)) : 0;
    filestream.clear();
    filestream.seekg(offsets[start_line]);
    while(getline(filestream,tmp)) {
        cout << tmp << endl;
    }

}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x250, %rsp            # imm = 0x250
movl %esi, %ebx
testl %esi, %esi
jle 0x243d
movq %rdi, %rsi
leaq 0x48(%rsp), %rdi
pushq $0x8
popq %rdx
callq 0x2170
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
callq 0x2586
leaq 0x48(%rsp), %r14
leaq 0x28(%rsp), %r15
leaq 0x10(%rsp), %r12
leaq 0x8(%rsp), %r13
movq %r14, %rdi
movq %r15, %rsi
callq 0x2030
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x239c
movq %r14, %rdi
callq 0x21a0
movq %rax, 0x8(%rsp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x2586
jmp 0x2369
movq 0x10(%rsp), %r12
movq 0x18(%rsp), %r15
movq 0x48(%rsp), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x2190
movl %ebx, %eax
subq %r12, %r15
sarq $0x3, %r15
xorl %ecx, %ecx
subq %rax, %r15
cmovbq %rcx, %r15
movq 0x10(%rsp), %rax
movq (%rax,%r15,8), %rsi
leaq 0x48(%rsp), %rdi
xorl %edx, %edx
callq 0x2140
leaq 0x48(%rsp), %rbx
leaq 0x28(%rsp), %r14
movq 0x2be7(%rip), %r15      # 0x4fd8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2030
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x241f
movq %r15, %rdi
movq %r14, %rsi
callq 0x2100
movq %rax, %rdi
callq 0x20a0
jmp 0x23f1
leaq 0x10(%rsp), %rdi
callq 0x2552
leaq 0x28(%rsp), %rdi
callq 0x2090
leaq 0x48(%rsp), %rdi
callq 0x2040
addq $0x250, %rsp            # imm = 0x250
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x2456
jmp 0x2456
jmp 0x2456
jmp 0x2456
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2552
leaq 0x28(%rsp), %rdi
callq 0x2090
leaq 0x48(%rsp), %rdi
callq 0x2040
movq %rbx, %rdi
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O2/eschwabe[P]interview-practice/src/printlastlines.cpp
// Function: main
int main(int argc, char *argv[])
{
    if(argc < 3) {
        cout << argv[0] << " FILE LINES" << endl;
        return 1;
    }
    PrintLastLines(argv[1],atoi(argv[2]));
    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
cmpl $0x2, %edi
jg 0x24b9
movq (%rbx), %rsi
movq 0x2b40(%rip), %rdi      # 0x4fd8
callq 0x2110
leaq 0xb60(%rip), %rsi       # 0x3004
movq %rax, %rdi
callq 0x2110
movq %rax, %rdi
callq 0x20a0
pushq $0x1
popq %rax
jmp 0x24ee
movq 0x8(%rbx), %rsi
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x250c
movq 0x10(%rbx), %rdi
callq 0x2160
movq %r14, %rdi
movl %eax, %esi
callq 0x22fc
leaq 0x8(%rsp), %rdi
callq 0x2090
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x21b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/statgen[P]statgen/lib/tclap-1.2.0/examples/test8.cpp
// Function: main
int main(int argc, char** argv)
{

	parseOptions(argc,argv);

	cout << "for string we got : " << _stringTest<< endl
		 << "for ulabeled one we got : " << _utest << endl
		 << "for ulabeled two we got : " << _ztest << endl
		 << "for bool B we got : " << _boolTestB << endl;

}

// Assembly:
pushq %rax
callq 0x45f2
movq 0xfa77(%rip), %rdi      # 0x13fd0
leaq 0x8ac2(%rip), %rsi      # 0xd022
callq 0x41b0
leaq 0xfc9c(%rip), %rsi      # 0x14208
movq %rax, %rdi
callq 0x41a0
movq %rax, %rdi
callq 0x40e0
leaq 0x8ab4(%rip), %rsi      # 0xd037
movq %rax, %rdi
callq 0x41b0
leaq 0xfc96(%rip), %rsi      # 0x14228
movq %rax, %rdi
callq 0x41a0
movq %rax, %rdi
callq 0x40e0
leaq 0x8aa9(%rip), %rsi      # 0xd052
movq %rax, %rdi
callq 0x41b0
leaq 0xfc90(%rip), %rsi      # 0x14248
movq %rax, %rdi
callq 0x41a0
movq %rax, %rdi
callq 0x40e0
leaq 0x8a9e(%rip), %rsi      # 0xd06d
movq %rax, %rdi
callq 0x41b0
movzbl 0xfc23(%rip), %esi      # 0x14201
movq %rax, %rdi
callq 0x42b0
movq %rax, %rdi
callq 0x40e0
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/statgen[P]statgen/lib/tclap-1.2.0/examples/../include/tclap/UnlabeledMultiArg.h
// Function: TCLAP::UnlabeledMultiArg<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::processArg(int*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
bool UnlabeledMultiArg<T>::processArg(int *i, std::vector<std::string>& args) 
{

	if ( _hasBlanks( args[*i] ) )
		return false;

	// never ignore an unlabeled multi arg


	// always take the first value, regardless of the start string 
	_extractValue( args[(*i)] );

	/*
	// continue taking args until we hit the end or a start string 
	while ( (unsigned int)(*i)+1 < args.size() &&
			args[(*i)+1].find_first_of( Arg::flagStartString() ) != 0 &&
            args[(*i)+1].find_first_of( Arg::nameStartString() ) != 0 ) 
		_extractValue( args[++(*i)] );
	*/

	_alreadySet = true;

	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movslq (%rsi), %rsi
shlq $0x5, %rsi
addq (%rdx), %rsi
callq 0x98ba
movl %eax, %ebp
testb %al, %al
jne 0xbdae
movslq (%r15), %rsi
shlq $0x5, %rsi
addq (%r14), %rsi
movq %rbx, %rdi
callq 0x99da
movb $0x1, 0x91(%rbx)
xorb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/statgen[P]statgen/lib/tclap-1.2.0/examples/../include/tclap/UnlabeledMultiArg.h
// Function: TCLAP::UnlabeledMultiArg<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::operator==(TCLAP::Arg const&) const
bool UnlabeledMultiArg<T>::operator==(const Arg& a) const
{
	if ( _name == a.getName() || _description == a.getDescription() )
		return true;
	else
		return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x28, %rdi
addq $0x28, %rsi
callq 0x7608
movb $0x1, %bpl
testb %al, %al
jne 0xbe0d
addq $0x48, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x7f80
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7608
movl %eax, %ebp
movq %r15, %rdi
callq 0x4388
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/smilingthax[P]cttrie/test_getindex.cpp
// Function: main
int main(int argc,char **argv)
{
  test1(index_list<1,0,1>(),[&](){
    printf("1 %d\n",argc);
  },[&](){
    printf("2\n");
  },[&](){
    printf("3\n");
  });

//  printf("%s\n",pack_tools::get_index<0>("The","other","thing"));
  test2<0,1,1,2>("The","other","thing");
  printf("\n");

  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0xeb5(%rip), %r14       # 0x201e
movq %r14, %rdi
callq 0x1050
leaq 0xe9c(%rip), %rdi       # 0x2014
movl %ebx, %esi
xorl %eax, %eax
callq 0x1030
movq %r14, %rdi
callq 0x1050
leaq 0xe74(%rip), %rdi       # 0x2004
leaq 0xe71(%rip), %rsi       # 0x2008
leaq 0xe70(%rip), %rdx       # 0x200e
callq 0x11b5
pushq $0xa
popq %rdi
callq 0x1040
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/deepaktabraham[P]BPlus-Tree/src/tree.cpp
// Function: BPlusTree::Search_Path(Node*, float, std::stack<Node*, std::deque<Node*, std::allocator<Node*>>>*)
void BPlusTree :: Search_Path(Node* node, float key, stack<Node*>* path)
{
	// push node to stack
        path->push(node);

	// check if the node pushed to stack is an internal node
	if(!node->Get_IsLeaf())
        {
		// search for the given key in the current node
		vector<float> keys = node->Get_Keys();
		vector<Node*> children = node->Get_Children();
                vector<float>::iterator index = lower_bound(keys.begin(), keys.end(), key);

		// check if key is found
		if(key == keys[index - keys.begin()])
		{
			// recursively repeat by searching the path through the corresponding right child index
                	Search_Path(children[(index - keys.begin()) + 1], key, path);
		}

		// if key is not found
		else
		{
			// recursively repeat by searching the path through the corresponding left child index
			Search_Path(children[index - keys.begin()], key, path);
		}
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rdi, %r14
leaq -0x28(%rbp), %r15
movq %rsi, (%r15)
movss %xmm0, -0x1c(%rbp)
movq %rdx, %rdi
movq %r15, %rsi
callq 0x347a
movq (%r15), %rdi
callq 0x3afc
testb %al, %al
jne 0x2af8
movq -0x28(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x3b06
movq -0x28(%rbp), %rsi
movq (%rsi), %rax
leaq -0x58(%rbp), %rdi
callq *0x30(%rax)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
callq 0x3788
movss -0x1c(%rbp), %xmm0
movq %rax, %rcx
subq -0x40(%rbp), %rcx
sarq $0x2, %rcx
ucomiss (%rax), %xmm0
movq -0x58(%rbp), %rax
jne 0x2ad7
jp 0x2ad7
movq 0x8(%rax,%rcx,8), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x2a48
jmp 0x2ae6
movq (%rax,%rcx,8), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x2a48
leaq -0x58(%rbp), %rdi
callq 0x3774
leaq -0x40(%rbp), %rdi
callq 0x3760
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2b07
jmp 0x2b07
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x3774
jmp 0x2b18
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x3760
movq %rbx, %rdi
callq 0x2270
nop
// File: /workspace/github_cpp_makefile_star2_O2/deepaktabraham[P]BPlus-Tree/src/tree.cpp
// Function: BPlusTree::Destroy(Node*)
void BPlusTree :: Destroy(Node* node)
{
	// recursively repeat the function to delete all the nodes level by level, starting with the leaf nodes
	if (!node->Get_IsLeaf())
	{
  	        vector<Node*> children = node->Get_Children();
                for(vector<Node*>::iterator index = children.begin(); index != children.end(); index++)
                {
                        Destroy(*index);
        	}
	}
	delete(node);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x3afc
testb %al, %al
jne 0x2b7c
movq (%rbx), %rax
leaq -0x30(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq *0x30(%rax)
movq (%r15), %r15
cmpq -0x28(%rbp), %r15
je 0x2b73
movq (%r15), %rsi
movq %r14, %rdi
callq 0x2b2a
addq $0x8, %r15
jmp 0x2b5c
leaq -0x30(%rbp), %rdi
callq 0x3774
movq %rbx, %rdi
callq 0x3392
movq %rbx, %rdi
callq 0x2130
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x3774
movq %rbx, %rdi
callq 0x2270
nop
// File: /workspace/github_cpp_makefile_star2_O2/deepaktabraham[P]BPlus-Tree/src/internalnode.cpp
// Function: InternalNode::Insert(float, Node*)
void InternalNode :: Insert(float key, Node* rightChild)
{
	// insert key in to suitable position in the given internal node
	vector<float>::iterator index = lower_bound(keys.begin(), keys.end(), key);
	keys.insert(index, key);

	// insert right child in the immediately next index in the children vector
	index = lower_bound(keys.begin(), keys.end(), key);
	children.insert(children.begin() + (index - keys.begin() + 1), rightChild);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq -0x24(%rbp), %r15
movss %xmm0, (%r15)
leaq -0x30(%rbp), %rbx
movq %rsi, (%rbx)
leaq 0x10(%rdi), %r12
movq 0x10(%rdi), %rdi
movq 0x18(%r14), %rsi
movq %r15, %rdx
callq 0x3788
movq %r12, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x3e08
movq 0x10(%r14), %rdi
movq 0x18(%r14), %rsi
movq %r15, %rdx
callq 0x3788
leaq 0x28(%r14), %rdi
movq 0x28(%r14), %rcx
subq 0x10(%r14), %rax
leaq (%rcx,%rax,2), %rsi
addq $0x8, %rsi
movq %rbx, %rdx
callq 0x3e7e
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/deepaktabraham[P]BPlus-Tree/src/internalnode.cpp
// Function: InternalNode::Split(float*)
Node* InternalNode :: Split(float* keyToParent)
{
	int length = keys.size();

	// create a new right internal node
	InternalNode* rightNode = new InternalNode;

	// key to be moved up to the parent is the middle element in the current internal node
	*keyToParent = keys[length/2];

	// Copy the second half of the current internal node excluding the middle element to the 
	// new right internal node. Erase the second half of the current internal node including 
	// the middle element, and thus current internal node becomes the left internal node.
	rightNode->keys.assign(keys.begin() + (length/2 + 1), keys.end());
	rightNode->children.assign(children.begin() + (length/2 + 1), children.end());
	keys.erase(keys.begin() + length/2, keys.end());
	children.erase(children.begin() + (length/2 + 1), children.end());

	// return the new right internal node
	return rightNode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x48(%rbp)
movq 0x10(%rdi), %r15
movq 0x18(%rdi), %r13
movq %r13, -0x40(%rbp)
subq %r15, %r13
shrq $0x2, %r13
pushq $0x40
popq %rdi
callq 0x2150
movq %rax, %r14
leaq 0x10(%rax), %rdi
andq $0x0, 0x20(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
leaq 0x5f9f(%rip), %rax      # 0x9ce0
movq %rax, (%r14)
leaq 0x28(%r14), %rax
movq %rax, -0x38(%rbp)
andq $0x0, 0x38(%r14)
movups %xmm0, 0x28(%r14)
movb $0x0, 0x8(%r14)
pushq $0x2
popq %rcx
movl %r13d, %eax
cltd
idivl %ecx
movslq %eax, %r12
leaq (,%r12,4), %r13
leaq (%r15,%r12,4), %rsi
addq $0x4, %rsi
movss -0x4(%rsi), %xmm0
movq -0x30(%rbp), %rax
movss %xmm0, (%rax)
movq -0x40(%rbp), %rdx
callq 0x425c
leaq 0x28(%rbx), %rax
movq %rax, -0x30(%rbp)
leaq 0x8(,%r12,8), %r15
movq 0x28(%rbx), %rsi
addq %r15, %rsi
movq 0x30(%rbx), %rdx
movq -0x38(%rbp), %rdi
callq 0x4392
addq 0x10(%rbx), %r13
movq 0x18(%rbx), %rdx
movq -0x48(%rbp), %rdi
movq %r13, %rsi
callq 0x3f3a
addq 0x28(%rbx), %r15
movq 0x30(%rbx), %rdx
movq -0x30(%rbp), %rdi
movq %r15, %rsi
callq 0x3f44
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/deepaktabraham[P]BPlus-Tree/src/leafnode.cpp
// Function: LeafNode::Insert(float, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void LeafNode :: Insert(float key, string value)
{
	// search for the key in the given leaf node
	vector<float>::iterator index = lower_bound(keys.begin(), keys.end(), key);

	// check if inserting a duplicate value for an existing key
	if((0 != keys.size()) && (key == keys[index - keys.begin()]))
	{
		// add the duplicate value for the given key
		values[index - keys.begin()].push_back(value);
	}

	// if inserting a new key and value
	else
	{
		// insert the new key
		keys.insert(index, key);

		//insert the corresponding value
		vector<string> newValue;
		newValue.push_back(value);
		index = lower_bound(keys.begin(), keys.end(), key);	
		values.insert(values.begin() + (index - keys.begin()), newValue);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x14(%rbp), %rdx
movss %xmm0, (%rdx)
movq 0x10(%rdi), %rdi
movq 0x18(%rbx), %rsi
callq 0x3788
movq 0x10(%rbx), %rcx
cmpq %rcx, 0x18(%rbx)
je 0x4627
movss -0x14(%rbp), %xmm0
ucomiss (%rax), %xmm0
jne 0x4627
jp 0x4627
subq %rcx, %rax
shrq $0x2, %rax
imulq $0x18, %rax, %rdi
addq 0x38(%rbx), %rdi
movq %r14, %rsi
callq 0x47ec
jmp 0x4685
leaq 0x10(%rbx), %rdi
leaq -0x14(%rbp), %rdx
movq %rax, %rsi
callq 0x3e08
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq %r14, %rsi
callq 0x47ec
movq 0x10(%rbx), %rdi
movq 0x18(%rbx), %rsi
leaq -0x14(%rbp), %rdx
callq 0x3788
leaq 0x38(%rbx), %rdi
subq 0x10(%rbx), %rax
shrq $0x2, %rax
imulq $0x18, %rax, %rsi
addq 0x38(%rbx), %rsi
leaq -0x30(%rbp), %rdx
callq 0x4828
leaq -0x30(%rbp), %rdi
callq 0x39be
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x4692
jmp 0x4692
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x39be
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O2/deepaktabraham[P]BPlus-Tree/src/leafnode.cpp
// Function: LeafNode::Split(float*)
Node* LeafNode :: Split(float* keyToParent)
{
	// create a new right leaf node
	LeafNode* rightNode = new LeafNode;

	// key to be moved up to the parent is the middle element in the current leaf node
	*keyToParent = keys[keys.size()/2];

	// Copy the second half of the current leaf node to the new right leaf node. Erase the second
	// half of the current leaf node, and thus the current leaf node becomes the left leaf node.
	rightNode->keys.assign(keys.begin() + keys.size()/2, keys.end());
	rightNode->values.assign(values.begin() + values.size()/2, values.end());
	keys.erase(keys.begin() + keys.size()/2, keys.end());
	values.erase(values.begin() + values.size()/2, values.end());

	// link the leaf nodes to form a doubly linked list
	rightNode->next = next;
	rightNode->prev = this;
	next = rightNode;
	(rightNode->next)->prev = rightNode;

	// return the right leaf node
	return rightNode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
pushq $0x50
popq %rdi
callq 0x2150
movq %rax, %r14
leaq 0x10(%rax), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
andq $0x0, 0x20(%rax)
leaq 0x5674(%rip), %rax      # 0x9d50
movq %rax, (%r14)
leaq 0x38(%r14), %r13
movups %xmm0, 0x38(%r14)
andq $0x0, 0x48(%r14)
movb $0x1, 0x8(%r14)
movq %r14, 0x28(%r14)
movq %r14, 0x30(%r14)
leaq 0x10(%rbx), %r12
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rdx
movq %rdx, %rcx
subq %rax, %rcx
sarq %rcx
andq $-0x4, %rcx
leaq (%rax,%rcx), %rsi
movss (%rax,%rcx), %xmm0
movss %xmm0, (%r15)
callq 0x425c
leaq 0x38(%rbx), %r15
movq 0x38(%rbx), %rdi
movq 0x40(%rbx), %rcx
movq %rcx, %rax
subq %rdi, %rax
pushq $0x18
popq %rsi
cqto
idivq %rsi
shrq %rax
imulq $0x18, %rax, %rsi
addq %rdi, %rsi
movq %r13, %rdi
movq %rcx, %rdx
callq 0x4f16
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rdx
movq %rdx, %rsi
subq %rax, %rsi
sarq %rsi
andq $-0x4, %rsi
addq %rax, %rsi
movq %r12, %rdi
callq 0x3f3a
movq 0x38(%rbx), %rdi
movq 0x40(%rbx), %rcx
movq %rcx, %rax
subq %rdi, %rax
cqto
pushq $0x18
popq %rsi
idivq %rsi
shrq %rax
imulq $0x18, %rax, %rsi
addq %rdi, %rsi
movq %r15, %rdi
movq %rcx, %rdx
callq 0x48c4
movq 0x30(%rbx), %rax
movq %rax, 0x30(%r14)
movq %rbx, 0x28(%r14)
movq %r14, 0x30(%rbx)
movq %r14, 0x28(%rax)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/xocoder[P]m_kcptun/src/kcp_remote.cpp
// Function: remote_kcpin_create(tun_remote_t*)
static int
_remote_kcpin_create(tun_remote_t *tun) {
   ikcp_allocator(kcp_malloc, kcp_free);

   tun->kcpin = ikcp_create(tun->kcpconv, tun);
   if (tun->kcpin == NULL) {
      cerr << "Fail to create kcp in !" << endl;
      return 0;
   }

   ikcp_setoutput(tun->kcpin, _remote_kcpin_callback);
   ikcp_nodelay(tun->kcpin, tun->conf->nodelay, tun->conf->interval, tun->conf->resend, tun->conf->nc);
   ikcp_wndsize(tun->kcpin, tun->conf->snd_wndsize, tun->conf->rcv_wndsize);
   ikcp_setmtu(tun->kcpin, tun->conf->mtu);

   if (tun->conf->fast == 3) {
      tun->kcpin->rx_minrto = 20;
   } else if (tun->conf->fast == 2) {
      tun->kcpin->rx_minrto = 40;
   }
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq -0x887(%rip), %rdi      # 0x7487
leaq -0x878(%rip), %rsi      # 0x749d
callq 0x25dc
movl 0x50(%rbx), %edi
movq %rbx, %rsi
callq 0x26b3
movq %rax, 0x48(%rbx)
testq %rax, %rax
je 0x7db7
leaq 0xf0(%rip), %rsi        # 0x7e29
movq %rax, %rdi
callq 0x2967
movq 0x48(%rbx), %rdi
movq 0x78(%rbx), %rax
movl 0x130(%rax), %esi
movl 0x134(%rax), %edx
movl 0x138(%rax), %ecx
movl 0x13c(%rax), %r8d
callq 0x3b8a
movq 0x48(%rbx), %rdi
movq 0x78(%rbx), %rax
movl 0x128(%rax), %edx
movl 0x12c(%rax), %esi
callq 0x3bdb
movq 0x48(%rbx), %rdi
movq 0x78(%rbx), %rax
movl 0x140(%rax), %esi
callq 0x3b0c
movq 0x78(%rbx), %rax
movl 0x144(%rax), %ecx
pushq $0x1
popq %rax
cmpl $0x2, %ecx
je 0x7dd6
cmpl $0x3, %ecx
jne 0x7de1
movq 0x48(%rbx), %rcx
movl $0x14, 0x34(%rcx)
jmp 0x7de1
movq 0x7232(%rip), %rdi      # 0xeff0
leaq 0x32a5(%rip), %rsi      # 0xb06a
callq 0x2260
movq %rax, %rdi
callq 0x2140
xorl %eax, %eax
jmp 0x7de1
movq 0x48(%rbx), %rcx
movl $0x28, 0x34(%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tokuhirom[P]nanouri/t/../nanouri.hpp
// Function: nanouri::escape_uri(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static NANOURI_DECLARE std::string escape_uri(const std::string &src) {
  std::string dst;
  dst.reserve(src.size() * 3 + 1);
  for (unsigned int i = 0; i < src.size(); i++) {
    if (nanouri_isuric((unsigned char) src[i])) {
      dst += '%';
      dst += nanouri_hex_char((src[i] >> 4) & 0x0f);
      dst += nanouri_hex_char(src[i] & 0x0f);
    } else {
      dst += src[i];
    }
  }
  return dst;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rax
leaq (%rax,%rax,2), %rsi
incq %rsi
callq 0x21a0
xorl %r15d, %r15d
pushq $0x25
popq %rbp
movl %r15d, %r15d
cmpq %r15, 0x8(%r14)
jbe 0x23b7
movq (%r14), %rax
movzbl (%rax,%r15), %edi
callq 0x2cd4
testl %eax, %eax
je 0x23a0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2110
movq (%r14), %rax
movzbl (%rax,%r15), %edi
shrl $0x4, %edi
callq 0x2ce2
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2110
movq (%r14), %rax
movzbl (%rax,%r15), %edi
andl $0xf, %edi
callq 0x2ce2
jmp 0x23a7
movq (%r14), %rax
movb (%rax,%r15), %al
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2110
incl %r15d
jmp 0x234f
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x23c7
movq %rax, %r14
movq %rbx, %rdi
callq 0x2090
movq %r14, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/tokuhirom[P]nanouri/t/../nanouri.hpp
// Function: nanouri::unescape_uri(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static NANOURI_DECLARE std::string unescape_uri(const std::string &src) {
  std::string dst;
  dst.reserve(src.size() * 3 + 1);
  for (unsigned int i = 0; i < src.size(); i++) {
    if (src[i] == '%') {
      unsigned char c;
      if (src[++i] != '\0') {
        c = unhex(src[i]) << 4;
      }
      if (src[++i] != '\0') {
        c += unhex(src[i]);
      }
      dst += c;
    } else {
      dst += src[i];
    }
  }
  return dst;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rax
leaq (%rax,%rax,2), %rsi
incq %rsi
callq 0x21a0
xorl %r15d, %r15d
movl %r15d, %eax
cmpq %rax, 0x8(%r14)
jbe 0x246e
movq (%r14), %r12
movb (%r12,%rax), %al
cmpb $0x25, %al
jne 0x245e
leal 0x1(%r15), %eax
movb (%r12,%rax), %al
testb %al, %al
je 0x2439
movzbl %al, %edi
callq 0x2491
movl %eax, %ebp
shlb $0x4, %bpl
addl $0x2, %r15d
movb (%r12,%r15), %al
testb %al, %al
je 0x2450
movzbl %al, %edi
callq 0x2491
addb %al, %bpl
movsbl %bpl, %esi
movq %rbx, %rdi
callq 0x2110
jmp 0x2469
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2110
incl %r15d
jmp 0x240b
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x247e
jmp 0x247e
movq %rax, %r14
movq %rbx, %rdi
callq 0x2090
movq %r14, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/tokuhirom[P]nanouri/t/nanotap.h
// Function: void is<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const*)
inline NANOTAP_DECLARE void is(T got, T expected, const char *msg) {
    if (got == expected) {
        ok(true, msg);
    } else {
        ok(false, msg);
        std::cout << "  # got      : " << got << std::endl;
        std::cout << "  # expected : " << expected << std::endl;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2c9d
testb %al, %al
je 0x2627
pushq $0x1
popq %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x24b0
xorl %edi, %edi
movq %r15, %rsi
callq 0x24b0
movq 0x2998(%rip), %r15      # 0x4fd0
leaq 0xa86(%rip), %rsi       # 0x30c5
movq %r15, %rdi
callq 0x2140
movq %rax, %rdi
movq %r14, %rsi
callq 0x2130
movq %rax, %rdi
callq 0x20a0
leaq 0xa74(%rip), %rsi       # 0x30d5
movq %r15, %rdi
callq 0x2140
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2130
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x20a0
// File: /workspace/github_cpp_makefile_star2_O2/tokuhirom[P]nanouri/t/nanotap.h
// Function: is_binary(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*)
inline NANOTAP_DECLARE void is_binary(const std::string &got, const std::string& expected, const char *msg) {
    if (got.size() != expected.size()) {
        ok(0, msg);
        std::stringstream ss;
        ss << "Expected " << expected.size() << " bytes chars, but got " << got.size() << " bytes chars";
        diag(ss.str());
        return;
    }
    for (size_t i=0; i<got.size(); i++) {
        if (got[i] != expected[i]) {
            ok(0, msg);

            std::stringstream ss;
            ss << "Expected " << std::hex << int(expected[i]) << " but got " << int(got[i]) << ", at " << i;
            diag(ss.str());
            return;
        }
    }
    ok(true, msg);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
jne 0x2754
movq (%rbx), %rcx
movq (%r15), %rsi
xorl %r14d, %r14d
cmpq %r14, %rax
je 0x27c3
movb (%rcx,%r14), %dil
cmpb (%rsi,%r14), %dil
jne 0x27da
incq %r14
jmp 0x2738
xorl %edi, %edi
movq %rdx, %rsi
callq 0x24b0
leaq 0x28(%rsp), %rdi
callq 0x20d0
leaq 0x38(%rsp), %rdi
leaq 0x8b0(%rip), %rsi       # 0x3024
callq 0x2140
movq 0x8(%r15), %rsi
movq %rax, %rdi
callq 0x20c0
leaq 0x8a2(%rip), %rsi       # 0x302e
movq %rax, %rdi
callq 0x2140
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x20c0
leaq 0x89e(%rip), %rsi       # 0x3045
movq %rax, %rdi
callq 0x2140
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x21b0
jmp 0x286c
pushq $0x1
popq %rdi
movq %rdx, %rsi
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %r15
jmp 0x24b0
xorl %edi, %edi
movq %rdx, %rsi
callq 0x24b0
leaq 0x28(%rsp), %rdi
callq 0x20d0
leaq 0x38(%rsp), %rdi
leaq 0x82a(%rip), %rsi       # 0x3024
callq 0x2140
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rax,%rcx)
movq (%r15), %rcx
movsbl (%rcx,%r14), %esi
movq %rax, %rdi
callq 0x21c0
leaq 0x810(%rip), %rsi       # 0x303b
movq %rax, %rdi
callq 0x2140
movq (%rbx), %rcx
movsbl (%rcx,%r14), %esi
movq %rax, %rdi
callq 0x21c0
leaq 0x808(%rip), %rsi       # 0x3052
movq %rax, %rdi
callq 0x2140
movq %rax, %rdi
movq %r14, %rsi
callq 0x20c0
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x21b0
leaq 0x8(%rsp), %rbx
movq (%rbx), %rdi
callq 0x24f1
movq %rbx, %rdi
callq 0x2090
leaq 0x28(%rsp), %rdi
callq 0x20f0
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %r15
retq
jmp 0x289e
jmp 0x289e
jmp 0x289e
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/tokuhirom[P]nanouri/t/03_class.cc
// Function: main
int main() {
    std::string src;

    nanouri::Uri uri;
    ok(!uri, "not parsed yet");
    ok(uri.parse("http://mixi.jp/hoge.pl"));
    ok(uri, "parse succeeded");
    is(uri.host(), "mixi.jp");
    is(uri.path_query(), "/hoge.pl");
    is(uri.scheme(), "http");

    done_testing();
}

// Assembly:
pushq %rbx
subq $0x130, %rsp            # imm = 0x130
leaq 0x120(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
leaq 0x98(%rsp), %rcx
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
xorl %edx, %edx
movb %dl, (%rcx)
leaq 0xb8(%rsp), %rcx
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
movb %dl, (%rcx)
leaq 0xd8(%rsp), %rcx
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
movb %dl, (%rax)
movb %dl, (%rcx)
leaq 0x100(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %dl, (%rax)
leaq 0x735(%rip), %rsi       # 0x3058
pushq $0x1
popq %rdi
callq 0x24b0
leaq 0x735(%rip), %rsi       # 0x3067
leaq 0x68(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x2adc
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x2b18
leaq 0xa8(%rsp), %rbx
movzbl %al, %edi
callq 0x26ff
leaq 0x68(%rsp), %rdi
callq 0x2090
xorl %edi, %edi
cmpq $0x0, -0x18(%rbx)
setne %dil
leaq 0x6ff(%rip), %rsi       # 0x307e
callq 0x24b0
leaq 0x48(%rsp), %rdi
movq %rbx, %rsi
callq 0x2170
leaq 0x6f6(%rip), %rsi       # 0x308e
leaq 0x48(%rsp), %rdi
callq 0x2a65
leaq 0xf0(%rsp), %rbx
leaq 0x48(%rsp), %rdi
callq 0x2090
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x2170
leaq 0x6ad(%rip), %rsi       # 0x3075
leaq 0x28(%rsp), %rdi
callq 0x2a65
leaq 0xc8(%rsp), %rbx
leaq 0x28(%rsp), %rdi
callq 0x2090
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x2170
leaq 0x69e(%rip), %rsi       # 0x3096
leaq 0x8(%rsp), %rdi
callq 0x2a65
leaq 0x8(%rsp), %rdi
callq 0x2090
callq 0x255e
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x2a39
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0x2a39
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
jmp 0x2a39
jmp 0x2a40
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x2090
jmp 0x2a43
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x2b28
leaq 0x110(%rsp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/tokuhirom[P]nanouri/t/../nanouri.hpp
// Function: nanouri::Uri::parse(char const*, unsigned long)
bool parse(const char *src, size_t src_len) {
    const char *scheme;
    size_t scheme_len;
    const char *host;
    size_t host_len;
    const char *path_query;
    int path_query_len;
    int ret =
        nanouri_parse_uri(src, src_len, &scheme, &scheme_len, &host, &host_len,
                          &port_, &path_query, &path_query_len);
    if (ret != 0) {
      return false;  // parse error
    }
    uri_.assign(src, src_len);
    host_.assign(host, host_len);
    path_query_.assign(path_query, path_query_len);
    scheme_.assign(scheme, scheme_len);
    return true;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x60(%rdi), %rax
subq $0x8, %rsp
leaq 0x14(%rsp), %r10
leaq 0x18(%rsp), %r11
leaq 0x38(%rsp), %rdx
leaq 0x30(%rsp), %rcx
leaq 0x28(%rsp), %r8
leaq 0x20(%rsp), %r9
movq %rsi, %rdi
movq %r14, %rsi
pushq %r10
pushq %r11
pushq %rax
callq 0x2d19
addq $0x20, %rsp
movl %eax, %ebp
testl %eax, %eax
jne 0x2bed
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2160
leaq 0x20(%rbx), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x2160
leaq 0x68(%rbx), %rdi
movq 0x10(%rsp), %rsi
movslq 0xc(%rsp), %rdx
callq 0x2160
addq $0x40, %rbx
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0x2160
testl %ebp, %ebp
sete %al
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tokuhirom[P]nanouri/nanouri.c
// Function: nanouri_parse_uri(char const*, unsigned long, char const**, unsigned long*, char const**, unsigned long*, int*, char const**, int*)
int nanouri_parse_uri(const char* _buf, size_t len, const char** scheme, size_t *scheme_len, const char **host, size_t *host_len, int *port, const char **path_query, int*path_query_len) {
  const char * buf = _buf, * buf_end = buf + len;

  *scheme = buf;
  for (;;++buf) {
    CHECK_EOF();
    if (':' == *buf) {
      break;
    }
  }
  *scheme_len = buf - *scheme;

  EXPECT(':'); EXPECT('/'); EXPECT('/');

  *host = buf;
  *port = 0;
  *host_len = 0;
  *path_query_len = 0;
  for (;;++buf) {
    if (buf == buf_end) {
      *host_len = buf - *host;
      return 0;
    }
    if (':' == *buf) { /* with port */
      *host_len = buf - *host;
      buf++;

      *port = 0;
      for (;'0' <= *buf && *buf <= '9';buf++) {
        if (buf == buf_end) {
          return 0;
        }
        *port = *port * 10 + (*buf - '0');
      }
      if (buf == buf_end) {
        return 0;
      }
      break;
    }
    if ('/' == *buf) { /* no port */
      *host_len = buf - *host;
      break;
    }
  }

  *path_query = buf;
  *path_query_len = buf_end - buf;
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x38(%rsp), %r10
movq 0x30(%rsp), %rbx
movq 0x28(%rsp), %r14
leaq (%rdi,%rsi), %r11
movq %rdi, (%rdx)
xorl %edx, %edx
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
movq %rsi, %r15
subq %rdx, %r15
je 0x2dbe
cmpb $0x3a, (%rdi,%rdx)
je 0x2d50
incq %rdx
jmp 0x2d3d
movq %rdx, (%rcx)
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpb $0x3a, (%rdi,%rdx)
jne 0x2dbc
leaq -0x1(%rsi), %r12
cmpq %rdx, %r12
je 0x2dbe
cmpb $0x2f, 0x1(%rdi,%rdx)
jne 0x2dbc
leaq -0x2(%rsi), %r12
cmpq %rdx, %r12
je 0x2dbe
cmpb $0x2f, 0x2(%rdi,%rdx)
movl %ecx, %eax
jne 0x2dbe
leaq (%rdi,%rdx), %rax
addq $0x3, %rax
movq %rax, (%r8)
andl $0x0, (%r14)
andq $0x0, (%r9)
andl $0x0, (%r10)
leaq -0x3(%rsi), %rax
xorl %ecx, %ecx
cmpq %rdx, %rax
je 0x2dc6
movzbl 0x3(%rdi,%rdx), %r8d
cmpl $0x2f, %r8d
je 0x2e11
cmpl $0x3a, %r8d
je 0x2dcf
incq %rdx
incq %rcx
jmp 0x2d9d
movl %ecx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
retq
addq $-0x3, %r15
movq %r15, (%r9)
jmp 0x2e2f
movq %rcx, (%r9)
subq %rdx, %rsi
addq $-0x4, %rsi
leaq (%rdi,%rdx), %rcx
addq $0x4, %rcx
xorl %edx, %edx
movq %rcx, %rax
movl %edx, (%r14)
movb (%rcx), %dil
addb $-0x30, %dil
cmpb $0x9, %dil
ja 0x2e21
testq %rsi, %rsi
je 0x2e2f
imull $0xa, %edx, %r8d
movzbl %dil, %edx
addl %r8d, %edx
incq %rax
incq %rcx
decq %rsi
jmp 0x2de6
leaq (%rdi,%rdx), %rax
addq $0x3, %rax
movq %rcx, (%r9)
movq %rax, %rcx
jmp 0x2e26
testq %rsi, %rsi
je 0x2e2f
movq %rcx, (%rbx)
subl %eax, %r11d
movl %r11d, (%r10)
xorl %eax, %eax
jmp 0x2dbe
// File: /workspace/github_cpp_makefile_star2_O2/akw0088[P]openssl/huffman_enc.c
// Function: get_file
char *get_file(char *filename, unsigned int *size)
{
	FILE	*file;
	char	*buffer;
	int	file_size, bytes_read;

	file = fopen(filename, "rb");
	if (file == NULL)
		return 0;
	fseek(file, 0, SEEK_END);
	file_size = ftell(file);
	fseek(file, 0, SEEK_SET);
	buffer = malloc(file_size + 1);
	bytes_read = (int)fread(buffer, sizeof(char), file_size, file);
	if (bytes_read != file_size)
	{
		free((void *)buffer);
		fclose(file);
		return 0;
	}
	fclose(file);
	buffer[file_size] = '\0';

	if (size != NULL)
	{
		*size = file_size;
	}
	return buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0xde0(%rip), %rsi       # 0x2004
callq 0x10e0
testq %rax, %rax
je 0x12a5
movq %rax, %r14
pushq $0x2
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x10d0
movq %r14, %rdi
callq 0x10b0
movq %rax, %r12
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x10d0
leal 0x1(%r12), %eax
movslq %eax, %rdi
callq 0x10c0
movq %rax, %r15
movslq %r12d, %r13
pushq $0x1
popq %rsi
movq %rax, %rdi
movq %r13, %rdx
movq %r14, %rcx
callq 0x1050
cmpl %r13d, %eax
jne 0x1295
movq %r14, %rdi
callq 0x1060
movb $0x0, (%r15,%r13)
testq %rbx, %rbx
je 0x12a8
movl %r12d, (%rbx)
jmp 0x12a8
movq %r15, %rdi
callq 0x1030
movq %r14, %rdi
callq 0x1060
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/akw0088[P]openssl/huffman_enc.c
// Function: write_file
int write_file(char *filename, const char *bytes, int size)
{
	FILE *fp = fopen(filename, "wb");
	int ret;

	if (fp == NULL)
	{
		perror("Unable to open file for writing");
		return -1;
	}

	ret = fwrite(bytes, sizeof(char), size, fp);

	if (ret != size)
	{
		printf("fwrite didnt write all data\n");
		fclose(fp);
		return -1;
	}
	fclose(fp);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rsi, %r14
leaq 0xd36(%rip), %rsi       # 0x2007
callq 0x10e0
testq %rax, %rax
je 0x1325
movq %rax, %rbx
movslq %r15d, %r15
pushq $0x1
popq %rsi
movq %r14, %rdi
movq %r15, %rdx
movq %rax, %rcx
callq 0x1100
cmpl %r15d, %eax
jne 0x1303
movq %rbx, %rdi
callq 0x1060
xorl %eax, %eax
jmp 0x131a
leaq 0xd71(%rip), %rdi       # 0x207b
callq 0x1040
movq %rbx, %rdi
callq 0x1060
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xcde(%rip), %rdi       # 0x200a
callq 0x10f0
jmp 0x1317