// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: void testing::internal::HandleExceptionsInMethodIfSupported<testing::Test, void>(testing::Test*, void (testing::Test::*)(), char const*)
Result HandleExceptionsInMethodIfSupported(
    T* object, Result (T::*method)(), const char* location) {
  // NOTE: The user code can affect the way in which Google Test handles
  // exceptions by setting GTEST_FLAG(catch_exceptions), but only before
  // RUN_ALL_TESTS() starts. It is technically possible to check the flag
  // after the exception is caught and either report or re-throw the
  // exception based on the flag's value:
  //
  // try {
  //   // Perform the test method.
  // } catch (...) {
  //   if (GTEST_FLAG(catch_exceptions))
  //     // Report the exception as failure.
  //   else
  //     throw;  // Re-throws the original exception.
  // }
  //
  // However, the purpose of this flag is to allow the program to drop into
  // the debugger when the exception is thrown. On most platforms, once the
  // control enters the catch block, the exception origin information is
  // lost and the debugger will stop the program at the point of the
  // re-throw in this function -- instead of at the point of the original
  // throw statement in the code under test.  For this reason, we perform
  // the check early, sacrificing the ability to affect Google Test's
  // exception handling in the method where the exception is thrown.
  if (internal::GetUnitTestImpl()->catch_exceptions()) {
#if GTEST_HAS_EXCEPTIONS
    try {
      return HandleSehExceptionsInMethodIfSupported(object, method, location);
    } catch (const internal::GoogleTestFailureException&) {  // NOLINT
      // This exception type can only be thrown by a failed Google
      // Test assertion with the intention of letting another testing
      // framework catch it.  Therefore we just re-throw it.
      throw;
    } catch (const std::exception& e) {  // NOLINT
      internal::ReportFailureInUnknownLocation(
          TestPartResult::kFatalFailure,
          FormatCxxExceptionMessage(e.what(), location));
    } catch (...) {  // NOLINT
      internal::ReportFailureInUnknownLocation(
          TestPartResult::kFatalFailure,
          FormatCxxExceptionMessage(NULL, location));
    }
    return static_cast<Result>(0);
#else
    return HandleSehExceptionsInMethodIfSupported(object, method, location);
#endif  // GTEST_HAS_EXCEPTIONS
  } else {
    return (object->*method)();
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
callq 0x1f568
addq %r15, %r14
cmpb $0x1, 0x1f0(%rax)
jne 0x20a31
testb $0x1, %r12b
je 0x20a1f
movq (%r14), %rax
movq -0x1(%rax,%r12), %r12
movq %r14, %rdi
callq *%r12
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
testb $0x1, %r12b
movq %r12, %rcx
je 0x20a42
movq (%r14), %rax
movq -0x1(%rax,%rcx), %rcx
movq %r14, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rcx
movq %rdx, %r14
movq %rax, %rdi
cmpl $0x3, %r14d
je 0x20ac1
callq 0xd240
cmpl $0x2, %r14d
jne 0x20a91
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x1f0dd
pushq $0x2
popq %rdi
leaq 0x8(%rsp), %rsi
callq 0x14fec
jmp 0x20aad
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x1f0dd
pushq $0x2
popq %rdi
leaq 0x8(%rsp), %rsi
callq 0x14fec
leaq 0x8(%rsp), %rdi
callq 0xdd68
callq 0xdb60
jmp 0x20a25
callq 0xd240
callq 0xd9a0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xdd68
jmp 0x20add
movq %rax, %rbx
callq 0xdb60
jmp 0x20b05
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xdd68
jmp 0x20af6
movq %rax, %rbx
callq 0xdb60
jmp 0x20b05
movq %rax, %rbx
callq 0xdb60
movq %rbx, %rdi
callq 0xdbf0
movq %rax, %rdi
callq 0x1f577
nop