LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest-internal-inl.h
// Function: testing::internal::UnitTestImpl::AddTestInfo(void (*)(), void (*)(), testing::TestInfo*)
void AddTestInfo(internal::SetUpTestSuiteFunc set_up_tc,
                   internal::TearDownTestSuiteFunc tear_down_tc,
                   TestInfo* test_info) {
#if GTEST_HAS_FILE_SYSTEM
    // In order to support thread-safe death tests, we need to
    // remember the original working directory when the test program
    // was first invoked.  We cannot do this in RUN_ALL_TESTS(), as
    // the user may have changed the current directory before calling
    // RUN_ALL_TESTS().  Therefore we capture the current directory in
    // AddTestInfo(), which is called to register a TEST or TEST_F
    // before main() is reached.
    if (original_working_dir_.IsEmpty()) {
      original_working_dir_.Set(FilePath::GetCurrentDir());
      GTEST_CHECK_(!original_working_dir_.IsEmpty())
          << "Failed to get the current working directory.";
    }
#endif  // GTEST_HAS_FILE_SYSTEM

    GetTestSuite(test_info->test_suite_name(), test_info->type_param(),
                 set_up_tc, tear_down_tc)
        ->AddTestInfo(test_info);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
addq $0x10, %rdi
callq 0xa3920
testb $0x1, %al
jne 0xa8025
jmp 0xa8107
movq -0x58(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x68(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x7b080
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0xa3a80
jmp 0xa804d
leaq -0x40(%rbp), %rdi
callq 0xa3900
movq -0x58(%rbp), %rdi
addq $0x10, %rdi
callq 0xa3920
xorb $-0x1, %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x78790
testb $0x1, %al
jne 0xa8076
jmp 0xa8095
jmp 0xa8105
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xa3900
jmp 0xa814a
leaq 0x27a74(%rip), %rdx     # 0xcfb10
leaq -0x50(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movl $0x3, %esi
movl $0x2ad, %ecx            # imm = 0x2AD
callq 0x7d880
movq -0x78(%rbp), %rdi
callq 0x1f280
movq %rax, %rdi
leaq 0x27ab9(%rip), %rsi     # 0xcfb7f
callq 0x10720
movq %rax, -0x70(%rbp)
jmp 0xa80d1
movq -0x70(%rbp), %rdi
leaq 0x27ad7(%rip), %rsi     # 0xcfbb3
callq 0x10720
jmp 0xa80e3
leaq -0x50(%rbp), %rdi
callq 0x7d9c0
jmp 0xa8105
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x7d9c0
jmp 0xa814a
jmp 0xa8107
movq -0x20(%rbp), %rdi
callq 0xa3340
movq %rax, -0x80(%rbp)
movq -0x20(%rbp), %rdi
callq 0xa9740
movq -0x58(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq %rax, %rdx
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
callq 0x9b7b0
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x8aa70
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x10e00
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: halfflat[P]tinyopt/test/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_.c_str(), "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 0xa9e29
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0xa9e36
leaq 0x214d7(%rip), %rax     # 0xcb307
movq %rax, -0x40(%rbp)
jmp 0xa9e36
movq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x11(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x10e10
movq -0x38(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x1d070
jmp 0xa9e5e
leaq -0x11(%rbp), %rdi
callq 0x10810
movq -0x38(%rbp), %rdi
callq 0x10d70
testb $0x1, %al
jne 0xa9eef
movq -0x38(%rbp), %rdi
callq 0x102c0
movq %rax, %rdi
leaq 0x254e2(%rip), %rsi     # 0xcf369
callq 0xab4d0
movq %rax, -0x58(%rbp)
jmp 0xa9e92
movq -0x58(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
leaq 0x258c9(%rip), %rdi     # 0xcf76e
movl $0x1, %edx
movq %rdx, %rsi
callq 0x10f40
jmp 0xa9eb4
movq -0x30(%rbp), %rdi
callq 0x10730
jmp 0xa9ebf
jmp 0xa9eef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x10810
jmp 0xa9ef5
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x10fc8
jmp 0xa9ef5
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x10e00
nop
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::ScopedPrematureExitFile::~ScopedPrematureExitFile()
~ScopedPrematureExitFile() {
#ifndef GTEST_OS_ESP8266
    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;
      }
    }
#endif
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x10d70
testb $0x1, %al
jne 0xaa277
movq -0x18(%rbp), %rdi
callq 0x102c0
movq %rax, %rdi
callq 0x10e50
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0xaa275
leaq 0x23eb9(%rip), %rdx     # 0xce0bb
leaq -0x10(%rbp), %rdi
movl $0x2, %esi
movl $0x13d7, %ecx           # imm = 0x13D7
callq 0x7d880
jmp 0xaa217
leaq -0x10(%rbp), %rdi
callq 0x1f280
movq %rax, %rdi
leaq 0x25ada(%rip), %rsi     # 0xcfd04
callq 0x10720
movq %rax, -0x20(%rbp)
jmp 0xaa235
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdi
callq 0x10680
movq %rax, -0x28(%rbp)
jmp 0xaa248
movq -0x28(%rbp), %rdi
leaq 0x25adc(%rip), %rsi     # 0xcfd2f
callq 0x10720
movq %rax, -0x30(%rbp)
jmp 0xaa25e
movq -0x30(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x10de0
jmp 0xaa26c
leaq -0x10(%rbp), %rdi
callq 0x7d9c0
jmp 0xaa277
movq -0x18(%rbp), %rdi
callq 0x10fc8
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1dfc0
nop
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest-internal-inl.h
// Function: testing::internal::GetRandomSeedFromFlag(int)
inline int GetRandomSeedFromFlag(int32_t random_seed_flag) {
  const unsigned int raw_seed =
      (random_seed_flag == 0) ? static_cast<unsigned int>(GetTimeInMillis())
                              : static_cast<unsigned int>(random_seed_flag);

  // Normalizes the actual seed to range [1, kMaxRandomSeed] such that
  // it's easy to type.
  const int normalized_seed =
      static_cast<int>((raw_seed - 1U) %
                       static_cast<unsigned int>(kMaxRandomSeed)) +
      1;
  return normalized_seed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0xab16b
callq 0x84120
movl %eax, -0x10(%rbp)
jmp 0xab171
movl -0x4(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
subl $0x1, %eax
movl $0x1869f, %ecx          # imm = 0x1869F
xorl %edx, %edx
divl %ecx
addl $0x1, %edx
movl %edx, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: halfflat[P]tinyopt/test/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]));
  }

#ifdef GTEST_HAS_ABSL
  absl::InitializeSymbolizer(g_argvs[0].c_str());

#ifdef GTEST_HAS_ABSL_FLAGS
  // When using the Abseil Flags library, set the program usage message to the
  // help message, but remove the color-encoding from the message first.
  absl::SetProgramUsageMessage(absl::StrReplaceAll(
      kColorEncodedHelpMessage,
      {{"@D", ""}, {"@R", ""}, {"@G", ""}, {"@Y", ""}, {"@@", "@"}}));
#endif  // GTEST_HAS_ABSL_FLAGS
#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 0x9bc30
testb $0x1, %al
jne 0xabf8b
jmp 0xabf90
jmp 0xac02c
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jg 0xabf9e
jmp 0xac02c
leaq 0x6bbfb(%rip), %rdi     # 0x117ba0
callq 0xc7ec0
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
je 0xac012
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
leaq (%rax,%rcx,8), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0xc7d50
movq -0x50(%rbp), %rsi
leaq 0x6bbc0(%rip), %rdi     # 0x117ba0
callq 0x61bd0
jmp 0xabfe7
leaq -0x38(%rbp), %rdi
callq 0x10fc8
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xabfb1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x10fc8
jmp 0xac032
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x9cec0
callq 0xa29e0
movq %rax, %rdi
callq 0x9b720
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x10e00
nopl (%rax,%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/include/gtest/gtest-matchers.h
// Function: testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>::operator=(testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>&&)
MatcherBase& operator=(MatcherBase&& other) {
    if (this == &other) return *this;
    Destroy();
    vtable_ = other.vtable_;
    buffer_ = other.buffer_;
    other.vtable_ = nullptr;
    return *this;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
jne 0xad668
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xad69d
movq -0x20(%rbp), %rdi
callq 0xad6b0
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq $0x0, 0x8(%rcx)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest-port.cc
// Function: testing::internal::CapturedStream::GetCapturedString[abi:cxx11]()
std::string GetCapturedString() {
    if (uncaptured_fd_ != -1) {
      // Restores the original stream.
      fflush(nullptr);
      dup2(uncaptured_fd_, fd_);
      close(uncaptured_fd_);
      uncaptured_fd_ = -1;
    }

    FILE* const file = posix::FOpen(filename_.c_str(), "r");
    if (file == nullptr) {
      GTEST_LOG_(FATAL) << "Failed to open tmp file " << filename_
                        << " for capturing stream.";
    }
    const std::string content = ReadEntireFile(file);
    posix::FClose(file);
    return content;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $-0x1, 0x4(%rax)
je 0xadd07
xorl %eax, %eax
movl %eax, %edi
callq 0x10930
movq -0x38(%rbp), %rax
movl 0x4(%rax), %edi
movl (%rax), %esi
callq 0x106d0
movq -0x38(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x10f60
movq -0x38(%rbp), %rax
movl $0xffffffff, 0x4(%rax)  # imm = 0xFFFFFFFF
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
callq 0x102c0
movq %rax, %rdi
leaq 0x1c9c3(%rip), %rsi     # 0xca6e1
callq 0xab4d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xaddb9
leaq 0x2003f(%rip), %rdx     # 0xcdd78
leaq -0x1c(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movl $0x3, %esi
movl $0x481, %ecx            # imm = 0x481
callq 0x7d880
movq -0x58(%rbp), %rdi
callq 0x1f280
movq %rax, %rdi
leaq 0x21b39(%rip), %rsi     # 0xcf89c
callq 0x10720
movq %rax, -0x50(%rbp)
jmp 0xadd6e
movq -0x50(%rbp), %rdi
movq -0x38(%rbp), %rsi
addq $0x8, %rsi
callq 0x10680
movq %rax, -0x60(%rbp)
jmp 0xadd85
movq -0x60(%rbp), %rdi
leaq 0x21b25(%rip), %rsi     # 0xcf8b5
callq 0x10720
jmp 0xadd97
leaq -0x1c(%rbp), %rdi
callq 0x7d9c0
jmp 0xaddb9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1c(%rbp), %rdi
callq 0x7d9c0
jmp 0xade0b
movq -0x48(%rbp), %rdi
movb $0x0, -0x2d(%rbp)
movq -0x18(%rbp), %rsi
callq 0x7dc20
movq -0x18(%rbp), %rdi
callq 0xade60
jmp 0xaddd5
movb $0x1, -0x2d(%rbp)
testb $0x1, -0x2d(%rbp)
jne 0xade01
jmp 0xaddf8
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x10fc8
jmp 0xade0b
movq -0x48(%rbp), %rdi
callq 0x10fc8
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x10e00
nopw %cs:(%rax,%rax)
nop
// File: halfflat[P]tinyopt/test/googletest/googletest/include/gtest/internal/gtest-internal.h
// Function: testing::internal::SkipComma(char const*)
inline const char* SkipComma(const char* str) {
  const char* comma = strchr(str, ',');
  if (comma == nullptr) {
    return nullptr;
  }
  while (IsSpace(*(++comma))) {
  }
  return comma;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2c, %esi
callq 0x10270
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xae20f
movq $0x0, -0x8(%rbp)
jmp 0xae239
jmp 0xae211
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movsbl 0x1(%rax), %edi
callq 0xae250
testb $0x1, %al
jne 0xae22f
jmp 0xae231
jmp 0xae211
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/include/gtest/internal/gtest-port.h
// Function: testing::internal::posix::IsATTY(int)
inline int IsATTY(int fd) {
  // DoIsATTY might change errno (for example ENOTTY in case you redirect stdout
  // to a file on Linux), which is unexpected, so save the previous value, and
  // restore it after the call.
  int savedErrno = errno;
  int isAttyValue = DoIsATTY(fd);
  errno = savedErrno;

  return isAttyValue;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
callq 0x10080
movl (%rax), %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %edi
callq 0xb4530
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x10(%rbp)
callq 0x10080
movl -0x10(%rbp), %ecx
movl %ecx, (%rax)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/include/gtest/internal/gtest-port.h
// Function: testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::GetOrCreateValue() const
T* GetOrCreateValue() const {
    ThreadLocalValueHolderBase* const holder =
        static_cast<ThreadLocalValueHolderBase*>(pthread_getspecific(key_));
    if (holder != nullptr) {
      return CheckedDowncastToActualType<ValueHolder>(holder)->pointer();
    }

    ValueHolder* const new_holder = default_factory_->MakeNewHolder();
    ThreadLocalValueHolderBase* const holder_base = new_holder;
    GTEST_CHECK_POSIX_SUCCESS_(pthread_setspecific(key_, holder_base));
    return new_holder->pointer();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movl (%rax), %edi
callq 0x10c70
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xb4990
movq -0x18(%rbp), %rdi
callq 0xb4a80
movq %rax, %rdi
callq 0xb4b60
movq %rax, -0x8(%rbp)
jmp 0xb4a60
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
callq 0xb4b80
movq %rax, %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movl (%rax), %edi
movq -0x28(%rbp), %rsi
callq 0x10120
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0xb4a53
leaq 0x1afab(%rip), %rdx     # 0xcf983
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movl $0x3, %esi
movl $0x726, %ecx            # imm = 0x726
callq 0x7d880
movq -0x58(%rbp), %rdi
callq 0x1f280
movq %rax, %rdi
leaq 0x1b28d(%rip), %rsi     # 0xcfc8f
callq 0x10720
movq %rax, -0x50(%rbp)
jmp 0xb4a0d
movq -0x50(%rbp), %rdi
leaq 0x1b001(%rip), %rsi     # 0xcfa19
callq 0x10720
movq %rax, -0x60(%rbp)
jmp 0xb4a23
movq -0x60(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x10de0
jmp 0xb4a31
leaq -0x30(%rbp), %rdi
callq 0x7d9c0
jmp 0xb4a53
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x7d9c0
jmp 0xb4a6a
movq -0x20(%rbp), %rdi
callq 0xb4b60
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x10e00
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/include/gtest/internal/gtest-port.h
// Function: testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::ValueHolder* testing::internal::CheckedDowncastToActualType<testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::ValueHolder, testing::internal::ThreadLocalValueHolderBase>(testing::internal::ThreadLocalValueHolderBase*)
Derived* CheckedDowncastToActualType(Base* base) {
  static_assert(std::is_base_of<Base, Derived>::value,
                "target type not derived from source type");
#if GTEST_HAS_RTTI
  GTEST_CHECK_(base == nullptr || dynamic_cast<Derived*>(base) != nullptr);
#endif
  return static_cast<Derived*>(base);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movb $0x1, %al
cmpq $0x0, -0x8(%rbp)
movb %al, -0x1d(%rbp)
je 0xb4add
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xb4ac7
movq -0x28(%rbp), %rdi
leaq 0x61e07(%rip), %rsi     # 0x1168b8
leaq 0x61e10(%rip), %rdx     # 0x1168c8
xorl %eax, %eax
movl %eax, %ecx
callq 0x108b0
movq %rax, -0x30(%rbp)
jmp 0xb4acf
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0xb4acf
movq -0x30(%rbp), %rax
cmpq $0x0, %rax
setne %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x78790
testb $0x1, %al
jne 0xb4af1
jmp 0xb4af3
jmp 0xb4b4d
leaq 0x1ae89(%rip), %rdx     # 0xcf983
leaq -0xc(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl $0x3, %esi
movl $0x495, %ecx            # imm = 0x495
callq 0x7d880
movq -0x38(%rbp), %rdi
callq 0x1f280
movq %rax, %rdi
leaq 0x1b192(%rip), %rsi     # 0xcfcb6
callq 0x10720
jmp 0xb4b2b
leaq -0xc(%rbp), %rdi
callq 0x7d9c0
jmp 0xb4b4d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0xc(%rbp), %rdi
callq 0x7d9c0
jmp 0xb4b57
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x10e00
// File: halfflat[P]tinyopt/test/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&)
void Send(const std::string& message) override {
      GTEST_CHECK_(sockfd_ != -1)
          << "Send() can be called only when there is a connection.";

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpl $-0x1, 0x8(%rax)
setne %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x78790
testb $0x1, %al
jne 0xb6593
jmp 0xb6595
jmp 0xb6608
leaq 0x19574(%rip), %rdx     # 0xcfb10
leaq -0x14(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movl $0x3, %esi
movl $0x445, %ecx            # imm = 0x445
callq 0x7d880
movq -0x50(%rbp), %rdi
callq 0x1f280
movq %rax, %rdi
leaq 0x19777(%rip), %rsi     # 0xcfd3d
callq 0x10720
movq %rax, -0x48(%rbp)
jmp 0xb65d1
movq -0x48(%rbp), %rdi
leaq 0x19782(%rip), %rsi     # 0xcfd5e
callq 0x10720
jmp 0xb65e3
leaq -0x14(%rbp), %rdi
callq 0x7d9c0
jmp 0xb6608
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x14(%rbp), %rdi
callq 0x7d9c0
jmp 0xb66eb
movq -0x10(%rbp), %rdi
callq 0x10c60
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x30(%rbp)
movl 0x8(%rax), %eax
movl %eax, -0x54(%rbp)
movq -0x10(%rbp), %rdi
callq 0x102c0
movl -0x54(%rbp), %edi
movq %rax, %rsi
movq -0x30(%rbp), %rdx
callq 0x10240
cmpq -0x30(%rbp), %rax
je 0xb66e2
leaq 0x194c5(%rip), %rdx     # 0xcfb10
leaq -0x34(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movl $0x1, %esi
movl $0x44a, %ecx            # imm = 0x44A
callq 0x7d880
movq -0x68(%rbp), %rdi
callq 0x1f280
movq %rax, %rdi
leaq 0x1971f(%rip), %rsi     # 0xcfd94
callq 0x10720
movq %rax, -0x60(%rbp)
jmp 0xb6680
movq -0x60(%rbp), %rdi
movq -0x40(%rbp), %rsi
addq $0x10, %rsi
callq 0x10680
movq %rax, -0x70(%rbp)
jmp 0xb6697
movq -0x70(%rbp), %rdi
leaq 0x138e5(%rip), %rsi     # 0xc9f87
callq 0x10720
movq %rax, -0x78(%rbp)
jmp 0xb66ad
movq -0x78(%rbp), %rdi
movq -0x40(%rbp), %rsi
addq $0x30, %rsi
callq 0x10680
jmp 0xb66c0
leaq -0x34(%rbp), %rdi
callq 0x7d9c0
jmp 0xb66e2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x34(%rbp), %rdi
callq 0x7d9c0
jmp 0xb66eb
addq $0x80, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x10e00
nopw %cs:(%rax,%rax)
nop
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest-internal-inl.h
// Function: testing::internal::StreamingListener::SocketWriter::CloseConnection()
void CloseConnection() override {
      GTEST_CHECK_(sockfd_ != -1)
          << "CloseConnection() can be called only when there is a connection.";

      close(sockfd_);
      sockfd_ = -1;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $-0x1, 0x8(%rax)
setne %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x78790
testb $0x1, %al
jne 0xb672c
jmp 0xb672e
jmp 0xb679e
leaq 0x193db(%rip), %rdx     # 0xcfb10
leaq -0xc(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl $0x3, %esi
movl $0x455, %ecx            # imm = 0x455
callq 0x7d880
movq -0x38(%rbp), %rdi
callq 0x1f280
movq %rax, %rdi
leaq 0x195de(%rip), %rsi     # 0xcfd3d
callq 0x10720
movq %rax, -0x30(%rbp)
jmp 0xb676a
movq -0x30(%rbp), %rdi
leaq 0x19646(%rip), %rsi     # 0xcfdbb
callq 0x10720
jmp 0xb677c
leaq -0xc(%rbp), %rdi
callq 0x7d9c0
jmp 0xb679e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0xc(%rbp), %rdi
callq 0x7d9c0
jmp 0xb67bb
movq -0x28(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x10f60
movq -0x28(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x10e00
nopw %cs:(%rax,%rax)
nop
// File: halfflat[P]tinyopt/test/googletest/googletest/include/gtest/gtest-printers.h
// Function: testing::internal::UniversalTersePrinter<wchar_t const*>::Print(wchar_t const*, std::ostream*)
static void Print(const wchar_t* str, ::std::ostream* os) {
    if (str == nullptr) {
      *os << "NULL";
    } else {
      UniversalPrint(::std::wstring(str), os);
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xb75b9
movq -0x10(%rbp), %rdi
leaq 0x129d7(%rip), %rsi     # 0xc9f89
callq 0x10720
jmp 0xb7632
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x10360
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0xb7680
jmp 0xb75e1
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0xb7650
jmp 0xb75f0
leaq -0x30(%rbp), %rdi
callq 0x10d50
leaq -0x31(%rbp), %rdi
callq 0x10e30
jmp 0xb7632
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xb7627
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x10d50
leaq -0x31(%rbp), %rdi
callq 0x10e30
jmp 0xb7638
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x10e00
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/include/gtest/gtest-matchers.h
// Function: void testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>::DescribeImpl<testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>::ValuePolicy<testing::internal::EqMatcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, false>>(testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&> const&, std::ostream*, bool)
static void DescribeImpl(const MatcherBase& m, std::ostream* os,
                           bool negation) {
    if (negation) {
      P::Get(m).DescribeNegationTo(os);
    } else {
      P::Get(m).DescribeTo(os);
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
je 0xb8304
movq -0x8(%rbp), %rdi
callq 0xb83b0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0xb8470
jmp 0xb8319
movq -0x8(%rbp), %rdi
callq 0xb83b0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0xb84d0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: void testing::internal::HandleSehExceptionsInMethodIfSupported<testing::Test, void>(testing::Test*, void (testing::Test::*)(), char const*)
Result HandleSehExceptionsInMethodIfSupported(T* object, Result (T::*method)(),
                                              const char* location) {
#if GTEST_HAS_SEH
  __try {
    return (object->*method)();
  } __except (internal::UnitTestOptions::GTestProcessSEH(  // NOLINT
      GetExceptionCode(), location)) {
    return static_cast<Result>(0);
  }
#else
  (void)location;
  return (object->*method)();
#endif  // GTEST_HAS_SEH
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
movq %rdi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rax, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdx
addq %rdx, %rcx
movq %rcx, -0x38(%rbp)
andq $0x1, %rax
cmpq $0x0, %rax
je 0xc0de2
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rax
movq (%rax), %rax
subq $0x1, %rcx
movq (%rax,%rcx), %rax
movq %rax, -0x48(%rbp)
jmp 0xc0dea
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rax
callq *%rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ethanmick[P]Blowfish482/Tester.cpp
// Function: print_uint8_hex(unsigned char*, unsigned int, char const*)
void print_uint8_hex(uint8_t* buffer, uint32_t size, const char* label) {
    cout << label << hex;
    for ( unsigned int i = 0; i < size; i++ ) {
        cout << (uint32_t) buffer[ i ] << " ";
    }
    cout << dec << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rsi
movq 0x327a(%rip), %rdi      # 0x4fd8
callq 0x1070
movq %rax, %rdi
leaq 0x3e3(%rip), %rsi       # 0x2150
callq 0x1040
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x1db2
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
movzbl (%rax,%rcx), %esi
movq 0x3245(%rip), %rdi      # 0x4fd8
callq 0x10a0
movq %rax, %rdi
leaq 0x134a(%rip), %rsi      # 0x30ec
callq 0x1070
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1d79
movq 0x321f(%rip), %rdi      # 0x4fd8
leaq 0x3c0(%rip), %rsi       # 0x2180
callq 0x1040
movq %rax, %rdi
movq 0x31f9(%rip), %rsi      # 0x4fc8
callq 0x1080
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ekg[P]sgd2/src/sgd2.hpp
// Function: sgd2::layout_unweighted(unsigned long, double*, unsigned long, unsigned long*, unsigned long*, unsigned long, double)
void layout_unweighted(uint64_t n, double* X, uint64_t m, uint64_t* I, uint64_t* J, uint64_t t_max, double eps)
{
    try
    {
        //auto start = std::chrono::steady_clock::now();

        std::vector<term> terms = bfs(n, m, I, J);
        //auto end = std::chrono::steady_clock::now();
        //std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(end-start).count() << "ms" << std::endl;

        std::vector<double> etas = schedule(terms, t_max, eps);
        sgd(X, terms, etas);
        //end = std::chrono::steady_clock::now();
        //std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(end-start).count() << "ms" << std::endl;
    }
    catch (const char* msg)
    {
        std::cerr << "Error: " << msg << std::endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movsd %xmm0, -0x38(%rbp)
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
leaq -0x50(%rbp), %rdi
callq 0x2b90
jmp 0x4133
movq -0x30(%rbp), %rdx
movsd -0x38(%rbp), %xmm0
leaq -0x78(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x3b00
jmp 0x414b
movq -0x10(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0x78(%rbp), %rdx
xorps %xmm0, %xmm0
callq 0x2440
jmp 0x4161
leaq -0x78(%rbp), %rdi
callq 0xaa80
leaq -0x50(%rbp), %rdi
callq 0xa190
jmp 0x421a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x41b2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x41a9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xaa80
leaq -0x50(%rbp), %rdi
callq 0xa190
movl -0x5c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x4234
movq -0x58(%rbp), %rdi
callq 0x2060
movq %rax, -0x80(%rbp)
movq 0x29e1e(%rip), %rdi     # 0x2dff0
leaq 0x19f23(%rip), %rsi     # 0x1e0fc
callq 0x2180
movq %rax, -0x88(%rbp)
jmp 0x41e7
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x2180
movq %rax, -0x90(%rbp)
jmp 0x4200
movq -0x90(%rbp), %rdi
movq 0x29daa(%rip), %rsi     # 0x2dfb8
callq 0x21b0
jmp 0x4215
callq 0x2270
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0x2270
movq -0x58(%rbp), %rdi
callq 0x22a0
nopl (%rax)
// File: ekg[P]sgd2/src/sgd2.hpp
// Function: sgd2::layout_weighted(unsigned long, double*, unsigned long, unsigned long*, unsigned long*, double*, unsigned long, double)
void layout_weighted(uint64_t n, double* X, uint64_t m, uint64_t* I, uint64_t* J, double* V, uint64_t t_max, double eps)
{
    try
    {
        std::vector<term> terms = dijkstra(n, m, I, J, V);
        std::vector<double> etas = schedule(terms, t_max, eps);
        sgd(X, terms, etas);
    }
    catch (const char* msg)
    {
        std::cerr << "Error: " << msg << std::endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movsd %xmm0, -0x38(%rbp)
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
leaq -0x50(%rbp), %rdi
callq 0x34a0
jmp 0x428b
movq 0x10(%rbp), %rdx
movsd -0x38(%rbp), %xmm0
leaq -0x78(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x3b00
jmp 0x42a3
movq -0x10(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0x78(%rbp), %rdx
xorps %xmm0, %xmm0
callq 0x2440
jmp 0x42b9
leaq -0x78(%rbp), %rdi
callq 0xaa80
leaq -0x50(%rbp), %rdi
callq 0xa190
jmp 0x4372
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x430a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x4301
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xaa80
leaq -0x50(%rbp), %rdi
callq 0xa190
movl -0x5c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x438c
movq -0x58(%rbp), %rdi
callq 0x2060
movq %rax, -0x80(%rbp)
movq 0x29cc6(%rip), %rdi     # 0x2dff0
leaq 0x19dcb(%rip), %rsi     # 0x1e0fc
callq 0x2180
movq %rax, -0x88(%rbp)
jmp 0x433f
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x2180
movq %rax, -0x90(%rbp)
jmp 0x4358
movq -0x90(%rbp), %rdi
movq 0x29c52(%rip), %rsi     # 0x2dfb8
callq 0x21b0
jmp 0x436d
callq 0x2270
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0x2270
movq -0x58(%rbp), %rdi
callq 0x22a0
nopw %cs:(%rax,%rax)
// File: ekg[P]sgd2/src/sgd2.hpp
// Function: sgd2::layout_unweighted_convergent(unsigned long, double*, unsigned long, unsigned long*, unsigned long*, unsigned long, double, double, unsigned long)
void layout_unweighted_convergent(uint64_t n, double* X, uint64_t m, uint64_t* I, uint64_t* J, uint64_t t_max, double eps, double delta, uint64_t t_maxmax)
{
    try
    {
        std::vector<term> terms = bfs(n, m, I, J);
        std::vector<double> etas = schedule_convergent(terms, t_max, eps, t_maxmax);
        sgd(X, terms, etas, delta);
    } 
    catch (const char* msg)
    {
        std::cerr << "Error: " << msg << std::endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movsd %xmm0, -0x38(%rbp)
movsd %xmm1, -0x40(%rbp)
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
leaq -0x58(%rbp), %rdi
callq 0x2b90
jmp 0x43ec
movq -0x30(%rbp), %rdx
movsd -0x38(%rbp), %xmm0
movq 0x10(%rbp), %rcx
leaq -0x80(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x3d70
jmp 0x4408
movq -0x10(%rbp), %rdi
movsd -0x40(%rbp), %xmm0
leaq -0x58(%rbp), %rsi
leaq -0x80(%rbp), %rdx
callq 0x2440
jmp 0x4420
leaq -0x80(%rbp), %rdi
callq 0xaa80
leaq -0x58(%rbp), %rdi
callq 0xa190
jmp 0x44df
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x4471
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x4468
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x80(%rbp), %rdi
callq 0xaa80
leaq -0x58(%rbp), %rdi
callq 0xa190
movl -0x64(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x44f9
movq -0x60(%rbp), %rdi
callq 0x2060
movq %rax, -0x88(%rbp)
movq 0x29b5c(%rip), %rdi     # 0x2dff0
leaq 0x19c61(%rip), %rsi     # 0x1e0fc
callq 0x2180
movq %rax, -0x90(%rbp)
jmp 0x44a9
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x2180
movq %rax, -0x98(%rbp)
jmp 0x44c5
movq -0x98(%rbp), %rdi
movq 0x29ae5(%rip), %rsi     # 0x2dfb8
callq 0x21b0
jmp 0x44da
callq 0x2270
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
callq 0x2270
movq -0x60(%rbp), %rdi
callq 0x22a0
nopw %cs:(%rax,%rax)
// File: ekg[P]sgd2/src/sgd2.hpp
// Function: sgd2::layout_weighted_convergent(unsigned long, double*, unsigned long, unsigned long*, unsigned long*, double*, unsigned long, double, double, unsigned long)
void layout_weighted_convergent(uint64_t n, double* X, uint64_t m, uint64_t* I, uint64_t* J, double* V, uint64_t t_max, double eps, double delta, uint64_t t_maxmax)
{
    try
    {
        std::vector<term> terms = dijkstra(n, m, I, J, V);
        std::vector<double> etas = schedule_convergent(terms, t_max, eps, t_maxmax);
        sgd(X, terms, etas, delta);
    }
    catch (const char* msg)
    {
        std::cerr << "Error: " << msg << std::endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movsd %xmm0, -0x38(%rbp)
movsd %xmm1, -0x40(%rbp)
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
leaq -0x58(%rbp), %rdi
callq 0x34a0
jmp 0x4564
movq 0x10(%rbp), %rdx
movsd -0x38(%rbp), %xmm0
movq 0x18(%rbp), %rcx
leaq -0x80(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x3d70
jmp 0x4580
movq -0x10(%rbp), %rdi
movsd -0x40(%rbp), %xmm0
leaq -0x58(%rbp), %rsi
leaq -0x80(%rbp), %rdx
callq 0x2440
jmp 0x4598
leaq -0x80(%rbp), %rdi
callq 0xaa80
leaq -0x58(%rbp), %rdi
callq 0xa190
jmp 0x4657
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x45e9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x45e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x80(%rbp), %rdi
callq 0xaa80
leaq -0x58(%rbp), %rdi
callq 0xa190
movl -0x64(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x4671
movq -0x60(%rbp), %rdi
callq 0x2060
movq %rax, -0x88(%rbp)
movq 0x299e4(%rip), %rdi     # 0x2dff0
leaq 0x19ae9(%rip), %rsi     # 0x1e0fc
callq 0x2180
movq %rax, -0x90(%rbp)
jmp 0x4621
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x2180
movq %rax, -0x98(%rbp)
jmp 0x463d
movq -0x98(%rbp), %rdi
movq 0x2996d(%rip), %rsi     # 0x2dfb8
callq 0x21b0
jmp 0x4652
callq 0x2270
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
callq 0x2270
movq -0x60(%rbp), %rdi
callq 0x22a0
nopw (%rax,%rax)
// File: ekg[P]sgd2/src/sgd2.hpp
// Function: sgd2::mds_direct(unsigned long, double*, double*, double*, unsigned long, double*)
void mds_direct(uint64_t n, double* X, double* d, double* w, uint64_t t_max, double* eta)
{
    // initialize SGD
    uint64_t nC2 = (n*(n-1))/2;
    std::vector<term> terms;
    terms.reserve(nC2);
    uint64_t ij=0;
    for (uint64_t i=0; i<n; i++) // unpack the condensed distance matrices
    {
        for (uint64_t j=i+1; j<n; j++)
        {
            terms.push_back(term(i, j, d[ij], w[ij]));
            ij += 1;
        }
    }

    // initialize step sizes
    std::vector<double> etas;
    etas.reserve(t_max);
    for (uint64_t t=0; t<t_max; t++)
    {
        etas.push_back(eta[t]);
    }
    
    sgd(X, terms, etas, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
decq %rcx
imulq %rcx, %rax
shrq %rax
movq %rax, -0x38(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x9cd0
movq -0xc0(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x9cf0
jmp 0x46da
movq $0x0, -0x68(%rbp)
movq $0x0, -0x70(%rbp)
movq -0x70(%rbp), %rax
cmpq -0x8(%rbp), %rax
jae 0x478a
movq -0x70(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
cmpq -0x8(%rbp), %rax
jae 0x4777
movq -0x70(%rbp), %rsi
movq -0x78(%rbp), %rdx
movq -0x18(%rbp), %rax
movq -0x68(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x20(%rbp), %rax
movsd (%rax,%rcx,8), %xmm1
leaq -0x98(%rbp), %rdi
callq 0xa0a0
jmp 0x473a
leaq -0x50(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0xa070
jmp 0x474c
movq -0x68(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x68(%rbp)
movq -0x78(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x78(%rbp)
jmp 0x4704
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x484b
jmp 0x4779
movq -0x70(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x70(%rbp)
jmp 0x46ea
leaq -0xb0(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0xab20
movq -0xc8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xab40
jmp 0x47af
movq $0x0, -0xb8(%rbp)
movq -0xb8(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x4814
movq -0x30(%rbp), %rax
movq -0xb8(%rbp), %rcx
leaq (%rax,%rcx,8), %rsi
leaq -0xb0(%rbp), %rdi
callq 0xac70
jmp 0x47e4
jmp 0x47e6
movq -0xb8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xb8(%rbp)
jmp 0x47ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0xaa80
jmp 0x484b
movq -0x10(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0xb0(%rbp), %rdx
xorps %xmm0, %xmm0
callq 0x2440
jmp 0x482d
leaq -0xb0(%rbp), %rdi
callq 0xaa80
leaq -0x50(%rbp), %rdi
callq 0xa190
addq $0xd0, %rsp
popq %rbp
retq
leaq -0x50(%rbp), %rdi
callq 0xa190
movq -0x58(%rbp), %rdi
callq 0x22a0
nopl (%rax)
// File: ekg[P]sgd2/src/sgd2.hpp
// Function: sgd2::layout_sparse_unweighted(unsigned long, double*, unsigned long, unsigned long*, unsigned long*, unsigned long, unsigned long, double)
void layout_sparse_unweighted(uint64_t n, double* X, uint64_t m, uint64_t* I, uint64_t* J, uint64_t p, uint64_t t_max, double eps)
{
    try
    {
        std::vector<std::vector<uint64_t>> g = build_graph_unweighted(n, m, I, J);
        auto closest_pivots = maxmin_random_sp_unweighted(g, p, 0);
        auto terms = MSSP_unweighted(g, closest_pivots);
        auto etas = schedule(terms, t_max, eps);
        sgd(X, terms, etas);
    }
    catch (const char* msg)
    {
        std::cerr << "Error: " << msg << std::endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movsd %xmm0, -0x38(%rbp)
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
leaq -0x50(%rbp), %rdi
callq 0x2880
jmp 0x87d7
movq -0x30(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
leaq -0x78(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x4cc0
jmp 0x87ee
leaq -0x90(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0x78(%rbp), %rdx
callq 0x5480
jmp 0x8804
movq 0x10(%rbp), %rdx
movsd -0x38(%rbp), %xmm0
leaq -0xa8(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x84b0
jmp 0x8822
movq -0x10(%rbp), %rdi
leaq -0x90(%rbp), %rsi
leaq -0xa8(%rbp), %rdx
callq 0x4860
jmp 0x883b
leaq -0xa8(%rbp), %rdi
callq 0xaa80
leaq -0x90(%rbp), %rdi
callq 0xba00
leaq -0x78(%rbp), %rdi
callq 0xa130
leaq -0x50(%rbp), %rdi
callq 0x9c10
jmp 0x8946
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x88d8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x88cf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x88c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x88ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0xaa80
leaq -0x90(%rbp), %rdi
callq 0xba00
leaq -0x78(%rbp), %rdi
callq 0xa130
leaq -0x50(%rbp), %rdi
callq 0x9c10
movl -0x5c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x8960
movq -0x58(%rbp), %rdi
callq 0x2060
movq %rax, -0xb0(%rbp)
movq 0x256f5(%rip), %rdi     # 0x2dff0
leaq 0x157fa(%rip), %rsi     # 0x1e0fc
callq 0x2180
movq %rax, -0xb8(%rbp)
jmp 0x8910
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
callq 0x2180
movq %rax, -0xc0(%rbp)
jmp 0x892c
movq -0xc0(%rbp), %rdi
movq 0x2567e(%rip), %rsi     # 0x2dfb8
callq 0x21b0
jmp 0x8941
callq 0x2270
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0x2270
movq -0x58(%rbp), %rdi
callq 0x22a0
nopl (%rax)
// File: ekg[P]sgd2/src/sgd2.hpp
// Function: sgd2::layout_sparse_weighted(unsigned long, double*, unsigned long, unsigned long*, unsigned long*, double*, unsigned long, unsigned long, double)
void layout_sparse_weighted(uint64_t n, double* X, uint64_t m, uint64_t* I, uint64_t* J, double* V, uint64_t p, uint64_t t_max, double eps)
{
    try
    {
        std::vector<std::vector<edge>> g = build_graph_weighted(n, m, I, J, V);

        auto closest_pivots = maxmin_random_sp_weighted(g, p, 0);
        auto terms = MSSP_weighted(g, closest_pivots);
        auto etas = schedule(terms, t_max, eps);
        sgd(X, terms, etas);
    }
    catch (const char* msg)
    {
        std::cerr << "Error: " << msg << std::endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movsd %xmm0, -0x38(%rbp)
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
leaq -0x50(%rbp), %rdi
callq 0x3040
jmp 0x89bf
movq 0x10(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
leaq -0x78(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x6730
jmp 0x89d6
leaq -0x90(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0x78(%rbp), %rdx
callq 0x7070
jmp 0x89ec
movq 0x18(%rbp), %rdx
movsd -0x38(%rbp), %xmm0
leaq -0xa8(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x84b0
jmp 0x8a0a
movq -0x10(%rbp), %rdi
leaq -0x90(%rbp), %rsi
leaq -0xa8(%rbp), %rdx
callq 0x4860
jmp 0x8a23
leaq -0xa8(%rbp), %rdi
callq 0xaa80
leaq -0x90(%rbp), %rdi
callq 0xba00
leaq -0x78(%rbp), %rdi
callq 0xa130
leaq -0x50(%rbp), %rdi
callq 0xa520
jmp 0x8b2e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x8ac0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x8ab7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x8aae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x8aa2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0xaa80
leaq -0x90(%rbp), %rdi
callq 0xba00
leaq -0x78(%rbp), %rdi
callq 0xa130
leaq -0x50(%rbp), %rdi
callq 0xa520
movl -0x5c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x8b48
movq -0x58(%rbp), %rdi
callq 0x2060
movq %rax, -0xb0(%rbp)
movq 0x2550d(%rip), %rdi     # 0x2dff0
leaq 0x15612(%rip), %rsi     # 0x1e0fc
callq 0x2180
movq %rax, -0xb8(%rbp)
jmp 0x8af8
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
callq 0x2180
movq %rax, -0xc0(%rbp)
jmp 0x8b14
movq -0xc0(%rbp), %rdi
movq 0x25496(%rip), %rsi     # 0x2dfb8
callq 0x21b0
jmp 0x8b29
callq 0x2270
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0x2270
movq -0x58(%rbp), %rdi
callq 0x22a0
nopw %cs:(%rax,%rax)
// File: Marm0t[P]dji-phantom3-parser/packet.cpp
// Function: Packet::doubleFromBytePos(int) const
const double Packet::doubleFromBytePos(int iPosition) const
{
    uint8_t aBytes[8]; // 8 - sizeof(double)

    // copy 8 bytes to aBytes
    for (int j = 0; j<sizeof(double); ++j)
    {
        aBytes[j] = _packv[j+iPosition];
    }
    // convert aBytes to double
   return  Packet::doubleFromBytes(aBytes);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movslq -0x18(%rbp), %rax
cmpq $0x8, %rax
jae 0x45d3
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movl -0x18(%rbp), %eax
addl -0xc(%rbp), %eax
movslq %eax, %rsi
callq 0x6270
movb (%rax), %cl
movslq -0x18(%rbp), %rax
movb %cl, -0x14(%rbp,%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x459e
leaq -0x14(%rbp), %rdi
callq 0x4540
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Marm0t[P]dji-phantom3-parser/packet.cpp
// Function: Packet::floatFromBytePos(int) const
const float Packet::floatFromBytePos(int iPosition) const
{
    uint8_t aBytes[4]; // 4 - sizeof(float)

    // copy 4 bytes to aBytes
    for (int j = 0; j<sizeof(float); ++j)
    {
        aBytes[j] = _packv[iPosition+j];
    }
    // convert aBytes to double
   return  Packet::floatFromBytes(aBytes);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
cmpq $0x4, %rax
jae 0x4643
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movl -0xc(%rbp), %eax
addl -0x14(%rbp), %eax
movslq %eax, %rsi
callq 0x6270
movb (%rax), %cl
movslq -0x14(%rbp), %rax
movb %cl, -0x10(%rbp,%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x460e
leaq -0x10(%rbp), %rdi
callq 0x4560
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)