LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::GTestFlagSaver::GTestFlagSaver()
GTestFlagSaver() {
    also_run_disabled_tests_ = GTEST_FLAG(also_run_disabled_tests);
    break_on_failure_ = GTEST_FLAG(break_on_failure);
    catch_exceptions_ = GTEST_FLAG(catch_exceptions);
    color_ = GTEST_FLAG(color);
    death_test_style_ = GTEST_FLAG(death_test_style);
    death_test_use_fork_ = GTEST_FLAG(death_test_use_fork);
    filter_ = GTEST_FLAG(filter);
    internal_run_death_test_ = GTEST_FLAG(internal_run_death_test);
    list_tests_ = GTEST_FLAG(list_tests);
    output_ = GTEST_FLAG(output);
    print_time_ = GTEST_FLAG(print_time);
    random_seed_ = GTEST_FLAG(random_seed);
    repeat_ = GTEST_FLAG(repeat);
    shuffle_ = GTEST_FLAG(shuffle);
    stack_trace_depth_ = GTEST_FLAG(stack_trace_depth);
    stream_result_to_ = GTEST_FLAG(stream_result_to);
    throw_on_failure_ = GTEST_FLAG(throw_on_failure);
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
xorl %eax, %eax
movb %al, 0x18(%rdi)
leaq 0x38(%rdi), %rcx
movq %rcx, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
movb %al, 0x38(%rdi)
leaq 0x60(%rdi), %rcx
movq %rcx, 0x50(%rdi)
andq $0x0, 0x58(%rdi)
addq $0x8, %rdi
movb %al, 0x60(%r14)
leaq 0x80(%r14), %rcx
movq %rcx, 0x70(%r14)
andq $0x0, 0x78(%r14)
leaq 0x28(%r14), %r15
leaq 0x50(%r14), %r12
movb %al, 0x80(%r14)
leaq 0xa8(%r14), %rcx
movq %rcx, 0x98(%r14)
andq $0x0, 0xa0(%r14)
leaq 0x70(%r14), %r13
leaq 0x98(%r14), %rbp
movb %al, 0xa8(%r14)
leaq 0xe0(%r14), %rcx
movq %rcx, 0xd0(%r14)
andq $0x0, 0xd8(%r14)
leaq 0xd0(%r14), %rbx
movb %al, 0xe0(%r14)
movb 0x17f5a(%rip), %al      # 0x2e562
movb %al, (%r14)
movb 0x17f52(%rip), %al      # 0x2e563
movb %al, 0x1(%r14)
movb 0x17f49(%rip), %al      # 0x2e564
movb %al, 0x2(%r14)
leaq 0x17f42(%rip), %rsi     # 0x2e568
movq %rdi, (%rsp)
callq 0x6230
leaq 0x180ba(%rip), %rsi     # 0x2e6f0
movq %r15, %rdi
callq 0x6230
movb 0x180cc(%rip), %al      # 0x2e710
movb %al, 0x48(%r14)
leaq 0x17f39(%rip), %rsi     # 0x2e588
movq %r12, %rdi
callq 0x6230
leaq 0x18072(%rip), %rsi     # 0x2e6d0
movq %r13, %rdi
callq 0x6230
movb 0x17f3c(%rip), %al      # 0x2e5a8
movb %al, 0x90(%r14)
leaq 0x17f36(%rip), %rsi     # 0x2e5b0
movq %rbp, %rdi
callq 0x6230
movb 0x17f48(%rip), %al      # 0x2e5d0
movb %al, 0xb8(%r14)
movl 0x17f3f(%rip), %eax     # 0x2e5d4
movl %eax, 0xbc(%r14)
movl 0x17f36(%rip), %eax     # 0x2e5d8
movl %eax, 0xc0(%r14)
movb 0x17f2e(%rip), %al      # 0x2e5dd
movb %al, 0xc4(%r14)
movl 0x17f24(%rip), %eax     # 0x2e5e0
movl %eax, 0xc8(%r14)
leaq 0x17f1e(%rip), %rsi     # 0x2e5e8
movq %rbx, %rdi
callq 0x6230
movb 0x17f30(%rip), %al      # 0x2e608
movb %al, 0xf0(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x6a28
movq %rbp, %rdi
callq 0x6a28
movq %r13, %rdi
callq 0x6a28
movq %r12, %rdi
callq 0x6a28
movq %r15, %rdi
callq 0x6a28
movq (%rsp), %rdi
callq 0x6a28
movq %r14, %rdi
callq 0x6900
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::GTestFlagSaver::~GTestFlagSaver()
~GTestFlagSaver() {
    GTEST_FLAG(also_run_disabled_tests) = also_run_disabled_tests_;
    GTEST_FLAG(break_on_failure) = break_on_failure_;
    GTEST_FLAG(catch_exceptions) = catch_exceptions_;
    GTEST_FLAG(color) = color_;
    GTEST_FLAG(death_test_style) = death_test_style_;
    GTEST_FLAG(death_test_use_fork) = death_test_use_fork_;
    GTEST_FLAG(filter) = filter_;
    GTEST_FLAG(internal_run_death_test) = internal_run_death_test_;
    GTEST_FLAG(list_tests) = list_tests_;
    GTEST_FLAG(output) = output_;
    GTEST_FLAG(print_time) = print_time_;
    GTEST_FLAG(random_seed) = random_seed_;
    GTEST_FLAG(repeat) = repeat_;
    GTEST_FLAG(shuffle) = shuffle_;
    GTEST_FLAG(stack_trace_depth) = stack_trace_depth_;
    GTEST_FLAG(stream_result_to) = stream_result_to_;
    GTEST_FLAG(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, 0x17e22(%rip)      # 0x2e562
movb 0x1(%rdi), %al
movb %al, 0x17e1a(%rip)      # 0x2e563
movb 0x2(%rdi), %al
movb %al, 0x17e12(%rip)      # 0x2e564
leaq 0x8(%rdi), %rsi
leaq 0x17e0b(%rip), %rdi     # 0x2e568
movq %rsi, (%rsp)
callq 0x6230
leaq 0x28(%r15), %r14
leaq 0x17f7f(%rip), %rdi     # 0x2e6f0
movq %r14, %rsi
callq 0x6230
movb 0x48(%r15), %al
movb %al, 0x17f8d(%rip)      # 0x2e710
leaq 0x50(%r15), %r12
leaq 0x17dfa(%rip), %rdi     # 0x2e588
movq %r12, %rsi
callq 0x6230
leaq 0x70(%r15), %r13
leaq 0x17f2f(%rip), %rdi     # 0x2e6d0
movq %r13, %rsi
callq 0x6230
movb 0x90(%r15), %al
movb %al, 0x17df2(%rip)      # 0x2e5a8
leaq 0x98(%r15), %rbp
leaq 0x17dec(%rip), %rdi     # 0x2e5b0
movq %rbp, %rsi
callq 0x6230
movb 0xb8(%r15), %al
movb %al, 0x17df7(%rip)      # 0x2e5d0
movl 0xbc(%r15), %eax
movl %eax, 0x17dee(%rip)     # 0x2e5d4
movl 0xc0(%r15), %eax
movl %eax, 0x17de5(%rip)     # 0x2e5d8
movb 0xc4(%r15), %al
movb %al, 0x17ddd(%rip)      # 0x2e5dd
movl 0xc8(%r15), %eax
movl %eax, 0x17dd3(%rip)     # 0x2e5e0
leaq 0xd0(%r15), %rbx
leaq 0x17dcd(%rip), %rdi     # 0x2e5e8
movq %rbx, %rsi
callq 0x6230
movb 0xf0(%r15), %al
movb %al, 0x17dd8(%rip)      # 0x2e608
movq %rbx, %rdi
callq 0x6a28
movq %rbp, %rdi
callq 0x6a28
movq %r13, %rdi
callq 0x6a28
movq %r12, %rdi
callq 0x6a28
movq %r14, %rdi
callq 0x6a28
movq (%rsp), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6a28
movq %rax, %rdi
callq 0x7311
nop
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::UnitTestImpl::AddTestInfo(void (*)(), void (*)(), testing::TestInfo*)
void AddTestInfo(Test::SetUpTestCaseFunc set_up_tc,
                   Test::TearDownTestCaseFunc tear_down_tc,
                   TestInfo* test_info) {
    // 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.";
    }

    GetTestCase(test_info->test_case_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 0x16af1
leaq 0x10(%r12), %r13
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
callq 0x13a96
movq %r13, %rdi
movq %rbp, %rsi
callq 0x6230
leaq 0x8(%rsp), %rdi
callq 0x6a28
cmpq $0x0, 0x18(%r12)
jne 0x16af1
leaq 0x77ae(%rip), %rdx      # 0x1e261
leaq 0x8(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x42b, %ecx            # imm = 0x42B
callq 0x1418e
movq 0x1751c(%rip), %rdi     # 0x2dfe8
leaq 0x8bdc(%rip), %rsi      # 0x1f6af
callq 0x6410
leaq 0x8c04(%rip), %rsi      # 0x1f6e3
movq %rax, %rdi
callq 0x6410
leaq 0x8(%rsp), %rdi
callq 0x14252
movq (%rbx), %rsi
movq 0x40(%rbx), %rax
testq %rax, %rax
je 0x16b02
movq (%rax), %rdx
jmp 0x16b04
xorl %edx, %edx
movq %r12, %rdi
movq %r15, %rcx
movq %r14, %r8
callq 0x10470
movq %rax, %rdi
movq %rbx, %rsi
callq 0xc42c
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x14252
jmp 0x16b48
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6a28
movq %rbx, %rdi
callq 0x6900
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::ScopedPrematureExitFile::ScopedPrematureExitFile(char const*)
explicit ScopedPrematureExitFile(const char* premature_exit_filepath)
      : premature_exit_filepath_(premature_exit_filepath) {
    // If a path to the premature-exit file is specified...
    if (premature_exit_filepath != NULL && *premature_exit_filepath != '\0') {
      // create the file with a single "0" character in it.  I/O
      // errors are ignored as there's nothing better we can do and we
      // don't want to fail the test because of this.
      FILE* pfile = posix::FOpen(premature_exit_filepath, "w");
      fwrite("0", 1, 1, pfile);
      fclose(pfile);
    }
  }

// Assembly:
movq %rsi, (%rdi)
testq %rsi, %rsi
je 0x17293
cmpb $0x0, (%rsi)
je 0x17293
pushq %rbx
leaq 0x78d3(%rip), %rax      # 0x1eb44
movq %rsi, %rdi
movq %rax, %rsi
callq 0x6590
movq %rax, %rbx
pushq $0x30
popq %rdi
movq %rax, %rsi
callq 0x6610
movq %rbx, %rdi
popq %rbx
jmp 0x6420
retq
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest.h
// Function: testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::~ThreadLocal()
~ThreadLocal() {
    // Destroys the managed object for the current thread, if any.
    DeleteThreadLocalValue(pthread_getspecific(key_));

    // Releases resources associated with the key.  This will *not*
    // delete managed objects for other threads.
    GTEST_CHECK_POSIX_SUCCESS_(pthread_key_delete(key_));
  }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %edi
callq 0x67c0
testq %rax, %rax
je 0x1744d
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
movl (%rbx), %edi
callq 0x65a0
testl %eax, %eax
je 0x174a9
movl %eax, %ebp
leaq 0x8142(%rip), %rdx      # 0x1f5a3
leaq 0x4(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0xa21, %ecx            # imm = 0xA21
callq 0x1418e
movq 0x16b6e(%rip), %rdi     # 0x2dfe8
leaq 0x88ff(%rip), %rsi      # 0x1fd80
callq 0x6410
leaq 0x8142(%rip), %rsi      # 0x1f5cf
movq %rax, %rdi
callq 0x6410
movq %rax, %rdi
movl %ebp, %esi
callq 0x68e0
leaq 0x4(%rsp), %rdi
callq 0x14252
addq $0x8, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x19322
movq %rax, %rdi
callq 0x7311
nop
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::GetRandomSeedFromFlag(int)
inline int GetRandomSeedFromFlag(Int32 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 0x17765
pushq %rax
callq 0x8ec5
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/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::GetNextRandomSeed(int)
inline int GetNextRandomSeed(int seed) {
  GTEST_CHECK_(1 <= seed && seed <= kMaxRandomSeed)
      << "Invalid random seed " << seed << " - must be in [1, "
      << kMaxRandomSeed << "].";
  const int next_seed = seed + 1;
  return (next_seed > kMaxRandomSeed) ? 1 : next_seed;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
leal -0x1(%rbx), %eax
cmpl $0x1869f, %eax          # imm = 0x1869F
jb 0x17812
leaq 0x6ac2(%rip), %rdx      # 0x1e261
leaq 0xc(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x229, %ecx            # imm = 0x229
callq 0x1418e
movq 0x16830(%rip), %rdi     # 0x2dfe8
leaq 0x81d7(%rip), %rsi      # 0x1f996
callq 0x6410
leaq 0x8202(%rip), %rsi      # 0x1f9cd
movq %rax, %rdi
callq 0x6410
movq %rax, %rdi
movl %ebx, %esi
callq 0x68e0
leaq 0x81fe(%rip), %rsi      # 0x1f9e2
movq %rax, %rdi
callq 0x6410
movq %rax, %rdi
movl $0x1869f, %esi          # imm = 0x1869F
callq 0x68e0
leaq 0x81f5(%rip), %rsi      # 0x1f9f5
movq %rax, %rdi
callq 0x6410
leaq 0xc(%rsp), %rdi
callq 0x14252
leal 0x1(%rbx), %ecx
cmpl $0x1869f, %ebx          # imm = 0x1869F
pushq $0x1
popq %rax
cmovll %ecx, %eax
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x14252
movq %rbx, %rdi
callq 0x6900
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: void testing::internal::ShuffleRange<int>(testing::internal::Random*, int, int, std::vector<int, std::allocator<int>>*)
void ShuffleRange(internal::Random* random, int begin, int end,
                  std::vector<E>* v) {
  const int size = static_cast<int>(v->size());
  GTEST_CHECK_(0 <= begin && begin <= size)
      << "Invalid shuffle range start " << begin << ": must be in range [0, "
      << size << "].";
  GTEST_CHECK_(begin <= end && end <= size)
      << "Invalid shuffle range finish " << end << ": must be in range ["
      << begin << ", " << size << "].";

  // Fisher-Yates shuffle, from
  // http://en.wikipedia.org/wiki/Fisher-Yates_shuffle
  for (int range_width = end - begin; range_width >= 2; range_width--) {
    const int last_in_range = begin + range_width - 1;
    const int selected = begin + random->Generate(range_width);
    std::swap((*v)[selected], (*v)[last_in_range]);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %r12d
movl %esi, %ebp
movq %rdi, %r14
movq 0x8(%rcx), %r15
subq (%rcx), %r15
shrq $0x2, %r15
testl %esi, %esi
js 0x1790a
cmpl %ebp, %r15d
jge 0x17982
leaq 0x6950(%rip), %rdx      # 0x1e261
leaq 0x4(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x2cb, %ecx            # imm = 0x2CB
callq 0x1418e
movq 0x166be(%rip), %rdi     # 0x2dfe8
leaq 0x8468(%rip), %rsi      # 0x1fd99
callq 0x6410
leaq 0x848b(%rip), %rsi      # 0x1fdc8
movq %rax, %rdi
callq 0x6410
movq %rax, %rdi
movl %ebp, %esi
callq 0x68e0
leaq 0x848f(%rip), %rsi      # 0x1fde5
movq %rax, %rdi
callq 0x6410
movq %rax, %rdi
movl %r15d, %esi
callq 0x68e0
leaq 0x8085(%rip), %rsi      # 0x1f9f5
movq %rax, %rdi
callq 0x6410
leaq 0x4(%rsp), %rdi
callq 0x14252
movl %r12d, %r13d
subl %ebp, %r13d
jl 0x17993
cmpl %r12d, %r15d
jge 0x17a21
leaq 0x68c7(%rip), %rdx      # 0x1e261
movq %rsp, %rdi
pushq $0x3
popq %rsi
movl $0x2ce, %ecx            # imm = 0x2CE
callq 0x1418e
movq 0x16637(%rip), %rdi     # 0x2dfe8
leaq 0x8445(%rip), %rsi      # 0x1fdfd
callq 0x6410
leaq 0x8468(%rip), %rsi      # 0x1fe2c
movq %rax, %rdi
callq 0x6410
movq %rax, %rdi
movl %r12d, %esi
callq 0x68e0
leaq 0x846c(%rip), %rsi      # 0x1fe4a
movq %rax, %rdi
callq 0x6410
movq %rax, %rdi
movl %ebp, %esi
callq 0x68e0
leaq 0x8403(%rip), %rsi      # 0x1fdfa
movq %rax, %rdi
callq 0x6410
movq %rax, %rdi
movl %r15d, %esi
callq 0x68e0
leaq 0x7fe4(%rip), %rsi      # 0x1f9f5
movq %rax, %rdi
callq 0x6410
movq %rsp, %rdi
callq 0x14252
movslq %r13d, %r15
movslq %ebp, %rax
leaq -0x4(,%rax,4), %r12
cmpq $0x1, %r15
jle 0x17a5e
movq %r14, %rdi
movl %r15d, %esi
callq 0x77ca
addl %ebp, %eax
cltq
movq (%rbx), %rcx
leaq (%rcx,%r12), %rdx
movl (%rcx,%rax,4), %esi
movl (%rdx,%r15,4), %edi
movl %edi, (%rcx,%rax,4)
movl %esi, (%rdx,%r15,4)
decq %r15
jmp 0x17a2f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x4(%rsp), %rdi
jmp 0x17a7d
movq %rax, %rbx
movq %rsp, %rdi
callq 0x14252
movq %rbx, %rdi
callq 0x6900
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: void testing::internal::InitGoogleTestImpl<char>(int*, char**)
void InitGoogleTestImpl(int* argc, CharType** argv) {
  g_init_gtest_count++;

  // We don't want to run the initialization code twice.
  if (g_init_gtest_count != 1) return;

  if (*argc <= 0) return;

  internal::g_executable_path = internal::StreamableToString(argv[0]);

#if GTEST_HAS_DEATH_TEST

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

#endif  // GTEST_HAS_DEATH_TEST

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl 0x165a4(%rip), %eax     # 0x2e60c
leal 0x1(%rax), %ecx
movl %ecx, 0x1659b(%rip)     # 0x2e60c
testl %eax, %eax
jne 0x18107
movq %rdi, %r14
cmpl $0x0, (%rdi)
jle 0x18107
movq %rsi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x1c2d7
leaq 0x165ac(%rip), %rdi     # 0x2e648
movq %r15, %rsi
callq 0x65f0
movq %r15, %rdi
callq 0x6a28
leaq 0x16695(%rip), %r12     # 0x2e748
movq %r12, %rdi
callq 0x1c3ba
xorl %ebp, %ebp
movq %rbx, %r13
movl (%r14), %eax
cmpq %rax, %rbp
je 0x180ef
movq %r15, %rdi
movq %r13, %rsi
callq 0x1c2d7
movq %r12, %rdi
movq %r15, %rsi
callq 0x1a2fe
movq %r15, %rdi
callq 0x6a28
incq %rbp
addq $0x8, %r13
jmp 0x180c0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x17a8a
callq 0x1552e
movq %rax, %rdi
callq 0x10428
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6a28
movq %rbx, %rdi
callq 0x6900
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: void testing::internal::Arguments::AddArguments<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
void AddArguments(const ::std::vector<Str>& arguments) {
    for (typename ::std::vector<Str>::const_iterator i = arguments.begin();
         i != arguments.end();
         ++i) {
      args_.insert(args_.end() - 1, posix::StrDup(i->c_str()));
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %r13
leaq 0x8(%rsp), %r15
cmpq 0x8(%rbx), %r13
je 0x182d1
movq 0x8(%r14), %r12
addq $-0x8, %r12
movq (%r13), %rdi
callq 0x6960
movq %rax, 0x8(%rsp)
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x1a262
addq $0x20, %r13
jmp 0x182a1
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::CapturedStream::GetCapturedString[abi:cxx11]()
std::string GetCapturedString() {
    if (uncaptured_fd_ != -1) {
      // Restores the original stream.
      fflush(NULL);
      dup2(uncaptured_fd_, fd_);
      close(uncaptured_fd_);
      uncaptured_fd_ = -1;
    }

    FILE* const file = posix::FOpen(filename_.c_str(), "r");
    const std::string content = ReadEntireFile(file);
    posix::FClose(file);
    return content;
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $-0x1, 0x4(%rsi)
je 0x18597
xorl %edi, %edi
callq 0x6580
movl (%r14), %esi
movl 0x4(%r14), %edi
callq 0x63f0
movl 0x4(%r14), %edi
callq 0x6a00
orl $-0x1, 0x4(%r14)
movq 0x8(%r14), %rdi
leaq 0x78fb(%rip), %rsi      # 0x1fe9d
callq 0x6590
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1429e
movq %r14, %rdi
callq 0x6420
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: void testing::internal::PrintCharAndCodeTo<unsigned char, signed char>(signed char, std::ostream*)
void PrintCharAndCodeTo(Char c, ostream* os) {
  // First, print c as a literal in the most readable form we can find.
  *os << ((sizeof(c) > 1) ? "L'" : "'");
  const CharFormat format = PrintAsCharLiteralTo<UnsignedChar>(c, os);
  *os << "'";

  // To aid user debugging, we also print c's code in decimal, unless
  // it's 0 (in which case c was printed as '\\0', making the code
  // obvious).
  if (c == 0)
    return;
  *os << " (" << static_cast<int>(c);

  // For more convenience, we print c's code again in hexidecimal,
  // unless c was already printed in the form '\x##' or the code is in
  // [1, 9].
  if (format == kHexEscape || (1 <= c && c <= 9)) {
    // Do nothing.
  } else {
    *os << ", 0x" << String::FormatHexInt(static_cast<UnsignedChar>(c));
  }
  *os << ")";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movl %edi, %r14d
leaq 0x76d8(%rip), %rsi      # 0x1fea9
movq %rbx, %rdi
callq 0x6410
movsbl %r14b, %r15d
movzbl %r14b, %ebp
cmpl $0xd, %r14d
ja 0x18803
movl %r14d, %eax
leaq 0x5a33(%rip), %rcx      # 0x1e224
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x5c9c(%rip), %rsi      # 0x1e49d
jmp 0x18878
cmpl $0x27, %r14d
je 0x18871
cmpl $0x5c, %r14d
jne 0x18818
leaq 0x767a(%rip), %rsi      # 0x1fe90
jmp 0x18878
leal -0x20(%r15), %eax
cmpl $0x5e, %eax
ja 0x1890b
movq %rbx, %rdi
movl %r15d, %esi
callq 0x6550
jmp 0x18880
leaq 0x7669(%rip), %rsi      # 0x1fea2
jmp 0x18878
leaq 0x7657(%rip), %rsi      # 0x1fe99
jmp 0x18878
leaq 0x7651(%rip), %rsi      # 0x1fe9c
jmp 0x18878
leaq 0x763f(%rip), %rsi      # 0x1fe93
jmp 0x18878
leaq 0x719b(%rip), %rsi      # 0x1f9f8
jmp 0x18878
leaq 0x7630(%rip), %rsi      # 0x1fe96
jmp 0x18878
leaq 0x7630(%rip), %rsi      # 0x1fe9f
jmp 0x18878
leaq 0x7615(%rip), %rsi      # 0x1fe8d
movq %rbx, %rdi
callq 0x6410
xorl %r12d, %r12d
leaq 0x761f(%rip), %rsi      # 0x1fea9
movq %rbx, %rdi
callq 0x6410
testb %r14b, %r14b
je 0x188fe
leaq 0x5b8b(%rip), %rsi      # 0x1e429
movq %rbx, %rdi
callq 0x6410
movq %rax, %rdi
movl %r15d, %esi
callq 0x68e0
cmpb $0xa, %r14b
setb %al
orb %r12b, %al
jne 0x188ef
leaq 0x75c4(%rip), %rsi      # 0x1fe88
movq %rbx, %rdi
callq 0x6410
movq %rax, %r14
movq %rsp, %r15
movq %r15, %rdi
movl %ebp, %esi
callq 0xa9f4
movq %r14, %rdi
movq %r15, %rsi
callq 0x63c0
movq %rsp, %rdi
callq 0x6a28
leaq 0x5ffc(%rip), %rsi      # 0x1e8f2
movq %rbx, %rdi
callq 0x6410
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movl %ebp, %esi
callq 0xa9f4
leaq 0x7584(%rip), %rsi      # 0x1fea5
movq %rsp, %rdi
movq %r12, %rdx
callq 0x16224
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x63c0
movq %rsp, %rdi
callq 0x6a28
leaq 0x20(%rsp), %rdi
callq 0x6a28
movb $0x1, %r12b
jmp 0x18883
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6a28
jmp 0x18961
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
jmp 0x1896e
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6a28
movq %rbx, %rdi
callq 0x6900
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest.h
// Function: testing::internal::SkipComma(char const*)
inline const char* SkipComma(const char* str) {
  const char* comma = strchr(str, ',');
  if (comma == NULL) {
    return NULL;
  }
  while (IsSpace(*(++comma))) {}
  return comma;
}

// Assembly:
pushq %rbx
pushq $0x2c
popq %rsi
callq 0x6190
testq %rax, %rax
je 0x18acb
movq %rax, %rbx
movsbl 0x1(%rbx), %edi
incq %rbx
callq 0x1a495
testb %al, %al
jne 0x18ab9
jmp 0x18acd
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest.h
// Function: testing::internal::MutexBase::Unlock()
void Unlock() {
    // Since the lock is being released the owner_ field should no longer be
    // considered valid. We don't protect writing to has_owner_ here, as it's
    // the caller's responsibility to ensure that the current thread holds the
    // mutex when this is called.
    has_owner_ = false;
    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_unlock(&mutex_));
  }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movb $0x0, 0x28(%rdi)
callq 0x6310
testl %eax, %eax
je 0x18d79
movl %eax, %ebx
leaq 0x6872(%rip), %rdx      # 0x1f5a3
leaq 0xc(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x99b, %ecx            # imm = 0x99B
callq 0x1418e
movq 0x1529e(%rip), %rdi     # 0x2dfe8
leaq 0x6891(%rip), %rsi      # 0x1f5e2
callq 0x6410
leaq 0x6872(%rip), %rsi      # 0x1f5cf
movq %rax, %rdi
callq 0x6410
movq %rax, %rdi
movl %ebx, %esi
callq 0x68e0
leaq 0xc(%rsp), %rdi
callq 0x14252
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x14252
movq %rbx, %rdi
callq 0x6900
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest.h
// Function: testing::internal::ThreadLocal<testing::TestPartResultReporterInterface*>::GetOrCreateValue() const
T* GetOrCreateValue() const {
    ThreadLocalValueHolderBase* const holder =
        static_cast<ThreadLocalValueHolderBase*>(pthread_getspecific(key_));
    if (holder != NULL) {
      return CheckedDowncastToActualType<ValueHolder>(holder)->pointer();
    }

    ValueHolder* const new_holder = new ValueHolder(default_);
    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 0x67c0
testq %rax, %rax
je 0x1a886
movq %rax, %rdi
callq 0x1a925
movq %rax, %rbx
addq $0x8, %rbx
jmp 0x1a904
pushq $0x10
popq %rdi
callq 0x6430
leaq 0x134b3(%rip), %rcx     # 0x2dd48
movq %rcx, (%rax)
leaq 0x8(%rax), %rbx
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rax)
movl (%r14), %edi
movq %rax, %rsi
callq 0x60c0
testl %eax, %eax
je 0x1a904
movl %eax, %ebp
leaq 0x4ce7(%rip), %rdx      # 0x1f5a3
leaq 0xc(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0xa48, %ecx            # imm = 0xA48
callq 0x1418e
movq 0x13713(%rip), %rdi     # 0x2dfe8
leaq 0x4e66(%rip), %rsi      # 0x1f742
callq 0x6410
leaq 0x4ce7(%rip), %rsi      # 0x1f5cf
movq %rax, %rdi
callq 0x6410
movq %rax, %rdi
movl %ebp, %esi
callq 0x68e0
leaq 0xc(%rsp), %rdi
callq 0x14252
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x14252
movq %rbx, %rdi
callq 0x6900
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest.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) {
#if GTEST_HAS_RTTI
  GTEST_CHECK_(typeid(*base) == typeid(Derived));
  return dynamic_cast<Derived*>(base);  // NOLINT
#else
  return static_cast<Derived*>(base);  // Poor man's downcast.
#endif
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x190eb
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x8(%rax), %rdi
leaq 0x14b61(%rip), %rsi     # 0x2dbf0
callq 0x1911a
testb %al, %al
jne 0x190ce
leaq 0x6504(%rip), %rdx      # 0x1f5a3
leaq 0xc(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x8ce, %ecx            # imm = 0x8CE
callq 0x1418e
movq 0x14f30(%rip), %rdi     # 0x2dfe8
leaq 0x66aa(%rip), %rsi      # 0x1f769
callq 0x6410
leaq 0xc(%rsp), %rdi
callq 0x14252
leaq 0x14b0b(%rip), %rsi     # 0x2dbe0
leaq 0x14b14(%rip), %rdx     # 0x2dbf0
movq %rbx, %rdi
xorl %ecx, %ecx
addq $0x10, %rsp
popq %rbx
jmp 0x6520
callq 0x64e0
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x14252
movq %rbx, %rdi
callq 0x6900
nop
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::StreamingListener::OnTestPartResult(testing::TestPartResult const&)
void OnTestPartResult(const TestPartResult& test_part_result) {
    const char* file_name = test_part_result.file_name();
    if (file_name == NULL)
      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 0x19671
movq 0x8(%r14), %rax
testq %rax, %rax
leaq 0x542a(%rip), %rsi      # 0x1eaa5
cmovneq %rax, %rsi
leaq 0xf0(%rsp), %r15
movq %r15, %rdi
callq 0xf412
leaq 0x6256(%rip), %rsi      # 0x1f8ec
leaq 0x50(%rsp), %rdi
movq %r15, %rdx
callq 0x16224
leaq 0x625d(%rip), %rdx      # 0x1f907
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x154d7
movl 0x28(%r14), %eax
leaq 0xc(%rsp), %rsi
movl %eax, (%rsi)
leaq 0x30(%rsp), %rdi
callq 0x1703c
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x16fd5
leaq 0x6222(%rip), %rdx      # 0x1f90e
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x154d7
movq 0x50(%r14), %rsi
leaq 0x10(%rsp), %rdi
callq 0xf412
leaq 0xd0(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x16fd5
leaq 0xd0(%rsp), %rsi
movq %rbx, %rdi
callq 0x19eb6
leaq 0xd0(%rsp), %rdi
callq 0x6a28
leaq 0x10(%rsp), %rdi
callq 0x6a28
leaq 0xb0(%rsp), %rdi
callq 0x6a28
leaq 0x90(%rsp), %rdi
callq 0x6a28
leaq 0x30(%rsp), %rdi
callq 0x6a28
leaq 0x70(%rsp), %rdi
callq 0x6a28
leaq 0x50(%rsp), %rdi
callq 0x6a28
leaq 0xf0(%rsp), %rdi
callq 0x6a28
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0x6a28
jmp 0x197b7
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x6a28
jmp 0x197c6
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0x6a28
jmp 0x197d8
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x6a28
jmp 0x197ea
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x6a28
leaq 0x70(%rsp), %rdi
callq 0x6a28
leaq 0x50(%rsp), %rdi
callq 0x6a28
leaq 0xf0(%rsp), %rdi
callq 0x6a28
movq %rbx, %rdi
callq 0x6900
movq %rax, %rbx
jmp 0x197f4
movq %rax, %rbx
jmp 0x197fe
movq %rax, %rbx
jmp 0x19808
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::StreamingListener::OnTestEnd(testing::TestInfo const&)
void OnTestEnd(const TestInfo& test_info) {
    SendLn("event=TestEnd&passed=" +
           FormatBool((test_info.result())->Passed()) +
           "&elapsed_time=" +
           StreamableToString((test_info.result())->elapsed_time()) + "ms");
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x68(%rsi), %rdi
callq 0x16ed6
movzbl %al, %edx
leaq 0xb0(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x19f3a
leaq 0x60b4(%rip), %rsi      # 0x1f918
leaq 0x30(%rsp), %rdi
movq %r15, %rdx
callq 0x16224
leaq 0x60b6(%rip), %rdx      # 0x1f92e
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x154d7
movq 0xd8(%r14), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x16ee0
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x16fd5
leaq 0x6082(%rip), %rdx      # 0x1f93d
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x154d7
leaq 0x90(%rsp), %rsi
movq %rbx, %rdi
callq 0x19eb6
leaq 0x90(%rsp), %rdi
callq 0x6a28
leaq 0x70(%rsp), %rdi
callq 0x6a28
leaq 0x10(%rsp), %rdi
callq 0x6a28
leaq 0x50(%rsp), %rdi
callq 0x6a28
leaq 0x30(%rsp), %rdi
callq 0x6a28
leaq 0xb0(%rsp), %rdi
callq 0x6a28
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x6a28
jmp 0x19941
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x6a28
jmp 0x19950
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x6a28
jmp 0x1995f
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x6a28
jmp 0x1996e
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x6a28
leaq 0xb0(%rsp), %rdi
callq 0x6a28
movq %rbx, %rdi
callq 0x6900
movq %rax, %rbx
jmp 0x19978
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::StreamingListener::OnTestProgramEnd(testing::UnitTest const&)
void OnTestProgramEnd(const UnitTest& unit_test) {
    // Note that Google Test current only report elapsed time for each
    // test iteration, not for the entire test program.
    SendLn("event=TestProgramEnd&passed=" + FormatBool(unit_test.Passed()));

    // Notify the streaming server to stop.
    socket_writer_->CloseConnection();
  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xd54e
movzbl %al, %edx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x19f3a
leaq 0x5cef(%rip), %rsi      # 0x1f979
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0x16224
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x19eb6
leaq 0x8(%rsp), %rdi
callq 0x6a28
leaq 0x28(%rsp), %rdi
callq 0x6a28
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6a28
jmp 0x19cdc
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x6a28
movq %rbx, %rdi
callq 0x6900
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::StreamingListener::SocketWriter::Send(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
virtual void Send(const string& message) {
      GTEST_CHECK_(sockfd_ != -1)
          << "Send() can be called only when there is a connection.";

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %edi
cmpl $-0x1, %edi
jne 0x19d9d
leaq 0x4505(%rip), %rdx      # 0x1e261
leaq 0xc(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x5e1, %ecx            # imm = 0x5E1
callq 0x1418e
movq 0x14273(%rip), %rdi     # 0x2dfe8
leaq 0x5a21(%rip), %rsi      # 0x1f79d
callq 0x6410
leaq 0x5a36(%rip), %rsi      # 0x1f7be
movq %rax, %rdi
callq 0x6410
leaq 0xc(%rsp), %rdi
callq 0x14252
movl 0x8(%rbx), %edi
movslq 0x8(%r14), %r15
movq (%r14), %rsi
movq %r15, %rdx
callq 0x6160
cmpq %r15, %rax
je 0x19e11
leaq 0x44a9(%rip), %rdx      # 0x1e261
leaq 0x8(%rsp), %rdi
pushq $0x1
popq %rsi
movl $0x5e6, %ecx            # imm = 0x5E6
callq 0x1418e
movq 0x14217(%rip), %rdi     # 0x2dfe8
leaq 0x5a1c(%rip), %rsi      # 0x1f7f4
callq 0x6410
leaq 0x10(%rbx), %rsi
movq %rax, %rdi
callq 0x63c0
leaq 0x500f(%rip), %rsi      # 0x1edff
movq %rax, %rdi
callq 0x6410
addq $0x30, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x63c0
leaq 0x8(%rsp), %rdi
callq 0x14252
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
jmp 0x19e2d
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x14252
movq %rbx, %rdi
callq 0x6900
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::StreamingListener::SocketWriter::CloseConnection()
void CloseConnection() {
      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 0x19e92
leaq 0x4410(%rip), %rdx      # 0x1e261
leaq 0xc(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x5f2, %ecx            # imm = 0x5F2
callq 0x1418e
movq 0x1417e(%rip), %rdi     # 0x2dfe8
leaq 0x592c(%rip), %rsi      # 0x1f79d
callq 0x6410
leaq 0x599e(%rip), %rsi      # 0x1f81b
movq %rax, %rdi
callq 0x6410
leaq 0xc(%rsp), %rdi
callq 0x14252
movl 0x8(%rbx), %edi
callq 0x6a00
orl $-0x1, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x14252
movq %rbx, %rdi
callq 0x6900
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest.h
// Function: testing::internal::UniversalTersePrinter<char const*>::Print(char const*, std::ostream*)
static void Print(const char* str, ::std::ostream* os) {
    if (str == NULL) {
      *os << "NULL";
    } else {
      UniversalPrint(string(str), os);
    }
  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
testq %rdi, %rdi
je 0x1a643
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x1543a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x14847
leaq 0x8(%rsp), %rdi
callq 0x6a28
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x4e83(%rip), %rsi      # 0x1f4cd
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x6410
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6a28
movq %rbx, %rdi
callq 0x6900
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest.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 == NULL) {
      *os << "NULL";
    } else {
      UniversalPrint(::std::wstring(str), os);
    }
  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
testq %rdi, %rdi
je 0x1a6af
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x1a6da
movq %r14, %rdi
movq %rbx, %rsi
callq 0x14859
leaq 0x8(%rsp), %rdi
callq 0x60a0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x4e17(%rip), %rsi      # 0x1f4cd
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x6410
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x60a0
movq %rbx, %rdi
callq 0x6900
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest.h
// Function: testing::internal::FloatingPoint<double>::AlmostEquals(testing::internal::FloatingPoint<double> const&) const
bool AlmostEquals(const FloatingPoint& rhs) const {
    // The IEEE standard says that any comparison operation involving
    // a NAN must return false.
    if (is_nan() || rhs.is_nan()) return false;

    return DistanceBetweenSignAndMagnitudeNumbers(u_.bits_, rhs.u_.bits_)
        <= kMaxUlps;
  }

// Assembly:
movabsq $0x7ff0000000000000, %rax # imm = 0x7FF0000000000000
movq (%rdi), %rcx
movq %rcx, %rdx
notq %rdx
testq %rax, %rdx
sete %dl
shlq $0xc, %rcx
setne %cl
testb %cl, %dl
jne 0x1aa99
movabsq $0xfffffffffffff, %rcx  # imm = 0xFFFFFFFFFFFFF
movq (%rsi), %rdx
movq %rdx, %r8
notq %r8
testq %r8, %rax
sete %al
testq %rcx, %rdx
setne %cl
testb %cl, %al
je 0x1aa9c
xorl %eax, %eax
retq
pushq %rax
callq 0x1aaae
cmpq $0x5, %rax
setb %al
addq $0x8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest.h
// Function: testing::internal::ThreadLocal<testing::TestPartResultReporterInterface*>::CreateKey()
static pthread_key_t CreateKey() {
    pthread_key_t key;
    // When a thread exits, DeleteThreadLocalValue() will be called on
    // the object managed for that thread.
    GTEST_CHECK_POSIX_SUCCESS_(
        pthread_key_create(&key, &DeleteThreadLocalValue));
    return key;
  }

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0x7e(%rip), %rsi        # 0x1be44
leaq 0xc(%rsp), %rdi
callq 0x6830
testl %eax, %eax
je 0x1be25
movl %eax, %ebx
leaq 0x37c6(%rip), %rdx      # 0x1f5a3
leaq 0x8(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0xa3b, %ecx            # imm = 0xA3B
callq 0x1418e
movq 0x121f2(%rip), %rdi     # 0x2dfe8
leaq 0x3f51(%rip), %rsi      # 0x1fd4e
callq 0x6410
leaq 0x37c6(%rip), %rsi      # 0x1f5cf
movq %rax, %rdi
callq 0x6410
movq %rax, %rdi
movl %ebx, %esi
callq 0x68e0
leaq 0x8(%rsp), %rdi
callq 0x14252
movl 0xc(%rsp), %eax
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x14252
movq %rbx, %rdi
callq 0x6900
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/jacobi.cpp
// Function: matrix_vector_mult(int, double const*, double const*, double*)
void matrix_vector_mult(const int n, const double* A, const double* x, double* y)
{
    for (int i = 0; i < n; i++) {
        y[i] = 0;
        for (int j = 0; j < n; j++) {
            y[i] += A[i * n + j] * x[j];
        }
    }
}

// Assembly:
movslq %edi, %rax
xorl %edi, %edi
testl %eax, %eax
movl $0x0, %r8d
cmovgl %eax, %r8d
movl %eax, %r9d
shlq $0x3, %rax
cmpq %r8, %rdi
je 0x1c724
andq $0x0, (%rcx,%rdi,8)
xorpd %xmm0, %xmm0
xorl %r10d, %r10d
cmpq %r10, %r9
je 0x1c71c
movsd (%rsi,%r10,8), %xmm1
mulsd (%rdx,%r10,8), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%rcx,%rdi,8)
incq %r10
jmp 0x1c6fd
incq %rdi
addq %rax, %rsi
jmp 0x1c6ec
retq
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/jacobi.cpp
// Function: matrix_vector_mult(int, int, double const*, double const*, double*)
void matrix_vector_mult(const int n, const int m, const double* A, const double* x, double* y)
{
    for (int i = 0; i < n; i++) {
        y[i] = 0;
        for (int j = 0; j < m; j++) {
            y[i] += A[i * m + j] * x[j];
        }
    }
}

// Assembly:
xorl %eax, %eax
testl %esi, %esi
movl $0x0, %r9d
cmovgl %esi, %r9d
movslq %esi, %rsi
testl %edi, %edi
cmovlel %eax, %edi
shlq $0x3, %rsi
cmpq %rdi, %rax
je 0x1c778
andq $0x0, (%r8,%rax,8)
xorpd %xmm0, %xmm0
xorl %r10d, %r10d
cmpq %r10, %r9
je 0x1c770
movsd (%rdx,%r10,8), %xmm1
mulsd (%rcx,%r10,8), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%r8,%rax,8)
incq %r10
jmp 0x1c750
incq %rax
addq %rsi, %rdx
jmp 0x1c73f
retq
// File: /workspace/github_cpp_makefile_star2_O2/hzeller[P]jcxxgen/schema-compiler.cc
// Function: main
int main(int argc, char *argv[]) {
  if (argc < 2) {
    fprintf(stderr, "usage: %s [options] <protocol-spec-yaml>\n", argv[0]);
    fprintf(stderr, "Options:\n"
            "  -o <filename>     : Output to filename\n"
            "  -j <json-include> : Include path to json.hpp, "
            "including brackets <> or quotes \"\" around.\n"
            "                      Default: '<nlohmann/json.hpp>'\n");
    return 1;
  }

  const char *out_filename = nullptr;
  const char *nlohmann_json_include = "<nlohmann/json.hpp>";
  int opt;
  while ((opt = getopt(argc, argv, "o:")) != -1) {
    switch (opt) {
    case 'o': out_filename = strdup(optarg); break;
    case 'j': nlohmann_json_include = strdup(optarg); break;
    }
  }

  const char *schema_filename = argv[optind];
  auto objects = LoadObjectTypes(schema_filename);
  if (!objects) {
    fprintf(stderr, "Couldn't parse spec\n");
    return 2;
  }

  FILE *out = stdout;
  if (out_filename) {
    out = fopen(out_filename, "w");
    if (!out) {
      perror("opening output file");
      return 3;
    }
  }

  GenerateCode(schema_filename, nlohmann_json_include, *objects, out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
cmpl $0x2, %edi
jl 0x5996
movl %edi, %r12d
leaq 0xec52(%rip), %rbx      # 0x1450a
xorl %r14d, %r14d
leaq 0xec5c(%rip), %r13      # 0x1451e
movl %r12d, %edi
movq %r15, %rsi
movq %r13, %rdx
callq 0x4090
cmpl $-0x1, %eax
je 0x5907
cmpl $0x6a, %eax
je 0x58f3
cmpl $0x6f, %eax
jne 0x58c2
movq 0x196a2(%rip), %rax     # 0x1ef88
movq (%rax), %rdi
callq 0x44d0
movq %rax, %r14
jmp 0x58c2
movq 0x1968e(%rip), %rax     # 0x1ef88
movq (%rax), %rdi
callq 0x44d0
movq %rax, %rbx
jmp 0x58c2
movq 0x196aa(%rip), %rax     # 0x1efb8
movslq (%rax), %rax
movq (%r15,%rax,8), %r15
leaq -0x30(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x469c
movq (%r12), %r12
testq %r12, %r12
je 0x59ce
testq %r14, %r14
je 0x5960
leaq 0xebf9(%rip), %rsi      # 0x14536
movq %r14, %rdi
callq 0x4350
movq %rax, %rcx
testq %rax, %rax
jne 0x596a
leaq 0xebe4(%rip), %rdi      # 0x14538
callq 0x4250
pushq $0x3
jmp 0x59ec
movq 0x19609(%rip), %rax     # 0x1ef70
movq (%rax), %rcx
xorl %r14d, %r14d
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x52f6
leaq -0x30(%rbp), %rdi
callq 0x5a18
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x19613(%rip), %rbx     # 0x1efb0
movq (%rbx), %rdi
movq (%r15), %rdx
leaq 0xea73(%rip), %rsi      # 0x1441d
xorl %eax, %eax
callq 0x4400
movq (%rbx), %rcx
leaq 0xea8c(%rip), %rdi      # 0x14447
pushq $0x1
popq %rdx
movl $0xc2, %esi
callq 0x4530
pushq $0x1
popq %r14
jmp 0x5984
movq 0x195db(%rip), %rax     # 0x1efb0
movq (%rax), %rcx
leaq 0xeb42(%rip), %rdi      # 0x14521
pushq $0x14
popq %rsi
pushq $0x1
popq %rdx
callq 0x4530
pushq $0x2
popq %r14
jmp 0x597b
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x5a18
movq %rbx, %rdi
callq 0x44a0
// File: /workspace/github_cpp_makefile_star2_O2/Merulo[P]CompilerJFTT/src/External/EmulatorRunner.cpp
// Function: EmulatorRunner::emulate(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool EmulatorRunner::emulate(std::string tmpFileName, std::string resultFileName)
{
    if (!fileExists("emulator.py"))
    {
        return false;
    }

    std::string command = "python3 emulator.py " + tmpFileName + " " + resultFileName + "> /dev/null 2> /dev/null";
    int v = system(command.c_str());
    return v == 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x1e6fe(%rip), %rsi     # 0x23004
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x4a54
leaq 0x8(%rsp), %rsi
callq 0x4a16
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x4548
testb %bpl, %bpl
je 0x49c0
leaq 0x1e6d5(%rip), %rsi     # 0x23010
leaq 0x68(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x4acd
leaq 0x1fb19(%rip), %rdx     # 0x2446b
leaq 0x48(%rsp), %rdi
movq %r15, %rsi
callq 0x4a8f
leaq 0x28(%rsp), %rdi
leaq 0x48(%rsp), %rsi
movq %rbx, %rdx
callq 0x4aae
leaq 0x1e6ad(%rip), %rdx     # 0x23025
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x4a8f
leaq 0x28(%rsp), %rdi
callq 0x4548
leaq 0x48(%rsp), %rdi
callq 0x4548
leaq 0x68(%rsp), %rdi
callq 0x4548
movq 0x8(%rsp), %rdi
callq 0x4230
testl %eax, %eax
sete %bl
leaq 0x8(%rsp), %rdi
callq 0x4548
jmp 0x49c2
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x49fc
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x4548
jmp 0x49e6
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x4548
jmp 0x49f5
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
jmp 0x4a04
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4548
jmp 0x4a0e
movq %rax, %rbx
movq %rbx, %rdi
callq 0x4490
// File: /workspace/github_cpp_makefile_star2_O2/Merulo[P]CompilerJFTT/src/Register/RegisterBlock.cpp
// Function: RegisterBlock::RegisterBlock(RegisterBlock const&)
RegisterBlock::RegisterBlock(const RegisterBlock &rb){
    for(auto r : rb._registers)
    {
        Register copy = r;
        _registers.push_back(copy);
    }
    _addressRegister = rb._addressRegister;
    _currentRegister = rb._currentRegister;
    _symbolTable = rb._symbolTable;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r12
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
addq $0x10, %rdi
movq %rdi, 0x10(%rsp)
callq 0x7fbc
leaq 0x68(%rbx), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%rbx)
movq %rbx, 0x8(%rsp)
andq $0x0, 0x78(%rbx)
movq 0x68(%r12), %r13
movq 0x70(%r12), %rbx
leaq 0x70(%rsp), %rbp
leaq 0x18(%rsp), %r14
cmpq %rbx, %r13
je 0x4cc0
movq %rbp, %rdi
movq %r13, %rsi
callq 0x8050
movq %r14, %rdi
movq %rbp, %rsi
callq 0x8050
movq %r15, %rdi
movq %r14, %rsi
callq 0x809e
movq %r14, %rdi
callq 0x80ca
movq %rbp, %rdi
callq 0x80ca
addq $0x58, %r13
jmp 0x4c84
leaq 0x10(%r12), %rsi
movq 0x10(%rsp), %rdi
callq 0x80e4
movl 0x80(%r12), %eax
movq 0x8(%rsp), %rdi
movl %eax, 0x80(%rdi)
movq %r12, %rsi
callq 0x84d4
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4cfe
movq %rax, %r14
jmp 0x4d1f
movq %rax, %r14
jmp 0x4d15
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x80ca
leaq 0x70(%rsp), %rdi
callq 0x80ca
movq %r15, %rdi
callq 0x8120
movq 0x10(%rsp), %rdi
callq 0x80ca
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
callq 0x85a8
movq %r14, %rdi
callq 0x4490
nop