LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::UnitTestImpl::UnshuffleTests()
void UnitTestImpl::UnshuffleTests() {
  for (size_t i = 0; i < test_suites_.size(); i++) {
    // Unshuffles the tests in each test suite.
    test_suites_[i]->UnshuffleTests();
    // Resets the index of each test suite.
    test_suite_indices_[i] = static_cast<int>(i);
  }
}

// Assembly:
movq 0xb8(%rdi), %rax
movq 0xc0(%rdi), %rcx
subq %rax, %rcx
je 0x5eb57
sarq $0x3, %rcx
movq 0xd0(%rdi), %rdx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %esi, %esi
movdqa 0x1236e(%rip), %xmm0    # 0x70e00
movdqa 0x12376(%rip), %xmm1    # 0x70e10
pcmpeqd %xmm2, %xmm2
movdqa 0x1237a(%rip), %xmm3    # 0x70e20
movq (%rax,%rsi,8), %r8
movq 0x48(%r8), %rdi
movq 0x50(%r8), %r9
subq %rdi, %r9
je 0x5eb48
sarq $0x2, %r9
cmpq $0x1, %r9
adcq $0x0, %r9
leaq 0x1(%r9), %r8
andq $-0x2, %r8
decq %r9
movq %r9, %xmm4
pshufd $0x44, %xmm4, %xmm4     # xmm4 = xmm4[0,1,0,1]
pxor %xmm1, %xmm4
xorl %r9d, %r9d
movdqa %xmm0, %xmm5
movdqa %xmm5, %xmm6
pxor %xmm1, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm4, %xmm7
pcmpeqd %xmm4, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %r10d
notl %r10d
testb $0x1, %r10b
je 0x5eb22
movl %r9d, (%rdi,%r9,4)
pxor %xmm2, %xmm6
pextrw $0x4, %xmm6, %r10d
testb $0x1, %r10b
je 0x5eb3b
leal 0x1(%r9), %r10d
movl %r10d, 0x4(%rdi,%r9,4)
addq $0x2, %r9
paddq %xmm3, %xmm5
cmpq %r9, %r8
jne 0x5eae7
movl %esi, (%rdx,%rsi,4)
incq %rsi
cmpq %rcx, %rsi
jne 0x5eaa6
retq
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::PrintOnOneLine(char const*, int)
static void PrintOnOneLine(const char* str, int max_length) {
  if (str != nullptr) {
    for (int i = 0; *str != '\0'; ++str) {
      if (i >= max_length) {
        printf("...");
        break;
      }
      if (*str == '\n') {
        printf("\\n");
        i += 2;
      } else {
        printf("%c", *str);
        ++i;
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x5ebb6
movq %rdi, %rbx
movb (%rdi), %al
testb %al, %al
je 0x5ebb6
incq %rbx
leaq 0x13a71(%rip), %r14     # 0x725f0
xorl %ebp, %ebp
cmpl $0xfa, %ebp
jae 0x5ebbb
cmpb $0xa, %al
jne 0x5eb9e
movq %r14, %rdi
xorl %eax, %eax
callq 0xd080
movl $0x2, %eax
jmp 0x5ebab
movsbl %al, %edi
callq 0xd830
movl $0x1, %eax
addl %eax, %ebp
movb (%rbx), %al
incq %rbx
testb %al, %al
jne 0x5eb81
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x13ba2(%rip), %rdi     # 0x72764
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0xd080
nop
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::ParseFlag(char const*, char const*, int*)
bool ParseFlag(const char* str, const char* flag_name, int32_t* 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.
  return ParseInt32(Message() << "The value of flag --" << flag_name, value_str,
                    value);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
xorl %ebp, %ebp
xorl %edx, %edx
callq 0x5ed25
testq %rax, %rax
je 0x5ecfb
movq %rax, %r15
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x4ca86
movq (%rbx), %rbx
leaq 0x10(%rbx), %r13
leaq 0x13d7f(%rip), %rsi     # 0x72a26
movl $0x14, %edx
movq %r13, %rdi
callq 0xd600
testq %r12, %r12
je 0x5ecc6
movq %r12, %rdi
callq 0xd210
movq %rax, %rdx
jmp 0x5ecd2
movl $0x6, %edx
leaq 0x12fd7(%rip), %r12     # 0x71ca9
movq %r13, %rdi
movq %r12, %rsi
callq 0xd600
movq %rsp, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x47499
movl %eax, %ebp
testq %rbx, %rbx
je 0x5ecfb
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
testq %rbx, %rbx
je 0x5ed1d
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %r14, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::GetDirFromEnv[abi:cxx11](std::initializer_list<char const*>, char const*, char)
static std::string GetDirFromEnv(
    std::initializer_list<const char*> environment_variables,
    const char* fallback, char separator) {
  for (const char* variable_name : environment_variables) {
    const char* value = internal::posix::GetEnv(variable_name);
    if (value != nullptr && value[0] != '\0') {
      if (value[strlen(value) - 1] != separator) {
        return std::string(value).append(1, separator);
      }
      return value;
    }
  }
  return fallback;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r15
movq %rdi, %rbx
testq %rdx, %rdx
je 0x5efaa
movq %rdx, %r12
movq %rsi, %r13
shlq $0x3, %r12
xorl %ebp, %ebp
movq (%r13,%rbp), %rdi
callq 0xd6d0
testq %rax, %rax
je 0x5efa1
movq %rax, %r14
cmpb $0x0, (%rax)
jne 0x5efc9
addq $0x8, %rbp
cmpq %rbp, %r12
jne 0x5ef8a
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2008e
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0xd210
cmpb $0x2f, -0x1(%r14,%rax)
jne 0x5f007
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0xd210
movq %r14, %rdx
addq %rax, %rdx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1558a
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq %r14, %rdi
callq 0xd210
movq %r14, %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1558a
movq 0x8(%r15), %rsi
movl $0x1, %ecx
movq %r15, %rdi
xorl %edx, %edx
movl $0x2f, %r8d
callq 0xdb10
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x152da
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x5efba
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
jmp 0x5efba
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x5f09b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::SrcDir[abi:cxx11]()
std::string SrcDir() {
#if defined(GTEST_CUSTOM_SRCDIR_FUNCTION_)
  return GTEST_CUSTOM_SRCDIR_FUNCTION_();
#elif defined(GTEST_OS_WINDOWS) || defined(GTEST_OS_WINDOWS_MOBILE)
  return GetDirFromEnv({"TEST_SRCDIR"}, GetCurrentExecutableDirectory().c_str(),
                       '\\');
#elif defined(GTEST_OS_LINUX_ANDROID)
  return GetDirFromEnv({"TEST_SRCDIR"}, GetCurrentExecutableDirectory().c_str(),
                       '/');
#else
  return GetDirFromEnv({"TEST_SRCDIR"}, GetCurrentExecutableDirectory().c_str(),
                       '/');
#endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
leaq 0x1399d(%rip), %rax     # 0x72a53
movq %rax, 0x48(%rsp)
leaq 0x358be(%rip), %rsi     # 0x94980
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x3e1ee
movq (%r14), %rax
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x152da
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rdx
movq %rax, %rcx
testq %rdx, %rdx
je 0x5f13d
movq %rax, %rsi
movb (%rsi), %dil
cmpb $0x2f, %dil
setne %r8b
cmpq %rax, %rcx
sete %r9b
orb %r8b, %r9b
jne 0x5f121
cmpb $0x2f, -0x1(%rcx)
je 0x5f131
movb %dil, (%rcx)
incq %rcx
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rdx
incq %rsi
leaq (%rax,%rdx), %rdi
cmpq %rdi, %rsi
jne 0x5f104
movq %rcx, %rdx
subq %rax, %rdx
leaq 0x8(%rsp), %r14
movq %rdx, 0x8(%r14)
movb $0x0, (%rcx)
leaq 0x28(%rsp), %rdi
callq 0x20770
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x44aa6
leaq 0x60(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
addq %rsi, %rdx
leaq 0x50(%rsp), %rdi
callq 0x152da
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5f1a1
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xd530
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x5f1b8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
movq 0x50(%rsp), %rcx
leaq 0x48(%rsp), %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x5ef65
movq 0x50(%rsp), %rdi
cmpq %r14, %rdi
je 0x5f1e6
movq 0x60(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x50(%rsp), %rdi
cmpq %r14, %rdi
je 0x5f250
movq 0x60(%rsp), %rsi
jmp 0x5f239
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5f22a
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xd530
jmp 0x5f22a
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x5f250
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
jmp 0x5f250
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20770
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/googletest/googletest/src/gtest-printers.cc
// Function: testing::internal::PrintAsStringLiteralTo(char32_t, std::ostream*)
static CharFormat PrintAsStringLiteralTo(char32_t c, ostream* os) {
  switch (c) {
    case L'\'':
      *os << "'";
      return kAsIs;
    case L'"':
      *os << "\\\"";
      return kSpecialEscape;
    default:
      return PrintAsCharLiteralTo(c, os);
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movl %edi, %r14d
cmpl $0x21, %edi
jg 0x5fef8
cmpl $0xd, %r14d
ja 0x5ff7d
movl %r14d, %eax
leaq 0xfe52(%rip), %rcx      # 0x6fd38
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x11dcb(%rip), %rsi     # 0x71cc1
jmp 0x5ff62
cmpl $0x22, %r14d
je 0x5ff52
cmpl $0x5c, %r14d
je 0x5ff5b
cmpl $0x27, %r14d
jne 0x5ff7d
leaq 0x11959(%rip), %rsi     # 0x7186a
jmp 0x5ff8e
leaq 0x126d6(%rip), %rsi     # 0x725f0
jmp 0x5ff62
leaq 0x126d0(%rip), %rsi     # 0x725f3
jmp 0x5ff62
leaq 0x126be(%rip), %rsi     # 0x725ea
jmp 0x5ff62
leaq 0x13691(%rip), %rsi     # 0x735c6
jmp 0x5ff62
leaq 0x126af(%rip), %rsi     # 0x725ed
jmp 0x5ff62
leaq 0x126af(%rip), %rsi     # 0x725f6
jmp 0x5ff62
leaq 0x13679(%rip), %rsi     # 0x735c9
jmp 0x5ff62
leaq 0x1369d(%rip), %rsi     # 0x735f6
jmp 0x5ff62
leaq 0x13661(%rip), %rsi     # 0x735c3
movl $0x2, %edx
movq %rbx, %rdi
callq 0xd600
movl $0x2, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leal -0x20(%r14), %eax
cmpl $0x5e, %eax
ja 0x5ff9f
leaq 0xf(%rsp), %rsi
movb %r14b, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0xd600
xorl %eax, %eax
jmp 0x5ff74
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ebp
leaq 0x1361b(%rip), %rsi     # 0x735cc
movl $0x2, %edx
movq %rbx, %rdi
callq 0xd600
movq (%rbx), %rax
movq -0x18(%rax), %rcx
movl 0x18(%rbx,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rbx,%rcx)
movq -0x18(%rax), %rax
orl $0x4000, 0x18(%rbx,%rax) # imm = 0x4000
movq %rbx, %rdi
movl %r14d, %esi
callq 0xda30
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl %ebp, 0x18(%rbx,%rax)
movl $0x1, %eax
jmp 0x5ff74
nop
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::(anonymous namespace)::FailureTest::TestBody()
void TestBody() override {
    if (as_error_) {
      AssertHelper(TestPartResult::kNonFatalFailure, loc_.file.c_str(),
                   loc_.line, "") = Message() << error_message_;
    } else {
      std::cout << error_message_ << std::endl;
    }
  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
cmpb $0x1, 0x58(%rdi)
jne 0x60309
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x4ca86
movq (%rbx), %rbx
leaq 0x10(%rbx), %rdi
movq 0x38(%r14), %rsi
movq 0x40(%r14), %rdx
callq 0xd600
movq 0x10(%r14), %rdx
movl 0x30(%r14), %ecx
leaq 0xed09(%rip), %r8       # 0x6efd5
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x4902a
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x46a1c
leaq 0x8(%rsp), %rdi
callq 0x49096
testq %rbx, %rbx
je 0x6034e
movq (%rbx), %rax
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
jmpq *0x8(%rax)
movq 0x38(%r14), %rsi
movq 0x40(%r14), %rdx
movq 0x33ca0(%rip), %rdi     # 0x93fb8
callq 0xd600
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xd4e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0xd050
movq %rax, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0xd350
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x49096
jmp 0x6036a
jmp 0x60367
movq %rax, %r14
testq %rbx, %rbx
je 0x60378
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %r14, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x4ca86
movq (%rbx), %rbx
leaq 0x10(%rbx), %r15
testq %r13, %r13
je 0x60542
leaq 0x13109(%rip), %rsi     # 0x7361a
movl $0x20, %edx
movq %r15, %rdi
callq 0xd600
movq %r13, %rdi
callq 0xd210
movq %r15, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0xd600
movl $0x1, %edx
leaq 0x12130(%rip), %rsi     # 0x72670
jmp 0x6054e
movl $0x15, %edx
leaq 0x130ed(%rip), %rsi     # 0x7363b
movq %r15, %rdi
callq 0xd600
leaq 0x130f4(%rip), %rsi     # 0x73651
movl $0xb, %edx
movq %r15, %rdi
callq 0xd600
testq %r12, %r12
je 0x6057c
movq %r12, %rdi
callq 0xd210
movq %rax, %rdx
jmp 0x60588
movl $0x6, %edx
leaq 0x11721(%rip), %r12     # 0x71ca9
movq %r15, %rdi
movq %r12, %rsi
callq 0xd600
leaq 0xce25(%rip), %rsi      # 0x6d3bf
movl $0x1, %edx
movq %r15, %rdi
callq 0xd600
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4ccdd
testq %rbx, %rbx
je 0x605cd
movq (%rbx), %rax
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmpq *0x8(%rax)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x605ee
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
xorl %edx, %edx
callq 0x5ed25
movq %rax, %r14
testq %rax, %rax
je 0x615ce
movq 0x8(%rbx), %r15
movq %r14, %rdi
callq 0xd210
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0xd960
testq %r14, %r14
setne %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xeb10(%rip), %r12      # 0x702f0
leaq 0xeb99(%rip), %r13      # 0x70380
leaq 0x18(%rsp), %rbx
leaq 0x11230(%rip), %r14     # 0x72a23
xorl %r15d, %r15d
movl %r15d, %ebp
movq %rbx, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x1558a
movq 0x8(%rsp), %rdx
movl %r15d, %edi
movq %r14, %rsi
xorl %eax, %eax
callq 0x520fb
movq 0x8(%rsp), %rdi
cmpq %rbx, %rdi
je 0x61837
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
movzbl 0x1(%r13), %eax
leaq 0x2(%r13), %r12
cmpl $0x46, %eax
jle 0x6185c
cmpl $0x47, %eax
je 0x61874
cmpl $0x52, %eax
je 0x6187c
cmpl $0x59, %eax
jne 0x61869
movl $0x3, %r15d
jmp 0x61897
cmpl $0x40, %eax
je 0x61884
xorl %r15d, %r15d
cmpl $0x44, %eax
je 0x61897
incq %r13
movl %ebp, %r15d
movq %r13, %r12
jmp 0x61897
movl $0x2, %r15d
jmp 0x61897
movl $0x1, %r15d
jmp 0x61897
movl %ebp, %edi
leaq 0x11f22(%rip), %rsi     # 0x737af
xorl %eax, %eax
callq 0x520fb
movl %ebp, %r15d
movq %r12, %rdi
movl $0x40, %esi
callq 0xd1e0
movq %rax, %r13
testq %rax, %rax
jne 0x617f6
leaq 0x1116c(%rip), %rsi     # 0x72a23
movl %r15d, %edi
movq %r12, %rdx
xorl %eax, %eax
callq 0x520fb
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %rbx, %rdi
je 0x618ed
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
movq %r14, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x1, %edx
callq 0x5ed25
testq %rax, %rax
je 0x6191f
movzbl (%rax), %edx
xorl %ecx, %ecx
cmpl $0x30, %edx
je 0x6191d
cmpl $0x66, %edx
je 0x6191d
cmpb $0x46, %dl
setne %cl
movb %cl, (%rbx)
testq %rax, %rax
setne %al
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x63ed0
leaq 0x10(%r12), %r13
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
callq 0x446ec
movq %r13, %rdi
movq %rbp, %rsi
callq 0xd2a0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x63e73
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
cmpq $0x0, 0x18(%r12)
jne 0x63ed0
leaq 0xf228(%rip), %rdx      # 0x730aa
leaq 0x8(%rsp), %rdi
movl $0x3, %esi
movl $0x2ad, %ecx            # imm = 0x2AD
callq 0x47006
movq 0x30153(%rip), %rdi     # 0x93ff0
leaq 0xf275(%rip), %rsi      # 0x73119
movl $0x33, %edx
callq 0xd600
movq 0x3013b(%rip), %rdi     # 0x93ff0
leaq 0xf291(%rip), %rsi      # 0x7314d
movl $0x2c, %edx
callq 0xd600
leaq 0x8(%rsp), %rdi
callq 0x47148
movq (%rbx), %rsi
movq 0x40(%rbx), %rax
testq %rax, %rax
je 0x63ee1
movq (%rax), %rdx
jmp 0x63ee3
xorl %edx, %edx
movq %r12, %rdi
movq %r15, %rcx
movq %r14, %r8
callq 0x5df26
movq %rax, %rdi
movq %rbx, %rsi
callq 0x516de
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x47148
jmp 0x63f38
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x63f38
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O3/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 0xab07(%rip), %rax      # 0x6efd5
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 0x1558a
cmpq $0x0, 0x8(%rbx)
je 0x64525
movq (%rbx), %rdi
leaq 0xe408(%rip), %rsi      # 0x72909
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_O3/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 0x64737
movq (%rbx), %rdi
callq 0xdaa0
testl %eax, %eax
je 0x64737
movl %eax, %ebp
leaq 0xcfee(%rip), %rdx      # 0x716bb
leaq 0xc(%rsp), %rdi
movl $0x2, %esi
movl $0x13d7, %ecx           # imm = 0x13D7
callq 0x47006
movq 0x2f908(%rip), %rdi     # 0x93ff0
leaq 0xeb73(%rip), %rsi      # 0x73262
movl $0x2a, %edx
callq 0xd600
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x2f8e9(%rip), %rdi     # 0x93ff0
callq 0xd600
movq %rax, %r14
leaq 0xeb77(%rip), %rsi      # 0x7328d
movl $0xd, %edx
movq %rax, %rdi
callq 0xd600
movq %r14, %rdi
movl %ebp, %esi
callq 0xda30
leaq 0xc(%rsp), %rdi
callq 0x47148
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x64756
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 0x1536f
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2f643(%rip), %rsi     # 0x94980
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x3e1ee
movq (%r15), %rbx
movq 0x8(%r15), %r12
movq %r15, %rdi
callq 0x20770
cmpq %r12, %rbx
jne 0x653f9
cmpl $0x0, (%r14)
jle 0x653f9
movq %r13, (%rsp)
movq 0x2f609(%rip), %rsi     # 0x94980
leaq 0x2f602(%rip), %rdi     # 0x94980
callq 0x6bd88
cmpl $0x0, (%r14)
je 0x653dc
leaq 0x18(%rsp), %rbp
xorl %ebx, %ebx
leaq 0x8(%rsp), %r15
leaq 0x2f5e4(%rip), %r12     # 0x94980
movq (%rsp), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x6bc8d
movq %r12, %rdi
movq %r15, %rsi
callq 0x33dd4
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x653cd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
incq %rbx
movl (%r14), %eax
addq $0x8, %r13
cmpq %rax, %rbx
jne 0x653a0
movq %r14, %rdi
movq (%rsp), %rsi
callq 0x64ffc
callq 0x490c6
movq 0x2f5ec(%rip), %rdi     # 0x949e0
callq 0x5de94
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 0x65422
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O3/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 0x65c9d
movq %rsi, %r14
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x65c85
cmpq $0x0, 0x18(%rax)
je 0x65c85
movq 0x10(%rbx), %rax
lock
decl (%rax)
jne 0x65c85
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_O3/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 0x65f5d
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 0x844c(%rip), %rsi      # 0x6e3b4
callq 0xd660
movq %rax, %r14
testq %rax, %rax
je 0x65f7d
movq %rbx, %rdi
movq %r14, %rsi
jmp 0x65fe7
leaq 0xb3f4(%rip), %rdx      # 0x71378
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x481, %ecx            # imm = 0x481
callq 0x47006
movq 0x2e051(%rip), %rdi     # 0x93ff0
leaq 0xce90(%rip), %rsi      # 0x72e36
movl $0x18, %edx
callq 0xd600
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
movq 0x2e031(%rip), %rdi     # 0x93ff0
callq 0xd600
leaq 0xce84(%rip), %rsi      # 0x72e4f
movl $0x16, %edx
movq %rax, %rdi
callq 0xd600
leaq 0xc(%rsp), %rdi
callq 0x47148
movq %rbx, %rdi
xorl %esi, %esi
callq 0x47312
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 0x47148
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O3/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 0x671ad
movq %rax, %rdi
callq 0x67253
movq %rax, %rbx
jmp 0x6722e
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 0x6722e
movl %eax, %ebp
leaq 0xbd4b(%rip), %rdx      # 0x72f1d
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x726, %ecx            # imm = 0x726
callq 0x47006
movq 0x2ce03(%rip), %rdi     # 0x93ff0
leaq 0xbff9(%rip), %rsi      # 0x731ed
movl $0x26, %edx
callq 0xd600
movq 0x2cdeb(%rip), %rdi     # 0x93ff0
leaq 0xbda7(%rip), %rsi      # 0x72fb3
movl $0x12, %edx
callq 0xd600
movq 0x2cdd3(%rip), %rdi     # 0x93ff0
movl %ebp, %esi
callq 0xda30
leaq 0xc(%rsp), %rdi
callq 0x47148
addq $0x8, %rbx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x47148
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O3/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 0x672ba
leaq 0x2c759(%rip), %rsi     # 0x939c0
leaq 0x2c762(%rip), %rdx     # 0x939d0
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xd5f0
testq %rax, %rax
jne 0x672ba
leaq 0xbc99(%rip), %rdx      # 0x72f1d
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x495, %ecx            # imm = 0x495
callq 0x47006
movq 0x2cd51(%rip), %rdi     # 0x93ff0
leaq 0xbf6e(%rip), %rsi      # 0x73214
movl $0x4d, %edx
callq 0xd600
leaq 0xc(%rsp), %rdi
callq 0x47148
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x47148
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O3/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 0x68af8
leaq 0xa603(%rip), %rdx      # 0x730aa
leaq 0x4(%rsp), %rdi
movl $0x3, %esi
movl $0x445, %ecx            # imm = 0x445
callq 0x47006
movq 0x2b52e(%rip), %rdi     # 0x93ff0
leaq 0xa7d2(%rip), %rsi      # 0x7329b
movl $0x20, %edx
callq 0xd600
movq 0x2b516(%rip), %rdi     # 0x93ff0
leaq 0xa7db(%rip), %rsi      # 0x732bc
movl $0x35, %edx
callq 0xd600
leaq 0x4(%rsp), %rdi
callq 0x47148
movl 0x8(%rbx), %edi
movq (%r14), %rsi
movq 0x8(%r14), %r14
movq %r14, %rdx
callq 0xd1c0
cmpq %r14, %rax
je 0x68b80
leaq 0xa597(%rip), %rdx      # 0x730aa
movq %rsp, %rdi
movl $0x1, %esi
movl $0x44a, %ecx            # imm = 0x44A
callq 0x47006
movq 0x2b4c4(%rip), %rdi     # 0x93ff0
leaq 0xa7bf(%rip), %rsi      # 0x732f2
movl $0x26, %edx
callq 0xd600
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
movq 0x2b4a4(%rip), %rdi     # 0x93ff0
callq 0xd600
movq %rax, %r14
leaq 0x4d68(%rip), %rsi      # 0x6d8c3
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 0x47148
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x4(%rsp), %rdi
jmp 0x68b98
movq %rax, %rbx
movq %rsp, %rdi
callq 0x47148
movq %rbx, %rdi
callq 0xda70
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x68c0e
leaq 0xa4ed(%rip), %rdx      # 0x730aa
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x455, %ecx            # imm = 0x455
callq 0x47006
movq 0x2b418(%rip), %rdi     # 0x93ff0
leaq 0xa6bc(%rip), %rsi      # 0x7329b
movl $0x20, %edx
callq 0xd600
movq 0x2b400(%rip), %rdi     # 0x93ff0
leaq 0xa722(%rip), %rsi      # 0x73319
movl $0x40, %edx
callq 0xd600
leaq 0xc(%rsp), %rdi
callq 0x47148
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 0x47148
movq %rbx, %rdi
callq 0xda70
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x68e12
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 0x68e58
movq (%r15), %rdi
movq 0x8(%r15), %rsi
movq %rbx, %rdx
callq 0x4850c
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x68e06
movq 0x18(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0xd530
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x4aac(%rip), %rsi      # 0x6d8c5
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 0x68e50
movq 0x18(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0xd530
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O3/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 0x19a8
movq %rdx, %r14
movq %rdx, %rdi
callq 0x1050
movq 0x263d(%rip), %rdi      # 0x3fd8
movq %r14, %rsi
movq %rax, %rdx
callq 0x10d0
jmp 0x19c6
movq 0x2629(%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 0x260b(%rip), %r14      # 0x3fd8
movq (%r14), %rax
movq -0x18(%rax), %rcx
movl 0x18(%r14,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%r14,%rcx)
testl %ebp, %ebp
je 0x1a22
movl %ebp, %r13d
xorl %ebp, %ebp
movq 0x25e4(%rip), %r15      # 0x3fd8
leaq 0x6f1(%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 0x19fb
movq (%r15), %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_O3/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 -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rdx
callq 0x7278
leaq -0x40(%rbp), %rdx
movq %rbx, -0x48(%rbp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x7318
testq %r12, %r12
je 0x2977
xorl %ebx, %ebx
movq (%r15,%rbx,8), %rcx
movq %rcx, -0x30(%rbp)
movq (%r14,%rbx,8), %rax
movq %rax, -0x38(%rbp)
cmpq %r13, %rcx
jae 0x2993
cmpq %r13, %rax
jae 0x2993
cmpq %rax, %rcx
je 0x296b
imulq $0x38, %rax, %rdi
addq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x837c
testq %rax, %rax
jne 0x296b
imulq $0x38, -0x30(%rbp), %rdi
addq -0x60(%rbp), %rdi
movq %rdi, -0x40(%rbp)
leaq -0x38(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x83de
imulq $0x38, -0x38(%rbp), %rdi
addq -0x60(%rbp), %rdi
movq %rdi, -0x40(%rbp)
leaq -0x30(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x83de
movq -0x30(%rbp), %rcx
movq -0x48(%rbp), %rax
movq (%rax), %rax
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x292b
movq -0x38(%rbp), %rcx
movq %rcx, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x293f
leaq -0x38(%rbp), %rdx
callq 0x86a4
movq -0x38(%rbp), %rcx
movq -0x48(%rbp), %rax
movq (%rax), %rax
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x2962
movq -0x30(%rbp), %rax
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x296b
leaq -0x30(%rbp), %rdx
callq 0x86a4
incq %rbx
cmpq %rbx, %r12
jne 0x2884
leaq -0x60(%rbp), %rdi
callq 0x73f8
movq -0x48(%rbp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x2080
leaq 0x8708(%rip), %rcx      # 0xb0ac
movq %rcx, (%rax)
movq 0xc612(%rip), %rsi      # 0xefc0
movq %rax, %rdi
xorl %edx, %edx
callq 0x2220
movq %rax, %rbx
jmp 0x29cd
jmp 0x29c1
jmp 0x29c1
movq %rax, %rbx
movq -0x48(%rbp), %rdi
callq 0x7396
leaq -0x60(%rbp), %rdi
callq 0x73f8
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3470
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 0x344d
jmp 0x3478
movapd %xmm1, %xmm2
movapd %xmm1, %xmm3
movsd 0x7b88(%rip), %xmm1     # 0xb008
divsd %xmm3, %xmm1
divsd %xmm2, %xmm0
movsd %xmm1, -0x38(%rbp)
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x2100
movapd %xmm0, -0x30(%rbp)
xorpd %xmm0, %xmm0
movupd %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x794a
testq %r14, %r14
je 0x3569
movq %r14, %xmm0
punpckldq 0x7b90(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x7b98(%rip), %xmm0     # 0xb070
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
addsd 0x7b34(%rip), %xmm1     # 0xb020
movapd -0x30(%rbp), %xmm0
xorpd 0x7b97(%rip), %xmm0     # 0xb090
divsd %xmm1, %xmm0
movapd %xmm0, -0x30(%rbp)
xorl %r12d, %r12d
leaq -0x40(%rbp), %r15
movq %r12, %xmm1
punpckldq 0x7b4a(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x7b52(%rip), %xmm1     # 0xb070
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
mulsd -0x30(%rbp), %xmm0
callq 0x2240
mulsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x3556
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x3561
movq %rbx, %rdi
movq %r15, %rdx
callq 0x94b2
incq %r12
cmpq %r12, %r14
jne 0x3509
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x357b
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3592
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2170
movq %r14, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O3/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 0x29de
leaq -0x48(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movq %r14, %rdx
movsd -0x30(%rbp), %xmm0
callq 0x3414
leaq -0x28(%rbp), %rsi
leaq -0x48(%rbp), %rdx
xorps %xmm0, %xmm0
movq %rbx, %rdi
callq 0x263c
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x385a
movq -0x38(%rbp), %rsi
subq %rdi, %rsi
callq 0x2170
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x386f
movq -0x18(%rbp), %rsi
subq %rdi, %rsi
callq 0x2170
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rdx, %r14
movq %rax, %rbx
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x389b
movq -0x38(%rbp), %rsi
subq %rdi, %rsi
callq 0x2170
jmp 0x389b
movq %rdx, %r14
movq %rax, %rbx
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x38b8
movq -0x18(%rbp), %rsi
subq %rdi, %rsi
callq 0x2170
jmp 0x38b8
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x390a
movq %rbx, %rdi
callq 0x2060
movq %rax, %rbx
movq 0xb720(%rip), %rdi      # 0xeff0
leaq 0x7855(%rip), %rsi      # 0xb12c
movl $0x7, %edx
callq 0x2180
movq 0xb708(%rip), %rdi      # 0xeff0
movq %rbx, %rsi
callq 0x2150
movq %rax, %rdi
callq 0x2070
callq 0x2200
jmp 0x386f
movq %rax, %rbx
callq 0x2200
movq %rbx, %rdi
callq 0x2230