LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest.cc
// Function: testing::internal::UnitTestImpl::ConfigureStreamingOutput()
void UnitTestImpl::ConfigureStreamingOutput() {
  const std::string& target = GTEST_FLAG(stream_result_to);
  if (!target.empty()) {
    const size_t pos = target.find(':');
    if (pos != std::string::npos) {
      listeners()->Append(new StreamingListener(target.substr(0, pos),
                                                target.substr(pos+1)));
    } else {
      GTEST_LOG_(WARNING) << "unrecognized streaming target \"" << target
                          << "\" ignored.";
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq 0x50962(%rip), %rax     # 0x7c980
movq %rax, -0x10(%rbp)
leaq 0x50957(%rip), %rdi     # 0x7c980
callq 0x9bc0
testb $0x1, %al
jne 0x2c1f2
leaq 0x50943(%rip), %rdi     # 0x7c980
movl $0x3a, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x9950
movq %rax, -0x18(%rbp)
cmpq $-0x1, -0x18(%rbp)
je 0x2c14b
movq -0x78(%rbp), %rdi
callq 0x37d10
movq %rax, -0x88(%rbp)
movl $0x10, %edi
callq 0x9600
movq %rax, -0x80(%rbp)
movb $0x1, -0x69(%rbp)
movq -0x18(%rbp), %rcx
leaq 0x508f9(%rip), %rsi     # 0x7c980
xorl %eax, %eax
movl %eax, %edx
leaq -0x38(%rbp), %rdi
callq 0x9660
jmp 0x2c096
movq -0x18(%rbp), %rdx
incq %rdx
leaq 0x508dc(%rip), %rsi     # 0x7c980
leaq -0x68(%rbp), %rdi
movq $-0x1, %rcx
callq 0x9660
jmp 0x2c0b6
movq -0x80(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0x3d620
jmp 0x2c0c9
movq -0x80(%rbp), %rsi
movq -0x88(%rbp), %rdi
movb $0x0, -0x69(%rbp)
callq 0x2ab20
jmp 0x2c0df
leaq -0x68(%rbp), %rdi
callq 0x9db8
leaq -0x38(%rbp), %rdi
callq 0x9db8
jmp 0x2c1f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2c130
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2c127
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x9db8
leaq -0x38(%rbp), %rdi
callq 0x9db8
testb $0x1, -0x69(%rbp)
jne 0x2c138
jmp 0x2c146
movq -0x80(%rbp), %rdi
movl $0x10, %esi
callq 0x9630
jmp 0x2c1fb
leaq 0x2c01c(%rip), %rdx     # 0x5816e
leaq -0x70(%rbp), %rdi
movq %rdi, -0x98(%rbp)
movl $0x1, %esi
movl $0x1356, %ecx           # imm = 0x1356
callq 0x33f70
movq -0x98(%rbp), %rdi
callq 0x377b0
movq %rax, -0x90(%rbp)
jmp 0x2c181
movq -0x90(%rbp), %rdi
leaq 0x2ccad(%rip), %rsi     # 0x58e3c
callq 0x95e0
movq %rax, -0xa0(%rbp)
jmp 0x2c19d
movq -0xa0(%rbp), %rdi
leaq 0x507d5(%rip), %rsi     # 0x7c980
callq 0x9550
movq %rax, -0xa8(%rbp)
jmp 0x2c1b9
movq -0xa8(%rbp), %rdi
leaq 0x2cc6a(%rip), %rsi     # 0x58e31
callq 0x95e0
jmp 0x2c1ce
leaq -0x70(%rbp), %rdi
callq 0x340b0
jmp 0x2c1f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x340b0
jmp 0x2c1fb
jmp 0x2c1f2
addq $0xb0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x9c40
nopw %cs:(%rax,%rax)
// File: ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest.cc
// Function: testing::ScopedTrace::PushTrace(char const*, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void ScopedTrace::PushTrace(const char* file, int line, std::string message) {
  internal::TraceInfo trace;
  trace.file = file;
  trace.line = line;
  trace.message.swap(message);

  UnitTest::GetInstance()->PushGTestTrace(trace);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rcx, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3ebb0
movq -0x70(%rbp), %rsi
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x9440
callq 0x16240
movq %rax, -0x68(%rbp)
jmp 0x2dc1a
movq -0x68(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x2b610
jmp 0x2dc29
leaq -0x50(%rbp), %rdi
callq 0x3ebd0
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3ebd0
movq -0x58(%rbp), %rdi
callq 0x9c40
nopw %cs:(%rax,%rax)
// File: ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest-death-test.cc
// Function: testing::internal::InDeathTestChild()
bool InDeathTestChild() {
# if GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA

  // On Windows and Fuchsia, death tests are thread-safe regardless of the value
  // of the death_test_style flag.
  return !GTEST_FLAG(internal_run_death_test).empty();

# else

  if (GTEST_FLAG(death_test_style) == "threadsafe")
    return !GTEST_FLAG(internal_run_death_test).empty();
  else
    return g_in_fast_death_test_child;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x4edf1(%rip), %rdi     # 0x7ca90
leaq 0x2b407(%rip), %rsi     # 0x590ad
callq 0xfeb0
testb $0x1, %al
jne 0x2dcb1
jmp 0x2dcc6
leaq 0x4edb8(%rip), %rdi     # 0x7ca70
callq 0x9bc0
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2dcd1
movb 0x4ede5(%rip), %al      # 0x7cab1
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest-death-test.cc
// Function: testing::ExitedWithCode::operator()(int) const
bool ExitedWithCode::operator()(int exit_status) const {
# if GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA

  return exit_status == exit_code_;

# else

  return WIFEXITED(exit_status) && WEXITSTATUS(exit_status) == exit_code_;

# endif  // GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
andl $0x7f, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0xd(%rbp)
jne 0x2dd3a
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
cmpl (%rcx), %eax
sete %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest-death-test.cc
// Function: testing::internal::DeathTestThreadWarning[abi:cxx11](unsigned long)
static std::string DeathTestThreadWarning(size_t thread_count) {
  Message msg;
  msg << "Death tests use fork(), which is unsafe particularly"
      << " in a threaded context. For this test, " << GTEST_NAME_ << " ";
  if (thread_count == 0) {
    msg << "couldn't detect the number of threads.";
  } else {
    msg << "detected " << thread_count << " threads.";
  }
  msg << " See "
         "https://github.com/google/googletest/blob/master/googletest/docs/"
         "advanced.md#death-tests-and-threads"
      << " for more explanation and suggested solutions, especially if"
      << " this is the last message you see before your test times out.";
  return msg.GetString();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x190b0
movq -0x38(%rbp), %rdi
leaq 0x2963d(%rip), %rsi     # 0x59cf3
callq 0x45c20
movq %rax, -0x30(%rbp)
jmp 0x306c1
movq -0x30(%rbp), %rdi
leaq 0x2965c(%rip), %rsi     # 0x59d28
callq 0x43110
movq %rax, -0x50(%rbp)
jmp 0x306d7
movq -0x50(%rbp), %rdi
leaq 0x28189(%rip), %rsi     # 0x5886b
callq 0x12760
movq %rax, -0x58(%rbp)
jmp 0x306ed
movq -0x58(%rbp), %rdi
leaq 0x27ba5(%rip), %rsi     # 0x5829d
callq 0x38bc0
jmp 0x306ff
cmpq $0x0, -0x10(%rbp)
jne 0x30734
leaq 0x29643(%rip), %rsi     # 0x59d50
leaq -0x18(%rbp), %rdi
callq 0x3a800
jmp 0x30718
jmp 0x30771
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xf3f0
jmp 0x307d4
leaq 0x2963c(%rip), %rsi     # 0x59d77
leaq -0x18(%rbp), %rdi
callq 0x3f920
movq %rax, -0x60(%rbp)
jmp 0x3074a
movq -0x60(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x45c60
movq %rax, -0x68(%rbp)
jmp 0x3075d
movq -0x68(%rbp), %rdi
leaq 0x29605(%rip), %rsi     # 0x59d6d
callq 0x3f920
jmp 0x3076f
jmp 0x30771
leaq 0x29609(%rip), %rsi     # 0x59d81
leaq -0x18(%rbp), %rdi
callq 0x45ca0
movq %rax, -0x70(%rbp)
jmp 0x30787
movq -0x70(%rbp), %rdi
leaq 0x29659(%rip), %rsi     # 0x59deb
callq 0x45ce0
movq %rax, -0x78(%rbp)
jmp 0x3079d
movq -0x78(%rbp), %rdi
leaq 0x29680(%rip), %rsi     # 0x59e28
callq 0x3a840
jmp 0x307af
movq -0x48(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x19430
jmp 0x307be
leaq -0x18(%rbp), %rdi
callq 0xf3f0
movq -0x40(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x9c40
nopl (%rax)
// File: ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest-filepath.cc
// Function: testing::internal::FilePath::IsRootDirectory() const
bool FilePath::IsRootDirectory() const {
#if GTEST_OS_WINDOWS
  // FIXME: on Windows a network share like
  // \\server\share can be a root directory, although it cannot be the
  // current directory.  Handle this properly.
  return pathname_.length() == 3 && IsAbsolutePath();
#else
  return pathname_.length() == 1 && IsPathSeparator(pathname_.c_str()[0]);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x9aa0
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x1, %rcx
movb %al, -0x9(%rbp)
jne 0x3385b
movq -0x18(%rbp), %rdi
callq 0x9230
movsbl (%rax), %edi
callq 0x33870
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest-port.cc
// Function: testing::internal::CaptureStream(int, char const*, testing::internal::CapturedStream**)
static void CaptureStream(int fd, const char* stream_name,
                          CapturedStream** stream) {
  if (*stream != NULL) {
    GTEST_LOG_(FATAL) << "Only one " << stream_name
                      << " capturer can exist at a time.";
  }
  *stream = new CapturedStream(fd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x341e4
leaq 0x25356(%rip), %rdx     # 0x594be
leaq -0x1c(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movl $0x3, %esi
movl $0x437, %ecx            # imm = 0x437
callq 0x33f70
movq -0x40(%rbp), %rdi
callq 0x377b0
movq %rax, %rdi
leaq 0x25e35(%rip), %rsi     # 0x59fc7
callq 0x95e0
movq %rax, -0x38(%rbp)
jmp 0x3419d
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x95e0
movq %rax, -0x48(%rbp)
jmp 0x341b0
movq -0x48(%rbp), %rdi
leaq 0x25e16(%rip), %rsi     # 0x59fd1
callq 0x95e0
jmp 0x341c2
leaq -0x1c(%rbp), %rdi
callq 0x340b0
jmp 0x341e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1c(%rbp), %rdi
callq 0x340b0
jmp 0x3422d
movl $0x28, %edi
callq 0x9600
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movl -0x4(%rbp), %esi
callq 0x46dd0
jmp 0x34202
movq -0x50(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x28, %esi
callq 0x9630
movq -0x28(%rbp), %rdi
callq 0x9c40
nopw %cs:(%rax,%rax)
// File: ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest-printers.cc
// Function: testing::internal::CharFormat testing::internal::PrintCharsAsStringTo<char>(char const*, unsigned long, std::ostream*)
static CharFormat PrintCharsAsStringTo(
    const CharType* begin, size_t len, ostream* os) {
  const char* const kQuoteBegin = sizeof(CharType) == 1 ? "\"" : "L\"";
  *os << kQuoteBegin;
  bool is_previous_hex = false;
  CharFormat print_format = kAsIs;
  for (size_t index = 0; index < len; ++index) {
    const CharType cur = begin[index];
    if (is_previous_hex && IsXDigit(cur)) {
      // Previous character is of '\x..' form and this character can be
      // interpreted as another hexadecimal digit in its number. Break string to
      // disambiguate.
      *os << "\" " << kQuoteBegin;
    }
    is_previous_hex = PrintAsStringLiteralTo(cur, os) == kHexEscape;
    // Remember if any characters required hex escaping.
    if (is_previous_hex) {
      print_format = kHexEscape;
    }
  }
  *os << "\"";
  return print_format;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x241b3(%rip), %rax     # 0x58cae
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x241a4(%rip), %rsi     # 0x58cae
callq 0x95e0
movb $0x0, -0x21(%rbp)
movl $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x34ba8
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x31(%rbp)
testb $0x1, -0x21(%rbp)
je 0x34b6e
movsbl -0x31(%rbp), %edi
callq 0x54650
testb $0x1, %al
jne 0x34b4f
jmp 0x34b6e
movq -0x18(%rbp), %rdi
leaq 0x25710(%rip), %rsi     # 0x5a26a
callq 0x95e0
movq %rax, %rdi
leaq 0x24145(%rip), %rsi     # 0x58cae
callq 0x95e0
movb -0x31(%rbp), %al
movq -0x18(%rbp), %rsi
movsbl %al, %edi
callq 0x37710
cmpl $0x1, %eax
sete %al
andb $0x1, %al
movb %al, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
je 0x34b95
movl $0x1, -0x28(%rbp)
jmp 0x34b97
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x34b22
movq -0x18(%rbp), %rdi
leaq 0x240fb(%rip), %rsi     # 0x58cae
callq 0x95e0
movl -0x28(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest-printers.cc
// Function: testing::internal::(anonymous namespace)::ContainsUnprintableControlCodes(char const*, unsigned long)
bool ContainsUnprintableControlCodes(const char* str, size_t length) {
  const unsigned char *s = reinterpret_cast<const unsigned char *>(str);

  for (size_t i = 0; i < length; i++) {
    unsigned char ch = *s++;
    if (std::iscntrl(ch)) {
        switch (ch) {
        case '\t':
        case '\n':
        case '\r':
          break;
        default:
          return true;
        }
      }
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x36551
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb (%rax), %al
movb %al, -0x29(%rbp)
movzbl -0x29(%rbp), %edi
callq 0x9a70
cmpl $0x0, %eax
je 0x36541
movzbl -0x29(%rbp), %eax
movl %eax, -0x30(%rbp)
addl $-0x9, %eax
subl $0x2, %eax
jb 0x36537
jmp 0x3652d
movl -0x30(%rbp), %eax
subl $0xd, %eax
jne 0x36539
jmp 0x36537
jmp 0x3653f
movb $0x1, -0x1(%rbp)
jmp 0x36555
jmp 0x36541
jmp 0x36543
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x364f0
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest.cc
// Function: bool testing::internal::ParseStringFlag<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
static bool ParseStringFlag(const char* str, const char* flag, String* value) {
  // Gets the value of the flag as a string.
  const char* const value_str = ParseFlagValue(str, flag, false);

  // Aborts if the parsing failed.
  if (value_str == NULL) return false;

  // Sets *value to the value of the flag.
  *value = value_str;
  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), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x2d8a0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x36d34
movb $0x0, -0x1(%rbp)
jmp 0x36d45
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdi
callq 0x99b0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest.cc
// Function: testing::internal::LoadFlagsFromFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static void LoadFlagsFromFile(const std::string& path) {
  FILE* flagfile = posix::FOpen(path.c_str(), "r");
  if (!flagfile) {
    GTEST_LOG_(FATAL) << "Unable to open file \"" << GTEST_FLAG(flagfile)
                      << "\"";
  }
  std::string contents(ReadEntireFile(flagfile));
  posix::FClose(flagfile);
  std::vector<std::string> lines;
  SplitString(contents, '\n', &lines);
  for (size_t i = 0; i < lines.size(); ++i) {
    if (lines[i].empty())
      continue;
    if (!ParseGoogleTestFlag(lines[i].c_str()))
      g_help_flag = true;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9230
movq %rax, %rdi
leaq 0x21eea(%rip), %rsi     # 0x58c5c
callq 0x3dfe0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x36e0f
leaq 0x213e1(%rip), %rdx     # 0x5816e
leaq -0x14(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movl $0x3, %esi
movl $0x16be, %ecx           # imm = 0x16BE
callq 0x33f70
movq -0x78(%rbp), %rdi
callq 0x377b0
movq %rax, %rdi
leaq 0x22bbc(%rip), %rsi     # 0x59973
callq 0x95e0
movq %rax, -0x70(%rbp)
jmp 0x36dc2
movq -0x70(%rbp), %rdi
leaq 0x45bdb(%rip), %rsi     # 0x7c9a8
callq 0x9550
movq %rax, -0x80(%rbp)
jmp 0x36dd8
movq -0x80(%rbp), %rdi
leaq 0x21ecb(%rip), %rsi     # 0x58cae
callq 0x95e0
jmp 0x36dea
leaq -0x14(%rbp), %rdi
callq 0x340b0
jmp 0x36e0f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x14(%rbp), %rdi
callq 0x340b0
jmp 0x36f2e
movq -0x10(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x34320
movq -0x10(%rbp), %rdi
callq 0x46fb0
jmp 0x36e27
leaq -0x60(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x378a0
movq -0x88(%rbp), %rdx
leaq -0x48(%rbp), %rdi
movl $0xa, %esi
callq 0x18f10
jmp 0x36e4e
movq $0x0, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x38760
movq %rax, %rcx
movq -0x90(%rbp), %rax
cmpq %rcx, %rax
jae 0x36f0a
movq -0x68(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x37ab0
movq %rax, %rdi
callq 0x9bc0
testb $0x1, %al
jne 0x36e98
jmp 0x36ebf
jmp 0x36ef9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x36f25
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x378c0
jmp 0x36f25
movq -0x68(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x37ab0
movq %rax, %rdi
callq 0x9230
movq %rax, %rdi
callq 0x36a40
movb %al, -0x91(%rbp)
jmp 0x36ee4
movb -0x91(%rbp), %al
testb $0x1, %al
jne 0x36ef7
jmp 0x36ef0
movb $0x1, 0x45a02(%rip)     # 0x7c8f9
jmp 0x36ef9
movq -0x68(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x68(%rbp)
jmp 0x36e56
leaq -0x60(%rbp), %rdi
callq 0x378c0
leaq -0x48(%rbp), %rdi
callq 0x9db8
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x48(%rbp), %rdi
callq 0x9db8
movq -0x20(%rbp), %rdi
callq 0x9c40
nopw (%rax,%rax)
// File: ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest-printers.cc
// Function: testing::internal::CharFormat testing::internal::PrintAsCharLiteralTo<unsigned char, unsigned char>(unsigned char, std::ostream*)
static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
  switch (static_cast<wchar_t>(c)) {
    case L'\0':
      *os << "\\0";
      break;
    case L'\'':
      *os << "\\'";
      break;
    case L'\\':
      *os << "\\\\";
      break;
    case L'\a':
      *os << "\\a";
      break;
    case L'\b':
      *os << "\\b";
      break;
    case L'\f':
      *os << "\\f";
      break;
    case L'\n':
      *os << "\\n";
      break;
    case L'\r':
      *os << "\\r";
      break;
    case L'\t':
      *os << "\\t";
      break;
    case L'\v':
      *os << "\\v";
      break;
    default:
      if (IsPrintableAscii(c)) {
        *os << static_cast<char>(c);
        return kAsIs;
      } else {
        ostream::fmtflags flags = os->flags();
        *os << "\\x" << std::hex << std::uppercase
            << static_cast<int>(static_cast<UnsignedChar>(c));
        os->flags(flags);
        return kHexEscape;
      }
  }
  return kSpecialEscape;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
movb %al, -0x5(%rbp)
movq %rsi, -0x10(%rbp)
movzbl -0x5(%rbp), %eax
movq %rax, -0x20(%rbp)
subq $0x5c, %rax
ja 0x3730a
movq -0x20(%rbp), %rax
leaq 0x1fa99(%rip), %rcx     # 0x56cc8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
leaq 0x21157(%rip), %rsi     # 0x5839a
callq 0x95e0
jmp 0x37398
movq -0x10(%rbp), %rdi
leaq 0x22fea(%rip), %rsi     # 0x5a242
callq 0x95e0
jmp 0x37398
movq -0x10(%rbp), %rdi
leaq 0x22fd8(%rip), %rsi     # 0x5a245
callq 0x95e0
jmp 0x37398
movq -0x10(%rbp), %rdi
leaq 0x22fc6(%rip), %rsi     # 0x5a248
callq 0x95e0
jmp 0x37398
movq -0x10(%rbp), %rdi
leaq 0x219b8(%rip), %rsi     # 0x58c4f
callq 0x95e0
jmp 0x37398
movq -0x10(%rbp), %rdi
leaq 0x219ac(%rip), %rsi     # 0x58c58
callq 0x95e0
jmp 0x37398
movq -0x10(%rbp), %rdi
leaq 0x21994(%rip), %rsi     # 0x58c55
callq 0x95e0
jmp 0x37398
movq -0x10(%rbp), %rdi
leaq 0x21985(%rip), %rsi     # 0x58c5b
callq 0x95e0
jmp 0x37398
movq -0x10(%rbp), %rdi
leaq 0x21967(%rip), %rsi     # 0x58c52
callq 0x95e0
jmp 0x37398
movq -0x10(%rbp), %rdi
leaq 0x22f4b(%rip), %rsi     # 0x5a24b
callq 0x95e0
jmp 0x37398
movzbl -0x5(%rbp), %edi
callq 0x545e0
testb $0x1, %al
jne 0x37319
jmp 0x3732f
movq -0x10(%rbp), %rdi
movsbl -0x5(%rbp), %esi
callq 0x97d0
movl $0x0, -0x4(%rbp)
jmp 0x3739f
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x54610
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x22f01(%rip), %rsi     # 0x5a24e
callq 0x95e0
movq %rax, %rdi
leaq 0x27e4(%rip), %rsi      # 0x39b40
callq 0x91c0
movq %rax, %rdi
leaq 0x2805(%rip), %rsi      # 0x39b70
callq 0x91c0
movq %rax, %rdi
movzbl -0x5(%rbp), %esi
callq 0x9c20
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl -0x14(%rbp), %esi
callq 0x54630
movl $0x1, -0x4(%rbp)
jmp 0x3739f
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest.cc
// Function: testing::internal::ScopedPrematureExitFile::ScopedPrematureExitFile(char const*)
explicit ScopedPrematureExitFile(const char* premature_exit_filepath)
      : premature_exit_filepath_(premature_exit_filepath ?
                                 premature_exit_filepath : "") {
    // If a path to the premature-exit file is specified...
    if (!premature_exit_filepath_.empty()) {
      // create the file with a single "0" character in it.  I/O
      // errors are ignored as there's nothing better we can do and we
      // don't want to fail the test because of this.
      FILE* pfile = posix::FOpen(premature_exit_filepath, "w");
      fwrite("0", 1, 1, pfile);
      fclose(pfile);
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3ca59
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x3ca66
leaq 0x1bf2c(%rip), %rax     # 0x5898c
movq %rax, -0x40(%rbp)
jmp 0x3ca66
movq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x11(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x9c50
movq -0x38(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0xf1d0
jmp 0x3ca8e
leaq -0x11(%rbp), %rdi
callq 0x96d0
movq -0x38(%rbp), %rdi
callq 0x9bc0
testb $0x1, %al
jne 0x3cb17
movq -0x10(%rbp), %rdi
leaq 0x1c4a1(%rip), %rsi     # 0x58f50
callq 0x3dfe0
movq %rax, -0x58(%rbp)
jmp 0x3caba
movq -0x58(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
leaq 0x1d46b(%rip), %rdi     # 0x59f38
movl $0x1, %edx
movq %rdx, %rsi
callq 0x9d60
jmp 0x3cadc
movq -0x30(%rbp), %rdi
callq 0x95f0
jmp 0x3cae7
jmp 0x3cb17
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x96d0
jmp 0x3cb1d
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x9db8
jmp 0x3cb1d
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x9c40
nopw %cs:(%rax,%rax)
// File: ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest.cc
// Function: testing::internal::ScopedPrematureExitFile::~ScopedPrematureExitFile()
~ScopedPrematureExitFile() {
    if (!premature_exit_filepath_.empty()) {
      int retval = remove(premature_exit_filepath_.c_str());
      if (retval) {
        GTEST_LOG_(ERROR) << "Failed to remove premature exit filepath \""
                          << premature_exit_filepath_ << "\" with error "
                          << retval;
      }
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x9bc0
testb $0x1, %al
jne 0x3cea7
movq -0x18(%rbp), %rdi
callq 0x9230
movq %rax, %rdi
callq 0x9c90
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x3cea5
leaq 0x1b33c(%rip), %rdx     # 0x5816e
leaq -0x10(%rbp), %rdi
movl $0x2, %esi
movl $0x112d, %ecx           # imm = 0x112D
callq 0x33f70
jmp 0x3ce47
leaq -0x10(%rbp), %rdi
callq 0x377b0
movq %rax, %rdi
leaq 0x1cb8c(%rip), %rsi     # 0x599e6
callq 0x95e0
movq %rax, -0x20(%rbp)
jmp 0x3ce65
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdi
callq 0x9550
movq %rax, -0x28(%rbp)
jmp 0x3ce78
movq -0x28(%rbp), %rdi
leaq 0x1cb8e(%rip), %rsi     # 0x59a11
callq 0x95e0
movq %rax, -0x30(%rbp)
jmp 0x3ce8e
movq -0x30(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x9c20
jmp 0x3ce9c
leaq -0x10(%rbp), %rdi
callq 0x340b0
jmp 0x3cea7
movq -0x18(%rbp), %rdi
callq 0x9db8
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x109c0
nop
// File: ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest.cc
// Function: void testing::internal::InitGoogleTestImpl<char>(int*, char**)
void InitGoogleTestImpl(int* argc, CharType** argv) {
  // We don't want to run the initialization code twice.
  if (GTestIsInitialized()) return;

  if (*argc <= 0) return;

  g_argvs.clear();
  for (int i = 0; i != *argc; i++) {
    g_argvs.push_back(StreamableToString(argv[i]));
  }

#if GTEST_HAS_ABSL
  absl::InitializeSymbolizer(g_argvs[0].c_str());
#endif  // GTEST_HAS_ABSL

  ParseGoogleTestFlagsOnly(argc, argv);
  GetUnitTestImpl()->PostFlagParsingInit();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x2c630
testb $0x1, %al
jne 0x3ea2b
jmp 0x3ea30
jmp 0x3eacc
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jg 0x3ea3e
jmp 0x3eacc
leaq 0x3dfbb(%rip), %rdi     # 0x7ca00
callq 0x542f0
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
je 0x3eab2
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
leaq (%rax,%rcx,8), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x54180
movq -0x50(%rbp), %rsi
leaq 0x3df80(%rip), %rdi     # 0x7ca00
callq 0x37ea0
jmp 0x3ea87
leaq -0x38(%rbp), %rdi
callq 0x9db8
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3ea51
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x9db8
jmp 0x3ead2
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2daa0
callq 0x37ce0
movq %rax, %rdi
callq 0x2c210
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x9c40
nopl (%rax,%rax)
// File: ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest-internal-inl.h
// Function: testing::internal::StreamingListener::SocketWriter::Send(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
virtual void Send(const std::string& message) {
      GTEST_CHECK_(sockfd_ != -1)
          << "Send() can be called only when there is a connection.";

      const int len = static_cast<int>(message.length());
      if (write(sockfd_, message.c_str(), len) != len) {
        GTEST_LOG_(WARNING)
            << "stream_result_to: failed to stream to "
            << host_name_ << ":" << port_num_;
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $-0x1, 0x8(%rax)
setne %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x16060
testb $0x1, %al
jne 0x45570
jmp 0x45572
jmp 0x455e5
leaq 0x14318(%rip), %rdx     # 0x59891
leaq -0x14(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movl $0x3, %esi
movl $0x42d, %ecx            # imm = 0x42D
callq 0x33f70
movq -0x48(%rbp), %rdi
callq 0x377b0
movq %rax, %rdi
leaq 0x1447c(%rip), %rsi     # 0x59a1f
callq 0x95e0
movq %rax, -0x40(%rbp)
jmp 0x455ae
movq -0x40(%rbp), %rdi
leaq 0x14487(%rip), %rsi     # 0x59a40
callq 0x95e0
jmp 0x455c0
leaq -0x14(%rbp), %rdi
callq 0x340b0
jmp 0x455e5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x14(%rbp), %rdi
callq 0x340b0
jmp 0x456c7
movq -0x10(%rbp), %rdi
callq 0x9aa0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movl %ecx, -0x28(%rbp)
movl 0x8(%rax), %eax
movl %eax, -0x4c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9230
movl -0x4c(%rbp), %edi
movq %rax, %rsi
movslq -0x28(%rbp), %rdx
callq 0x91d0
movslq -0x28(%rbp), %rcx
cmpq %rcx, %rax
je 0x456c1
leaq 0x14267(%rip), %rdx     # 0x59891
leaq -0x2c(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movl $0x1, %esi
movl $0x432, %ecx            # imm = 0x432
callq 0x33f70
movq -0x60(%rbp), %rdi
callq 0x377b0
movq %rax, %rdi
leaq 0x14422(%rip), %rsi     # 0x59a76
callq 0x95e0
movq %rax, -0x58(%rbp)
jmp 0x4565f
movq -0x58(%rbp), %rdi
movq -0x38(%rbp), %rsi
addq $0x10, %rsi
callq 0x9550
movq %rax, -0x68(%rbp)
jmp 0x45676
movq -0x68(%rbp), %rdi
leaq 0x13730(%rip), %rsi     # 0x58db1
callq 0x95e0
movq %rax, -0x70(%rbp)
jmp 0x4568c
movq -0x70(%rbp), %rdi
movq -0x38(%rbp), %rsi
addq $0x30, %rsi
callq 0x9550
jmp 0x4569f
leaq -0x2c(%rbp), %rdi
callq 0x340b0
jmp 0x456c1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x2c(%rbp), %rdi
callq 0x340b0
jmp 0x456c7
addq $0x70, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x9c40
// File: ambersun1234[P]AVL_Tree/./googletest/googletest/include/gtest/gtest-printers.h
// Function: testing::internal::UniversalTersePrinter<char const*>::Print(char const*, std::ostream*)
static void Print(const char* str, ::std::ostream* os) {
    if (str == NULL) {
      *os << "NULL";
    } else {
      UniversalPrint(std::string(str), os);
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x477f9
movq -0x10(%rbp), %rdi
leaq 0xeec5(%rip), %rsi      # 0x566b7
callq 0x95e0
jmp 0x47872
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x9c50
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0xf1d0
jmp 0x47821
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x47890
jmp 0x47830
leaq -0x30(%rbp), %rdi
callq 0x9db8
leaq -0x31(%rbp), %rdi
callq 0x96d0
jmp 0x47872
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x47867
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x9db8
leaq -0x31(%rbp), %rdi
callq 0x96d0
jmp 0x47878
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x9c40
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: xocoder[P]m_kcptun/vendor/kcp/ikcp.c
// Function: ikcp_log
void ikcp_log(ikcpcb *kcp, int mask, const char *fmt, ...)
{
	char buffer[1024];
	va_list argptr;
	if ((mask & kcp->logmask) == 0 || kcp->writelog == 0) return;
	va_start(argptr, fmt);
	vsprintf(buffer, fmt, argptr);
	va_end(argptr);
	kcp->writelog(buffer, kcp, kcp->user);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4f0, %rsp            # imm = 0x4F0
testb %al, %al
je 0x37c7
movaps %xmm0, -0x4c0(%rbp)
movaps %xmm1, -0x4b0(%rbp)
movaps %xmm2, -0x4a0(%rbp)
movaps %xmm3, -0x490(%rbp)
movaps %xmm4, -0x480(%rbp)
movaps %xmm5, -0x470(%rbp)
movaps %xmm6, -0x460(%rbp)
movaps %xmm7, -0x450(%rbp)
movq %r9, -0x4c8(%rbp)
movq %r8, -0x4d0(%rbp)
movq %rcx, -0x4d8(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
andl 0xf4(%rcx), %eax
cmpl $0x0, %eax
je 0x3807
movq -0x8(%rbp), %rax
cmpq $0x0, 0x100(%rax)
jne 0x3809
jmp 0x3871
leaq -0x440(%rbp), %rax
leaq -0x4f0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
leaq -0x420(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x440(%rbp), %rdx
callq 0x3180
leaq -0x440(%rbp), %rax
movq -0x8(%rbp), %rax
movq 0x100(%rax), %rax
leaq -0x420(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x8(%rbp), %rcx
movq 0xd8(%rcx), %rdx
callq *%rax
addq $0x4f0, %rsp            # imm = 0x4F0
popq %rbp
retq
nopw (%rax,%rax)
// File: xocoder[P]m_kcptun/vendor/kcp/ikcp.c
// Function: ikcp_free(void*)
static void ikcp_free(void *ptr) {
	if (ikcp_free_hook) {
		ikcp_free_hook(ptr);
	}	else {
		free(ptr);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x146fc(%rip)     # 0x18320
je 0x3c35
movq 0x146f3(%rip), %rax     # 0x18320
movq -0x8(%rbp), %rdi
callq *%rax
jmp 0x3c3e
movq -0x8(%rbp), %rdi
callq 0x33d0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: xocoder[P]m_kcptun/vendor/kcp/ikcp.c
// Function: ikcp_peeksize
int ikcp_peeksize(const ikcpcb *kcp)
{
	struct IQUEUEHEAD *p;
	IKCPSEG *seg;
	int length = 0;

	assert(kcp);

	if (iqueue_is_empty(&kcp->rcv_queue)) return -1;

	seg = iqueue_entry(kcp->rcv_queue.next, IKCPSEG, node);
	if (seg->frg == 0) return seg->len;

	if (kcp->nrcv_que < seg->frg + 1) return -1;

	for (p = kcp->rcv_queue.next; p != &kcp->rcv_queue; p = p->next) {
		seg = iqueue_entry(p, IKCPSEG, node);
		length += seg->len;
		if (seg->frg == 0) break;
	}

	return length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x24(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x42ec
jmp 0x430b
leaq 0xed11(%rip), %rdi      # 0x13004
leaq 0xed0e(%rip), %rsi      # 0x13008
movl $0x1bd, %edx            # imm = 0x1BD
leaq 0xed71(%rip), %rcx      # 0x13077
callq 0x3210
movq -0x10(%rbp), %rax
addq $0x98, %rax
movq -0x10(%rbp), %rcx
cmpq 0x98(%rcx), %rax
jne 0x432e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x43ca
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x4353
movq -0x20(%rbp), %rax
movl 0x2c(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x43ca
movq -0x10(%rbp), %rax
movl 0x64(%rax), %eax
movq -0x20(%rbp), %rcx
movl 0x18(%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jae 0x4371
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x43ca
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
addq $0x98, %rcx
cmpq %rcx, %rax
je 0x43c4
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x2c(%rax), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x43b5
jmp 0x43c4
jmp 0x43b7
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x4380
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: xocoder[P]m_kcptun/vendor/kcp/ikcp.c
// Function: ikcp_parse_una(IKCPCB*, unsigned int)
static void ikcp_parse_una(ikcpcb *kcp, IUINT32 una)
{
	struct IQUEUEHEAD *p, *next;
	for (p = kcp->snd_buf.next; p != &kcp->snd_buf; p = next) {
		IKCPSEG *seg = iqueue_entry(p, IKCPSEG, node);
		next = p->next;
		if (_itimediff(una, seg->sn) > 0) {
			iqueue_del(p);
			ikcp_segment_delete(kcp, seg);
			kcp->nsnd_buf--;
		}	else {
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0xa8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
addq $0xa8, %rcx
cmpq %rcx, %rax
je 0x51d7
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %edi
movq -0x28(%rbp), %rax
movl 0x24(%rax), %esi
callq 0x4ae0
cmpq $0x0, %rax
jle 0x51c6
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x3f30
movq -0x8(%rbp), %rax
movl 0x60(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x60(%rax)
jmp 0x51c8
jmp 0x51d7
jmp 0x51ca
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x512e
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: xocoder[P]m_kcptun/vendor/kcp/ikcp.c
// Function: ikcp_shrink_buf(IKCPCB*)
static void ikcp_shrink_buf(ikcpcb *kcp)
{
	struct IQUEUEHEAD *p = kcp->snd_buf.next;
	if (p != &kcp->snd_buf) {
		IKCPSEG *seg = iqueue_entry(p, IKCPSEG, node);
		kcp->snd_una = seg->sn;
	}	else {
		kcp->snd_una = kcp->snd_nxt;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0xa8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
addq $0xa8, %rcx
cmpq %rcx, %rax
je 0x5223
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x24(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
jmp 0x5231
movq -0x8(%rbp), %rax
movl 0x14(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: xocoder[P]m_kcptun/vendor/kcp/ikcp.c
// Function: ikcp_update_ack(IKCPCB*, int)
static void ikcp_update_ack(ikcpcb *kcp, IINT32 rtt)
{
	IINT32 rto = 0;
	if (kcp->rx_srtt == 0) {
		kcp->rx_srtt = rtt;
		kcp->rx_rttval = rtt / 2;
	}	else {
		long delta = rtt - kcp->rx_srtt;
		if (delta < 0) delta = -delta;
		kcp->rx_rttval = (3 * kcp->rx_rttval + delta) / 4;
		kcp->rx_srtt = (7 * kcp->rx_srtt + rtt) / 8;
		if (kcp->rx_srtt < 1) kcp->rx_srtt = 1;
	}
	rto = kcp->rx_srtt + _imax_(kcp->interval, 4 * kcp->rx_rttval);
	kcp->rx_rto = _ibound_(kcp->rx_minrto, rto, IKCP_RTO_MAX);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
jne 0x5280
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x2c(%rax)
movl -0xc(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x28(%rax)
jmp 0x52f5
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
subl 0x2c(%rcx), %eax
cltq
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jge 0x52a1
xorl %eax, %eax
subq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
imull $0x3, 0x28(%rax), %eax
cltq
addq -0x18(%rbp), %rax
movl $0x4, %ecx
cqto
idivq %rcx
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x8(%rbp), %rax
imull $0x7, 0x2c(%rax), %eax
addl -0xc(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x2c(%rax)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x2c(%rax)
jge 0x52f3
movq -0x8(%rbp), %rax
movl $0x1, 0x2c(%rax)
jmp 0x52f5
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl 0x50(%rax), %edi
movq -0x8(%rbp), %rax
movl 0x28(%rax), %esi
shll $0x2, %esi
callq 0x6610
movl %eax, %ecx
movl -0x1c(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x34(%rax), %edi
movl -0x10(%rbp), %esi
movl $0xea60, %edx           # imm = 0xEA60
callq 0x6690
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x30(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: xocoder[P]m_kcptun/vendor/kcp/ikcp.c
// Function: ikcp_parse_ack(IKCPCB*, unsigned int)
static void ikcp_parse_ack(ikcpcb *kcp, IUINT32 sn)
{
	struct IQUEUEHEAD *p, *next;

	if (_itimediff(sn, kcp->snd_una) < 0 || _itimediff(sn, kcp->snd_nxt) >= 0)
		return;

	for (p = kcp->snd_buf.next; p != &kcp->snd_buf; p = next) {
		IKCPSEG *seg = iqueue_entry(p, IKCPSEG, node);
		next = p->next;
		if (sn == seg->sn) {
			iqueue_del(p);
			ikcp_segment_delete(kcp, seg);
			kcp->nsnd_buf--;
			break;
		}
		if (_itimediff(sn, seg->sn) < 0) {
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x4ae0
cmpq $0x0, %rax
jl 0x5389
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rax
movl 0x14(%rax), %esi
callq 0x4ae0
cmpq $0x0, %rax
jl 0x538e
jmp 0x5452
movq -0x8(%rbp), %rax
movq 0xa8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
addq $0xa8, %rcx
cmpq %rcx, %rax
je 0x5452
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl 0x24(%rcx), %eax
jne 0x542c
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x3f30
movq -0x8(%rbp), %rax
movl 0x60(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x60(%rax)
jmp 0x5452
movl -0xc(%rbp), %edi
movq -0x28(%rbp), %rax
movl 0x24(%rax), %esi
callq 0x4ae0
cmpq $0x0, %rax
jge 0x5443
jmp 0x5452
jmp 0x5445
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x539d
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: xocoder[P]m_kcptun/vendor/kcp/ikcp.c
// Function: ikcp_ack_push(IKCPCB*, unsigned int, unsigned int)
static void ikcp_ack_push(ikcpcb *kcp, IUINT32 sn, IUINT32 ts)
{
	size_t newsize = kcp->ackcount + 1;
	IUINT32 *ptr;

	if (newsize > kcp->ackblock) {
		IUINT32 *acklist;
		size_t newblock;

		for (newblock = 8; newblock < newsize; newblock <<= 1);
		acklist = (IUINT32*)ikcp_malloc(newblock * sizeof(IUINT32) * 2);

		if (acklist == NULL) {
			assert(acklist != NULL);
			abort();
		}

		if (kcp->acklist != NULL) {
			size_t x;
			for (x = 0; x < kcp->ackcount; x++) {
				acklist[x * 2 + 0] = kcp->acklist[x * 2 + 0];
				acklist[x * 2 + 1] = kcp->acklist[x * 2 + 1];
			}
			ikcp_free(kcp->acklist);
		}

		kcp->acklist = acklist;
		kcp->ackblock = newblock;
	}

	ptr = &kcp->acklist[kcp->ackcount * 2];
	ptr[0] = sn;
	ptr[1] = ts;
	kcp->ackcount++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0xd0(%rax), %eax
addl $0x1, %eax
movl %eax, %eax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0xd4(%rcx), %ecx
cmpq %rcx, %rax
jbe 0x55b7
movq $0x8, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x54bd
jmp 0x54b0
movq -0x30(%rbp), %rax
shlq %rax
movq %rax, -0x30(%rbp)
jmp 0x54a4
movq -0x30(%rbp), %rdi
shlq $0x2, %rdi
shlq %rdi
callq 0x3bd0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x5505
cmpq $0x0, -0x28(%rbp)
je 0x54e1
jmp 0x5500
leaq 0xdc52(%rip), %rdi      # 0x1313a
leaq 0xdb19(%rip), %rsi      # 0x13008
movl $0x283, %edx            # imm = 0x283
leaq 0xdc4f(%rip), %rcx      # 0x1314a
callq 0x3210
callq 0x31d0
movq -0x8(%rbp), %rax
cmpq $0x0, 0xc8(%rax)
je 0x5598
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0xd0(%rcx), %ecx
cmpq %rcx, %rax
jae 0x5588
movq -0x8(%rbp), %rax
movq 0xc8(%rax), %rax
movq -0x38(%rbp), %rcx
shlq %rcx
movl (%rax,%rcx,4), %edx
movq -0x28(%rbp), %rax
movq -0x38(%rbp), %rcx
shlq %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movq 0xc8(%rax), %rax
movq -0x38(%rbp), %rcx
shlq %rcx
movl 0x4(%rax,%rcx,4), %edx
movq -0x28(%rbp), %rax
movq -0x38(%rbp), %rcx
shlq %rcx
movl %edx, 0x4(%rax,%rcx,4)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x551f
movq -0x8(%rbp), %rax
movq 0xc8(%rax), %rdi
callq 0x3c10
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xc8(%rax)
movq -0x30(%rbp), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xd4(%rax)
movq -0x8(%rbp), %rax
movq 0xc8(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0xd0(%rcx), %ecx
shll %ecx
movl %ecx, %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movl 0xd0(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xd0(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: xocoder[P]m_kcptun/vendor/kcp/ikcp.c
// Function: ikcp_parse_fastack(IKCPCB*, unsigned int)
static void ikcp_parse_fastack(ikcpcb *kcp, IUINT32 sn)
{
	struct IQUEUEHEAD *p, *next;

	if (_itimediff(sn, kcp->snd_una) < 0 || _itimediff(sn, kcp->snd_nxt) >= 0)
		return;

	for (p = kcp->snd_buf.next; p != &kcp->snd_buf; p = next) {
		IKCPSEG *seg = iqueue_entry(p, IKCPSEG, node);
		next = p->next;
		if (_itimediff(sn, seg->sn) < 0) {
			break;
		}
		else if (sn != seg->sn) {
			seg->fastack++;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x4ae0
cmpq $0x0, %rax
jl 0x5649
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rax
movl 0x14(%rax), %esi
callq 0x4ae0
cmpq $0x0, %rax
jl 0x564b
jmp 0x56bf
movq -0x8(%rbp), %rax
movq 0xa8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
addq $0xa8, %rcx
cmpq %rcx, %rax
je 0x56bf
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %edi
movq -0x28(%rbp), %rax
movl 0x24(%rax), %esi
callq 0x4ae0
cmpq $0x0, %rax
jge 0x5698
jmp 0x56bf
movl -0xc(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl 0x24(%rcx), %eax
je 0x56b1
movq -0x28(%rbp), %rax
movl 0x38(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x38(%rax)
jmp 0x56b3
jmp 0x56b5
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x565a
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: xocoder[P]m_kcptun/vendor/kcp/ikcp.c
// Function: ikcp_output(IKCPCB*, void const*, int)
static int ikcp_output(ikcpcb *kcp, const void *data, int size)
{
	assert(kcp);
	assert(kcp->output);
	if (ikcp_canlog(kcp, IKCP_LOG_OUTPUT)) {
		ikcp_log(kcp, IKCP_LOG_OUTPUT, "[RO] %ld bytes", (long)size);
	}
	if (size == 0) return 0;
	return kcp->output((const char*)data, size, kcp, kcp->user);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5fec
jmp 0x600b
leaq 0xd011(%rip), %rdi      # 0x13004
leaq 0xd00e(%rip), %rsi      # 0x13008
movl $0xcd, %edx
leaq 0xd173(%rip), %rcx      # 0x13179
callq 0x3210
movq -0x10(%rbp), %rax
cmpq $0x0, 0xf8(%rax)
je 0x601b
jmp 0x603a
leaq 0xd184(%rip), %rdi      # 0x131a6
leaq 0xcfdf(%rip), %rsi      # 0x13008
movl $0xce, %edx
leaq 0xd144(%rip), %rcx      # 0x13179
callq 0x3210
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x43e0
cmpl $0x0, %eax
je 0x6068
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rcx
movl $0x1, %esi
leaq 0xd151(%rip), %rdx      # 0x131b2
movb $0x0, %al
callq 0x3780
cmpl $0x0, -0x1c(%rbp)
jne 0x6077
movl $0x0, -0x4(%rbp)
jmp 0x609d
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x10(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq 0xd8(%rcx), %rcx
callq *%rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)