LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movl 0x60(%rcx), %eax
shrl $0x3, %eax
andl $0x3f, %eax
movl %eax, %eax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
shll $0x3, %eax
addl 0x60(%rcx), %eax
movl %eax, 0x60(%rcx)
movq -0x18(%rbp), %rcx
shll $0x3, %ecx
cmpl %ecx, %eax
jae 0x6f90
movq -0x38(%rbp), %rax
movl 0x64(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x64(%rax)
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
shrl $0x1d, %ecx
addl 0x64(%rax), %ecx
movl %ecx, 0x64(%rax)
movl $0x40, %eax
subq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0x7018
movq -0x38(%rbp), %rdi
addq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x3290
movq -0x38(%rbp), %rsi
movq %rsi, %rdi
callq 0x7050
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x40, %rax
cmpq -0x18(%rbp), %rax
ja 0x700e
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq -0x30(%rbp), %rsi
callq 0x7050
movq -0x30(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x30(%rbp)
jmp 0x6fe1
movq $0x0, -0x20(%rbp)
jmp 0x7020
movq $0x0, -0x30(%rbp)
movq -0x38(%rbp), %rdi
addq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdx
subq -0x30(%rbp), %rdx
callq 0x3290
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movb $-0x80, 0xf385(%rip)    # 0x17330
testb $0x1, 0x68(%rax)
jne 0x805b
movq -0x28(%rbp), %rax
movl 0x60(%rax), %ecx
movl %ecx, -0x10(%rbp)
movl 0x64(%rax), %ecx
movl %ecx, -0xc(%rbp)
movl 0x60(%rax), %eax
shrl $0x3, %eax
andl $0x3f, %eax
movl %eax, %eax
movq %rax, -0x18(%rbp)
cmpq $0x38, -0x18(%rbp)
jae 0x7fea
movl $0x38, %eax
subq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x7ff7
movl $0x78, %eax
subq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
leaq 0xf322(%rip), %rsi      # 0x17330
callq 0x6f40
movq -0x28(%rbp), %rdi
leaq -0x10(%rbp), %rsi
movl $0x8, %edx
callq 0x6f40
movq -0x28(%rbp), %rdi
movq 0x50(%rdi), %rax
movq %rax, 0x40(%rdi)
movq 0x58(%rdi), %rax
movq %rax, 0x48(%rdi)
xorl %esi, %esi
movl $0x40, %edx
callq 0x31d0
movq -0x28(%rbp), %rax
movl $0x0, 0x60(%rax)
movl $0x0, 0x64(%rax)
movb $0x1, 0x68(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
testb $0x1, 0x68(%rax)
jne 0x80e7
leaq -0x11(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x3570
movq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rdx
leaq 0x8082(%rip), %rsi      # 0x1013a
callq 0x3400
jmp 0x80bf
leaq -0x11(%rbp), %rdi
callq 0x3340
jmp 0x817b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x3340
jmp 0x8188
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x21, %edx
callq 0x31d0
movl $0x0, -0x54(%rbp)
cmpl $0x10, -0x54(%rbp)
jge 0x8139
movq -0x60(%rbp), %rax
leaq -0x50(%rbp), %rdi
movl -0x54(%rbp), %ecx
shll %ecx
movslq %ecx, %rcx
addq %rcx, %rdi
movslq -0x54(%rbp), %rcx
movzbl 0x40(%rax,%rcx), %edx
leaq 0x8015(%rip), %rsi      # 0x1013c
movb $0x0, %al
callq 0x30b0
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x80fe
leaq -0x55(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3570
movq -0x70(%rbp), %rdi
movq -0x80(%rbp), %rdx
leaq -0x50(%rbp), %rsi
callq 0x3400
jmp 0x8159
leaq -0x55(%rbp), %rdi
callq 0x3340
jmp 0x817b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x55(%rbp), %rdi
callq 0x3340
jmp 0x8188
movq -0x68(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3560
nopw %cs:(%rax,%rax)
// File: 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
subq $0xa0, %rsp
movq %rsi, -0xa0(%rbp)
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x7c(%rbp), %rdi
callq 0x6ee0
movq -0xa0(%rbp), %rdi
callq 0x3150
movq -0xa0(%rbp), %rdi
movq %rax, -0x98(%rbp)
callq 0x3250
movq -0x98(%rbp), %rsi
movq %rax, %rdx
leaq -0x7c(%rbp), %rdi
callq 0x7f60
leaq -0x7c(%rbp), %rdi
callq 0x7f90
movq -0x90(%rbp), %rdi
leaq -0x7c(%rbp), %rsi
callq 0x8070
movq -0x88(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x200(%rbp)
movq %rdi, %rax
movq %rax, -0x1f8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0xd205(%rip), %rdi      # 0x16fc0
leaq 0x6422(%rip), %rsi      # 0x101e4
callq 0x3300
leaq -0x30(%rbp), %rdi
movq %rdi, -0x1f0(%rbp)
callq 0x3410
leaq -0x50(%rbp), %rdi
callq 0x3410
movq -0x1f0(%rbp), %rsi
movq 0xd1ea(%rip), %rdi      # 0x16fd8
callq 0x30c0
jmp 0x9df5
movq -0x200(%rbp), %rdi
movb $0x0, -0x5d(%rbp)
callq 0x8250
movl $0x10, %edi
movl $0x8, %esi
callq 0x8230
movl %eax, -0x204(%rbp)
jmp 0x9e1c
movl -0x204(%rbp), %edx
leaq -0x1e8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x34a0
jmp 0x9e34
jmp 0x9e36
leaq -0x1e8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x33a0
movq %rax, -0x210(%rbp)
jmp 0x9e4f
movq -0x210(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3380
movb %al, -0x211(%rbp)
jmp 0x9e6d
movb -0x211(%rbp), %al
testb $0x1, %al
jne 0x9e79
jmp 0x9ec3
movq -0x200(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x8270
jmp 0x9e8b
jmp 0x9e36
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x9f13
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x9f07
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x1e8(%rbp), %rdi
callq 0x3260
jmp 0x9f07
movb $0x1, -0x5d(%rbp)
leaq -0x1e8(%rbp), %rdi
callq 0x3260
testb $0x1, -0x5d(%rbp)
jne 0x9ee5
movq -0x200(%rbp), %rdi
callq 0x5570
leaq -0x50(%rbp), %rdi
callq 0x3210
leaq -0x30(%rbp), %rdi
callq 0x3210
movq -0x1f8(%rbp), %rax
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
movq -0x200(%rbp), %rdi
callq 0x5570
leaq -0x50(%rbp), %rdi
callq 0x3210
leaq -0x30(%rbp), %rdi
callq 0x3210
movq -0x58(%rbp), %rdi
callq 0x3560
nop
// File: 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
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xba00
movl $0x0, -0x18(%rbp)
movslq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd270
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0xbc4b
movq -0x50(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xd500
jmp 0xbc27
jmp 0xbc29
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xbbfb
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xbce0
jmp 0xbc9d
movq -0x50(%rbp), %rdi
callq 0xd5c0
movq -0x50(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0xd5f0
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0xd570
jmp 0xbc80
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xbc93
movq -0x50(%rbp), %rdi
callq 0xbce0
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3560
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x8(%rbp)
jge 0x2739
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq 0x38ce(%rip), %rdi      # 0x5fd8
callq 0x2140
movq %rax, %rdi
leaq 0x18eb(%rip), %rsi      # 0x4004
callq 0x2140
movq %rax, %rdi
movq 0x38a0(%rip), %rsi      # 0x5fc8
callq 0x2170
movl $0x1, -0x4(%rbp)
jmp 0x27c8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x58(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x2290
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x2930
jmp 0x2765
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2220
movl %eax, %esi
leaq -0x30(%rbp), %rdi
callq 0x2400
jmp 0x277f
leaq -0x30(%rbp), %rdi
callq 0x20c0
leaq -0x31(%rbp), %rdi
callq 0x2190
movl $0x0, -0x4(%rbp)
jmp 0x27c8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x27bd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x20c0
leaq -0x31(%rbp), %rdi
callq 0x2190
jmp 0x27d1
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x2280
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x57e0
movq 0x208ae(%rip), %rdi     # 0x25fd0
leaq 0x15909(%rip), %rsi     # 0x1b032
callq 0x5280
movq %rax, %rdi
leaq 0x20ba0(%rip), %rsi     # 0x262d8
callq 0x5260
movq %rax, %rdi
movq 0x20869(%rip), %rsi     # 0x25fb0
callq 0x52c0
movq %rax, %rdi
leaq 0x158f1(%rip), %rsi     # 0x1b047
callq 0x5280
movq %rax, %rdi
leaq 0x20b93(%rip), %rsi     # 0x262f8
callq 0x5260
movq %rax, %rdi
movq 0x2083c(%rip), %rsi     # 0x25fb0
callq 0x52c0
movq %rax, %rdi
leaq 0x158df(%rip), %rsi     # 0x1b062
callq 0x5280
movq %rax, %rdi
leaq 0x20b86(%rip), %rsi     # 0x26318
callq 0x5260
movq %rax, %rdi
movq 0x2080f(%rip), %rsi     # 0x25fb0
callq 0x52c0
movq %rax, %rdi
leaq 0x158cd(%rip), %rsi     # 0x1b07d
callq 0x5280
movq %rax, %rdi
movb 0x20b13(%rip), %al      # 0x262d1
andb $0x1, %al
movzbl %al, %esi
callq 0x5490
movq %rax, %rdi
movq 0x207de(%rip), %rsi     # 0x25fb0
callq 0x52c0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq (%rax), %rsi
callq 0x70f0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x12df0
testb $0x1, %al
jne 0x1911e
jmp 0x19124
movb $0x0, -0x1(%rbp)
jmp 0x1914f
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq (%rax), %rsi
callq 0x70f0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x13020
movq -0x28(%rbp), %rax
movb $0x1, 0x91(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
addq $0x28, %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x12710
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0xb930
movb %al, %cl
movb $0x0, -0x39(%rbp)
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x3a(%rbp)
jne 0x191d2
movq -0x50(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0xe1b0
movq -0x58(%rbp), %rdi
movb $0x1, -0x39(%rbp)
leaq -0x38(%rbp), %rsi
callq 0xb930
movb %al, -0x3a(%rbp)
movb -0x3a(%rbp), %al
movb %al, -0x59(%rbp)
testb $0x1, -0x39(%rbp)
jne 0x191e0
jmp 0x191e9
leaq -0x38(%rbp), %rdi
callq 0x5528
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x191f2
jmp 0x191f8
movb $0x1, -0x1(%rbp)
jmp 0x191fc
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x21(%rbp), %rsi
leaq -0x22(%rbp), %rdx
callq 0x11a0
leaq 0xe8e(%rip), %rdi       # 0x2004
leaq 0xe8b(%rip), %rsi       # 0x2008
leaq 0xe8a(%rip), %rdx       # 0x200e
callq 0x13c0
leaq 0xe85(%rip), %rdi       # 0x2015
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x40e0
movq -0x10(%rbp), %rdi
callq 0x6c40
testb $0x1, %al
jne 0x3097
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x6c60
movq -0x10(%rbp), %rsi
movq (%rsi), %rax
movq 0x30(%rax), %rax
leaq -0x50(%rbp), %rdi
callq *%rax
jmp 0x2f35
leaq -0x38(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x4160
movq -0xa8(%rbp), %rdi
movq %rax, -0x70(%rbp)
callq 0x4190
movq %rax, -0x78(%rbp)
movq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rsi
leaq -0x14(%rbp), %rdx
callq 0x4110
movq %rax, -0xa0(%rbp)
jmp 0x2f73
movq -0xa0(%rbp), %rax
movq %rax, -0x68(%rbp)
movss -0x14(%rbp), %xmm0
movss %xmm0, -0xac(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4160
movq %rax, -0x80(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x41e0
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
callq 0x41c0
movss -0xac(%rbp), %xmm0
ucomiss (%rax), %xmm0
jne 0x3030
jp 0x3030
leaq -0x38(%rbp), %rdi
callq 0x4160
movq %rax, -0x88(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x41e0
movq %rax, %rsi
incq %rsi
leaq -0x50(%rbp), %rdi
callq 0x4220
movq -0x98(%rbp), %rdi
movq (%rax), %rsi
movss -0x14(%rbp), %xmm0
movq -0x20(%rbp), %rdx
callq 0x2ed0
jmp 0x3009
jmp 0x3078
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x308c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x4240
jmp 0x308c
leaq -0x38(%rbp), %rdi
callq 0x4160
movq %rax, -0x90(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x41e0
movq %rax, %rsi
leaq -0x50(%rbp), %rdi
callq 0x4220
movq -0x98(%rbp), %rdi
movq (%rax), %rsi
movss -0x14(%rbp), %xmm0
movq -0x20(%rbp), %rdx
callq 0x2ed0
jmp 0x3076
jmp 0x3078
leaq -0x50(%rbp), %rdi
callq 0x4240
leaq -0x38(%rbp), %rdi
callq 0x42a0
jmp 0x3097
leaq -0x38(%rbp), %rdi
callq 0x42a0
jmp 0x30a0
addq $0xb0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x22d0
nopl (%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6c40
testb $0x1, %al
jne 0x315e
movq -0x10(%rbp), %rsi
movq (%rsi), %rax
leaq -0x28(%rbp), %rdi
callq *0x30(%rax)
leaq -0x28(%rbp), %rdi
callq 0x4300
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4370
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x4330
testb $0x1, %al
jne 0x3114
jmp 0x3155
leaq -0x30(%rbp), %rdi
callq 0x43a0
movq -0x58(%rbp), %rdi
movq (%rax), %rsi
callq 0x30b0
jmp 0x312b
jmp 0x312d
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x43c0
movq %rax, -0x50(%rbp)
jmp 0x30f4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4240
jmp 0x3184
leaq -0x28(%rbp), %rdi
callq 0x4240
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0x317e
movq -0x60(%rbp), %rdi
callq 0x4400
movq -0x60(%rbp), %rdi
callq 0x2180
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x22d0
nopl (%rax)
// File: 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
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x90(%rbp)
addq $0x10, %rdi
callq 0x4160
movq -0x90(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x10, %rdi
callq 0x4190
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0xc(%rbp), %rdx
callq 0x4110
movq %rax, %rcx
movq -0x90(%rbp), %rax
movq %rcx, -0x20(%rbp)
addq $0x10, %rax
movq %rax, -0x98(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x7a20
movq -0x98(%rbp), %rdi
movq -0x38(%rbp), %rsi
leaq -0xc(%rbp), %rdx
callq 0x7820
movq -0x90(%rbp), %rdi
movq %rax, -0x40(%rbp)
addq $0x10, %rdi
callq 0x4160
movq -0x90(%rbp), %rdi
movq %rax, -0x50(%rbp)
addq $0x10, %rdi
callq 0x4190
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
leaq -0xc(%rbp), %rdx
callq 0x4110
movq -0x90(%rbp), %rdi
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rdi, %rax
addq $0x28, %rax
movq %rax, -0x88(%rbp)
addq $0x28, %rdi
callq 0x4300
movq -0x90(%rbp), %rdi
movq %rax, -0x70(%rbp)
addq $0x10, %rdi
callq 0x4160
movq %rax, -0x78(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x41e0
movq %rax, %rsi
addq $0x1, %rsi
leaq -0x70(%rbp), %rdi
callq 0x7c60
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x7ca0
movq -0x88(%rbp), %rdi
movq -0x60(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x7a60
movq %rax, -0x80(%rbp)
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: xocoder[P]m_kcptun/src/kcp_remote.cpp
// Function: main
int
main(int argc, const char *argv[]) {

   tun_remote_t *tun = new tun_remote_t;
   memset(tun, 0, sizeof(*tun));

   if ( tun ) {

      tun->conf = conf_create(argc, argv);
      if ( tun->conf ) {

         if ( _remote_network_init(tun) ) {
            
            _remote_network_runloop(tun);

            _remote_network_fini(tun);
         }

         conf_release(tun->conf);
      }

      delete tun;
   }

   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x10098, %edi          # imm = 0x10098
callq 0x32f0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x10098, %edx          # imm = 0x10098
callq 0x31b0
cmpq $0x0, -0x18(%rbp)
je 0xd558
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0xbd60
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x78(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x78(%rax)
je 0xd53a
movq -0x18(%rbp), %rdi
callq 0xd560
cmpl $0x0, %eax
je 0xd52d
movq -0x18(%rbp), %rdi
callq 0xd7f0
movq -0x18(%rbp), %rdi
callq 0xda10
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rdi
callq 0xcf30
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xd556
movq -0x20(%rbp), %rdi
movl $0x10098, %esi          # imm = 0x10098
callq 0x3310
jmp 0xd558
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: xocoder[P]m_kcptun/src/kcp_remote.cpp
// Function: remote_network_fini(tun_remote_t*)
static int
_remote_network_fini(tun_remote_t *tun) {
   if (tun) {
      tmr_destroy_lst(tun->tmr);      
      while (skt_count(tun->session_lst) > 0) {
         session_unit_t *u = (session_unit_t*)skt_popf(tun->session_lst);
         mnet_chann_close(u->tcp);      
         session_destroy(NULL, u);
      }
      skt_destroy(tun->session_lst);      
      _remote_kcpin_destroy(tun);
      rskcp_release(tun->rt);
      mnet_fini();
      return 1;
   }
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xdaaa
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rdi
callq 0xacf0
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0xb510
cmpl $0x0, %eax
jle 0xda76
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0xb9f0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x7280
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0xd450
jmp 0xda37
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0xb460
movq -0x10(%rbp), %rdi
callq 0xe040
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rdi
callq 0xe780
callq 0x6870
movl $0x1, -0x4(%rbp)
jmp 0xdab1
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
leaq -0xe73(%rip), %rdi      # 0xcf70
leaq -0xe4a(%rip), %rsi      # 0xcfa0
callq 0x3740
movq -0x10(%rbp), %rax
movl 0x50(%rax), %edi
movq -0x10(%rbp), %rsi
callq 0x3880
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0xde43
movq 0xb1d4(%rip), %rdi      # 0x18ff0
leaq 0x71d2(%rip), %rsi      # 0x14ff5
callq 0x32d0
movq %rax, %rdi
movq 0xb18e(%rip), %rsi      # 0x18fc0
callq 0x3320
movl $0x0, -0x4(%rbp)
jmp 0xdf2c
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
leaq 0x22e(%rip), %rsi       # 0xe080
callq 0x3f40
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rax
movl 0x130(%rax), %esi
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rax
movl 0x134(%rax), %edx
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rax
movl 0x138(%rax), %ecx
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rax
movl 0x13c(%rax), %r8d
callq 0x6510
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rax
movl 0x12c(%rax), %esi
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rax
movl 0x128(%rax), %edx
callq 0x65b0
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rax
movl 0x140(%rax), %esi
callq 0x6430
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rax
cmpl $0x3, 0x144(%rax)
jne 0xdf03
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movl $0x14, 0x34(%rax)
jmp 0xdf25
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rax
cmpl $0x2, 0x144(%rax)
jne 0xdf23
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movl $0x28, 0x34(%rax)
jmp 0xdf25
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: xocoder[P]m_kcptun/src/kcp_remote.cpp
// Function: remote_kcpin_reset(tun_remote_t*, unsigned int)
static void
_remote_kcpin_reset(tun_remote_t *tun, uint32_t kcpconv) {
   
   cout << "udp & kcp reset " << kcpconv << endl;
   tun->kcpconv = kcpconv;

   _remote_kcpin_destroy(tun);
   _remote_kcpin_create(tun);

   while (skt_count(tun->session_lst) > 0) {
      session_unit_t *u = (session_unit_t*)skt_popf(tun->session_lst);
      mnet_chann_close(u->tcp);
      session_destroy(NULL, u);
   }
   skt_destroy(tun->session_lst);
   tun->session_lst = skt_create();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq 0xb03a(%rip), %rdi      # 0x18fd0
leaq 0x7047(%rip), %rsi      # 0x14fe4
callq 0x32d0
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x3420
movq %rax, %rdi
movq 0xb009(%rip), %rsi      # 0x18fc0
callq 0x3320
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x50(%rax)
movq -0x8(%rbp), %rdi
callq 0xe040
movq -0x8(%rbp), %rdi
callq 0xddd0
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0xb510
cmpl $0x0, %eax
jle 0xe017
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0xb9f0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x7280
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0xd450
jmp 0xdfd8
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0xb460
callq 0xb340
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x58(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: xocoder[P]m_kcptun/src/kcp_remote.cpp
// Function: tcpout_open_and_connect(tun_remote_t*, unsigned int)
static int
_tcpout_open_and_connect(tun_remote_t *tun, unsigned sid) {
   chann_t *tcp = mnet_chann_open(CHANN_TYPE_STREAM);
   if (tcp == NULL) {
      cerr << "Fail to create tcp out !" << endl;
      return 0;
   }

   session_unit_t *u = session_create(tun->session_lst, sid, tcp, tun);
   if ( u ) {
      mnet_chann_set_cb(tcp, _remote_tcpout_callback, u);
      if (mnet_chann_connect(tcp, tun->conf->dest_ip[0], tun->conf->dest_port[0]) > 0) {
         cout << "tcp out try connect with sid " << sid << endl;
         return 1;
      }
   } else {
      mnet_chann_close(tcp);
   }

   cerr << "tcp out fail to connect with sid " << sid << endl;
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x1, %edi
callq 0x71a0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xe2e2
movq 0xad35(%rip), %rdi      # 0x18ff0
leaq 0x6d94(%rip), %rsi      # 0x15056
callq 0x32d0
movq %rax, %rdi
movq 0xacef(%rip), %rsi      # 0x18fc0
callq 0x3320
movl $0x0, -0x4(%rbp)
jmp 0xe3b9
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rcx
callq 0xd350
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xe37c
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0xbc(%rip), %rsi        # 0xe3d0
callq 0x7940
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rsi
addq $0x98, %rsi
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rax
movl 0x118(%rax), %edx
callq 0x72f0
cmpl $0x0, %eax
jle 0xe37a
movq 0xac85(%rip), %rdi      # 0x18fd0
leaq 0x6d1d(%rip), %rsi      # 0x1506f
callq 0x32d0
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x3420
movq %rax, %rdi
movq 0xac54(%rip), %rsi      # 0x18fc0
callq 0x3320
movl $0x1, -0x4(%rbp)
jmp 0xe3b9
jmp 0xe385
movq -0x20(%rbp), %rdi
callq 0x7280
movq 0xac64(%rip), %rdi      # 0x18ff0
leaq 0x6cfa(%rip), %rsi      # 0x1508d
callq 0x32d0
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x3420
movq %rax, %rdi
movq 0xac13(%rip), %rsi      # 0x18fc0
callq 0x3320
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x2260
movq -0x10(%rbp), %rdi
callq 0x2120
movq -0x30(%rbp), %rdi
leaq 0x1(%rax,%rax,2), %rsi
callq 0x22a0
jmp 0x249d
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2120
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x25a3
movq -0x10(%rbp), %rdi
movl -0x28(%rbp), %eax
movl %eax, %esi
callq 0x2200
movzbl (%rax), %edi
callq 0x3b20
movl %eax, -0x44(%rbp)
jmp 0x24df
movl -0x44(%rbp), %eax
cmpl $0x0, %eax
je 0x2575
movq -0x30(%rbp), %rdi
movl $0x25, %esi
callq 0x20f0
jmp 0x24fb
movq -0x10(%rbp), %rdi
movl -0x28(%rbp), %eax
movl %eax, %esi
callq 0x2200
movzbl (%rax), %edi
shrl $0x4, %edi
andl $0xf, %edi
callq 0x3b40
movb %al, -0x45(%rbp)
jmp 0x251c
movq -0x30(%rbp), %rdi
movb -0x45(%rbp), %al
movsbl %al, %esi
callq 0x20f0
jmp 0x252d
movq -0x10(%rbp), %rdi
movl -0x28(%rbp), %eax
movl %eax, %esi
callq 0x2200
movzbl (%rax), %edi
andl $0xf, %edi
callq 0x3b40
movb %al, -0x46(%rbp)
jmp 0x254b
movq -0x30(%rbp), %rdi
movb -0x46(%rbp), %al
movsbl %al, %esi
callq 0x20f0
jmp 0x255c
jmp 0x2593
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x20e0
jmp 0x25c0
movq -0x10(%rbp), %rdi
movl -0x28(%rbp), %eax
movl %eax, %esi
callq 0x2200
movq -0x30(%rbp), %rdi
movsbl (%rax), %esi
callq 0x20f0
jmp 0x2591
jmp 0x2593
jmp 0x2595
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x24a4
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x25b6
movq -0x30(%rbp), %rdi
callq 0x20e0
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x22e0
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x2260
movq -0x10(%rbp), %rdi
callq 0x2120
movq -0x38(%rbp), %rdi
leaq 0x1(%rax,%rax,2), %rsi
callq 0x22a0
jmp 0x260d
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2120
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x2730
movq -0x10(%rbp), %rdi
movl -0x28(%rbp), %eax
movl %eax, %esi
callq 0x2200
movsbl (%rax), %eax
cmpl $0x25, %eax
jne 0x2702
movq -0x10(%rbp), %rdi
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movl %eax, %eax
movl %eax, %esi
callq 0x2200
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x26ac
movq -0x10(%rbp), %rdi
movl -0x28(%rbp), %eax
movl %eax, %esi
callq 0x2200
movzbl (%rax), %edi
callq 0x2760
movl %eax, -0x4c(%rbp)
jmp 0x2687
movl -0x4c(%rbp), %eax
shll $0x4, %eax
movb %al, -0x29(%rbp)
jmp 0x26ac
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x20e0
jmp 0x274d
movq -0x10(%rbp), %rdi
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movl %eax, %eax
movl %eax, %esi
callq 0x2200
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x26f1
movq -0x10(%rbp), %rdi
movl -0x28(%rbp), %eax
movl %eax, %esi
callq 0x2200
movzbl (%rax), %edi
callq 0x2760
movl %eax, -0x50(%rbp)
jmp 0x26e5
movl -0x50(%rbp), %ecx
movzbl -0x29(%rbp), %eax
addl %ecx, %eax
movb %al, -0x29(%rbp)
movq -0x38(%rbp), %rdi
movsbl -0x29(%rbp), %esi
callq 0x20f0
jmp 0x2700
jmp 0x2720
movq -0x10(%rbp), %rdi
movl -0x28(%rbp), %eax
movl %eax, %esi
callq 0x2200
movq -0x38(%rbp), %rdi
movsbl (%rax), %esi
callq 0x20f0
jmp 0x271e
jmp 0x2720
jmp 0x2722
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x2614
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x2743
movq -0x38(%rbp), %rdi
callq 0x20e0
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x22e0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x3a10
testb $0x1, %al
jne 0x2a97
jmp 0x2aa7
movq -0x18(%rbp), %rsi
movl $0x1, %edi
callq 0x27d0
jmp 0x2b0e
movq -0x18(%rbp), %rsi
xorl %edi, %edi
callq 0x27d0
movq 0x3517(%rip), %rdi      # 0x5fd0
leaq 0x1605(%rip), %rsi      # 0x40c5
callq 0x21b0
movq -0x28(%rbp), %rsi
movq %rax, %rdi
callq 0x2190
movq %rax, %rdi
movq 0x34e5(%rip), %rsi      # 0x5fc0
callq 0x21c0
movq 0x34e9(%rip), %rdi      # 0x5fd0
leaq 0x15e7(%rip), %rsi      # 0x40d5
callq 0x21b0
movq -0x20(%rbp), %rsi
movq %rax, %rdi
callq 0x2190
movq %rax, %rdi
movq 0x34b7(%rip), %rsi      # 0x5fc0
callq 0x21c0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
leaq -0x20(%rbp), %rdi
callq 0x2260
leaq -0xa8(%rbp), %rdi
callq 0x33f0
jmp 0x2fc2
leaq -0xa8(%rbp), %rdi
callq 0x3440
movb %al, -0x141(%rbp)
jmp 0x2fd6
movb -0x141(%rbp), %al
notb %al
movzbl %al, %edi
andl $0x1, %edi
leaq 0x106d(%rip), %rsi      # 0x4058
callq 0x27d0
jmp 0x2ff2
leaq -0xd9(%rbp), %rdi
movq %rdi, -0x150(%rbp)
callq 0x22f0
movq -0x150(%rbp), %rdx
leaq 0x1054(%rip), %rsi      # 0x4067
leaq -0xd8(%rbp), %rdi
callq 0x3310
jmp 0x3021
leaq -0xa8(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x3460
movb %al, -0x151(%rbp)
jmp 0x303c
movb -0x151(%rbp), %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x2c00
jmp 0x304f
leaq -0xd8(%rbp), %rdi
callq 0x20e0
leaq -0xd9(%rbp), %rdi
callq 0x21e0
leaq -0xa8(%rbp), %rdi
callq 0x3440
movb %al, -0x152(%rbp)
jmp 0x307b
movb -0x152(%rbp), %al
movzbl %al, %edi
andl $0x1, %edi
leaq 0xff0(%rip), %rsi       # 0x407e
callq 0x27d0
jmp 0x3095
leaq -0x100(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x34b0
jmp 0x30aa
leaq 0xfdd(%rip), %rsi       # 0x408e
leaq -0x100(%rbp), %rdi
callq 0x3250
jmp 0x30bf
leaq -0x100(%rbp), %rdi
callq 0x20e0
leaq -0x120(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x34e0
jmp 0x30e0
leaq 0xf8e(%rip), %rsi       # 0x4075
leaq -0x120(%rbp), %rdi
callq 0x3250
jmp 0x30f5
leaq -0x120(%rbp), %rdi
callq 0x20e0
leaq -0x140(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x3510
jmp 0x3116
leaq 0xf79(%rip), %rsi       # 0x4096
leaq -0x140(%rbp), %rdi
callq 0x3250
jmp 0x312b
leaq -0x140(%rbp), %rdi
callq 0x20e0
callq 0x2950
jmp 0x313e
leaq -0xa8(%rbp), %rdi
callq 0x3540
leaq -0x20(%rbp), %rdi
callq 0x20e0
xorl %eax, %eax
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x3236
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x322a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x31be
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x20e0
leaq -0xd9(%rbp), %rdi
callq 0x21e0
jmp 0x322a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0x100(%rbp), %rdi
callq 0x20e0
jmp 0x322a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0x120(%rbp), %rdi
callq 0x20e0
jmp 0x322a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0x140(%rbp), %rdi
callq 0x20e0
leaq -0xa8(%rbp), %rdi
callq 0x3540
leaq -0x20(%rbp), %rdi
callq 0x20e0
movq -0xb0(%rbp), %rdi
callq 0x22e0
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %r11
movq %r11, -0x58(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x60, %r11
leaq -0x28(%rbp), %rdx
leaq -0x30(%rbp), %rcx
leaq -0x38(%rbp), %r8
leaq -0x40(%rbp), %r9
leaq -0x48(%rbp), %r10
leaq -0x4c(%rbp), %rax
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x3ba0
movl %eax, -0x50(%rbp)
cmpl $0x0, -0x50(%rbp)
je 0x3702
movb $0x0, -0x1(%rbp)
jmp 0x3756
movq -0x58(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2250
movq -0x58(%rbp), %rdi
addq $0x20, %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x2250
movq -0x58(%rbp), %rdi
addq $0x68, %rdi
movq -0x48(%rbp), %rsi
movslq -0x4c(%rbp), %rdx
callq 0x2250
movq -0x58(%rbp), %rdi
addq $0x40, %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x2250
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: tokuhirom[P]nanouri/nanouri.c
// Function: nanouri_hex_char(unsigned int)
char nanouri_hex_char(unsigned int n) {
  assert(n < 16);

  if (n < 10) {
    return '0'+n;
  } else {
    return 'a'+n-10;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
cmpl $0x10, -0x8(%rbp)
jae 0x3b53
jmp 0x3b72
leaq 0x58b(%rip), %rdi       # 0x40e5
leaq 0x58b(%rip), %rsi       # 0x40ec
movl $0x34, %edx
leaq 0x589(%rip), %rcx       # 0x40f6
callq 0x2100
cmpl $0xa, -0x8(%rbp)
jae 0x3b83
movl -0x8(%rbp), %eax
addl $0x30, %eax
movb %al, -0x1(%rbp)
jmp 0x3b8f
movl -0x8(%rbp), %eax
addl $0x61, %eax
subl $0xa, %eax
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xdf9(%rip), %rsi       # 0x2004
callq 0x10c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1228
movq $0x0, -0x8(%rbp)
jmp 0x12d1
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x10b0
movq -0x20(%rbp), %rdi
callq 0x1090
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x10b0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x10a0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x2c(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl $0x1, %esi
callq 0x1040
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x2c(%rbp), %eax
je 0x12a4
movq -0x28(%rbp), %rdi
callq 0x1030
movq -0x20(%rbp), %rdi
callq 0x1050
movq $0x0, -0x8(%rbp)
jmp 0x12d1
movq -0x20(%rbp), %rdi
callq 0x1050
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
cmpq $0x0, -0x18(%rbp)
je 0x12c9
movl -0x2c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xd09(%rip), %rsi       # 0x2007
callq 0x10c0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x1323
leaq 0xcf5(%rip), %rdi       # 0x200a
callq 0x10d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1374
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl $0x1, %esi
callq 0x10e0
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
je 0x1364
leaq 0xcdf(%rip), %rdi       # 0x202a
movb $0x0, %al
callq 0x1060
movq -0x28(%rbp), %rdi
callq 0x1050
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1374
movq -0x28(%rbp), %rdi
callq 0x1050
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)