LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
cmpq $0x0, 0x18(%rdi)
jne 0x6574c
leaq 0x10(%r12), %r13
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
callq 0x45e54
movq %r13, %rdi
movq %rbp, %rsi
callq 0xd2a0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x656ef
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
cmpq $0x0, 0x18(%r12)
jne 0x6574c
leaq 0xf99c(%rip), %rdx      # 0x7509a
leaq 0x8(%rsp), %rdi
movl $0x3, %esi
movl $0x2ad, %ecx            # imm = 0x2AD
callq 0x48796
movq 0x308d7(%rip), %rdi     # 0x95ff0
leaq 0xf9e9(%rip), %rsi      # 0x75109
movl $0x33, %edx
callq 0xd600
movq 0x308bf(%rip), %rdi     # 0x95ff0
leaq 0xfa05(%rip), %rsi      # 0x7513d
movl $0x2c, %edx
callq 0xd600
leaq 0x8(%rsp), %rdi
callq 0x488d8
movq (%rbx), %rsi
movq 0x40(%rbx), %rax
testq %rax, %rax
je 0x6575d
movq (%rax), %rdx
jmp 0x6575f
xorl %edx, %edx
movq %r12, %rdi
movq %r15, %rcx
movq %r14, %r8
callq 0x5f8ea
movq %rax, %rdi
movq %rbx, %rsi
callq 0x52f54
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x488d8
jmp 0x657b4
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x657b4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
leaq 0xb2ae(%rip), %rax      # 0x70ff8
cmoveq %rax, %r14
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq %r14, %rdi
callq 0xd210
leaq (%rax,%r14), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x15892
cmpq $0x0, 0x8(%rbx)
je 0x65da1
movq (%rbx), %rdi
leaq 0xeb7c(%rip), %rsi      # 0x748f9
callq 0xd660
movq %rax, %rbx
movl $0x30, %edi
movq %rax, %rsi
callq 0xd700
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd4f0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x65fb3
movq (%rbx), %rdi
callq 0xdaa0
testl %eax, %eax
je 0x65fb3
movl %eax, %ebp
leaq 0xd762(%rip), %rdx      # 0x736ab
leaq 0xc(%rsp), %rdi
movl $0x2, %esi
movl $0x13d7, %ecx           # imm = 0x13D7
callq 0x48796
movq 0x3008c(%rip), %rdi     # 0x95ff0
leaq 0xf2e7(%rip), %rsi      # 0x75252
movl $0x2a, %edx
callq 0xd600
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x3006d(%rip), %rdi     # 0x95ff0
callq 0xd600
movq %rax, %r14
leaq 0xf2eb(%rip), %rsi      # 0x7527d
movl $0xd, %edx
movq %rax, %rdi
callq 0xd600
movq %r14, %rdi
movl %ebp, %esi
callq 0xda30
leaq 0xc(%rsp), %rdi
callq 0x488d8
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x65fd2
movq (%rbx), %rsi
incq %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0xd530
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rdi
callq 0x15674
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r13
movq %rdi, %r14
leaq 0x2fdb1(%rip), %rsi     # 0x96980
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x3f90c
movq (%r15), %rbx
movq 0x8(%r15), %r12
movq %r15, %rdi
callq 0x20fca
cmpq %r12, %rbx
jne 0x66c8b
cmpl $0x0, (%r14)
jle 0x66c8b
movq %r13, (%rsp)
movq 0x2fd77(%rip), %rsi     # 0x96980
leaq 0x2fd70(%rip), %rdi     # 0x96980
callq 0x6d5fc
cmpl $0x0, (%r14)
je 0x66c6e
leaq 0x18(%rsp), %rbp
xorl %ebx, %ebx
leaq 0x8(%rsp), %r15
leaq 0x2fd52(%rip), %r12     # 0x96980
movq (%rsp), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x6d4fd
movq %r12, %rdi
movq %r15, %rsi
callq 0x34fc4
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x66c5f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
incq %rbx
movl (%r14), %eax
addq $0x8, %r13
cmpq %rax, %rbx
jne 0x66c32
movq %r14, %rdi
movq (%rsp), %rsi
callq 0x66890
callq 0x4a8ea
movq 0x2fd5a(%rip), %rdi     # 0x969e0
callq 0x5f858
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x66cb4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x67521
movq %rsi, %r14
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x67509
cmpq $0x0, 0x18(%rax)
je 0x67509
movq 0x10(%rbx), %rax
lock
decl (%rax)
jne 0x67509
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rdi
callq *0x18(%rax)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
movq $0x0, 0x8(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
cmpl $-0x1, 0x4(%rsi)
je 0x677e1
xorl %edi, %edi
callq 0xd650
movl (%r15), %esi
movl 0x4(%r15), %edi
callq 0xd4c0
movl 0x4(%r15), %edi
callq 0xdb60
movl $0xffffffff, 0x4(%r15)  # imm = 0xFFFFFFFF
movq 0x8(%r15), %rdi
leaq 0x8be8(%rip), %rsi      # 0x703d4
callq 0xd660
movq %rax, %r14
testq %rax, %rax
jne 0x6785e
leaq 0xbb68(%rip), %rdx      # 0x73368
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x481, %ecx            # imm = 0x481
callq 0x48796
movq 0x2e7d5(%rip), %rdi     # 0x95ff0
leaq 0xd604(%rip), %rsi      # 0x74e26
movl $0x18, %edx
callq 0xd600
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
movq 0x2e7b5(%rip), %rdi     # 0x95ff0
callq 0xd600
leaq 0xd5f8(%rip), %rsi      # 0x74e3f
movl $0x16, %edx
movq %rax, %rdi
callq 0xd600
leaq 0xc(%rsp), %rdi
callq 0x488d8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x48aa7
movq %r14, %rdi
callq 0xd4f0
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x488d8
movq %rbx, %rdi
callq 0xda70
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movl (%rdi), %edi
callq 0xd900
testq %rax, %rax
je 0x68a2b
movq %rax, %rdi
callq 0x68ad1
movq %rax, %rbx
jmp 0x68aac
movq 0x8(%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rbx
movl (%r14), %edi
movq %rax, %rsi
callq 0xd0f0
testl %eax, %eax
je 0x68aac
movl %eax, %ebp
leaq 0xc4bd(%rip), %rdx      # 0x74f0d
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x726, %ecx            # imm = 0x726
callq 0x48796
movq 0x2d585(%rip), %rdi     # 0x95ff0
leaq 0xc76b(%rip), %rsi      # 0x751dd
movl $0x26, %edx
callq 0xd600
movq 0x2d56d(%rip), %rdi     # 0x95ff0
leaq 0xc519(%rip), %rsi      # 0x74fa3
movl $0x12, %edx
callq 0xd600
movq 0x2d555(%rip), %rdi     # 0x95ff0
movl %ebp, %esi
callq 0xda30
leaq 0xc(%rsp), %rdi
callq 0x488d8
addq $0x8, %rbx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x488d8
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testq %rdi, %rdi
je 0x68b38
leaq 0x2cebb(%rip), %rsi     # 0x959a0
leaq 0x2cec4(%rip), %rdx     # 0x959b0
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xd5f0
testq %rax, %rax
jne 0x68b38
leaq 0xc40b(%rip), %rdx      # 0x74f0d
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x495, %ecx            # imm = 0x495
callq 0x48796
movq 0x2d4d3(%rip), %rdi     # 0x95ff0
leaq 0xc6e0(%rip), %rsi      # 0x75204
movl $0x4d, %edx
callq 0xd600
leaq 0xc(%rsp), %rdi
callq 0x488d8
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x488d8
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $-0x1, 0x8(%rdi)
jne 0x6a373
leaq 0xad75(%rip), %rdx      # 0x7509a
leaq 0x4(%rsp), %rdi
movl $0x3, %esi
movl $0x445, %ecx            # imm = 0x445
callq 0x48796
movq 0x2bcb0(%rip), %rdi     # 0x95ff0
leaq 0xaf44(%rip), %rsi      # 0x7528b
movl $0x20, %edx
callq 0xd600
movq 0x2bc98(%rip), %rdi     # 0x95ff0
leaq 0xaf4d(%rip), %rsi      # 0x752ac
movl $0x35, %edx
callq 0xd600
leaq 0x4(%rsp), %rdi
callq 0x488d8
movq (%r14), %rsi
movq 0x8(%r14), %r14
movl 0x8(%rbx), %edi
movq %r14, %rdx
callq 0xd1c0
cmpq %r14, %rax
je 0x6a3fe
leaq 0xad09(%rip), %rdx      # 0x7509a
movq %rsp, %rdi
movl $0x1, %esi
movl $0x44a, %ecx            # imm = 0x44A
callq 0x48796
movq 0x2bc46(%rip), %rdi     # 0x95ff0
leaq 0xaf31(%rip), %rsi      # 0x752e2
movl $0x26, %edx
callq 0xd600
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
movq 0x2bc26(%rip), %rdi     # 0x95ff0
callq 0xd600
movq %rax, %r14
leaq 0x58a7(%rip), %rsi      # 0x6fc80
movl $0x1, %edx
movq %rax, %rdi
callq 0xd600
movq 0x30(%rbx), %rsi
movq 0x38(%rbx), %rdx
movq %r14, %rdi
callq 0xd600
movq %rsp, %rdi
callq 0x488d8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x4(%rsp), %rdi
jmp 0x6a416
movq %rax, %rbx
movq %rsp, %rdi
callq 0x488d8
movq %rbx, %rdi
callq 0xda70
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $-0x1, 0x8(%rdi)
jne 0x6a487
leaq 0xac61(%rip), %rdx      # 0x7509a
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x455, %ecx            # imm = 0x455
callq 0x48796
movq 0x2bb9c(%rip), %rdi     # 0x95ff0
leaq 0xae30(%rip), %rsi      # 0x7528b
movl $0x20, %edx
callq 0xd600
movq 0x2bb84(%rip), %rdi     # 0x95ff0
leaq 0xae96(%rip), %rsi      # 0x75309
movl $0x40, %edx
callq 0xd600
leaq 0xc(%rsp), %rdi
callq 0x488d8
movl 0x8(%rbx), %edi
callq 0xdb60
movl $0xffffffff, 0x8(%rbx)  # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x488d8
movq %rbx, %rdi
callq 0xda70
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
testq %rdi, %rdi
je 0x6a68e
movq %rdi, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
callq 0xd440
leaq (%r14,%rax,4), %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x6a6d4
movq (%r15), %rdi
movq 0x8(%r15), %rsi
movq %rbx, %rdx
callq 0x49d07
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x6a682
movq 0x18(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0xd530
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x55ed(%rip), %rsi      # 0x6fc82
movl $0x4, %edx
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xd600
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x6a6cc
movq 0x18(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0xd530
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
testq %rdx, %rdx
je 0x19c8
movq %rdx, %r14
movq %rdx, %rdi
callq 0x1050
movq 0x261d(%rip), %rdi      # 0x3fd8
movq %r14, %rsi
movq %rax, %rdx
callq 0x10d0
jmp 0x19e6
movq 0x2609(%rip), %rax      # 0x3fd8
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
leaq (%rax,%rcx), %rdi
movl 0x20(%rax,%rcx), %esi
orl $0x1, %esi
callq 0x1130
movq 0x25eb(%rip), %r14      # 0x3fd8
movq (%r14), %rax
movq -0x18(%rax), %rax
movl 0x18(%r14,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%r14,%rax)
testl %ebp, %ebp
je 0x1a3f
movl %ebp, %r13d
xorl %ebp, %ebp
movq 0x25c4(%rip), %r15      # 0x3fd8
leaq 0x6d1(%rip), %r12       # 0x20ec
movzbl (%rbx,%rbp), %esi
movq %r15, %rdi
callq 0x1070
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x10d0
incq %rbp
cmpq %rbp, %r13
jne 0x1a1b
movq (%r14), %rax
movq -0x18(%rax), %rcx
movl 0x18(%r14,%rcx), %edx
andl $-0x4b, %edx
orl $0x2, %edx
movl %edx, 0x18(%r14,%rcx)
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x10b0
movsbl %al, %esi
movq %r14, %rdi
callq 0x1040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1080
// File: /workspace/github_cpp_makefile_star2_O1/ekg[P]sgd2/src/sgd2.hpp
// Function: sgd2::schedule(std::vector<sgd2::term, std::allocator<sgd2::term>> const&, unsigned long, double)
std::vector<double> schedule(const std::vector<term> &terms, uint64_t t_max, double eps)
{
    double w_min = terms[0].w, w_max = terms[0].w;
    for (uint64_t i=1; i<terms.size(); i++)
    {
        double w = terms[i].w;
        if (w < w_min) w_min = w;
        if (w > w_max) w_max = w;
    }
    double eta_max = 1.0 / w_min;
    double eta_min = eps / w_max;

    double lambda = log(eta_max/eta_min) / ((double)t_max-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_max * exp(-lambda * t));

    return etas;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
movsd 0x18(%rax), %xmm1
subq %rax, %rcx
sarq $0x5, %rcx
cmpq $0x2, %rcx
jb 0x35ac
decq %rcx
addq $0x38, %rax
movapd %xmm1, %xmm4
movsd (%rax), %xmm2
movapd %xmm2, %xmm3
minsd %xmm1, %xmm3
maxsd %xmm4, %xmm2
addq $0x20, %rax
movapd %xmm3, %xmm1
movapd %xmm2, %xmm4
decq %rcx
jne 0x3589
jmp 0x35b4
movapd %xmm1, %xmm2
movapd %xmm1, %xmm3
movsd 0x7a4c(%rip), %xmm1     # 0xb008
divsd %xmm3, %xmm1
divsd %xmm2, %xmm0
movsd %xmm1, -0x38(%rbp)
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x2110
movapd %xmm0, -0x30(%rbp)
xorpd %xmm0, %xmm0
movupd %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8080
testq %r14, %r14
je 0x36a5
movq %r14, %xmm0
punpckldq 0x7a54(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x7a5c(%rip), %xmm0     # 0xb070
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
addsd 0x79f8(%rip), %xmm1     # 0xb020
movapd -0x30(%rbp), %xmm0
xorpd 0x7a5b(%rip), %xmm0     # 0xb090
divsd %xmm1, %xmm0
movapd %xmm0, -0x30(%rbp)
xorl %r12d, %r12d
leaq -0x40(%rbp), %r15
movq %r12, %xmm1
punpckldq 0x7a0e(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x7a16(%rip), %xmm1     # 0xb070
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
mulsd -0x30(%rbp), %xmm0
callq 0x2250
mulsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x3692
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x369d
movq %rbx, %rdi
movq %r15, %rdx
callq 0x9b78
incq %r12
cmpq %r12, %r14
jne 0x3645
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x36b7
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x36ce
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2180
movq %r14, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x40, %rsp
movsd %xmm0, -0x30(%rbp)
movq %r9, %r14
movq %rsi, %rbx
movq %rdi, %rsi
leaq -0x28(%rbp), %rdi
callq 0x2acc
leaq -0x48(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movq %r14, %rdx
movsd -0x30(%rbp), %xmm0
callq 0x3550
leaq -0x28(%rbp), %rsi
leaq -0x48(%rbp), %rdx
xorps %xmm0, %xmm0
movq %rbx, %rdi
callq 0x265c
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x3996
movq -0x38(%rbp), %rsi
subq %rdi, %rsi
callq 0x2180
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x39ab
movq -0x18(%rbp), %rsi
subq %rdi, %rsi
callq 0x2180
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rdx, %r14
movq %rax, %rbx
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x39d7
movq -0x38(%rbp), %rsi
subq %rdi, %rsi
callq 0x2180
jmp 0x39d7
movq %rdx, %r14
movq %rax, %rbx
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x39f4
movq -0x18(%rbp), %rsi
subq %rdi, %rsi
callq 0x2180
jmp 0x39f4
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x3a46
movq %rbx, %rdi
callq 0x2060
movq %rax, %rbx
movq 0xb5e4(%rip), %rdi      # 0xeff0
leaq 0x7719(%rip), %rsi      # 0xb12c
movl $0x7, %edx
callq 0x2190
movq 0xb5cc(%rip), %rdi      # 0xeff0
movq %rbx, %rsi
callq 0x2160
movq %rax, %rdi
callq 0x2070
callq 0x2210
jmp 0x39ab
movq %rax, %rbx
callq 0x2210
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x40, %rsp
movsd %xmm0, -0x30(%rbp)
movq %rsi, %rbx
movq %rdi, %rsi
leaq -0x28(%rbp), %rdi
callq 0x3147
movq 0x10(%rbp), %rdx
leaq -0x48(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movsd -0x30(%rbp), %xmm0
callq 0x3550
leaq -0x28(%rbp), %rsi
leaq -0x48(%rbp), %rdx
xorps %xmm0, %xmm0
movq %rbx, %rdi
callq 0x265c
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x3aab
movq -0x38(%rbp), %rsi
subq %rdi, %rsi
callq 0x2180
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x3ac0
movq -0x18(%rbp), %rsi
subq %rdi, %rsi
callq 0x2180
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rdx, %r14
movq %rax, %rbx
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x3aec
movq -0x38(%rbp), %rsi
subq %rdi, %rsi
callq 0x2180
jmp 0x3aec
movq %rdx, %r14
movq %rax, %rbx
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x3b09
movq -0x18(%rbp), %rsi
subq %rdi, %rsi
callq 0x2180
jmp 0x3b09
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x3b5b
movq %rbx, %rdi
callq 0x2060
movq %rax, %rbx
movq 0xb4cf(%rip), %rdi      # 0xeff0
leaq 0x7604(%rip), %rsi      # 0xb12c
movl $0x7, %edx
callq 0x2190
movq 0xb4b7(%rip), %rdi      # 0xeff0
movq %rbx, %rsi
callq 0x2160
movq %rax, %rdi
callq 0x2070
callq 0x2210
jmp 0x3ac0
movq %rax, %rbx
callq 0x2210
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x40, %rsp
movsd %xmm1, -0x30(%rbp)
movsd %xmm0, -0x38(%rbp)
movq %r9, %r14
movq %rsi, %rbx
movq %rdi, %rsi
leaq -0x28(%rbp), %rdi
callq 0x2acc
movq 0x10(%rbp), %rcx
leaq -0x50(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movq %r14, %rdx
movsd -0x38(%rbp), %xmm0
callq 0x36d6
leaq -0x28(%rbp), %rsi
leaq -0x50(%rbp), %rdx
movq %rbx, %rdi
movsd -0x30(%rbp), %xmm0
callq 0x265c
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x3bcd
movq -0x40(%rbp), %rsi
subq %rdi, %rsi
callq 0x2180
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x3be2
movq -0x18(%rbp), %rsi
subq %rdi, %rsi
callq 0x2180
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rdx, %r14
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x3c0e
movq -0x40(%rbp), %rsi
subq %rdi, %rsi
callq 0x2180
jmp 0x3c0e
movq %rdx, %r14
movq %rax, %rbx
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x3c2b
movq -0x18(%rbp), %rsi
subq %rdi, %rsi
callq 0x2180
jmp 0x3c2b
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x3c7d
movq %rbx, %rdi
callq 0x2060
movq %rax, %rbx
movq 0xb3ad(%rip), %rdi      # 0xeff0
leaq 0x74e2(%rip), %rsi      # 0xb12c
movl $0x7, %edx
callq 0x2190
movq 0xb395(%rip), %rdi      # 0xeff0
movq %rbx, %rsi
callq 0x2160
movq %rax, %rdi
callq 0x2070
callq 0x2210
jmp 0x3be2
movq %rax, %rbx
callq 0x2210
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x40, %rsp
movsd %xmm1, -0x30(%rbp)
movsd %xmm0, -0x38(%rbp)
movq %rsi, %rbx
movq %rdi, %rsi
leaq -0x28(%rbp), %rdi
callq 0x3147
movq 0x18(%rbp), %rcx
movq 0x10(%rbp), %rdx
leaq -0x50(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movsd -0x38(%rbp), %xmm0
callq 0x36d6
leaq -0x28(%rbp), %rsi
leaq -0x50(%rbp), %rdx
movq %rbx, %rdi
movsd -0x30(%rbp), %xmm0
callq 0x265c
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x3ced
movq -0x40(%rbp), %rsi
subq %rdi, %rsi
callq 0x2180
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x3d02
movq -0x18(%rbp), %rsi
subq %rdi, %rsi
callq 0x2180
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rdx, %r14
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x3d2e
movq -0x40(%rbp), %rsi
subq %rdi, %rsi
callq 0x2180
jmp 0x3d2e
movq %rdx, %r14
movq %rax, %rbx
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x3d4b
movq -0x18(%rbp), %rsi
subq %rdi, %rsi
callq 0x2180
jmp 0x3d4b
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x3d9d
movq %rbx, %rdi
callq 0x2060
movq %rax, %rbx
movq 0xb28d(%rip), %rdi      # 0xeff0
leaq 0x73c2(%rip), %rsi      # 0xb12c
movl $0x7, %edx
callq 0x2190
movq 0xb275(%rip), %rdi      # 0xeff0
movq %rbx, %rsi
callq 0x2160
movq %rax, %rdi
callq 0x2070
callq 0x2210
jmp 0x3d02
movq %rax, %rbx
callq 0x2210
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r9, -0x80(%rbp)
movq %r8, -0x88(%rbp)
movq %rcx, -0x98(%rbp)
movq %rdx, %r13
movq %rsi, -0x78(%rbp)
movq %rdi, %rbx
leaq -0x1(%rdi), %rsi
imulq %rdi, %rsi
shrq %rsi
xorps %xmm0, %xmm0
leaq -0x70(%rbp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x7b74
testq %rbx, %rbx
je 0x3e80
xorl %r15d, %r15d
xorl %r14d, %r14d
leaq 0x1(%r15), %r12
cmpq %rbx, %r12
movq %r12, -0x90(%rbp)
jae 0x3e74
movsd (%r13,%r14,8), %xmm0
movq -0x98(%rbp), %rax
movsd (%rax,%r14,8), %xmm1
movq %r15, -0x50(%rbp)
movq %r12, -0x48(%rbp)
movsd %xmm0, -0x40(%rbp)
movsd %xmm1, -0x38(%rbp)
movq -0x68(%rbp), %rsi
cmpq -0x60(%rbp), %rsi
je 0x3e5c
movups -0x50(%rbp), %xmm0
movups -0x40(%rbp), %xmm1
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
addq $0x20, %rsi
movq %rsi, -0x68(%rbp)
jmp 0x3e69
leaq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %rdx
callq 0x9286
incq %r14
incq %r12
cmpq %rbx, %r12
jb 0x3e13
movq -0x90(%rbp), %r15
cmpq %rbx, %r15
jne 0x3e03
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq -0x88(%rbp), %r15
movq %r15, %rsi
callq 0x8080
testq %r15, %r15
movq -0x80(%rbp), %r14
je 0x3edf
leaq -0x50(%rbp), %rbx
movq -0x48(%rbp), %rsi
cmpq -0x40(%rbp), %rsi
je 0x3ecb
movsd (%r14), %xmm0
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x3ed6
movq %rbx, %rdi
movq %r14, %rdx
callq 0x9c9e
addq $0x8, %r14
decq %r15
jne 0x3eae
leaq -0x70(%rbp), %rsi
leaq -0x50(%rbp), %rdx
xorps %xmm0, %xmm0
movq -0x78(%rbp), %rdi
callq 0x265c
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x3f08
movq -0x40(%rbp), %rsi
subq %rdi, %rsi
callq 0x2180
movq -0x70(%rbp), %rdi
testq %rdi, %rdi
je 0x3f1d
movq -0x60(%rbp), %rsi
subq %rdi, %rsi
callq 0x2180
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3f4a
jmp 0x3f30
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x3f4d
movq -0x40(%rbp), %rsi
subq %rdi, %rsi
callq 0x2180
jmp 0x3f4d
movq %rax, %rbx
movq -0x70(%rbp), %rdi
testq %rdi, %rdi
je 0x3f62
movq -0x60(%rbp), %rsi
subq %rdi, %rsi
callq 0x2180
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x70, %rsp
movsd %xmm0, -0x30(%rbp)
movq %r9, %r14
movq %rsi, %rbx
movq %rdi, %rsi
leaq -0x78(%rbp), %rdi
callq 0x28d3
leaq -0x60(%rbp), %rdi
leaq -0x78(%rbp), %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x41f8
leaq -0x28(%rbp), %rdi
leaq -0x78(%rbp), %rsi
leaq -0x60(%rbp), %rdx
callq 0x470c
movq 0x10(%rbp), %rdx
leaq -0x48(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movsd -0x30(%rbp), %xmm0
callq 0x6ba8
leaq -0x28(%rbp), %rsi
leaq -0x48(%rbp), %rdx
movq %rbx, %rdi
callq 0x3f6a
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x6e03
movq -0x38(%rbp), %rsi
subq %rdi, %rsi
callq 0x2180
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x6e18
movq -0x18(%rbp), %rsi
subq %rdi, %rsi
callq 0x2180
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
je 0x6e2d
movq -0x50(%rbp), %rsi
subq %rdi, %rsi
callq 0x2180
leaq -0x78(%rbp), %rdi
callq 0x7ac8
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rdx, %r14
movq %rax, %rbx
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x6e62
movq -0x38(%rbp), %rsi
subq %rdi, %rsi
callq 0x2180
jmp 0x6e62
movq %rdx, %r14
movq %rax, %rbx
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x6e7f
movq -0x18(%rbp), %rsi
subq %rdi, %rsi
callq 0x2180
jmp 0x6e7f
movq %rdx, %r14
movq %rax, %rbx
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
je 0x6e9c
movq -0x50(%rbp), %rsi
subq %rdi, %rsi
callq 0x2180
jmp 0x6e9c
movq %rdx, %r14
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x7ac8
jmp 0x6ead
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x6eff
movq %rbx, %rdi
callq 0x2060
movq %rax, %rbx
movq 0x812b(%rip), %rdi      # 0xeff0
leaq 0x4260(%rip), %rsi      # 0xb12c
movl $0x7, %edx
callq 0x2190
movq 0x8113(%rip), %rdi      # 0xeff0
movq %rbx, %rsi
callq 0x2160
movq %rax, %rdi
callq 0x2070
callq 0x2210
jmp 0x6e36
movq %rax, %rbx
callq 0x2210
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x70, %rsp
movsd %xmm0, -0x30(%rbp)
movq %rsi, %rbx
movq %rdi, %rsi
leaq -0x78(%rbp), %rdi
callq 0x2e84
movq 0x10(%rbp), %rdx
leaq -0x60(%rbp), %rdi
leaq -0x78(%rbp), %rsi
xorl %ecx, %ecx
callq 0x5645
leaq -0x28(%rbp), %rdi
leaq -0x78(%rbp), %rsi
leaq -0x60(%rbp), %rdx
callq 0x5bcb
movq 0x18(%rbp), %rdx
leaq -0x48(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movsd -0x30(%rbp), %xmm0
callq 0x6ba8
leaq -0x28(%rbp), %rsi
leaq -0x48(%rbp), %rdx
movq %rbx, %rdi
callq 0x3f6a
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x6f85
movq -0x38(%rbp), %rsi
subq %rdi, %rsi
callq 0x2180
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x6f9a
movq -0x18(%rbp), %rsi
subq %rdi, %rsi
callq 0x2180
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
je 0x6faf
movq -0x50(%rbp), %rsi
subq %rdi, %rsi
callq 0x2180
leaq -0x78(%rbp), %rdi
callq 0x7df2
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rdx, %r14
movq %rax, %rbx
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x6fe4
movq -0x38(%rbp), %rsi
subq %rdi, %rsi
callq 0x2180
jmp 0x6fe4
movq %rdx, %r14
movq %rax, %rbx
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x7001
movq -0x18(%rbp), %rsi
subq %rdi, %rsi
callq 0x2180
jmp 0x7001
movq %rdx, %r14
movq %rax, %rbx
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
je 0x701e
movq -0x50(%rbp), %rsi
subq %rdi, %rsi
callq 0x2180
jmp 0x701e
movq %rdx, %r14
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x7df2
jmp 0x702f
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x7081
movq %rbx, %rdi
callq 0x2060
movq %rax, %rbx
movq 0x7fa9(%rip), %rdi      # 0xeff0
leaq 0x40de(%rip), %rsi      # 0xb12c
movl $0x7, %edx
callq 0x2190
movq 0x7f91(%rip), %rdi      # 0xeff0
movq %rbx, %rsi
callq 0x2160
movq %rax, %rdi
callq 0x2070
callq 0x2210
jmp 0x6fb8
movq %rax, %rbx
callq 0x2210
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O1/Marm0t[P]dji-phantom3-parser/packet.cpp
// Function: Packet::dateFromFourBytes[abi:cxx11](unsigned char const*)
string Packet::dateFromFourBytes(const uint8_t* iBytes)
{
    // NOTE: it's only for test purpose!
    // We are not sure that date and time envoded in this particular format!!!

    //Convert 4 bytes to datetime according to this rule
    // YYYYYYYMMMMDDDDDHHHHMMMMMMSSSSSS
    //    7     4   5    4    6     6  
    // stored as little endian 32bit unsigned integer
    
    unsigned int aValue;
    memcpy(&aValue, iBytes, sizeof(unsigned int)); 
    
    int sec = aValue &  0x3f; //0x3F(16) = 0011 1111 (2)
    aValue = aValue >> 6; // move to minutes
    int min = aValue & 0x3f;
    aValue = aValue >> 6; // move to hours
    int hour = aValue & 0xf; // 0xf = 1111
    aValue = aValue >> 4; // move to day
    int day = aValue & 0x1f; // 0x1f = 0001 1111
    aValue = aValue >> 5; // move to month
    int month = aValue & 0xf; // 0xf = 1111
    aValue = aValue >> 4; // ove to year
    int year = aValue & 0x7F; // 0x7F = 0011 1111
    stringstream ss;
    ss << day<<"/"<<month<<"/"<<year<<" "
       << hour<<":"<<min<<":"<<sec;
    return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rdi, %rbx
movl (%rsi), %r14d
movl %r14d, %r15d
shrl $0x10, %r15d
andl $0x1f, %r15d
leaq -0x1a0(%rbp), %rdi
callq 0x20e0
leaq -0x190(%rbp), %rdi
movl %r15d, %esi
callq 0x21e0
movq %rax, %r15
leaq 0x23c4(%rip), %rsi      # 0x5130
movl $0x1, %edx
movq %rax, %rdi
callq 0x2170
movl %r14d, %esi
shrl $0x15, %esi
andl $0xf, %esi
movq %r15, %rdi
callq 0x21e0
movq %rax, %r15
leaq 0x239c(%rip), %rsi      # 0x5130
movl $0x1, %edx
movq %rax, %rdi
callq 0x2170
movl %r14d, %esi
shrl $0x19, %esi
movq %r15, %rdi
callq 0x21e0
movq %rax, %r15
leaq 0x248d(%rip), %rsi      # 0x5246
movl $0x1, %edx
movq %rax, %rdi
callq 0x2170
movl %r14d, %esi
shrl $0xc, %esi
andl $0xf, %esi
movq %r15, %rdi
callq 0x21e0
movq %rax, %r15
leaq 0x24e5(%rip), %rsi      # 0x52c6
movl $0x1, %edx
movq %rax, %rdi
callq 0x2170
movl %r14d, %esi
shrl $0x6, %esi
andl $0x3f, %esi
movq %r15, %rdi
callq 0x21e0
movq %rax, %r15
leaq 0x24bd(%rip), %rsi      # 0x52c6
movl $0x1, %edx
movq %rax, %rdi
callq 0x2170
andl $0x3f, %r14d
movq %r15, %rdi
movl %r14d, %esi
callq 0x21e0
leaq -0x188(%rbp), %rsi
movq %rbx, %rdi
callq 0x21b0
movq 0x417d(%rip), %rsi      # 0x6fb8
leaq -0x1a0(%rbp), %rdi
callq 0x2100
leaq -0x120(%rbp), %rdi
callq 0x2070
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x414a(%rip), %rsi      # 0x6fb8
leaq -0x1a0(%rbp), %rdi
callq 0x2100
leaq -0x120(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O1/Marm0t[P]dji-phantom3-parser/packet.cpp
// Function: Packet::parseHex()
void Packet::parseHex()
{
    if (_packv.size() < PACKET_HEADER_LEN)
    {
        cerr << "Error while parsing message: message to short, size: " << dec <<_packv.size() << endl;
        _valid = false;
        return;
    }

    // byte 1 - packet len
    _packetLen = _packv[1];
    // packet len in byte1 must be the same as _packv vector length
    // otherwise consider that message is corrupted
    if (_packetLen != _packv.size() )
    {
        cerr << "Error while parsing message: message length in packet ("<< dec << (int)_packetLen
             << ") is not equal to number of bytes read from file("<< dec << _packv.size() << ")" << endl;
        _valid = false;
        return;
    }

    // bytes 3 and 4 - packet type (2 bytes)
    char aType[2];
    for (int i = 0; i<2; ++i) aType[i] = _packv[i+3];
    memcpy(&_packetType, aType, 2);

    // bytes 6-9 - message ID (4 bytes)
    char aMsgId[4];
    for (int i = 0; i<4; ++i)
    {
        aMsgId[i] = _packv[i+6];
    }
    memcpy(&_msgId, aMsgId, 4);

    _valid = true;

    // try to convert all data bytes into doubles
    dataToDoubles();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
subq %rax, %rcx
cmpq $0x9, %rcx
ja 0x3314
movq 0x3d22(%rip), %r14      # 0x6ff0
leaq 0x1e76(%rip), %rsi      # 0x514b
movl $0x35, %edx
movq %r14, %rdi
callq 0x2170
movq (%r14), %rax
movq -0x18(%rax), %rax
movl 0x18(%r14,%rax), %ecx
andl $-0x4b, %ecx
orl $0x2, %ecx
movl %ecx, 0x18(%r14,%rax)
movq 0x10(%rbx), %rsi
subq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x20c0
movq %rax, %r14
movq (%rax), %rax
jmp 0x33d4
movzbl 0x1(%rax), %edx
movb %dl, 0x20(%rbx)
cmpq %rdx, %rcx
jne 0x333e
movzwl 0x3(%rax), %ecx
movw %cx, 0x22(%rbx)
movl 0x6(%rax), %eax
movl %eax, 0x24(%rbx)
movb $0x1, 0x28(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2eb6
movq 0x3cab(%rip), %r14      # 0x6ff0
leaq 0x1e35(%rip), %rsi      # 0x5181
movl $0x37, %edx
movq %r14, %rdi
callq 0x2170
movq (%r14), %rax
movq -0x18(%rax), %rax
movl 0x18(%r14,%rax), %ecx
andl $-0x4b, %ecx
orl $0x2, %ecx
movl %ecx, 0x18(%r14,%rax)
movzbl 0x20(%rbx), %esi
movq %r14, %rdi
callq 0x21e0
movq %rax, %r14
leaq 0x1e33(%rip), %rsi      # 0x51b9
movl $0x31, %edx
movq %rax, %rdi
callq 0x2170
movq (%r14), %rax
movq -0x18(%rax), %rax
movl 0x18(%r14,%rax), %ecx
andl $-0x4b, %ecx
orl $0x2, %ecx
movl %ecx, 0x18(%r14,%rax)
movq 0x10(%rbx), %rsi
subq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x20c0
movq %rax, %r14
leaq 0x1e27(%rip), %rsi      # 0x51eb
movl $0x1, %edx
movq %rax, %rdi
callq 0x2170
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
movb $0x0, 0x28(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Marm0t[P]dji-phantom3-parser/packet.cpp
// Function: GPSPacket::parseHex()
void GPSPacket::parseHex()
{
    Packet::parseHex();
    
    // first we should check packet type (must be 0x01CF)
    if (this->getPacketType() != 0x01CF)
    {
     //   cout << "GPSPacket: Wrong packet type: " << hex << this->getPacketType();
        _valid = false;
        return;
    }

    // then check byte#6 (must be 0x00 for pgs packet)
    if (this->getPacketRaw()[6] != 0x00)
    {
     //   cout << "GPSPacket: Wrong byte#6 (muxt be 0x00) " << hex << this->getPacketRaw()[6] << endl;
        _valid = false;
        return;
    }

    // now we can get lat/long/alt values
    // TODO
    _lon=convertDoubleToGps(doubleFromBytePos(10)); // byte#10 - beginning of longitude
    _lat=convertDoubleToGps(doubleFromBytePos(18)); // byte#18 - beginning of latitude
    _alt=floatFromBytePos(26);

    _bytes30_33_f=floatFromBytePos(30);
    _bytes34_37_f=floatFromBytePos(34);
    _bytes38_41_f=floatFromBytePos(38);
    _bytes42_45_f=floatFromBytePos(42);
    
    _bytes46_49_f=floatFromBytePos(46);
    _bytes50_53_f=floatFromBytePos(50);
    _bytes54_57_f=floatFromBytePos(54);
    _bytes58_61_f=floatFromBytePos(58);
    
    
    _valid = true;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x32ac
cmpw $0x1cf, 0x22(%rbx)      # imm = 0x1CF
jne 0x3422
movq 0x8(%rbx), %rax
cmpb $0x0, 0x6(%rax)
je 0x342e
xorl %eax, %eax
movb %al, 0x5c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movsd 0x1cd2(%rip), %xmm0     # 0x5108
movsd 0xa(%rax), %xmm1
mulsd %xmm0, %xmm1
movsd 0x1cc9(%rip), %xmm2     # 0x5110
divsd %xmm2, %xmm1
movsd %xmm1, 0x48(%rbx)
mulsd 0x12(%rax), %xmm0
divsd %xmm2, %xmm0
movsd %xmm0, 0x50(%rbx)
movss 0x1a(%rax), %xmm0
movss %xmm0, 0x58(%rbx)
movss 0x1e(%rax), %xmm0
movss %xmm0, 0x60(%rbx)
movss 0x22(%rax), %xmm0
movss %xmm0, 0x64(%rbx)
movss 0x26(%rax), %xmm0
movss %xmm0, 0x68(%rbx)
movss 0x2a(%rax), %xmm0
movss %xmm0, 0x6c(%rbx)
movss 0x2e(%rax), %xmm0
movss %xmm0, 0x70(%rbx)
movss 0x32(%rax), %xmm0
movss %xmm0, 0x74(%rbx)
movss 0x36(%rax), %xmm0
movss %xmm0, 0x78(%rbx)
movss 0x3a(%rax), %xmm0
movss %xmm0, 0x7c(%rbx)
movb $0x1, %al
jmp 0x3424
nop