// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::UnitTestImpl::RunAllTests()
bool UnitTestImpl::RunAllTests() {
  // Makes sure InitGoogleTest() was called.
  if (!GTestIsInitialized()) {
    GTEST_LOG_(ERROR) << 
      "\nThis test program did NOT call ::testing::InitGoogleTest "
      "before calling RUN_ALL_TESTS().  Please fix it.";
    return false;
  }

  // Do not run any test if the --help flag was specified.
  if (g_help_flag)
    return true;

  // Repeats the call to the post-flag parsing initialization in case the
  // user didn't call InitGoogleTest.
  PostFlagParsingInit();

  // Even if sharding is not on, test runners may want to use the
  // GTEST_SHARD_STATUS_FILE to query whether the test supports the sharding
  // protocol.
  internal::WriteToShardStatusFileIfNeeded();

  // True iff we are in a subprocess for running a thread-safe-style
  // death test.
  bool in_subprocess_for_death_test = false;

#if GTEST_HAS_DEATH_TEST
  in_subprocess_for_death_test = (internal_run_death_test_flag_.get() != NULL);
# if defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_)
  if (in_subprocess_for_death_test) {
    GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_();
  }
# endif  // defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_)
#endif  // GTEST_HAS_DEATH_TEST

  const bool should_shard = ShouldShard(kTestTotalShards, kTestShardIndex,
                                        in_subprocess_for_death_test);

  // Compares the full test names with the filter to decide which
  // tests to run.
  const bool has_tests_to_run = FilterTests(should_shard
                                              ? HONOR_SHARDING_PROTOCOL
                                              : IGNORE_SHARDING_PROTOCOL) > 0;

  // Lists the tests and exits if the --gtest_list_tests flag was specified.
  if (GTEST_FLAG(list_tests)) {
    // This must be called *after* FilterTests() has been called.
    ListTestsMatchingFilter();
    return true;
  }

  random_seed_ = GTEST_FLAG(shuffle) ?
      GetRandomSeedFromFlag(GTEST_FLAG(random_seed)) : 0;

  // True iff at least one test has failed.
  bool failed = false;

  TestEventListener* repeater = listeners()->repeater();

  start_timestamp_ = GetTimeInMillis();
  repeater->OnTestProgramStart(*parent_);

  // How many times to repeat the tests?  We don't want to repeat them
  // when we are inside the subprocess of a death test.
  const int repeat = in_subprocess_for_death_test ? 1 : GTEST_FLAG(repeat);
  // Repeats forever if the repeat count is negative.
  const bool forever = repeat < 0;
  for (int i = 0; forever || i != repeat; i++) {
    // We want to preserve failures generated by ad-hoc test
    // assertions executed before RUN_ALL_TESTS().
    ClearNonAdHocTestResult();

    const TimeInMillis start = GetTimeInMillis();

    // Shuffles test cases and tests if requested.
    if (has_tests_to_run && GTEST_FLAG(shuffle)) {
      random()->Reseed(random_seed_);
      // This should be done before calling OnTestIterationStart(),
      // such that a test event listener can see the actual test order
      // in the event.
      ShuffleTests();
    }

    // Tells the unit test event listeners that the tests are about to start.
    repeater->OnTestIterationStart(*parent_, i);

    // Runs each test case if there is at least one test to run.
    if (has_tests_to_run) {
      // Sets up all environments beforehand.
      repeater->OnEnvironmentsSetUpStart(*parent_);
      ForEach(environments_, SetUpEnvironment);
      repeater->OnEnvironmentsSetUpEnd(*parent_);

      // Runs the tests only if there was no fatal failure during global
      // set-up.
      if (!Test::HasFatalFailure()) {
        for (int test_index = 0; test_index < total_test_case_count();
             test_index++) {
          GetMutableTestCase(test_index)->Run();
        }
      }

      // Tears down all environments in reverse order afterwards.
      repeater->OnEnvironmentsTearDownStart(*parent_);
      std::for_each(environments_.rbegin(), environments_.rend(),
                    TearDownEnvironment);
      repeater->OnEnvironmentsTearDownEnd(*parent_);
    }

    elapsed_time_ = GetTimeInMillis() - start;

    // Tells the unit test event listener that the tests have just finished.
    repeater->OnTestIterationEnd(*parent_, i);

    // Gets the result and clears it.
    if (!Passed()) {
      failed = true;
    }

    // Restores the original test order after the iteration.  This
    // allows the user to quickly repro a failure that happens in the
    // N-th iteration without repeating the first (N - 1) iterations.
    // This is not enclosed in "if (GTEST_FLAG(shuffle)) { ... }", in
    // case the user somehow changes the value of the flag somewhere
    // (it's always safe to unshuffle the tests).
    UnshuffleTests();

    if (GTEST_FLAG(shuffle)) {
      // Picks a new random seed for each iteration.
      random_seed_ = GetNextRandomSeed(random_seed_);
    }
  }

  repeater->OnTestProgramEnd(*parent_);

  return !failed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
callq 0x26070
testb $0x1, %al
jne 0x24cbb
leaq 0x658b2(%rip), %rdx     # 0x8a509
leaq -0x14(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movl $0x2, %esi
movl $0x11da, %ecx           # imm = 0x11DA
callq 0x2dbe0
movq -0x78(%rbp), %rdi
callq 0x305f0
movq %rax, -0x70(%rbp)
jmp 0x24c7d
movq -0x70(%rbp), %rdi
leaq 0x66583(%rip), %rsi     # 0x8b20b
callq 0xe750
jmp 0x24c8f
leaq -0x14(%rbp), %rdi
callq 0x2dd20
movb $0x0, -0x1(%rbp)
jmp 0x24ffb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x14(%rbp), %rdi
callq 0x2dd20
jmp 0x25009
testb $0x1, 0x9cc27(%rip)     # 0xc18e9
je 0x24ccd
movb $0x1, -0x1(%rbp)
jmp 0x24ffb
movq -0x68(%rbp), %rdi
callq 0x25c40
callq 0x26090
movq -0x68(%rbp), %rdi
movb $0x0, -0x25(%rbp)
addq $0x1d0, %rdi            # imm = 0x1D0
callq 0x36a90
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
leaq 0x648ab(%rip), %rdi     # 0x895b0
leaq 0x648c4(%rip), %rsi     # 0x895d0
andb $0x1, %al
movzbl %al, %edx
callq 0x1eca0
movq -0x68(%rbp), %rdi
andb $0x1, %al
movb %al, -0x26(%rbp)
movb -0x26(%rbp), %cl
movl $0x1, %esi
xorl %eax, %eax
testb $0x1, %cl
cmovnel %eax, %esi
callq 0x26110
cmpl $0x0, %eax
setg %al
andb $0x1, %al
movb %al, -0x27(%rbp)
testb $0x1, 0x9cbea(%rip)     # 0xc1930
je 0x24d5a
movq -0x68(%rbp), %rdi
callq 0x26580
movb $0x1, -0x1(%rbp)
jmp 0x24ffb
testb $0x1, 0x9cc04(%rip)     # 0xc1965
je 0x24d73
movl 0x9cbf3(%rip), %edi     # 0xc195c
callq 0x370d0
movl %eax, -0x7c(%rbp)
jmp 0x24d7a
xorl %eax, %eax
movl %eax, -0x7c(%rbp)
jmp 0x24d7a
movq -0x68(%rbp), %rdi
movl -0x7c(%rbp), %eax
movl %eax, 0x1b4(%rdi)
movb $0x0, -0x28(%rbp)
callq 0x310d0
movq %rax, %rdi
callq 0x164f0
movq %rax, -0x30(%rbp)
callq 0x16b30
movq %rax, %rcx
movq -0x68(%rbp), %rax
movq %rcx, 0x1c0(%rax)
movq -0x30(%rbp), %rdi
movq 0x8(%rax), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
testb $0x1, -0x25(%rbp)
je 0x24dcd
movl $0x1, %eax
movl %eax, -0x80(%rbp)
jmp 0x24dd6
movl 0x9cb8d(%rip), %eax     # 0xc1960
movl %eax, -0x80(%rbp)
movl -0x80(%rbp), %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
setl %al
andb $0x1, %al
movb %al, -0x35(%rbp)
movl $0x0, -0x3c(%rbp)
movb $0x1, %al
testb $0x1, -0x35(%rbp)
movb %al, -0x81(%rbp)
jne 0x24e0c
movl -0x3c(%rbp), %eax
cmpl -0x34(%rbp), %eax
setne %al
movb %al, -0x81(%rbp)
movb -0x81(%rbp), %al
testb $0x1, %al
jne 0x24e1b
jmp 0x24fdf
movq -0x68(%rbp), %rdi
callq 0x37120
callq 0x16b30
movq %rax, -0x48(%rbp)
testb $0x1, -0x27(%rbp)
je 0x24e60
testb $0x1, 0x9cb2b(%rip)     # 0xc1965
je 0x24e60
movq -0x68(%rbp), %rdi
callq 0x37150
movq %rax, %rdi
movq -0x68(%rbp), %rax
movl 0x1b4(%rax), %esi
callq 0x37170
movq -0x68(%rbp), %rdi
callq 0x26760
movq -0x68(%rbp), %rax
movq -0x30(%rbp), %rdi
movq 0x8(%rax), %rsi
movl -0x3c(%rbp), %edx
movq (%rdi), %rax
callq *0x18(%rax)
testb $0x1, -0x27(%rbp)
je 0x24f69
movq -0x68(%rbp), %rax
movq -0x30(%rbp), %rdi
movq 0x8(%rax), %rsi
movq (%rdi), %rax
callq *0x20(%rax)
movq -0x68(%rbp), %rdi
addq $0xa0, %rdi
leaq 0x19ad(%rip), %rsi      # 0x26850
callq 0x36a40
movq -0x68(%rbp), %rax
movq -0x30(%rbp), %rdi
movq 0x8(%rax), %rsi
movq (%rdi), %rax
callq *0x28(%rax)
callq 0x1d2f0
testb $0x1, %al
jne 0x24f09
movl $0x0, -0x4c(%rbp)
movq -0x68(%rbp), %rdi
movl -0x4c(%rbp), %eax
movl %eax, -0x88(%rbp)
callq 0x16660
movl %eax, %ecx
movl -0x88(%rbp), %eax
cmpl %ecx, %eax
jge 0x24f07
movq -0x68(%rbp), %rdi
movl -0x4c(%rbp), %esi
callq 0x35c10
movq %rax, %rdi
callq 0x1e390
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x24eca
jmp 0x24f09
movq -0x68(%rbp), %rax
movq -0x30(%rbp), %rdi
movq 0x8(%rax), %rsi
movq (%rdi), %rax
callq *0x58(%rax)
movq -0x68(%rbp), %rsi
addq $0xa0, %rsi
leaq -0x58(%rbp), %rdi
callq 0x37200
movq -0x68(%rbp), %rsi
addq $0xa0, %rsi
leaq -0x60(%rbp), %rdi
callq 0x37250
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq 0x191e(%rip), %rdx      # 0x26870
callq 0x37190
movq -0x68(%rbp), %rax
movq -0x30(%rbp), %rdi
movq 0x8(%rax), %rsi
movq (%rdi), %rax
callq *0x60(%rax)
callq 0x16b30
movq %rax, %rcx
movq -0x68(%rbp), %rax
subq -0x48(%rbp), %rcx
movq %rcx, 0x1c8(%rax)
movq -0x30(%rbp), %rdi
movq 0x8(%rax), %rsi
movl -0x3c(%rbp), %edx
movq (%rdi), %rax
callq *0x68(%rax)
movq -0x68(%rbp), %rdi
callq 0x35b10
testb $0x1, %al
jne 0x24fa2
movb $0x1, -0x28(%rbp)
movq -0x68(%rbp), %rdi
callq 0x26890
testb $0x1, 0x9c9b3(%rip)     # 0xc1965
je 0x24fcf
movq -0x68(%rbp), %rax
movl 0x1b4(%rax), %edi
callq 0x372a0
movl %eax, %ecx
movq -0x68(%rbp), %rax
movl %ecx, 0x1b4(%rax)
jmp 0x24fd1
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x24def
movq -0x68(%rbp), %rax
movq -0x30(%rbp), %rdi
movq 0x8(%rax), %rsi
movq (%rdi), %rax
callq *0x70(%rax)
movb -0x28(%rbp), %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xee80
nopw %cs:(%rax,%rax)