LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::FormatCxxExceptionMessage[abi:cxx11](char const*, char const*)
static std::string FormatCxxExceptionMessage(const char* description,
                                             const char* location) {
  Message message;
  if (description != nullptr) {
    message << "C++ exception with description \"" << description << "\"";
  } else {
    message << "Unknown C++ exception";
  }
  message << " thrown in " << location << ".";

  return message.GetString();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x3d5f6
movq (%r15), %rdi
addq $0x10, %rdi
testq %r14, %r14
je 0x4ae22
leaq 0x1285d(%rip), %rsi     # 0x5d65a
callq 0xd550
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x4c162
leaq 0x11898(%rip), %rsi     # 0x5c6b0
movq %rax, %rdi
callq 0x4c188
jmp 0x4ae2e
leaq 0x12852(%rip), %rsi     # 0x5d67b
callq 0xd550
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
leaq 0x12853(%rip), %rsi     # 0x5d691
callq 0xd550
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x4c162
leaq 0xc993(%rip), %rsi      # 0x577ec
movq %rax, %rdi
callq 0x4c188
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3d7ba
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x4ae7e
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x4ae9e
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0xdaa0
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: bool testing::internal::ParseFlag<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
static bool ParseFlag(const char* str, const char* flag_name, String* value) {
  // Gets the value of the flag as a string.
  const char* const value_str = ParseFlagValue(str, flag_name, false);

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

  // Sets *value to the value of the flag.
  *value = value_str;
  return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
xorl %edx, %edx
callq 0x4a062
movq %rax, %r14
testq %rax, %rax
je 0x4bc76
movq %rbx, %rdi
movq %r14, %rsi
callq 0xdb70
testq %r14, %r14
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::PrintColorEncoded(char const*)
static void PrintColorEncoded(const char* str) {
  GTestColor color = GTestColor::kDefault;  // The current color.

  // Conceptually, we split the string into segments divided by escape
  // sequences.  Then we print one segment at a time.  At the end of
  // each iteration, the str pointer advances to the beginning of the
  // next segment.
  for (;;) {
    const char* p = strchr(str, '@');
    if (p == nullptr) {
      ColoredPrintf(color, "%s", str);
      return;
    }

    ColoredPrintf(color, "%s", std::string(str, p).c_str());

    const char ch = p[1];
    str = p + 2;
    if (ch == '@') {
      ColoredPrintf(color, "@");
    } else if (ch == 'D') {
      color = GTestColor::kDefault;
    } else if (ch == 'R') {
      color = GTestColor::kRed;
    } else if (ch == 'G') {
      color = GTestColor::kGreen;
    } else if (ch == 'Y') {
      color = GTestColor::kYellow;
    } else {
      --str;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq 0xe520(%rip), %r15      # 0x5a360
pushq $0x40
popq %rbx
leaq 0x8(%rsp), %r14
xorl %ebp, %ebp
movq %r15, %r12
movq %r12, %rdi
movl %ebx, %esi
callq 0xd1f0
testq %rax, %rax
je 0x4beea
movq %rax, %r13
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x1384a
movq 0x8(%rsp), %rdx
movl %ebp, %edi
leaq 0x10bda(%rip), %rsi     # 0x5ca63
xorl %eax, %eax
callq 0x41733
movq %r14, %rdi
callq 0xdbe8
movzbl 0x1(%r13), %eax
leaq 0x2(%r13), %r15
cmpl $0x40, %eax
je 0x4bec5
cmpl $0x44, %eax
je 0x4be48
cmpl $0x47, %eax
je 0x4beda
cmpl $0x52, %eax
je 0x4bee2
incq %r13
movq %r13, %r12
cmpl $0x59, %eax
jne 0x4be4d
pushq $0x3
popq %rbp
jmp 0x4be4a
movl %ebp, %edi
leaq 0x11921(%rip), %rsi     # 0x5d7ef
xorl %eax, %eax
callq 0x41733
jmp 0x4be4a
pushq $0x2
popq %rbp
jmp 0x4be4a
pushq $0x1
popq %rbp
jmp 0x4be4a
leaq 0x10b72(%rip), %rsi     # 0x5ca63
movl %ebp, %edi
movq %r12, %rdx
xorl %eax, %eax
callq 0x41733
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xdbe8
movq %rbx, %rdi
callq 0xdaa0
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::ParseFlag(char const*, char const*, bool*)
static bool ParseFlag(const char* str, const char* flag_name, bool* value) {
  // Gets the value of the flag as a string.
  const char* const value_str = ParseFlagValue(str, flag_name, true);

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

  // Converts the string value to a bool.
  *value = !(*value_str == '0' || *value_str == 'f' || *value_str == 'F');
  return true;
}

// Assembly:
pushq %rbx
movq %rdx, %rbx
pushq $0x1
popq %rdx
callq 0x4a062
testq %rax, %rax
je 0x4bf49
movzbl (%rax), %edx
xorl %ecx, %ecx
cmpl $0x30, %edx
je 0x4bf47
cmpl $0x66, %edx
je 0x4bf47
cmpb $0x46, %dl
setne %cl
movb %cl, (%rbx)
testq %rax, %rax
setne %al
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/test/googletest/googletest/include/gtest/gtest-message.h
// Function: testing::Message& testing::Message::operator<<<char const>(char const* const&)
inline Message& operator<<(T* const& pointer) {  // NOLINT
    if (pointer == nullptr) {
      *ss_ << "(null)";
    } else {
      *ss_ << pointer;
    }
    return *this;
  }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
movq (%rdi), %rdi
addq $0x10, %rdi
testq %rax, %rax
leaq 0xfb6f(%rip), %rsi      # 0x5bce9
cmovneq %rax, %rsi
callq 0xd550
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4e11f
leaq 0x10(%r12), %r13
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
callq 0x3882c
movq %r13, %rdi
movq %rbp, %rsi
callq 0xd2e0
leaq 0x8(%rsp), %rdi
callq 0xdbe8
cmpq $0x0, 0x18(%r12)
jne 0x4e11f
leaq 0xf009(%rip), %rdx      # 0x5d0ea
leaq 0x8(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x2ad, %ecx            # imm = 0x2AD
callq 0x39dd8
movq 0x35eee(%rip), %rdi     # 0x83fe8
leaq 0xf058(%rip), %rsi      # 0x5d159
callq 0xd550
leaq 0xf080(%rip), %rsi      # 0x5d18d
movq %rax, %rdi
callq 0xd550
leaq 0x8(%rsp), %rdi
callq 0x39e9c
movq (%rbx), %rsi
movq 0x40(%rbx), %rax
testq %rax, %rax
je 0x4e130
movq (%rax), %rdx
jmp 0x4e132
xorl %edx, %edx
movq %r12, %rdi
movq %r15, %rcx
movq %r14, %r8
callq 0x495d4
movq %rax, %rdi
movq %rbx, %rsi
callq 0x41076
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x39e9c
jmp 0x4e176
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xdbe8
movq %rbx, %rdi
callq 0xdaa0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
leaq 0xa7f8(%rip), %rax      # 0x5906a
cmoveq %rax, %rsi
leaq 0xf(%rsp), %rdx
callq 0x1337a
cmpq $0x0, 0x8(%rbx)
je 0x4e8ac
movq (%rbx), %rdi
leaq 0xe0b8(%rip), %rsi      # 0x5c949
callq 0xd6c0
movq %rax, %rbx
pushq $0x30
popq %rdi
movq %rax, %rsi
callq 0xd760
movq %rbx, %rdi
callq 0xd560
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x4ea63
movq (%rbx), %rdi
callq 0xdad0
testl %eax, %eax
je 0x4ea63
movl %eax, %ebp
leaq 0xcceb(%rip), %rdx      # 0x5b6fb
leaq 0x4(%rsp), %rdi
pushq $0x2
popq %rsi
movl $0x13d7, %ecx           # imm = 0x13D7
callq 0x39dd8
movq 0x355bf(%rip), %rdi     # 0x83fe8
leaq 0xe872(%rip), %rsi      # 0x5d2a2
callq 0xd550
movq %rax, %rdi
movq %rbx, %rsi
callq 0xd4e0
leaq 0xe886(%rip), %rsi      # 0x5d2cd
movq %rax, %rdi
callq 0xd550
movq %rax, %rdi
movl %ebp, %esi
callq 0xda80
leaq 0x4(%rsp), %rdi
callq 0x39e9c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xdbe8
movq %rax, %rdi
callq 0x135af
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movl %edi, %eax
testl %edi, %edi
jne 0x4ee85
pushq %rax
callq 0x3d5b6
addq $0x8, %rsp
decl %eax
movl $0x1869f, %ecx          # imm = 0x1869F
xorl %edx, %edx
divl %ecx
leal 0x1(%rdx), %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movq %rdi, %r14
callq 0x497e8
testb %al, %al
jne 0x4f4b2
cmpl $0x0, (%r14)
jle 0x4f4b2
leaq 0x35557(%rip), %r15     # 0x849b0
movq %r15, %rdi
callq 0x557b0
xorl %ebp, %ebp
leaq 0x8(%rsp), %r12
movq %rbx, %r13
movl (%r14), %eax
cmpq %rax, %rbp
je 0x4f49a
movq %r12, %rdi
movq %r13, %rsi
callq 0x556b5
movq %r15, %rdi
movq %r12, %rsi
callq 0x2ce84
movq %r12, %rdi
callq 0xdbe8
incq %rbp
addq $0x8, %r13
jmp 0x4f46b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4f1d5
callq 0x4c032
movq %rax, %rdi
callq 0x49556
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xdbe8
movq %rbx, %rdi
callq 0xdaa0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4fb76
movq %rsi, %r14
movq %rbx, %rdi
callq 0x4fb82
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
andq $0x0, 0x8(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movq %rdi, %rbx
cmpl $-0x1, 0x4(%rsi)
je 0x4fe24
xorl %edi, %edi
callq 0xd6b0
movl (%r14), %esi
movl 0x4(%r14), %edi
callq 0xd520
movl 0x4(%r14), %edi
callq 0xdba0
orl $-0x1, 0x4(%r14)
movq 0x8(%r14), %rdi
leaq 0x861a(%rip), %rsi      # 0x58449
callq 0xd6c0
movq %rax, %r15
testq %rax, %rax
jne 0x4fe90
leaq 0xb575(%rip), %rdx      # 0x5b3b8
leaq 0xc(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x481, %ecx            # imm = 0x481
callq 0x39dd8
movq 0x3418c(%rip), %rdi     # 0x83fe8
leaq 0xd013(%rip), %rsi      # 0x5ce76
callq 0xd550
addq $0x8, %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0xd4e0
leaq 0xd011(%rip), %rsi      # 0x5ce8f
movq %rax, %rdi
callq 0xd550
leaq 0xc(%rsp), %rdi
callq 0x39e9c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x39ff5
movq %r15, %rdi
callq 0xd560
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x39e9c
movq %rbx, %rdi
callq 0xdaa0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq $0x2c
popq %rsi
callq 0xd1f0
testq %rax, %rax
je 0x4ffad
movq %rax, %rbx
movsbl 0x1(%rbx), %edi
incq %rbx
callq 0x4ffb4
testb %al, %al
jne 0x4ff9b
jmp 0x4ffaf
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %edi, %ebx
callq 0xd060
movq %rax, %r14
movl (%rax), %ebp
movl %ebx, %edi
callq 0xda90
movl %ebp, (%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xd960
testq %rax, %rax
je 0x5134c
movq %rax, %rdi
callq 0x513de
movq %rax, %rbx
jmp 0x513b9
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 0x513b9
movl %eax, %ebp
leaq 0xbbec(%rip), %rdx      # 0x5cf5d
leaq 0xc(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x726, %ecx            # imm = 0x726
callq 0x39dd8
movq 0x32c5e(%rip), %rdi     # 0x83fe8
leaq 0xbe9c(%rip), %rsi      # 0x5d22d
callq 0xd550
leaq 0xbc56(%rip), %rsi      # 0x5cff3
movq %rax, %rdi
callq 0xd550
movq %rax, %rdi
movl %ebp, %esi
callq 0xda80
leaq 0xc(%rsp), %rdi
callq 0x39e9c
addq $0x8, %rbx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x39e9c
movq %rbx, %rdi
callq 0xdaa0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5143e
leaq 0x325de(%rip), %rsi     # 0x839d0
leaq 0x325e7(%rip), %rdx     # 0x839e0
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xd650
testq %rax, %rax
jne 0x5143e
leaq 0xbb4e(%rip), %rdx      # 0x5cf5d
leaq 0xc(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x495, %ecx            # imm = 0x495
callq 0x39dd8
movq 0x32bc0(%rip), %rdi     # 0x83fe8
leaq 0xbe25(%rip), %rsi      # 0x5d254
callq 0xd550
leaq 0xc(%rsp), %rdi
callq 0x39e9c
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x39e9c
movq %rbx, %rdi
callq 0xdaa0
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/test/googletest/googletest/src/gtest-internal-inl.h
// Function: testing::internal::StreamingListener::OnTestPartResult(testing::TestPartResult const&)
void OnTestPartResult(const TestPartResult& test_part_result) override {
    const char* file_name = test_part_result.file_name();
    if (file_name == nullptr) file_name = "";
    SendLn("event=TestPartResult&file=" + UrlEncode(file_name) +
           "&line=" + StreamableToString(test_part_result.line_number()) +
           "&message=" + UrlEncode(test_part_result.message()));
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x517fd
movq 0x8(%r14), %rax
testq %rax, %rax
leaq 0x7863(%rip), %rsi      # 0x5906a
cmovneq %rax, %rsi
leaq 0xf0(%rsp), %r15
movq %r15, %rdi
callq 0x4828c
leaq 0xbc08(%rip), %rsi      # 0x5d42a
leaq 0x50(%rsp), %rdi
movq %r15, %rdx
callq 0x4c2c8
leaq 0xbc0f(%rip), %rdx      # 0x5d445
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x4c05c
movl 0x28(%r14), %eax
leaq 0xc(%rsp), %rsi
movl %eax, (%rsi)
leaq 0x30(%rsp), %rdi
callq 0x4c0e2
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x4c07b
leaq 0xbbd4(%rip), %rdx      # 0x5d44c
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x4c05c
movq 0x50(%r14), %rsi
leaq 0x10(%rsp), %rdi
callq 0x4828c
leaq 0xd0(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x4c07b
leaq 0xd0(%rsp), %rsi
movq %rbx, %rdi
callq 0x5203e
leaq 0xd0(%rsp), %rdi
callq 0xdbe8
leaq 0x10(%rsp), %rdi
callq 0xdbe8
leaq 0xb0(%rsp), %rdi
callq 0xdbe8
leaq 0x90(%rsp), %rdi
callq 0xdbe8
leaq 0x30(%rsp), %rdi
callq 0xdbe8
leaq 0x70(%rsp), %rdi
callq 0xdbe8
leaq 0x50(%rsp), %rdi
callq 0xdbe8
leaq 0xf0(%rsp), %rdi
callq 0xdbe8
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0xdbe8
jmp 0x51943
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xdbe8
jmp 0x51952
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0xdbe8
jmp 0x51964
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0xdbe8
jmp 0x51976
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xdbe8
leaq 0x70(%rsp), %rdi
callq 0xdbe8
leaq 0x50(%rsp), %rdi
callq 0xdbe8
leaq 0xf0(%rsp), %rdi
callq 0xdbe8
movq %rbx, %rdi
callq 0xdaa0
movq %rax, %rbx
jmp 0x51980
movq %rax, %rbx
jmp 0x5198a
movq %rax, %rbx
jmp 0x51994
// File: /workspace/github_cpp_makefile_star2_O2/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
movl 0x8(%rdi), %edi
cmpl $-0x1, %edi
jne 0x51f2c
leaq 0xb1ff(%rip), %rdx      # 0x5d0ea
leaq 0x4(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x445, %ecx            # imm = 0x445
callq 0x39dd8
movq 0x320e4(%rip), %rdi     # 0x83fe8
leaq 0xb3d0(%rip), %rsi      # 0x5d2db
callq 0xd550
leaq 0xb3e5(%rip), %rsi      # 0x5d2fc
movq %rax, %rdi
callq 0xd550
leaq 0x4(%rsp), %rdi
callq 0x39e9c
movl 0x8(%rbx), %edi
movq (%r14), %rsi
movq 0x8(%r14), %r14
movq %r14, %rdx
callq 0xd1d0
cmpq %r14, %rax
je 0x51f9c
leaq 0xb1a3(%rip), %rdx      # 0x5d0ea
movq %rsp, %rdi
pushq $0x1
popq %rsi
movl $0x44a, %ecx            # imm = 0x44A
callq 0x39dd8
movq 0x3208a(%rip), %rdi     # 0x83fe8
leaq 0xb3cd(%rip), %rsi      # 0x5d332
callq 0xd550
leaq 0x10(%rbx), %rsi
movq %rax, %rdi
callq 0xd4e0
leaq 0x5d73(%rip), %rsi      # 0x57cf0
movq %rax, %rdi
callq 0xd550
addq $0x30, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0xd4e0
movq %rsp, %rdi
callq 0x39e9c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x4(%rsp), %rdi
jmp 0x51fb4
movq %rax, %rbx
movq %rsp, %rdi
callq 0x39e9c
movq %rbx, %rdi
callq 0xdaa0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movl 0x8(%rdi), %edi
cmpl $-0x1, %edi
jne 0x5201a
leaq 0xb111(%rip), %rdx      # 0x5d0ea
leaq 0xc(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x455, %ecx            # imm = 0x455
callq 0x39dd8
movq 0x31ff6(%rip), %rdi     # 0x83fe8
leaq 0xb2e2(%rip), %rsi      # 0x5d2db
callq 0xd550
leaq 0xb354(%rip), %rsi      # 0x5d359
movq %rax, %rdi
callq 0xd550
leaq 0xc(%rsp), %rdi
callq 0x39e9c
movl 0x8(%rbx), %edi
callq 0xdba0
orl $-0x1, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x39e9c
movq %rbx, %rdi
callq 0xdaa0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
testq %rdi, %rdi
je 0x521db
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x52206
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3add2
leaq 0x8(%rsp), %rdi
callq 0xd0c0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x5b10(%rip), %rsi      # 0x57cf2
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0xd550
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xd0c0
movq %rbx, %rdi
callq 0xdaa0
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/test/googletest/googletest/src/gtest-internal-inl.h
// Function: testing::internal::GTestFlagSaver::~GTestFlagSaver()
~GTestFlagSaver() {
    GTEST_FLAG_SET(also_run_disabled_tests, also_run_disabled_tests_);
    GTEST_FLAG_SET(break_on_failure, break_on_failure_);
    GTEST_FLAG_SET(catch_exceptions, catch_exceptions_);
    GTEST_FLAG_SET(color, color_);
    GTEST_FLAG_SET(death_test_style, death_test_style_);
    GTEST_FLAG_SET(death_test_use_fork, death_test_use_fork_);
    GTEST_FLAG_SET(filter, filter_);
    GTEST_FLAG_SET(fail_fast, fail_fast_);
    GTEST_FLAG_SET(internal_run_death_test, internal_run_death_test_);
    GTEST_FLAG_SET(list_tests, list_tests_);
    GTEST_FLAG_SET(output, output_);
    GTEST_FLAG_SET(brief, brief_);
    GTEST_FLAG_SET(print_time, print_time_);
    GTEST_FLAG_SET(print_utf8, print_utf8_);
    GTEST_FLAG_SET(random_seed, random_seed_);
    GTEST_FLAG_SET(repeat, repeat_);
    GTEST_FLAG_SET(recreate_environments_when_repeating,
                   recreate_environments_when_repeating_);
    GTEST_FLAG_SET(shuffle, shuffle_);
    GTEST_FLAG_SET(stack_trace_depth, stack_trace_depth_);
    GTEST_FLAG_SET(stream_result_to, stream_result_to_);
    GTEST_FLAG_SET(throw_on_failure, throw_on_failure_);
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movb (%rdi), %al
movb %al, 0x305f7(%rip)      # 0x848e3
movb 0x1(%rdi), %al
movb %al, 0x305ef(%rip)      # 0x848e4
movb 0x2(%rdi), %al
movb %al, 0x305e7(%rip)      # 0x848e5
leaq 0x8(%rdi), %rsi
leaq 0x305df(%rip), %rdi     # 0x848e8
movq %rsi, (%rsp)
callq 0xd2e0
leaq 0x28(%r15), %r14
leaq 0x3053b(%rip), %rdi     # 0x84858
movq %r14, %rsi
callq 0xd2e0
movb 0x48(%r15), %al
movb %al, 0x30549(%rip)      # 0x84878
leaq 0x50(%r15), %r12
leaq 0x305ce(%rip), %rdi     # 0x84908
movq %r12, %rsi
callq 0xd2e0
movb 0x49(%r15), %al
movb %al, 0x30596(%rip)      # 0x848e2
leaq 0x70(%r15), %r13
leaq 0x30529(%rip), %rdi     # 0x84880
movq %r13, %rsi
callq 0xd2e0
movb 0x90(%r15), %al
movb %al, 0x305bd(%rip)      # 0x84929
leaq 0x98(%r15), %rbp
leaq 0x305b6(%rip), %rdi     # 0x84930
movq %rbp, %rsi
callq 0xd2e0
movb 0xb8(%r15), %al
movb %al, 0x305c1(%rip)      # 0x84950
movb 0xb9(%r15), %al
movb %al, 0x305b5(%rip)      # 0x84951
movb 0xba(%r15), %al
movb %al, 0x30537(%rip)      # 0x848e0
movl 0xbc(%r15), %eax
movl %eax, 0x3059e(%rip)     # 0x84954
movl 0xc0(%r15), %eax
movl %eax, 0x30595(%rip)     # 0x84958
movb 0xc4(%r15), %al
movb %al, 0x3058c(%rip)      # 0x8495c
movb 0xc5(%r15), %al
movb %al, 0x30581(%rip)      # 0x8495e
movl 0xc8(%r15), %eax
movl %eax, 0x30576(%rip)     # 0x84960
leaq 0xd0(%r15), %rbx
leaq 0x30570(%rip), %rdi     # 0x84968
movq %rbx, %rsi
callq 0xd2e0
movb 0xf0(%r15), %al
movb %al, 0x3057b(%rip)      # 0x84988
movq %rbx, %rdi
callq 0xdbe8
movq %rbp, %rdi
callq 0xdbe8
movq %r13, %rdi
callq 0xdbe8
movq %r12, %rdi
callq 0xdbe8
movq %r14, %rdi
callq 0xdbe8
movq (%rsp), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xdbe8
movq %rax, %rdi
callq 0x135af
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movq 0x276d(%rip), %rbx      # 0x3fd8
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x1090
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rax,%rcx)
movl %ebp, %r12d
xorl %r13d, %r13d
leaq 0x854(%rip), %r15       # 0x20ec
cmpq %r13, %r12
je 0x18ba
movzbl (%r14,%r13), %esi
movq %rbx, %rdi
callq 0x1060
movq %rax, %rdi
movq %r15, %rsi
callq 0x1090
incq %r13
jmp 0x1898
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ecx
andl $-0x4b, %ecx
orl $0x2, %ecx
movl %ecx, 0x18(%rbx,%rax)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1050
// File: /workspace/github_cpp_makefile_star2_O2/ekg[P]sgd2/src/sgd2.hpp
// Function: sgd2::build_graph_unweighted(unsigned long, unsigned long, unsigned long*, unsigned long*)
std::vector<std::vector<uint64_t>> build_graph_unweighted(uint64_t n, uint64_t m, uint64_t* I, uint64_t* J)
{
    // used to make graph undirected, in case it is not already
    std::vector<std::unordered_set<uint64_t>> undirected(n);
    std::vector<std::vector<uint64_t>> graph(n);

    for (uint64_t ij=0; ij<m; ij++)
    {
        uint64_t i = I[ij], j = J[ij];
        if (i >= n || j >= n)
            throw "i or j bigger than n";

        if (i != j && undirected[j].find(i) == undirected[j].end()) // if edge not seen
        {
            undirected[i].insert(j);
            undirected[j].insert(i);
            graph[i].push_back(j);
            graph[j].push_back(i);
        }
    }
    return graph;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
leaq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x5d6a
leaq -0x30(%rbp), %rdx
movq %rbx, -0x38(%rbp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x5dbc
xorl %ebx, %ebx
cmpq %rbx, %r12
je 0x2606
movq (%r15,%rbx,8), %rcx
movq %rcx, -0x30(%rbp)
movq (%r14,%rbx,8), %rax
movq %rax, -0x40(%rbp)
cmpq %r13, %rcx
jae 0x2622
cmpq %r13, %rax
jae 0x2622
cmpq %rax, %rcx
je 0x25fe
imulq $0x38, %rax, %rdi
addq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x7260
testq %rax, %rax
jne 0x25fe
imulq $0x38, -0x30(%rbp), %rdi
addq -0x58(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x72ea
imulq $0x38, -0x40(%rbp), %rdi
addq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x72ea
imulq $0x18, -0x30(%rbp), %rdi
movq -0x38(%rbp), %rax
addq (%rax), %rdi
leaq -0x40(%rbp), %rsi
callq 0x5e0e
imulq $0x18, -0x40(%rbp), %rdi
movq -0x38(%rbp), %rax
addq (%rax), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5e0e
incq %rbx
jmp 0x256a
leaq -0x58(%rbp), %rdi
callq 0x5e62
movq -0x38(%rbp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x2090
leaq 0x8a7b(%rip), %rcx      # 0xb0ac
movq %rcx, (%rax)
movq 0xe985(%rip), %rsi      # 0x10fc0
movq %rax, %rdi
xorl %edx, %edx
callq 0x2200
movq %rax, %rbx
jmp 0x265a
jmp 0x264e
jmp 0x264e
movq %rax, %rbx
movq -0x38(%rbp), %rdi
callq 0x5e36
leaq -0x58(%rbp), %rdi
callq 0x5e62
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O2/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
addq $0x38, %rax
pushq $0x1
popq %rdx
movapd %xmm1, %xmm2
cmpq %rcx, %rdx
jae 0x2e2d
movsd (%rax), %xmm3
movapd %xmm3, %xmm4
minsd %xmm2, %xmm4
maxsd %xmm1, %xmm3
incq %rdx
addq $0x20, %rax
movapd %xmm3, %xmm1
movapd %xmm4, %xmm2
jmp 0x2e07
movsd 0x81d3(%rip), %xmm3     # 0xb008
divsd %xmm2, %xmm3
divsd %xmm1, %xmm0
movsd %xmm3, -0x38(%rbp)
movapd %xmm3, %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x2100
movapd %xmm0, -0x30(%rbp)
xorpd %xmm0, %xmm0
movupd %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x61fc
movq %r14, %xmm0
punpckldq 0x81e3(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x81eb(%rip), %xmm0     # 0xb070
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
addsd 0x8187(%rip), %xmm1     # 0xb020
movapd -0x30(%rbp), %xmm2
xorpd 0x81ea(%rip), %xmm2     # 0xb090
divsd %xmm1, %xmm2
xorl %r12d, %r12d
leaq -0x40(%rbp), %r15
movapd %xmm2, -0x30(%rbp)
cmpq %r12, %r14
je 0x2f04
movq %r12, %xmm1
punpckldq 0x8198(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x81a0(%rip), %xmm1     # 0xb070
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
mulsd %xmm2, %xmm0
callq 0x2220
mulsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8c50
incq %r12
movapd -0x30(%rbp), %xmm2
jmp 0x2eb6
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2f16
movq %rax, %r14
movq %rbx, %rdi
callq 0x89de
movq %r14, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O2/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, -0x18(%rbp)
movq %r9, %r14
movq %rsi, %rbx
movq %rdi, %rsi
leaq -0x30(%rbp), %rdi
callq 0x266b
leaq -0x48(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movq %r14, %rdx
movsd -0x18(%rbp), %xmm0
callq 0x2dd4
leaq -0x30(%rbp), %rsi
leaq -0x48(%rbp), %rdx
xorps %xmm0, %xmm0
movq %rbx, %rdi
callq 0x237c
leaq -0x48(%rbp), %rdi
callq 0x89de
leaq -0x30(%rbp), %rdi
callq 0x77d2
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rdx, %r14
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x89de
jmp 0x31b1
movq %rdx, %r14
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x77d2
jmp 0x31c2
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x3208
movq %rbx, %rdi
callq 0x2050
movq %rax, %rbx
movq 0xde16(%rip), %rdi      # 0x10ff0
leaq 0x7f4b(%rip), %rsi      # 0xb12c
callq 0x2140
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2140
movq %rax, %rdi
callq 0x2080
callq 0x21e0
jmp 0x3191
movq %rax, %rbx
callq 0x21e0
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O2/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, -0x18(%rbp)
movq %rsi, %rbx
movq %rdi, %rsi
leaq -0x30(%rbp), %rdi
callq 0x2b10
movq 0x10(%rbp), %rdx
leaq -0x48(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movsd -0x18(%rbp), %xmm0
callq 0x2dd4
leaq -0x30(%rbp), %rsi
leaq -0x48(%rbp), %rdx
xorps %xmm0, %xmm0
movq %rbx, %rdi
callq 0x237c
leaq -0x48(%rbp), %rdi
callq 0x89de
leaq -0x30(%rbp), %rdi
callq 0x77d2
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rdx, %r14
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x89de
jmp 0x328a
movq %rdx, %r14
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x77d2
jmp 0x329b
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x32e1
movq %rbx, %rdi
callq 0x2050
movq %rax, %rbx
movq 0xdd3d(%rip), %rdi      # 0x10ff0
leaq 0x7e72(%rip), %rsi      # 0xb12c
callq 0x2140
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2140
movq %rax, %rdi
callq 0x2080
callq 0x21e0
jmp 0x326a
movq %rax, %rbx
callq 0x21e0
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O2/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, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movq %r9, %r14
movq %rsi, %rbx
movq %rdi, %rsi
leaq -0x38(%rbp), %rdi
callq 0x266b
movq 0x10(%rbp), %rcx
leaq -0x50(%rbp), %rdi
leaq -0x38(%rbp), %rsi
movq %r14, %rdx
movsd -0x20(%rbp), %xmm0
callq 0x2f29
leaq -0x38(%rbp), %rsi
leaq -0x50(%rbp), %rdx
movq %rbx, %rdi
movsd -0x18(%rbp), %xmm0
callq 0x237c
leaq -0x50(%rbp), %rdi
callq 0x89de
leaq -0x38(%rbp), %rdi
callq 0x77d2
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rdx, %r14
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x89de
jmp 0x3370
movq %rdx, %r14
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x77d2
jmp 0x3381
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x33c7
movq %rbx, %rdi
callq 0x2050
movq %rax, %rbx
movq 0xdc57(%rip), %rdi      # 0x10ff0
leaq 0x7d8c(%rip), %rsi      # 0xb12c
callq 0x2140
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2140
movq %rax, %rdi
callq 0x2080
callq 0x21e0
jmp 0x3350
movq %rax, %rbx
callq 0x21e0
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O2/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, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movq %rsi, %rbx
movq %rdi, %rsi
leaq -0x38(%rbp), %rdi
callq 0x2b10
movq 0x18(%rbp), %rcx
movq 0x10(%rbp), %rdx
leaq -0x50(%rbp), %rdi
leaq -0x38(%rbp), %rsi
movsd -0x20(%rbp), %xmm0
callq 0x2f29
leaq -0x38(%rbp), %rsi
leaq -0x50(%rbp), %rdx
movq %rbx, %rdi
movsd -0x18(%rbp), %xmm0
callq 0x237c
leaq -0x50(%rbp), %rdi
callq 0x89de
leaq -0x38(%rbp), %rdi
callq 0x77d2
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rdx, %r14
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x89de
jmp 0x3454
movq %rdx, %r14
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x77d2
jmp 0x3465
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x34ab
movq %rbx, %rdi
callq 0x2050
movq %rax, %rbx
movq 0xdb73(%rip), %rdi      # 0x10ff0
leaq 0x7ca8(%rip), %rsi      # 0xb12c
callq 0x2140
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2140
movq %rax, %rdi
callq 0x2080
callq 0x21e0
jmp 0x3434
movq %rax, %rbx
callq 0x21e0
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x68, %rsp
movq %r9, -0x60(%rbp)
movq %r8, -0x68(%rbp)
movq %rcx, -0x78(%rbp)
movq %rdx, %r13
movq %rsi, -0x58(%rbp)
movq %rdi, %rbx
leaq -0x1(%rdi), %rsi
imulq %rdi, %rsi
shrq %rsi
xorps %xmm0, %xmm0
leaq -0x90(%rbp), %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
callq 0x5e8e
xorl %r14d, %r14d
xorl %r15d, %r15d
cmpq %rbx, %r15
je 0x3555
leaq 0x1(%r15), %r12
movq %r12, -0x70(%rbp)
cmpq %rbx, %r12
jae 0x354f
movsd (%r13,%r14,8), %xmm0
movq -0x78(%rbp), %rax
movsd (%rax,%r14,8), %xmm1
movq %r15, -0x50(%rbp)
movq %r12, -0x48(%rbp)
movsd %xmm0, -0x40(%rbp)
movsd %xmm1, -0x38(%rbp)
leaq -0x90(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x7d9c
incq %r14
incq %r12
jmp 0x350f
movq -0x70(%rbp), %r15
jmp 0x3502
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq -0x68(%rbp), %r15
movq %r15, %rsi
callq 0x61fc
leaq -0x50(%rbp), %rbx
movq -0x60(%rbp), %r14
subq $0x1, %r15
jb 0x358f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6292
addq $0x8, %r14
jmp 0x3578
leaq -0x90(%rbp), %rsi
leaq -0x50(%rbp), %rdx
xorps %xmm0, %xmm0
movq -0x58(%rbp), %rdi
callq 0x237c
leaq -0x50(%rbp), %rdi
callq 0x89de
leaq -0x90(%rbp), %rdi
callq 0x77d2
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x35dc
jmp 0x35ce
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x89de
jmp 0x35df
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0x77d2
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O2/ekg[P]sgd2/src/sgd2.hpp
// Function: sgd2::maxmin_bfs_unweighted(std::vector<std::vector<unsigned long, std::allocator<unsigned long>>, std::allocator<std::vector<unsigned long, std::allocator<unsigned long>>>> const&, unsigned long, std::vector<unsigned long, std::allocator<unsigned long>>&, std::vector<unsigned long, std::allocator<unsigned long>>&)
void maxmin_bfs_unweighted(const std::vector<std::vector<uint64_t>>& graph, const uint64_t p, std::vector<uint64_t>& mins, std::vector<uint64_t>& argmins)
{
    uint64_t n = graph.size();
    std::queue<uint64_t> q;
    std::vector<uint64_t> d(n, -1);

    q.push(p);
    d[p] = 0;
    while (!q.empty())
    {
        uint64_t current = q.front();
        q.pop();
        for (uint64_t next : graph[current])
        {
            if (d[next] == -1)
            {
                q.push(next);
                d[next] = d[current] + 1;
                if (d[next] < mins[next])
                {
                    mins[next] = d[next];
                    argmins[next] = p;
                }
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, -0x50(%rbp)
movq %rdx, %r14
movq %rsi, -0x40(%rbp)
movq 0x8(%rdi), %rax
movq %rdi, -0x48(%rbp)
subq (%rdi), %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
movq %rax, %r12
leaq -0xb8(%rbp), %rdi
callq 0x5fa8
leaq -0x38(%rbp), %rdx
orq $-0x1, (%rdx)
leaq -0x68(%rbp), %rdi
leaq -0x29(%rbp), %rcx
movq %r12, %rsi
callq 0x5f48
leaq -0xb8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x7ad8
movq -0x40(%rbp), %rax
movq -0x68(%rbp), %rcx
andq $0x0, (%rcx,%rax,8)
leaq -0xb8(%rbp), %r12
movq -0xa8(%rbp), %rax
cmpq %rax, -0x88(%rbp)
je 0x3afd
movq (%rax), %r15
movq %r12, %rdi
callq 0x7d34
movq -0x48(%rbp), %rax
movq (%rax), %rax
imulq $0x18, %r15, %rcx
movq (%rax,%rcx), %rbx
movq 0x8(%rax,%rcx), %r13
cmpq %r13, %rbx
je 0x3a66
movq (%rbx), %rax
movq %rax, -0x38(%rbp)
movq -0x68(%rbp), %rcx
cmpq $-0x1, (%rcx,%rax,8)
jne 0x3af7
movq %r12, %rdi
leaq -0x38(%rbp), %rsi
callq 0x7ad8
movq -0x68(%rbp), %rcx
movq (%rcx,%r15,8), %rax
incq %rax
movq -0x38(%rbp), %rdx
movq %rax, (%rcx,%rdx,8)
movq -0x38(%rbp), %rax
movq (%rcx,%rax,8), %rcx
movq (%r14), %rdx
cmpq (%rdx,%rax,8), %rcx
jae 0x3af7
movq %rcx, (%rdx,%rax,8)
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
movq -0x50(%rbp), %rdx
movq (%rdx), %rdx
movq %rax, (%rdx,%rcx,8)
addq $0x8, %rbx
jmp 0x3a99
leaq -0x68(%rbp), %rdi
callq 0x7894
leaq -0xb8(%rbp), %rdi
callq 0x66ee
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3b2b
movq %rax, %rbx
jmp 0x3b37
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x7894
leaq -0xb8(%rbp), %rdi
callq 0x66ee
movq %rbx, %rdi
callq 0x2210